學習串列埠驅動，先從資料結構入手吧。串列埠驅動有3個核心資料結構:

（/drivers/tty/serial/omap-serial.c）
- UART特定的驅動程式結構定義：struct uart_driver serial_omap_reg;
- UART埠結構定義： struct uart_omap_port *ui[OMAP_MAX_HSUART_PORTS]；
- UART相關操作函式結構定義: struct uart_ops serial_omap_pops;

重要資料結構

1. uart_driver

uart_driver 封裝了tty_driver，使得底層的UART驅動無需關心tty_driver。

#include <linux/serial_core.h>

  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;
  };

其中的uart_state是裝置私有資訊結構體，

在uart_open()中:

tty->driver_data = state;

在其他uart_xxx()中：

struct uart_state *state = tty->driver_data;

就可以獲取裝置私有資訊結構體。

#include<linux/serial_core.h>

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,
};

一個tty驅動必須註冊/登出tty_driver，而一個UART驅動則變為註冊/登出uart_driver，使用如下介面：
int uart_register_driver(struct uart_driver *drv)；
void uart_unregister_driver(struct uart_driver *drv)；

2. uart_port

用於描述一個UART的I/O埠或者IO記憶體地址等資訊;實際上，一個uart_port例項對應一個串列埠裝置。

#include<linux/serial_core.h>

  struct uart_port {
      spinlock_t        lock;            /* port lock 串列埠埠鎖 */
      unsigned long        iobase;        /* in/out[bwl] io埠基地 */
      unsigned char __iomem    *membase;/* read/write[bwl] IO記憶體基地址,經對映(如ioremap)後的IO記憶體虛擬基地址 */
      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;            /* 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 type IO */
  #define UPIO_TSI        (5)            /* Tsi108/109 type IO */
  #define UPIO_DWAPB        (6)            /* DesignWare APB UART */
  #define UPIO_RM9000        (7)            /* RM9000 type IO */
  #define UPIO_DWAPB32        (8)            /* DesignWare APB UART (32 bit accesses) */

      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))
  #define UPF_CONS_FLOW        ((__force upf_t) (1 << 23))
  #define UPF_SHARE_IRQ        ((__force upf_t) (1 << 24))
  /* 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;      /*UART操作集*/
      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 */
  };

uart_omap_port 封裝了uart_port：

#inclide<linux/serial_core.h>

struct uart_omap_port {
    struct uart_port    port;
    struct uart_omap_dma    uart_dma;
    struct device       *dev;

    unsigned char       ier;
    unsigned char       lcr;
    unsigned char       mcr;
    unsigned char       fcr;
    unsigned char       efr;
    unsigned char       dll;
    unsigned char       dlh;
    unsigned char       mdr1;
    unsigned char       scr;

    int         use_dma;
    /*
     * Some bits in registers are cleared on a read, so they must
     * be saved whenever the register is read but the bits will not
     * be immediately processed.
     */
    unsigned int        lsr_break_flag;
    unsigned char       msr_saved_flags;
    char            name[20];
    unsigned long       port_activity;
    int         context_loss_cnt;
    u32         errata;
    u8          wakeups_enabled;

    int         DTR_gpio;
    int         DTR_inverted;
    int         DTR_active;

    struct pm_qos_request   pm_qos_request;
    u32         latency;
    u32         calc_latency;
    struct work_struct  qos_work;
    struct pinctrl      *pins;
    struct serial_rs485 rs485;
};

static struct uart_omap_port *ui[OMAP_MAX_HSUART_PORTS];

由此可見，對串列埠的一系列初始化，實際上落到了對ui結構體的填充上。

在serial_omap_probe(struct platform_device *pdev)中：
struct uart_omap_port up; /*uart_omap_port 封裝了uart_port /
ui[up->port.line] = up;

serial_omap_add_console_port(up);
uart_add_one_port(&serial_omap_reg, &up->port);

• uart_iconut為串列埠資訊計數器，包含了傳送字元計數、接收字元計數等。在串列埠的傳送中斷處理函式和接收中斷處理函式中，我們需要管理這些計數;

   struct uart_icount {
      __u32    cts;
      __u32    dsr;
      __u32    rng;
      __u32    dcd;
      __u32    rx;      /* 傳送字元計數 */
      __u32    tx;      /* 接受字元計數 */
      __u32    frame;   /* 幀錯誤計數 */
      __u32    overrun; /* Rx FIFO溢位計數 */
      __u32    parity;  /* 幀校驗錯誤計數 */
      __u32    brk;     /* break計數 */
      __u32    buf_overrun;
   };

• uart_stat有兩個成員在底層串列埠驅動會用到：xmit和port。使用者空間程式通過串列埠傳送資料時，上層驅動將使用者資料儲存在xmit；而串列埠傳送中斷處理函式就是通過xmit獲取到使用者資料並將它們傳送出去。串列埠接收中斷處理函式需要通過port將接收到的資料傳遞給行規則層。

  /*
   * This is the state information which is persistent across opens.
   */
  struct uart_state {
      struct tty_port        port;

      int            pm_state;
      struct circ_buf        xmit;

      struct tasklet_struct    tlet;
      struct uart_port    *uart_port;
 };

3. uart_ops

uart_ops涵蓋了串列埠驅動可對串列埠裝置進行的所有操作

  /*
   * This structure describes all the operations that can be
   * done on the physical hardware.
   */
  struct uart_ops {
      unsigned int    (*tx_empty)(struct uart_port *);/* 串列埠的Tx FIFO快取是否為空 */
      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);/* 傳送xChar */
      void        (*stop_rx)(struct uart_port *);/* 禁止串列埠接收資料 */
      void        (*enable_ms)(struct uart_port *);/* 使能modem的狀態訊號 */
      void        (*break_ctl)(struct uart_port *, int ctl); /* 設定break訊號 */
      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);
      void        (*wake_peer)(struct uart_port *);

      /*
       * 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 *);/* 釋放串列埠已申請的IO埠/IO記憶體資源,必要時還需iounmap */

      /*
       * Request IO and memory resources used by the port.
       * This includes iomapping the port if necessary.
       */
      int        (*request_port)(struct uart_port *); /* 申請必要的IO埠/IO記憶體資源,必要時還可以重新對映串列埠埠 */
      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
  };

UART驅動的主體工作通過下列函式來實現：

#include<>
static struct uart_ops serial_omap_pops = {
    .tx_empty   = serial_omap_tx_empty,/*檢車傳送FIFO緩衝區是否空*/
    .set_mctrl  = serial_omap_set_mctrl,/*是否設定串列埠流控cts*/
    .get_mctrl  = serial_omap_get_mctrl,/*是否串列埠流控*/
    .stop_tx    = serial_omap_stop_tx,/*停止傳送*/
    .start_tx   = serial_omap_start_tx,/*啟動傳送*/
    .throttle   = serial_omap_throttle,/**/
    .unthrottle = serial_omap_unthrottle,/**/
    .stop_rx    = serial_omap_stop_rx,/*停止接收*/
    .enable_ms  = serial_omap_enable_ms,/**/
    .break_ctl  = serial_omap_break_ctl,/*傳送break訊號*/
    .startup    = serial_omap_startup,/*串列埠傳送/接收，以及中斷申請初始配置函式*/
    .shutdown   = serial_omap_shutdown,/*關閉串列埠*/
    .set_termios    = serial_omap_set_termios,/*串列埠clk,波特率，資料位等引數設定*/
    .pm     = serial_omap_pm,/*電源管理函式*/
    .set_wake   = serial_omap_set_wake,/**/
    .type       = serial_omap_type,/*CPU型別關於串列埠*/
    .release_port   = serial_omap_release_port,/*釋放串列埠*/
    .request_port   = serial_omap_request_port,/*申請串列埠*/
    .config_port    = serial_omap_config_port,/*串列埠的一些配置資訊info*/
    .verify_port    = serial_omap_verify_port,/*串列埠檢測*/
    .ioctl      = serial_omap_ioctl,/**/
#ifdef CONFIG_CONSOLE_POLL
    .poll_put_char  = serial_omap_poll_put_char,/**/
    .poll_get_char  = serial_omap_poll_get_char,/**/
#endif
};

而在serial_core.c中定義了tty_operations的例項，包含uart_open()；uart_close()；uart_send_xchar()等成員函式，這些函數借助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,
#ifdef CONFIG_CONSOLE_POLL
    .poll_init    = uart_poll_init,
    .poll_get_char    = uart_poll_get_char,
    .poll_put_char    = uart_poll_put_char,
#endif
};

從下面的例子中可以看出串列埠核心層的tty_operations與uart_ops的關係：

/*
 * This function is used to send a high-priority XON/XOFF character to
 * the device
 */
static void uart_send_xchar(struct tty_struct *tty, char ch)
{
    struct uart_state *state = tty->driver_data;
    struct uart_port *port = state->uart_port;
    unsigned long flags;

    if (port->ops->send_xchar)/*如果uart_ops中實現了send_xchar成員函式*/
        port->ops->send_xchar(port, ch);
    else {
        port->x_char = ch;
        if (ch) {
            spin_lock_irqsave(&port->lock, flags);
            port->ops->start_tx(port);
            spin_unlock_irqrestore(&port->lock, flags);
        }
    }
}

(待續)