linux serial构架分析及驱动开发（4）

      在uart_register_driver函数中有这样的一个函数：tty_set_operations（normal,&uart_ops）,这个uart_ops就是tty_operations函数集，这里是串口操作的公用函数接口，本节及后面章节将结合串口操作的流程，来介绍上面的操作函数。

 

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

 

当用户程序调用open函数打开串口设备首先执行tty_open（前面tty分析中已经介绍过），tty_open中tty->ops->open即是串口核心中对应的uart_open函数。

 

/*
 * calls to uart_open are serialised by the BKL in
 *   fs/char_dev.c:chrdev_open()
 * Note that if this fails, then uart_close() _will_ be called.
 *
 * In time, we want to scrap the "opening nonpresent ports"
 * behaviour and implement an alternative way for setserial
 * to set base addresses/ports/types.  This will allow us to
 * get rid of a certain amount of extra tests.
 */
static int uart_open(struct tty_struct *tty, struct file *filp)
{

//先前在uart_register_driver中已经让tty_driver->driver_state指向uart_driver;我们知道tty_driver是用tty_drivers链表来

//管理的,而uart_driver只是tty_driver的一个扩展，因此也是保存在此链表中
 struct uart_driver *drv = (struct uart_driver *)tty->driver->driver_state;
 struct uart_state *state;
 int retval, line = tty->index; //设备索引

 BUG_ON(!kernel_locked());
 pr_debug("uart_open(%d) called/n", line);

 /*
  * tty->driver->num won't change, so we won't fail here with
  * tty->driver_data set to something non-NULL (and therefore
  * we won't get caught by uart_close()).
  */
 retval = -ENODEV;
 if (line >= tty->driver->num)
  goto fail;

 /*
  * We take the semaphore inside uart_get to guarantee that we won't
  * be re-entered while allocating the info structure, or while we
  * request any IRQs that the driver may need.  This also has the nice
  * side-effect that it delays the action of uart_hangup, so we can
  * guarantee that info->port.tty will always contain something reasonable.
  */

//当串口打开时必然已经调用uart_add_one_port将uart_port和uart_driver绑定，因此这里我们就要分配一个uart_info并作

//相应的初始化来表示一个打开的串口设备uart_get函数就做相应的操作

 state = uart_get(drv, line);
 if (IS_ERR(state)) {
  retval = PTR_ERR(state);
  goto fail;
 }

 /*
  * Once we set tty->driver_data here, we are guaranteed that
  * uart_close() will decrement the driver module use count.
  * Any failures from here onwards should not touch the count.
  */
 tty->driver_data = state; //注意这里的赋值，以后的操作需要
 state->port->info = &state->info;

//后面是否用工作队列操作的需要
 tty->low_latency = (state->port->flags & UPF_LOW_LATENCY) ? 1 : 0;
 tty->alt_speed = 0;
 state->info.port.tty = tty;

 /*
  * If the port is in the middle of closing, bail out now.
  */
 if (tty_hung_up_p(filp)) {
  retval = -EAGAIN;
  state->count--;
  mutex_unlock(&state->mutex);
  goto fail;
 }

 /*
  * Make sure the device is in D0 state.
  */
 if (state->count == 1)
  uart_change_pm(state, 0);  //使设备处于初始电源状态

 /*
  * Start up the serial port.
  */

//是串口处于工作状态，下面具体分析该函数
 retval = uart_startup(state, 0);

 /*
  * If we succeeded, wait until the port is ready.
  */

 //等待串口设备就绪，主要是针对不同进程操作同一设备情况的处理
 if (retval == 0)
  retval = uart_block_til_ready(filp, state);

 mutex_unlock(&state->mutex);

 /*
  * If this is the first open to succeed, adjust things to suit.
  */
 if (retval == 0 && !(state->info.flags & UIF_NORMAL_ACTIVE)) {
  state->info.flags |= UIF_NORMAL_ACTIVE;

  uart_update_termios(state);
 }

 fail:
 return retval;
}

 

 ///

/*
 * Startup the port.  This will be called once per open.  All calls
 * will be serialised by the per-port mutex.
 */
static int uart_startup(struct uart_state *state, int init_hw)
{
 struct uart_info *info = &state->info;
 struct uart_port *port = state->port;
 unsigned long page;
 int retval = 0;

 if (info->flags & UIF_INITIALIZED) //设备已经初始化完成
  return 0;

 /*
  * Set the TTY IO error marker - we will only clear this
  * once we have successfully opened the port.  Also set
  * up the tty->alt_speed kludge
  */
 set_bit(TTY_IO_ERROR, &info->port.tty->flags); //设备未完成初始化好时设置标志，后面初始化好后清除标志

 if (port->type == PORT_UNKNOWN)
  return 0;

 /*
  * Initialise and allocate the transmit and temporary
  * buffer.
  */

//为串口分配环形缓存并初始化
 if (!info->xmit.buf) {
  /* This is protected by the per port mutex */
  page = get_zeroed_page(GFP_KERNEL);
  if (!page)
   return -ENOMEM;

  info->xmit.buf = (unsigned char *) page;
  uart_circ_clear(&info->xmit);
 }

 retval = port->ops->startup(port);//启动串口
 if (retval == 0) {
  if (init_hw) {
   /*
    * Initialise the hardware port settings.
    */
   uart_change_speed(state, NULL);

   /*
    * Setup the RTS and DTR signals once the
    * port is open and ready to respond.
    */
   if (info->port.tty->termios->c_cflag & CBAUD)
    uart_set_mctrl(port, TIOCM_RTS | TIOCM_DTR);
  }

  if (info->flags & UIF_CTS_FLOW) {
   spin_lock_irq(&port->lock);
   if (!(port->ops->get_mctrl(port) & TIOCM_CTS))
    info->port.tty->hw_stopped = 1;
   spin_unlock_irq(&port->lock);
  }

  info->flags |= UIF_INITIALIZED;

  clear_bit(TTY_IO_ERROR, &info->port.tty->flags);
 }

 if (retval && capable(CAP_SYS_ADMIN))
  retval = 0;

 return retval;
}