Linux系统的tty架构及UART驱动详解

struct uart_driver {
        struct module    *owner; /*拥有该uart_driver的模块，一般为THIS_MODULE*/
        const char        *driver_name; /*驱动串口名，串口设备名以驱动名为基础*/
        const char        *dev_name; /*串口设备名*/
        int                 major; /*主设备号*/
        int                 minor; /*次设备号*/
        int                 nr; /*该uart_driver支持的串口数*/
        struct console    *cons; /*其对应的console,若该uart_driver支持serial console,
*否则为NULL*/
/*
* these are private; the low level driver should not
* touch these; they should be initialised to NULL
*/
struct uart_state *state; /*下层，窗口驱动层*/
struct tty_driver  *tty_driver; /*tty相关*/

struct console {
      char name[16];
      void(*write)(struct console *，const char *, unsigined);
      int (*read)(struct console *, char *, unsigned);
      struct tty_driver *(struct console *,int*);
      void (*unblank)(void);
      int  (*setup)(struct console *, char *);
      int  (*early_setup)(void);
      short  flags;
      short  index; /*用来指定该console使用哪一个uart port (对应的uart_port中的line),如果为-1,kernel会自动选择第一个uart port*/
      int   cflag;
      void  *data;
      struct   console *next;
};

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 {
        spinlock_t              lock;                   /* port lock */
        unsigned long           iobase;                 /* in/out[bwl] */
        unsigned char __iomem   *membase;               /* read/write[bwl] */
        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);
        int                     (*handle_irq)(struct uart_port *);
        void                    (*pm)(struct uart_port *, unsigned int state,
                                      unsigned int old);
        void                    (*handle_break)(struct uart_port *);
        unsigned int            irq;                    /* irq number */
        unsigned long           irqflags;               /* irq flags  */
        unsigned int            uartclk;                /* base uart clock */
        unsigned int            fifosize;               /* tx fifo size */
        unsigned char           x_char;                 /* xon/xoff char */
        unsigned char           regshift;               /* reg offset shift */
        unsigned char           iotype;                 /* io access style */
        unsigned char           unused1;
#define UPIO_PORT               (0)
#define UPIO_HUB6               (1)
#define UPIO_MEM                (2)
#define UPIO_MEM32              (3)
#define UPIO_AU                 (4)                     /* Au1x00 and RT288x type IO */
#define UPIO_TSI                (5)                     /* Tsi108/109 type IO */
        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 */
        struct console          *cons;                  /* struct console, if any */
#if defined(CONFIG_SERIAL_CORE_CONSOLE) || defined(SUPPORT_SYSRQ)
        unsigned long           sysrq;                  /* sysrq timeout */
#endif
        upf_t                   flags;
#define UPF_FOURPORT            ((__force upf_t) (1 << 1))
#define UPF_SAK                 ((__force upf_t) (1 << 2))
#define UPF_SPD_MASK            ((__force upf_t) (0x1030))
#define UPF_SPD_HI              ((__force upf_t) (0x0010))
#define UPF_SPD_VHI             ((__force upf_t) (0x0020))
#define UPF_SPD_CUST            ((__force upf_t) (0x0030))
#define UPF_SPD_SHI             ((__force upf_t) (0x1000))
#define UPF_SPD_WARP            ((__force upf_t) (0x1010))
#define UPF_SKIP_TEST           ((__force upf_t) (1 << 6))
#define UPF_AUTO_IRQ            ((__force upf_t) (1 << 7))
#define UPF_HARDPPS_CD          ((__force upf_t) (1 << 11))
#define UPF_LOW_LATENCY         ((__force upf_t) (1 << 13))
#define UPF_BUGGY_UART          ((__force upf_t) (1 << 14))
#define UPF_NO_TXEN_TEST        ((__force upf_t) (1 << 15))
#define UPF_MAGIC_MULTIPLIER    ((__force upf_t) (1 << 16))
/* Port has hardware-assisted h/w flow control (iow, auto-RTS *not* auto-CTS) */
#define UPF_HARD_FLOW           ((__force upf_t) (1 << 21))
/* Port has hardware-assisted s/w flow control */
#define UPF_SOFT_FLOW           ((__force upf_t) (1 << 22))
#define UPF_CONS_FLOW           ((__force upf_t) (1 << 23))
#define UPF_SHARE_IRQ           ((__force upf_t) (1 << 24))
#define UPF_EXAR_EFR            ((__force upf_t) (1 << 25))
#define UPF_BUG_THRE            ((__force upf_t) (1 << 26))
/* The exact UART type is known and should not be probed.  */
#define UPF_FIXED_TYPE          ((__force upf_t) (1 << 27))
#define UPF_BOOT_AUTOCONF       ((__force upf_t) (1 << 28))
#define UPF_FIXED_PORT          ((__force upf_t) (1 << 29))
#define UPF_DEAD                ((__force upf_t) (1 << 30))
#define UPF_IOREMAP             ((__force upf_t) (1 << 31))
#define UPF_CHANGE_MASK         ((__force upf_t) (0x17fff))
#define UPF_USR_MASK            ((__force upf_t) (UPF_SPD_MASK|UPF_LOW_LATENCY))
        unsigned int            mctrl;                  /* current modem ctrl settings */
        unsigned int            timeout;                /* character-based timeout */
        unsigned int            type;                   /* port type */
        const struct uart_ops   *ops;
        unsigned int            custom_divisor;
        unsigned int            line;                   /* port index */
        resource_size_t         mapbase;                /* for ioremap */
        struct device           *dev;                   /* parent device */
        unsigned char           hub6;                   /* this should be in the 8250 driver */
        unsigned char           suspended;
        unsigned char           irq_wake;
        unsigned char           unused[2];
        void                    *private_data;          /* generic platform data pointer */
};

struct uart_ops {
        unsigned int    (*tx_empty)(struct uart_port *);
        void            (*set_mctrl)(struct uart_port *, unsigned int mctrl);
        unsigned int    (*get_mctrl)(struct uart_port *);
        void            (*stop_tx)(struct uart_port *);
        void            (*start_tx)(struct uart_port *);
        void            (*throttle)(struct uart_port *);
        void            (*unthrottle)(struct uart_port *);
        void            (*send_xchar)(struct uart_port *, char ch);
        void            (*stop_rx)(struct uart_port *);
        void            (*enable_ms)(struct uart_port *);
        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);
        /*
         * Return a string describing the type of the port
         */
        const char      *(*type)(struct uart_port *);
        /*
         * Release IO and memory resources used by the port.
         * This includes iounmap if necessary.
         */
        void            (*release_port)(struct uart_port *);
        /*
         * Request IO and memory resources used by the port.
         * This includes iomapping the port if necessary.
         */
        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
        int             (*poll_init)(struct uart_port *);
        void            (*poll_put_char)(struct uart_port *, unsigned char);
        int             (*poll_get_char)(struct uart_port *);
#endif
};

/*功能：  uart_register_driver用于串口驱动uart_driver注册到内核(串口核心层）中，通常在模块初始化函数调用该函数。
 *参数：drv:要注册的uart_driver
 *返回值：成功，返回0；否则返回错误码
 */
int uart_register_driver(struct uart_driver *drv)

/*功能：uart_unregister 用于注销我们已注册的uart_driver,通常在模块卸载函数调用该函数，
 *参数 : drv:要注销的uart_driver
 *返回值：成功返回0，否则返回错误码
 */
void uart_unregister_driver(struct uart_driver *drv)

/*功能：uart_add_one_port用于为串口驱动添加一个串口端口，通常在探测到设备后(驱动的设备probe方法)调用该函数
 *参数：
 *     drv:串口驱动
 *     port:要添加的串口端口
 *返回值：成功，返回0；否则返回错误码
 */
int uart_add_one_port(struct uart_driver *drv,struct uart_port *port)

/*功能：uart_remove_one_port用于删除一个已经添加到串口驱动中的串口端口，通常在驱动卸载时调用该函数
 *参数：
 *     drv:串口驱动
 *     port:要删除的串口端口
 *返回值：成功，返回0；否则返回错误码
 */
int uart_remove_one_port(struct uart_driver *drv,struct uart_port *port)

/*功能：uart_write_wakeup唤醒上层因串口端口写数据而堵塞的进程，通常在串口发送中断处理函数中调用该函数
 *参数：
 *     port: 需要唤醒写堵塞进程的串口端口
 */
void uart_write_wakeup(struct uart_port *port)

/*功能：uart_suspend_port用于挂起特定的串口端口
 *参数：
 *     drv:要挂起的串口端口锁所属的串口驱动
 *     port:要挂起的串口端口
 *返回值：成功返回0；否则返回错误码
 */
int uart_suspend_port(struct uart_driver *drv, struct uart_port *port)

/*功能：uart_resume_port用于恢复某一已挂起的串口
 *参数：
 *     drv:要恢复的串口端口所属的串口驱动
 *     port:要恢复的串口端口
 *返回值：成功返回0；否则返回错误码
 */
int uart_resume_port(struct uart_driver *drv, struct uart_port *port)

/*功能：uart_get_baud_rate通过解码termios结构体来获取指定串口的波特率
 *参数：
 *     port：要获取波特率的串口端口
 *     termios:当前期望的termios配置(包括串口波特率)
 *     old:以前的termios配置，可以为NULL
 *     min:可以接受的最小波特率
 *     max:可以接受的最大波特率
 *     返回值：串口波特率
 */
unsigned int uart_get_baund_rate(struct uart_port *port, struct ktermios *termios, struct ktermios *old,unsigned int min, unsigned int max)

/*功能：uart_get_divisor 用于计算某一波特率的串口时钟分频数(串口波特率除数）
 *参数：
 *     port：要计算分频数的串口端口
 *     baud：期望的波特率
 *返回值：串口时钟分频数
 */
unsigned int uart_get_divisor(struct uart_port *port, unsigned int baund)

/*功能：uart_update_timeout用于更新（设置）串口FIFO超出时间
 *参数：
 *     port：要更新超时间的串口端口
 *     cfalg：termios结构体的cflag值
 *     baud：串口的波特率
 */
void uart_update_timeout(struct uart_port *port,unsigned int cflag, unsigned int baud)

/*功能：uart_insert_char用于向uart层插入一个字符
 *参数：
 *     port：要写信息的串口端口
 *     status：RX buffer状态
 *     overrun：在status中的overrun bit掩码
 *     ch：需要插入的字符
 *     flag：插入字符的flag：TTY_BREAK,TTY_PSRIYY, TTY_FRAME
 */
void uart_insert_char(struct uart_port *port, unsigned int status, unsigned int overrun,unsigned int ch, unsigned int flag)

/*功能：uart_console_write用于向串口端口写一控制台信息
 *参数：
 *     port：要写信息的串口端口
 *     s:要写的信息
 *     count：信息的大小
 *     putchar：用于向串口端口写字符的函数，该函数有两个参数：串口端口和要写的字符
 */
Void uart_console_write(struct uart_port *port,const char *s, unsigned int count,viod(*putchar)(struct uart_port*, int))

struct termious newtio, oldtio;
tegetattr(fd, &oldtio);

newtio.cflag |= CLOCAL|CREAD;

newtio.c_cflag = B115200;

newtio.c_cflag &= ~CSIZE;
Newtio.c_cflag |= CS8;

newtio.c_cflag &= ~CSTOPB; /*停止位设置为1*/
Newtio.c_cflag |= CSTOPB; /*停止位设置为2 */

newtio.c_cfag |= CRTSCTS /*开启硬件流控 */
newtio.c_cfag |= (IXON | IXOFF | IXANY); /*开启软件流控*/

newtio.c_cflag |= PARENB;
newtio.c_cflag |= PARODD;
newtio.c_iflag |= (INPCK | ISTRIP);

newtio.c_iflag |= (INPCK | ISTRIP);
newtio.c_cflag |= PARENB;
newtio.c_cflag |= ~PARODD;

newtio.c_cc[VTIME] = 0;
newtio.c_cc[VMIN]  = 0;

int tcflash(int filedes, int quene)
quene数应当是下列三个常数之一:
  *TCIFLUSH 刷清输入队列
  *TCOFLUSH 刷清输出队列
  *TCIOFLUSH 刷清输入、输出队列
例如：
tcflush(fd, TCIFLUSH);

int tcsetarr(int filedes, const struct termios *termptr);
opt 指定在什么时候新的终端属性才起作用，
   *TCSANOW:更改立即发生
   *TCSADRAIN:发送了所有输出后更改才发生。若更改输出参数则应使用此选项
   *TCSAFLUSH:发送了所有输出后更改才发生。更进一步，在更改发生时未读的
                 所有输入数据都被删除（刷清）
例如：tcsetatrr(fd, TCSANOW, &newtio);

fd = open("/dev/ttySLB0",O_RDWR | O_NOCTTY | O_NDELAY);
O_NOCTTY：是为了告诉Linux这个程序不会成为这个端口上的“控制终端”。如果不这样做的话，所有的输入，比如键盘上过来的Ctrl+C中止信号等等，会影响到你的进程。
O_NDELAY：这个标志则是告诉Linux这个程序并不关心DCD信号线的状态，也就是不管串口是否有数据到来，都是非阻塞的，程序继续执行。

fcntl(fd,F_SETFL,0);  //F_SETFL：设置文件flag为0，即默认，即阻塞状态

isatty(STDIN_FILENO);

串口的读写与普通文件一样，使用read，write函数
read(fd, buf ,8);
write(fd,buff,8);

#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <termios.h>
#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <log/log.h>
#include <stdlib.h>
#define UART_DEVICE     "/dev/ttySLB1"
struct temp {
 float temp_max1;
 float temp_max2;
 float temp_max3;
 float temp_min;
 float temp_mean;
 float temp_enviromem;
 char temp_col[1536];
};
int main(void)
{
 int count, i, fd;
 struct termios oldtio, newtio;
 struct temp *temp;
 temp = (struct temp *)malloc(sizeof(struct temp));
 if (!temp) {
  printf("malloc failed\n");
  return -1;
 }
 char cmd_buf1[] = { 0xAA, 0x01, 0x04, 0x00, 0x06, 0x10, 0x05, 0x00, 0xBB};
 char cmd_buf2[] = { 0xAA, 0x01, 0x04, 0x00, 0x00, 0xA0, 0x00, 0x03, 0xBB};
 char cmd_buf3[] = { 0xAA, 0x01, 0x04, 0x00, 0x03, 0x10, 0x01, 0x00, 0xBB};
 char read_buf[2000];
 //-----------打开uart设备文件------------------
 fd = open(UART_DEVICE, O_RDWR | O_NOCTTY);
 if (fd < 0) {
  printf("Open %s failed\n", UART_DEVICE);
  return -1;
 } else {
  printf("Open %s successfully\n", UART_DEVICE);
 }
 //-----------设置操作参数-----------------------
 tcgetattr(fd, &oldtio);//获取当前操作模式参数
 memset(&newtio, 0, sizeof(newtio));
 //波特率=230400 数据位=8 使能数据接收
 newtio.c_cflag = B230400 | CS8 | CLOCAL | CREAD | CSTOPB;
 newtio.c_iflag = IGNPAR;
 tcflush(fd, TCIFLUSH);//清空输入缓冲区和输出缓冲区
 tcsetattr(fd, TCSANOW, &newtio);//设置新的操作参数
 //printf("input: %s, len = %d\n", cmd_buf, strlen(cmd_buf));
 //------------向urat发送数据-------------------
 for (i = 0; i < 9; i++)
  printf("%#X ", cmd_buf1[i]);
 count = write(fd, cmd_buf1, 9);
 if (count != 9) {
  printf("send failed\n");
  return -1;
 }
 usleep(500000);
 memset(read_buf, 0, sizeof(read_buf));
 count = read(fd, read_buf, sizeof(read_buf));
 if (count > 0) {
  for (i = 0; i < count; i++);
  temp->temp_max1 = read_buf[7] << 8 | read_buf[6];
  temp->temp_max2 = read_buf[9] << 8 | read_buf[8];
  temp->temp_max3 = read_buf[11] << 8 | read_buf[10];
  temp->temp_min  = read_buf[13] << 8 | read_buf[12];
  temp->temp_mean = read_buf[15] << 8 | read_buf[14];
  printf("temp->temp_max1 = %f\n", temp->temp_max1 * 0.01);
  printf("temp->temp_max2 = %f\n", temp->temp_max2 * 0.01);
  printf("temp->temp_max3 = %f\n", temp->temp_max3 * 0.01);
  printf("temp->temp_min  = %f\n", temp->temp_min  * 0.01);
  printf("temp->temp_mean = %f\n", temp->temp_mean * 0.01);
 } else {
  printf("read temp failed\n");
  return -1;
 }
 count = write(fd, cmd_buf3, 9);
 if (count != 9) {
  printf("send failed\n");
  return -1;
 }
 usleep(365);
 memset(read_buf, 0, sizeof(read_buf));
 count = read(fd, read_buf, sizeof(read_buf));
 if (count > 0) {
  for (i = 0; i < count; i++);
  temp->temp_enviromem = read_buf[7] << 8 | read_buf[6];
  printf("temp->temp_enviromem = %f\n", temp->temp_enviromem * 0.01); 
 } else {
  printf("read enviromem failed\n");
  return -1;
 }
 count = write(fd, cmd_buf2, 9);
 if (count != 9) {
  printf("send failed\n");
  return -1;
 }
 usleep(70000);
 memset(read_buf, 0, sizeof(read_buf));
 memset(temp->temp_col, 0, sizeof(temp->temp_col));
 count = read(fd, read_buf, sizeof(read_buf));
 printf("count = %d\n", count);
 if (count > 0) {
  for (i = 0; i < count - 7; i++)
  temp->temp_col[i] = read_buf[i+6];
  for (i = 0; i < 1536; i++)
  {
   if (!(i%10))
    printf("\n");
   printf("%#X ", temp->temp_col[i]);
  }
 } else {
  printf("read temp colour failed\n");
  return -1;
 }
 free(temp); 
 close(fd);
 tcsetattr(fd, TCSANOW, &oldtio); //恢复原先的设置
 return 0;
}