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, консоль, спин-блокировку и т. д. */
 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};
    
 /*Блокируем порт, чтобы гарантировать, что условия гонки не возникнут при выполнении других операций*/
 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 и разблокируйте мьютекс порта.,и возвращает 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 */
    /*Если консоль не включает приостановку и обновление консоли, перейдите к разблокировке*/
 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.
  */
    /* */
     /*Если консоль отключена, остановите консоль*/
 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 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структураустановлен настройки флага консоли*/
 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
};