【驱动】串口驱动分析（三）-serial driver

struct uart_driver {
 struct module  *owner;
 const char  *driver_name;
 const char  *dev_name;
 int    major;
 int    minor;
 int    nr;
 struct console  *cons;

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

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);
 void   (*set_mctrl)(struct uart_port *, unsigned int);
 int   (*startup)(struct uart_port *port);
 void   (*shutdown)(struct uart_port *port);
 void   (*throttle)(struct uart_port *port);
 void   (*unthrottle)(struct uart_port *port);
 int   (*handle_irq)(struct uart_port *);
 void   (*pm)(struct uart_port *, unsigned int state,
          unsigned int old);
 void   (*handle_break)(struct uart_port *);
 int   (*rs485_config)(struct uart_port *,
      struct serial_rs485 *rs485);
 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;

 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 */
 /* flags must be updated while holding port mutex */
 upf_t   flags;
 /*
  * Must hold termios_rwsem, port mutex and port lock to change;
  * can hold any one lock to read.
  */
 upstat_t  status;

 int   hw_stopped;  /* sw-assisted CTS flow state */
 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 */
 unsigned int  minor;
 resource_size_t  mapbase;  /* for ioremap */
 resource_size_t  mapsize;
 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];
 struct attribute_group *attr_group;  /* port specific attributes */
 const struct attribute_group **tty_groups; /* all attributes (serial core use only) */
 struct serial_rs485     rs485;
 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 *, struct ktermios *);
 void  (*pm)(struct uart_port *, unsigned int state,
         unsigned int oldstate);
 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 *);

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

struct uart_state {
 struct tty_port  port;

 enum uart_pm_state pm_state;
 struct circ_buf  xmit;

 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);
 if (!drv->state)
  goto out;

 normal = alloc_tty_driver(drv->nr);
 if (!normal)
  goto out_kfree;

 drv->tty_driver = normal;

 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;

  tty_port_init(port);
  port->ops = &uart_port_ops;
 }

 retval = tty_register_driver(normal);
 if (retval >= 0)
  return retval;

 for (i = 0; i < drv->nr; i++)
  tty_port_destroy(&drv->state[i].port);
 put_tty_driver(normal);
out_kfree:
 kfree(drv->state);
out:
 return -ENOMEM;
}

/**
 * uart_unregister_driver - remove a driver from the uart core layer
 * @drv: low level driver structure
 *
 * Remove all references to a driver from the core driver.  The low
 * level driver must have removed all its ports via the
 * uart_remove_one_port() if it registered them with uart_add_one_port().
 * (ie, drv->port == NULL)
 */
void uart_unregister_driver(struct uart_driver *drv)
{
 struct tty_driver *p = drv->tty_driver;
 unsigned int i;
 /*获取与该驱动程序关联的 tty_driver 实例*/
 tty_unregister_driver(p);
    
    /*取消注册驱动程序，将它与系统中的 tty 设备断开关联*/
 put_tty_driver(p);
    
    /*释放该 tty_driver 实例，如果此时该实例的使用计数为零，即没有其他模块在使用该实例，那么它将会被完全卸载并释放所有内存资源*/
 for (i = 0; i < drv->nr; i++)
  tty_port_destroy(&drv->state[i].port);
 kfree(drv->state);
 drv->state = NULL;
 drv->tty_driver = NULL;
}

/**
 * uart_add_one_port - attach a driver-defined port structure
 * @drv: pointer to the uart low level driver structure for this port
 * @uport: uart port structure to use for this port.
 *
 * This allows the driver to register its own uart_port structure
 * with the core driver.  The main purpose is to allow the low
 * level uart drivers to expand uart_port, rather than having yet
 * more levels of structures.
 */
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;
 int num_groups;
 
    /*检查是否在中断上下文中，如果是则直接返回错误*/
 BUG_ON(in_interrupt());
    
 /*检查所添加的端口是否超出驱动程序支持的范围，如果是则返回EINVAL*/
 if (uport->line >= drv->nr)
  return -EINVAL;
 
    /*获取该端口所对应的状态信息（uart_state）以及端口（tty_port）*/
 state = drv->state + uport->line;
 port = &state->port;

 mutex_lock(&port_mutex);
 mutex_lock(&port->mutex);
    
    /*检查端口是否已经被其他设备占用，如果是则返回EINVAL*/
 if (state->uart_port) {
  ret = -EINVAL;
  goto out;
 }

 /* 链接端口和驱动程序状态表，并进行相应的初始化工作，包括PM状态、控制台、spinlock等 */
 state->uart_port = uport;
 uport->state = state;

 state->pm_state = UART_PM_STATE_UNDEFINED;
 uport->cons = drv->cons;
 uport->minor = drv->tty_driver->minor_start + uport->line;

 /*
  * If this port is a console, then the spinlock is already
  * initialised.
  */
 if (!(uart_console(uport) && (uport->cons->flags & CON_ENABLED))) {
  spin_lock_init(&uport->lock);
  lockdep_set_class(&uport->lock, &port_lock_key);
 }
 if (uport->cons && uport->dev)
  of_console_check(uport->dev->of_node, uport->cons->name, uport->line);
 
    /*配置端口的属性，例如波特率、数据位、停止位等*/
 uart_configure_port(drv, state, uport);

 num_groups = 2;
 if (uport->attr_group)
  num_groups++;
    
 /*分配并设置TTY设备属性组，这些属性组包括TTY设备通用属性组和用户自定义属性组*/
 uport->tty_groups = kcalloc(num_groups, sizeof(*uport->tty_groups),
        GFP_KERNEL);
 if (!uport->tty_groups) {
  ret = -ENOMEM;
  goto out;
 }
 uport->tty_groups[0] = &tty_dev_attr_group;
 if (uport->attr_group)
  uport->tty_groups[1] = uport->attr_group;

 /*注册TTY端口设备，并将其与tty_driver和tty_port关联起来*/
 tty_dev = tty_port_register_device_attr(port, drv->tty_driver,
   uport->line, uport->dev, port, uport->tty_groups);
    /*如果注册成功，将该设备标记为可唤醒*/
 if (likely(!IS_ERR(tty_dev))) {
  device_set_wakeup_capable(tty_dev, 1);
 } else {
  dev_err(uport->dev, "Cannot register tty device on line %d\n",
         uport->line);
 }

 /*
  * Ensure UPF_DEAD is not set.
  */
 uport->flags &= ~UPF_DEAD;
 
 out:
 mutex_unlock(&port->mutex);
 mutex_unlock(&port_mutex);

 return ret;
}

/**
 * uart_remove_one_port - detach a driver defined port structure
 * @drv: pointer to the uart low level driver structure for this port
 * @uport: uart port structure for this port
 *
 * This unhooks (and hangs up) the specified port structure from the
 * core driver.  No further calls will be made to the low-level code
 * for this port.
 */
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;
 struct tty_struct *tty;
 int ret = 0;
    
 /*检查当前是否处于中断上下文中*/
 BUG_ON(in_interrupt());
 
    /*检查uart状态结构中的uart端口指针是否等于传递给该函数的uart端口指针，如果不是则打印一条错误消息*/
 if (state->uart_port != uport)
  dev_alert(uport->dev, "Removing wrong port: %p != %p\n",
   state->uart_port, uport);
    
 /*获取tty端口结构的互斥锁，该锁用于防止并发修改端口状态*/
 mutex_lock(&port_mutex);

 /*获取tty端口结构的互斥锁，然后检查uart端口指针是否为空。如果为空，则表示当前端口已被删除。在这种情况下，将返回-EINVAL并解锁互斥锁 */
 mutex_lock(&port->mutex);
 if (!state->uart_port) {
  mutex_unlock(&port->mutex);
  ret = -EINVAL;
  goto out;
 }
    /*锁定 port->mutex 互斥锁，并将 uport->flags 设置为 UPF_DEAD，表示该端口已经被关闭。之后解锁 port->mutex。*/
 uport->flags |= UPF_DEAD;
 mutex_unlock(&port->mutex);

 /*从tty层中删除设备*/
 tty_unregister_device(drv->tty_driver, uport->line);
    
 /*获取 tty 设备对应的 tty 结构体，并使用 tty_vhangup() 函数关闭该 tty 设备的控制终端。最后，使用 tty_kref_put() 函数释放 tty 结构体的引用计数。*/
 tty = tty_port_tty_get(port);
 if (tty) {
  tty_vhangup(port->tty);
  tty_kref_put(tty);
 }

 /*如果该端口用作控制台，则使用 unregister_console() 函数取消该端口的控制台注册*/
 if (uart_console(uport))
  unregister_console(uport->cons);

 /*根据 uport->type 的值来释放端口的 IO 和内存资源，如果 uport->type 的值为 PORT_UNKNOWN，则表示没有对应的资源需要释放*/
 if (uport->type != PORT_UNKNOWN)
  uport->ops->release_port(uport);
 kfree(uport->tty_groups);

 /*将 uport->type 的值设置为 PORT_UNKNOWN，表示该端口不再存在。同时将 state->uart_port 设置为 NULL，表示 state 对应的端口不再与 uport 相关联。*/
 uport->type = PORT_UNKNOWN;

 state->uart_port = NULL;
out:
 mutex_unlock(&port_mutex);

 return ret;
}

/*
 * This routine is used by the interrupt handler to schedule processing in
 * the software interrupt portion of the driver.
 */
void uart_write_wakeup(struct uart_port *port)
{
 struct uart_state *state = port->state;
 /*
  * This means you called this function _after_ the port was
  * closed.  No cookie for you.
  */
 BUG_ON(!state);
    /*函数唤醒与state->port相关联的终端。*/
 tty_wakeup(state->port.tty);
}

int uart_suspend_port(struct uart_driver *drv, struct uart_port *uport)
{
 struct uart_state *state = drv->state + uport->line;
 struct tty_port *port = &state->port;
 struct device *tty_dev;
 struct uart_match match = {uport, drv};
    
 /*给port加锁，以确保在执行其他操作时不会发生竞争条件*/
 mutex_lock(&port->mutex);
 
    /*查找与uport->dev相关联的子设备。它使用match结构体和serial_match_port函数来匹配子设备*/
 tty_dev = device_find_child(uport->dev, &match, serial_match_port);
    /*如果找到了子设备并且该设备可以唤醒系统，则将uport->irq设置为唤醒中断，并将uport->irq_wake设置为1。然后，释放tty_dev并解锁port的互斥锁，并返回0*/
 if (device_may_wakeup(tty_dev)) {
  if (!enable_irq_wake(uport->irq))
   uport->irq_wake = 1;
  put_device(tty_dev);
  mutex_unlock(&port->mutex);
  return 0;
 }
    /*如果找到了子设备但该设备不能唤醒系统，则释放tty_dev*/
 put_device(tty_dev);

 /* Nothing to do if the console is not suspending */
    /*如果控制台未启用挂起并且uport是控制台，则跳转到unlock解锁*/
 if (!console_suspend_enabled && uart_console(uport))
  goto unlock;
 
    /*将uport->suspended设置为1，表示端口已挂起。*/
 uport->suspended = 1;
 
    /*如果端口已初始化，则执行一些操作以停止传输并关闭端口。这些操作包括设置ASYNCB_SUSPENDED和清除ASYNCB_INITIALIZED标志，停止发送和接收数据，等待发送缓冲区为空，关闭端口*/
 if (port->flags & ASYNC_INITIALIZED) {
  const struct uart_ops *ops = uport->ops;
  int tries;

  set_bit(ASYNCB_SUSPENDED, &port->flags);
  clear_bit(ASYNCB_INITIALIZED, &port->flags);

  spin_lock_irq(&uport->lock);
  ops->stop_tx(uport);
  ops->set_mctrl(uport, 0);
  ops->stop_rx(uport);
  spin_unlock_irq(&uport->lock);

  /*
   * Wait for the transmitter to empty.
   */
  for (tries = 3; !ops->tx_empty(uport) && tries; tries--)
   msleep(10);
  if (!tries)
   dev_err(uport->dev, "%s%d: Unable to drain transmitter\n",
    drv->dev_name,
    drv->tty_driver->name_base + uport->line);

  ops->shutdown(uport);
 }

 /*
  * Disable the console device before suspending.
  */
    /* */
     /*如果uport是控制台，则停止控制台*/
 if (uart_console(uport))
  console_stop(uport->cons);
 /*调用uart_change_pm函数以更改端口的电源管理状态为UART_PM_STATE_OFF*/
 uart_change_pm(state, UART_PM_STATE_OFF);
unlock:
 mutex_unlock(&port->mutex);

 return 0;
}

int uart_resume_port(struct uart_driver *drv, struct uart_port *uport)
{
 struct uart_state *state = drv->state + uport->line;
 struct tty_port *port = &state->port;
 struct device *tty_dev;
 struct uart_match match = {uport, drv};
 struct ktermios termios;

 mutex_lock(&port->mutex);
 
    /*使用device_find_child搜索与名为match的struct uart_match匹配的uport->dev的子设备*/
 tty_dev = device_find_child(uport->dev, &match, serial_match_port);
    
    /*如果找到设备并且端口未挂起并且设备可以唤醒，则函数禁用IRQ唤醒并返回0*/
 if (!uport->suspended && device_may_wakeup(tty_dev)) {
  if (uport->irq_wake) {
   disable_irq_wake(uport->irq);
   uport->irq_wake = 0;
  }
  put_device(tty_dev);
  mutex_unlock(&port->mutex);
  return 0;
 }
    
    /*函数将uport->suspended设置为0*/
 put_device(tty_dev);
 uport->suspended = 0;

 /*
  * Re-enable the console device after suspending.
  */
    /*如果端口是控制台端口，则函数将termios结构设置为控制台cflag设置*/
 if (uart_console(uport)) {
  /*
   * First try to use the console cflag setting.
   */
  memset(&termios, 0, sizeof(struct ktermios));
  termios.c_cflag = uport->cons->cflag;

  /*
   * If that's unset, use the tty termios setting.
   */
  if (port->tty && termios.c_cflag == 0)
   termios = port->tty->termios;
  /*如果启用了控制台挂起，则函数使用uart_change_pm将电源管理状态更改为打开状态，使用uport->ops->set_termios设置termios，并使用console_start启动控制台*/
  if (console_suspend_enabled)
   uart_change_pm(state, UART_PM_STATE_ON);
  uport->ops->set_termios(uport, &termios, NULL);
  if (console_suspend_enabled)
   console_start(uport->cons);
 }

 if (port->flags & ASYNC_SUSPENDED) {
  const struct uart_ops *ops = uport->ops;
  int ret;
 /*如果端口已挂起，则函数使用uart_change_pm将电源管理状态更改为打开状态*/
  uart_change_pm(state, UART_PM_STATE_ON);
  spin_lock_irq(&uport->lock);
        /*使用ops->set_mctrl将调制解调器控制线设置为0*/
  ops->set_mctrl(uport, 0);
  spin_unlock_irq(&uport->lock);
  if (console_suspend_enabled || !uart_console(uport)) {
   /* Protected by port mutex for now */
   struct tty_struct *tty = port->tty;
            /*使用ops->startup启动端口*/
   ret = ops->startup(uport);
   if (ret == 0) {
            /*如果端口成功启动，则使用uart_change_speed更改端口速度，使用ops->start_tx启动传输，并在port->flags中设置ASYNCB_INITIALIZED位*/
    if (tty)
     uart_change_speed(tty, state, NULL);
    spin_lock_irq(&uport->lock);
    ops->set_mctrl(uport, uport->mctrl);
                
    ops->start_tx(uport);
    spin_unlock_irq(&uport->lock);
    set_bit(ASYNCB_INITIALIZED, &port->flags);
   } else {
    /*
     * Failed to resume - maybe hardware went away?
     * Clear the "initialized" flag so we won't try
     * to call the low level drivers shutdown method.
     */
                /*如果端口无法恢复，则函数清除ASYNCB_INITIALIZED位并调用uart_shutdown*/
    uart_shutdown(tty, state);
   }
  }

  clear_bit(ASYNCB_SUSPENDED, &port->flags);
 }

 mutex_unlock(&port->mutex);

 return 0;
}

/**
 * uart_get_baud_rate - return baud rate for a particular port
 * @port: uart_port structure describing the port in question.
 * @termios: desired termios settings.
 * @old: old termios (or NULL)
 * @min: minimum acceptable baud rate
 * @max: maximum acceptable baud rate
 *
 * Decode the termios structure into a numeric baud rate,
 * taking account of the magic 38400 baud rate (with spd_*
 * flags), and mapping the %B0 rate to 9600 baud.
 *
 * If the new baud rate is invalid, try the old termios setting.
 * If it's still invalid, we try 9600 baud.
 *
 * Update the @termios structure to reflect the baud rate
 * we're actually going to be using. Don't do this for the case
 * where B0 is requested ("hang up").
 */
unsigned int
uart_get_baud_rate(struct uart_port *port, struct ktermios *termios,
     struct ktermios *old, unsigned int min, unsigned int max)
{
 unsigned int try;
 unsigned int baud;
 unsigned int altbaud;
 int hung_up = 0;
 upf_t flags = port->flags & UPF_SPD_MASK;
 
 switch (flags) {
 case UPF_SPD_HI:
  altbaud = 57600;
  break;
 case UPF_SPD_VHI:
  altbaud = 115200;
  break;
 case UPF_SPD_SHI:
  altbaud = 230400;
  break;
 case UPF_SPD_WARP:
  altbaud = 460800;
  break;
 default:
  altbaud = 38400;
  break;
 }

 for (try = 0; try < 2; try++) {
  baud = tty_termios_baud_rate(termios);

  /*
   * The spd_hi, spd_vhi, spd_shi, spd_warp kludge...
   * Die! Die! Die!
   */
  if (try == 0 && baud == 38400)
   baud = altbaud;

  /*
   * Special case: B0 rate.
   */
  if (baud == 0) {
   hung_up = 1;
   baud = 9600;
  }

  if (baud >= min && baud <= max)
   return baud;

  /*
   * Oops, the quotient was zero.  Try again with
   * the old baud rate if possible.
   */
  termios->c_cflag &= ~CBAUD;
  if (old) {
   baud = tty_termios_baud_rate(old);
   if (!hung_up)
    tty_termios_encode_baud_rate(termios,
        baud, baud);
   old = NULL;
   continue;
  }

  /*
   * As a last resort, if the range cannot be met then clip to
   * the nearest chip supported rate.
   */
  if (!hung_up) {
   if (baud <= min)
    tty_termios_encode_baud_rate(termios,
       min + 1, min + 1);
   else
    tty_termios_encode_baud_rate(termios,
       max - 1, max - 1);
  }
 }
 /* Should never happen */
 WARN_ON(1);
 return 0;
}

/**
 * uart_get_divisor - return uart clock divisor
 * @port: uart_port structure describing the port.
 * @baud: desired baud rate
 *
 * Calculate the uart clock divisor for the port.
 */
unsigned int
uart_get_divisor(struct uart_port *port, unsigned int baud)
{
 unsigned int quot;

 /*
  * Old custom speed handling.
  */
 if (baud == 38400 && (port->flags & UPF_SPD_MASK) == UPF_SPD_CUST)
  quot = port->custom_divisor;
 else
  quot = DIV_ROUND_CLOSEST(port->uartclk, 16 * baud);

 return quot;
}

/**
 * uart_update_timeout - update per-port FIFO timeout.
 * @port:  uart_port structure describing the port
 * @cflag: termios cflag value
 * @baud:  speed of the port
 *
 * Set the port FIFO timeout value.  The @cflag value should
 * reflect the actual hardware settings.
 */
void
uart_update_timeout(struct uart_port *port, unsigned int cflag,
      unsigned int baud)
{
 unsigned int bits;

 /* byte size and parity */
 switch (cflag & CSIZE) {
 case CS5:
  bits = 7;
  break;
 case CS6:
  bits = 8;
  break;
 case CS7:
  bits = 9;
  break;
 default:
  bits = 10;
  break; /* CS8 */
 }

 if (cflag & CSTOPB)
  bits++;
 if (cflag & PARENB)
  bits++;

 /*
  * The total number of bits to be transmitted in the fifo.
  */
 bits = bits * port->fifosize;

 /*
  * Figure the timeout to send the above number of bits.
  * Add .02 seconds of slop
  */
 port->timeout = (HZ * bits) / baud + HZ/50;
}

/*
 * Are the two ports equivalent?
 */
int uart_match_port(struct uart_port *port1, struct uart_port *port2)
{
 if (port1->iotype != port2->iotype)
  return 0;

 switch (port1->iotype) {
 case UPIO_PORT:
  return (port1->iobase == port2->iobase);
 case UPIO_HUB6:
  return (port1->iobase == port2->iobase) &&
         (port1->hub6   == port2->hub6);
 case UPIO_MEM:
 case UPIO_MEM32:
 case UPIO_MEM32BE:
 case UPIO_AU:
 case UPIO_TSI:
  return (port1->mapbase == port2->mapbase);
 }
 return 0;
}

/**
 * uart_console_write - write a console message to a serial port
 * @port: the port to write the message
 * @s: array of characters
 * @count: number of characters in string to write
 * @putchar: function to write character to port
 */
void uart_console_write(struct uart_port *port, const char *s,
   unsigned int count,
   void (*putchar)(struct uart_port *, int))
{
 unsigned int i;

 for (i = 0; i < count; i++, s++) {
  if (*s == '\n')
   putchar(port, '\r');
  putchar(port, *s);
 }
}

tty_set_operations(normal, &uart_ops);

void tty_set_operations(struct tty_driver *driver,const struct tty_operations *op)

{
 driver->ops = op;
};
EXPORT_SYMBOL(tty_set_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_show = uart_proc_show,
#endif
 .tiocmget = uart_tiocmget,
 .tiocmset = uart_tiocmset,
 .set_serial = uart_set_info_user,
 .get_serial = uart_get_info_user,
 .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
};