天天看點

tty初探 — uart驅動架構分析

寫在前面:

我們沒有講UART驅動,不過我們認為,隻要系統學習了第2期,應該具備分析UART驅動的能力,小編做答疑幾年以來,陸陸續續有不少人問到UART驅動怎麼寫,是以今天就分享一篇深度長文(17000字,閱讀時間43分鐘),作者是我們的答疑助手lizuobin,涉及很多資料結構,為了看懂本文,特意打開source insight 跟蹤了代碼,你也應該這樣,如果你的代碼不一樣,那或許linux版本不一樣。

作者:lizuobin

原文(有些許修正):

https://blog.csdn.net/lizuobin2/article/details/51773305

本文參考了大量牛人的部落格,對大神的分享表示由衷的感謝。

主要參考:

Linux TTY驅動–Uart_driver底層:

http://blog.csdn.net/sharecode/article/details/9196591

Linux TTY驅動–Serial Core層 :

http://blog.csdn.net/sharecode/article/details/9197567

前面學習過了 i2c、spi,這倆都是基于裝置總線驅動模型,分析起來相對比較簡單,今天打算迎難而上學習一下 Uart 驅動,因為它涉及了tty 、線路規程,确實有些難度,幸好有萬能的網際網路讓我可以學習大神們的部落格。一天下來總算有些收獲,下面總結一下(主要是架構)。

tty初探 — uart驅動架構分析

整個uart 架構大概如上圖所示,簡單來分的話可以說成兩層,一層是下層我們的序列槽驅動層,它直接與硬體接觸,我們需要填充一個 struct uart_ops 的結構體,另一層是上層 tty 層,包括 tty 核心以及線路規程,它們各自都有一個 Ops 結構,使用者空間通過 tty 注冊的字元裝置節點來通路,這麼說來如上圖所示涉及到了4個 ops 結構了,層層跳轉。下面,就來分析分析它們的層次結構。

在 s3c2440平台,它是這樣來注冊序列槽驅動的:配置設定一個struct uart_driver 簡單填充,并調用uart_register_driver 注冊到核心中去。

static struct uart_driver s3c24xx_uart_drv = {
  .owner    = THIS_MODULE,
  .dev_name  = "s3c2410_serial",
  .nr    = CONFIG_SERIAL_SAMSUNG_UARTS,
  .cons    = S3C24XX_SERIAL_CONSOLE,
  .driver_name  = S3C24XX_SERIAL_NAME,
  .major    = S3C24XX_SERIAL_MAJOR,
  .minor    = S3C24XX_SERIAL_MINOR,
};
static int __init s3c24xx_serial_modinit(void)
{
  int ret;
 
  ret = uart_register_driver(&s3c24xx_uart_drv);
  if (ret < 0) {
    printk(KERN_ERR "failed to register UART driver\n");
    return -1;
  }
 
  return 0;
}
           

uart_driver 中,我們隻是填充了一些名字、裝置号等資訊,這些都是不涉及底層硬體通路的,到底怎麼回事呢?來看一下完整的 uart_driver 結構或許就明白了。

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 */
 
  /* 下面這倆,它們應該被初始化為NULL */
  struct uart_state  *state;  <span style="white-space:pre">  </span>/* 下層,序列槽驅動層 */
  struct tty_driver  *tty_driver;  /* tty相關 */
};
           

在我們上邊填充的結構體中,有兩個成員未被指派,對于tty_driver 代表的是上層,它會在 uart_register_driver中的過程中指派,而uart_state 則代表下層,uart_state 也會在uart_register_driver的過程中配置設定空間,但是它裡面真正設定硬體相關的東西是 uart_state->uart_port ,這個uart_port 是需要我們從其它地方調用 uart_add_one_port 來添加的。

1、下層(序列槽驅動層)

首先,我們需要認識這幾個結構體

struct uart_state {
  struct tty_port    port;
  int      pm_state;
  struct circ_buf    xmit;
  struct tasklet_struct  tlet;
  struct uart_port  *uart_port;  // 對應于一個序列槽裝置
};
           

在注冊 driver 時,會根據 uart_driver->nr 來申請 nr 個 uart_state 空間,用來存放驅動所支援的序列槽(端口)的實體資訊。

struct uart_port {
  spinlock_t    lock;      /* port lock */
  unsigned long    iobase;      /* io端口基位址(實體) */
  unsigned char __iomem  *membase;    /* io記憶體基位址(虛拟) */
  unsigned int    (*serial_in)(struct uart_port *, int);
  void      (*serial_out)(struct uart_port *, int, int);
  unsigned int    irq;      /* 中斷号 */
  unsigned long    irqflags;    /* 中斷标志  */
  unsigned int    uartclk;    /* 序列槽時鐘 */
  unsigned int    fifosize;    /* 序列槽緩沖區大小 */
  unsigned char    x_char;      /* xon/xoff char */
  unsigned char    regshift;    /* 寄存器位移 */
  unsigned char    iotype;      /* IO通路方式 */
  unsigned char    unused1;
 
  unsigned int    read_status_mask;  /* 關心 Rx error status */
  unsigned int    ignore_status_mask;  /* 忽略 Rx error status */
  struct uart_state  *state;      /* pointer to parent state */
  struct uart_icount  icount;      /* 序列槽資訊計數器 */
 
  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;
 
  unsigned int    mctrl;      /* 目前的Moden 設定 */
  unsigned int    timeout;    /* character-based timeout */
  unsigned int    type;      /* 端口類型 */
  const struct uart_ops  *ops;    /* 序列槽端口操作函數 */
  unsigned int    custom_divisor;
  unsigned int    line;      /* 端口索引 */
  resource_size_t    mapbase;    /* io記憶體實體基位址 */
  struct device    *dev;      /* 父裝置 */
  unsigned char    hub6;      /* this should be in the 8250 driver */
  unsigned char    suspended;
  unsigned char    unused[2];
  void      *private_data;    /* generic platform data pointer */
};
           

這個結構體,是需要我們自己來填充的,比如s3c2440 有3個序列槽,那麼就需要填充3個 uart_port ,并且通過 uart_add_one_port 添加到 uart_driver->uart_state->uart_port 中去。當然 uart_driver 有多個 uart_state ,每個 uart_state 有一個 uart_port 。

在 uart_port 裡還有一個非常重要的成員 struct uart_ops *ops ,這個也是需要我們自己來實作的,一般晶片廠家都寫好了或者隻需要稍作修改。

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 *);/* 設定線路規程 */
  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 *);  /* 申請必要的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
};
           

實在是太複雜了。但這一層就跟裸機程式一樣,用來操作硬體寄存器,隻不過核心把“格式”給我們規定死了。

2、上層(tty 核心層)

tty 層要從 uart_register_driver來看起了,因為tty_driver是在注冊過程中建構的,我們也順便了解注冊過程。

int uart_register_driver(struct uart_driver *drv)
{
  struct tty_driver *normal = NULL;
  int i, retval;
 
 
  /* 根據driver支援的最大裝置數,申請n個 uart_state 空間,每一個 uart_state 都有一個uart_port */
  drv->state = kzalloc(sizeof(struct uart_state) * drv->nr, GFP_KERNEL);
  
  /* tty層:配置設定一個 tty_driver ,并将drv->tty_driver 指向它 */
  normal  = alloc_tty_driver(drv->nr);
  drv->tty_driver = normal;
  
  /* 對 tty_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;
  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;  /* driver->state->tty_port */
 
    tty_port_init(port);
    port->close_delay     = 500;  /* .5 seconds */
    port->closing_wait    = 30000;  /* 30 seconds */
    /* 初始化 tasklet */
    tasklet_init(&state->tlet, uart_tasklet_action,
           (unsigned long)state);
  }
  
  /* tty層:注冊 driver->tty_driver */
  retval = tty_register_driver(normal);
 
}
           

注冊過程幹了哪些事:

1、根據driver支援的最大裝置數,申請n個 uart_state 空間,每一個 uart_state 都有一個 uart_port 。

2、配置設定一個 tty_driver ,并将drv->tty_driver 指向它。

3、對 tty_driver 進行設定,其中包括預設波特率、校驗方式等,還有一個重要的

Ops ,uart_ops ,它是tty核心與我們序列槽驅動通信的接口。

4、初始化每一個 uart_state 的 tasklet 。

5、注冊 tty_driver 。

注冊 uart_driver 實際上是注冊 tty_driver,是以與使用者空間打交道的工作完全交給了 tty_driver ,而且這一部分都是核心實作好的,我們不需要修改,了解一下工作原理即可。

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,  // 當termios設定被改變時又tty核心調用
  .set_ldisc  = uart_set_ldisc,    // 設定線路規程函數
  .stop    = uart_stop,  
  .start    = uart_start,
  .hangup    = uart_hangup,    // 挂起函數,當驅動挂起tty裝置時調用
  .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,  // 獲得目前tty的線路規程的設定
  .tiocmset  = uart_tiocmset,  // 設定目前tty線路規程的設定
#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 核心的 Ops ,簡單看看,等後面分析調用關系時,在來細看,下面來看 tty_driver 的注冊。

int tty_register_driver(struct tty_driver *driver)
{
  int error;
  int i;
  dev_t dev;
  void **p = NULL;
 
  if (!(driver->flags & TTY_DRIVER_DEVPTS_MEM) && driver->num) {
    p = kzalloc(driver->num * 2 * sizeof(void *), GFP_KERNEL);
  }
  
  /* 如果沒有主裝置号則申請 */
  if (!driver->major) {
    error = alloc_chrdev_region(&dev, driver->minor_start,
            driver->num, driver->name);
  } else {
    dev = MKDEV(driver->major, driver->minor_start);
    error = register_chrdev_region(dev, driver->num, driver->name);
  }
 
  if (p) { /* 為線路規程和termios配置設定空間 */
    driver->ttys = (struct tty_struct **)p;
    driver->termios = (struct ktermios **)(p + driver->num);
  } else {
    driver->ttys = NULL;
    driver->termios = NULL;
  }
 
  /* 建立字元裝置,使用 tty_fops */
  cdev_init(&driver->cdev, &tty_fops);
  driver->cdev.owner = driver->owner;
  error = cdev_add(&driver->cdev, dev, driver->num);
 
  mutex_lock(&tty_mutex);
  
  /* 将該 driver->tty_drivers 添加到全局連結清單 tty_drivers */
  list_add(&driver->tty_drivers, &tty_drivers);
  mutex_unlock(&tty_mutex);
 
  if (!(driver->flags & TTY_DRIVER_DYNAMIC_DEV)) {
    for (i = 0; i < driver->num; i++)
        tty_register_device(driver, i, NULL);
  }
  
  /* proc 檔案系統注冊driver */
  proc_tty_register_driver(driver);
  driver->flags |= TTY_DRIVER_INSTALLED;
  return 0;
}
           

tty_driver 注冊過程幹了哪些事:

1、為線路規程和termios配置設定空間,并使 tty_driver 相應的成員指向它們。

2、注冊字元裝置,名字是 uart_driver->name 我們這裡是“ttySAC”,檔案操作函數集是 tty_fops。

3、将該 uart_driver->tty_drivers 添加到全局連結清單 tty_drivers 。

4、向 proc 檔案系統添加 driver ,這個暫時不了解。

至此,文章起初的結構圖中的4個ops已經出現了3個,另一個關于線路規程的在哪?繼續往下看。

3、調用關系分析

tty_driver 不是注冊了一個字元裝置麼,那我們就以它的 tty_fops 入手,以 open、read、write 為例,看看使用者空間是如何通路到最底層的硬體操作函數的。

3.1 tty_open

static int tty_open(struct inode *inode, struct file *filp)
{
  int ret;
 
  lock_kernel();
  ret = __tty_open(inode, filp);
  unlock_kernel();
  return ret;
}

為了友善分析,我把看不懂的代碼都删掉了。

static int __tty_open(struct inode *inode, struct file *filp)
{
  struct tty_struct *tty = NULL;
  int noctty, retval;
  struct tty_driver *driver;
  int index;
  dev_t device = inode->i_rdev;
  unsigned saved_flags = filp->f_flags;
  ...  
  //在全局tty_drivers連結清單中擷取Core注冊的tty_driver
  driver = get_tty_driver(device, &index);
  
  tty = tty_init_dev(driver, index, 0);  // tty->ops = driver->ops;
 
  filp->private_data = tty;
 
  if (tty->ops->open)
    /* 調用tty_driver->tty_foperation->open */
    retval = tty->ops->open(tty, filp);
  
  return 0;
}

從 tty_drivers 全局連結清單擷取到前邊我們注冊進去的 tty_driver ,然後配置設定設定一個 struct tty_struct 的東西,最後調用 tty_struct->ops->open 函數,其實 tty_struct->ops == tty_driver->ops 。

struct tty_struct *tty_init_dev(struct tty_driver *driver, int idx, int first_ok)
{
  struct tty_struct *tty;
  int retval;
  /* 配置設定一個 tty_struct */
  tty = alloc_tty_struct();
  
  /* 初始化 tty ,設定線路規程 Ops 等 */
  initialize_tty_struct(tty, driver, idx);
  
  //tty_ldisc_open(tty, ld)-> return ld->ops->open(tty) -> n_tty_open
  retval = tty_ldisc_setup(tty, tty->link);  
  
  return tty;
}

void initialize_tty_struct(struct tty_struct *tty,
    struct tty_driver *driver, int idx)
{
  memset(tty, 0, sizeof(struct tty_struct));
 
  /* 設定線路規程為 N_TTY */
  tty_ldisc_init(tty);//struct tty_ldisc *ld = tty_ldisc_get(N_TTY);tty_ldisc_assign(tty, ld);
 
  ...
  tty_buffer_init(tty);
  tty->driver = driver;
  
  /* 初始化等待隊列頭 */
  init_waitqueue_head(&tty->write_wait);
  init_waitqueue_head(&tty->read_wait);
  
  /* 将driver->ops 拷貝到 tty->ops  */
  tty->ops = driver->ops;
  tty->index = idx;
}


void tty_buffer_init(struct tty_struct *tty)
{
  spin_lock_init(&tty->buf.lock);
  tty->buf.head = NULL;
  tty->buf.tail = NULL;
  tty->buf.free = NULL;
  tty->buf.memory_used = 0;
  
  /* 初始化延時工作隊列 */
  INIT_DELAYED_WORK(&tty->buf.work, flush_to_ldisc);
}
           

整個 tty_open 的工作:

1、擷取 tty_driver

2、根據 tty_driver 初始化一個 tty_struct

2.1 設定 tty_struct 的線路規程為 N_TTY (不同類型的線路規程有不同的 ops)

2.2 初始化一個延時工作隊列,喚醒時調用flush_to_ldisc ,讀函數時我們需要分析它。

2.3 初始化 tty_struct 裡的兩個等待隊列頭。

2.4 設定 tty_struct->ops == tty_driver->ops 。

3、在 tty_ldisc_setup 函數中調用到線路規程的open函數,對于 N_TTY 來說是 n_tty_open 。

4、如果 tty_struct->ops 也就是 tty_driver->ops 定義了 open 函數則調用,顯然是有的 uart_open 。

對于 n_tty_open ,它應該是對線路規程如何“格式化資料”進行設定,太複雜了,忽略掉吧,跟我們沒多大關系。對于 uart_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;
 
  state = uart_get(drv, line);
  port = &state->port;  
  tty->driver_data = state;  
  state->uart_port->state = state;
  
  /* uport->ops->startup(uport) 調用到最底層的ops裡的startup 函數*/
  retval = uart_startup(state, 0);
 
}
           

根據 tty_struct 擷取到 uart_driver ,再由 uart_driver 擷取到裡面 的uart_state->uart_port->ops->startup 并調用它。至此,open函數分析完畢,它不是簡單的 “打開”,還有大量的初始化工作,最終調用到最底層的 startup 函數。

3.2 tty_write

static ssize_t tty_write(struct file *file, const char __user *buf, size_t count, loff_t *ppos)
{
  struct tty_struct *tty;
  struct inode *inode = file->f_path.dentry->d_inode;
  ssize_t ret;
  struct tty_ldisc *ld;
 
  tty = (struct tty_struct *)file->private_data;
 
  ld = tty_ldisc_ref_wait(tty);
  if (!ld->ops->write)
    ret = -EIO;
  else
    /* 調用 線路規程 n_tty_write 函數 */
    ret = do_tty_write(ld->ops->write, tty, file, buf, count);
  tty_ldisc_deref(ld);
  return ret;
}
static ssize_t n_tty_write(struct tty_struct *tty, struct file *file,
         const unsigned char *buf, size_t nr)
{
  const unsigned char *b = buf;
  DECLARE_WAITQUEUE(wait, current);
  int c;
  ssize_t retval = 0;
  // 将目前程序添加到等待隊列
  add_wait_queue(&tty->write_wait, &wait);
  while (1) {
    // 設定目前程序為可中斷的
    set_current_state(TASK_INTERRUPTIBLE);
    if (signal_pending(current)) {
      retval = -ERESTARTSYS;
      break;
    }
    if (tty_hung_up_p(file) || (tty->link && !tty->link->count)) {
      retval = -EIO;
      break;
    }
    /* 自行定義了輸出方式 */
    if (O_OPOST(tty) && !(test_bit(TTY_HW_COOK_OUT, &tty->flags))) {
      ....
    } else {
      while (nr > 0) {
        /* 調用到 uart_write */
        c = tty->ops->write(tty, b, nr);
        if (c < 0) {
          retval = c;
          goto break_out;
        }
        if (!c)
          break;
        b += c;
        nr -= c;
      }
    }
    if (!nr)
      break;
    if (file->f_flags & O_NONBLOCK) {
      retval = -EAGAIN;
      break;
    }
    // 程序排程 開始休眠
    schedule();
  }
}
           

n_tty_write 調用 tty->ops->write 也就是 uart_write。

static int uart_write(struct tty_struct *tty, const unsigned char *buf, int count)
{
  uart_start(tty);
  return ret;
}
 
static void uart_start(struct tty_struct *tty)
{
  __uart_start(tty);  
}
 
static void __uart_start(struct tty_struct *tty)
{
  struct uart_state *state = tty->driver_data;
  struct uart_port *port = state->uart_port;
 
  if (!uart_circ_empty(&state->xmit) && state->xmit.buf &&
      !tty->stopped && !tty->hw_stopped)
    /* 調用到最底層的 start_tx */
    port->ops->start_tx(port);
}
           

uart_write 又調用到了最底層的 uart_port->ops->start_tx 函數。

猜測一下,大概“寫”的思路:

1、将目前程序加入到等待隊列

2、設定目前程序為可打斷的

3、層層調用最終調用到底層的 start_tx 函數,将要發送的資料存入 DATA 寄存器,由硬體自動發送。

4、程序排程,目前程序進入休眠。

5、硬體發送完成,進入中斷處理函數,喚醒對面隊列。

當然這隻是我自己的猜測,到底是不是這樣,具體分析底層操作函數的時候應該會明白。

3.3 tty_read

static ssize_t tty_read(struct file *file, char __user *buf, size_t count,
      loff_t *ppos)
{
  int i;
  struct tty_struct *tty;
  struct inode *inode;
  struct tty_ldisc *ld;
 
  tty = (struct tty_struct *)file->private_data;
  inode = file->f_path.dentry->d_inode;
 
  
  ld = tty_ldisc_ref_wait(tty);
  /* 調用線路規程 n_tty_read */
  if (ld->ops->read)
    i = (ld->ops->read)(tty, file, buf, count);
  else
    i = -EIO;
  tty_ldisc_deref(ld);
  if (i > 0)
    inode->i_atime = current_fs_time(inode->i_sb);
  return i;
}
           

調用線路規程的 read 函數,對于 N_TTY 來說是 n_tty_read (删掉了一堆看不懂的代碼,還是有很多)

static ssize_t n_tty_read(struct tty_struct *tty, struct file *file,
       unsigned char __user *buf, size_t nr)
{
  unsigned char __user *b = buf;
  DECLARE_WAITQUEUE(wait, current);
  int c;
  int minimum, time;
  ssize_t retval = 0;
  ssize_t size;
  long timeout;
  unsigned long flags;
  int packet;
 
do_it_again:
 
  BUG_ON(!tty->read_buf);
 
  c = job_control(tty, file);
 
  minimum = time = 0;
  timeout = MAX_SCHEDULE_TIMEOUT;
  /* 如果是非标準模式 */
  if (!tty->icanon) {
    ...
  }
 
  packet = tty->packet;
 
  add_wait_queue(&tty->read_wait, &wait);
  while (nr) {
    /* First test for status change. */
    if (packet && tty->link->ctrl_status) {
      /* 看不懂的都删掉 */
    }
    /* This statement must be first before checking for input
       so that any interrupt will set the state back to
       TASK_RUNNING. */
    set_current_state(TASK_INTERRUPTIBLE);
 
    if (((minimum - (b - buf)) < tty->minimum_to_wake) &&
        ((minimum - (b - buf)) >= 1))
      tty->minimum_to_wake = (minimum - (b - buf));
 
    if (!input_available_p(tty, 0)) {
      /* 看不懂的都删掉 */
      
      /* FIXME: does n_tty_set_room need locking ? */
      n_tty_set_room(tty);
      /* 程序排程 休眠 */
      timeout = schedule_timeout(timeout);
      continue;
    }
    __set_current_state(TASK_RUNNING);
 
    /* Deal with packet mode. */
    if (packet && b == buf) {
      /* 看不懂的都删掉 */
    }
    
    /* 如果是标準模式 */
    if (tty->icanon) {
      /* N.B. avoid overrun if nr == 0 */
      while (nr && tty->read_cnt) {
        int eol;
 
        eol = test_and_clear_bit(tty->read_tail,
            tty->read_flags);
        
        /* 從tty->read_buf 擷取資料 */
        c = tty->read_buf[tty->read_tail];
        spin_lock_irqsave(&tty->read_lock, flags);
        tty->read_tail = ((tty->read_tail+1) &
              (N_TTY_BUF_SIZE-1));
        tty->read_cnt--;
        if (eol) {
          /* this test should be redundant:
           * we shouldn't be reading data if
           * canon_data is 0
           */
          if (--tty->canon_data < 0)
            tty->canon_data = 0;
        }
        spin_unlock_irqrestore(&tty->read_lock, flags);
 
        if (!eol || (c != __DISABLED_CHAR)) {
          /* 将資料拷貝到使用者空間 */
          if (tty_put_user(tty, c, b++)) {
            retval = -EFAULT;
            b--;
            break;
          }
          nr--;
        }
        if (eol) {
          tty_audit_push(tty);
          break;
        }
      }
      if (retval)
        break;
    } else {
      /* 非标準模式不關心删掉 */
    }
    ....
  }
  mutex_unlock(&tty->atomic_read_lock);
  remove_wait_queue(&tty->read_wait, &wait);
 
  if (!waitqueue_active(&tty->read_wait))
    tty->minimum_to_wake = minimum;
 
  __set_current_state(TASK_RUNNING);
  ...
  n_tty_set_room(tty);
  return retval;
}
           

“讀”過程幹了哪些事:

1、将目前程序加入等待隊列

2、設定目前程序可中斷

3、程序排程,目前程序進入休眠

4、在某處被喚醒

5、從 tty->read_buf 取出資料,通過 tty_put_user 拷貝到使用者空間。

那麼,在何處喚醒,猜測應該是在中斷處理函數中,當DATA寄存器滿,觸發中斷,中斷處理函數中調用 tty_flip_buffer_push 。

void tty_flip_buffer_push(struct tty_struct *tty)
{
  unsigned long flags;
  spin_lock_irqsave(&tty->buf.lock, flags);
  if (tty->buf.tail != NULL)
    tty->buf.tail->commit = tty->buf.tail->used;
  spin_unlock_irqrestore(&tty->buf.lock, flags);
 
  if (tty->low_latency)
    flush_to_ldisc(&tty->buf.work.work);
  else
    schedule_delayed_work(&tty->buf.work, 1);
}
           

tty_flip_buffer_push 有兩種方式調用到 flush_to_ldisc ,一種直接調用,另一種使用延時工作隊列,在很久很久以前,我們初始化了這麼一個工作隊列~(tty_open 初始化 tty_struct 時前面有提到)。

在flush_to_ldisc 會調用到 disc->ops->receive_buf ,對于 N_TTY 來說是 n_tty_receive_buf ,在 n_tty_receive_buf 中,将資料拷貝到 tty->read_buf ,然後 wake_up_interruptible(&tty->read_wait) 喚醒休眠隊列。

然後就是前面提到的,在n_tty_read 函數中 從 tty->read_buf 裡取出資料拷貝到使用者空間了。

tty初探 — uart驅動架構分析

至此,關于 uart 的架構分析基本就結束了, 對于 tty 以及線路規程是什麼東西,大概了解是個什麼東西。雖然大部分東西都不需要我們自己實作,但是了解它們有益無害。

下一篇文章–以 s3c2440 為例,分析底層的操作函數,以及 s3c2440 是如何初始化 uart_port 結構的,,這些是在移植驅動過程中需要做的工作~

--END--
           

關注公衆号百問科技(ID:baiwenkeji)第一時間學習嵌入式幹貨。

技術交流加個人威信13266630429,驗證: CSDN