【驱动】串口驱动分析(二)-tty core

/*
 * Ok, now we can initialize the rest of the tty devices and can count
 * on memory allocations, interrupts etc..
 */
int __init tty_init(void)
{
 tty_sysctl_init();
 cdev_init(&tty_cdev, &tty_fops);
 if (cdev_add(&tty_cdev, MKDEV(TTYAUX_MAJOR, 0), 1) ||
     register_chrdev_region(MKDEV(TTYAUX_MAJOR, 0), 1, "/dev/tty") < 0)
  panic("Couldn't register /dev/tty driver\n");
 device_create(tty_class, NULL, MKDEV(TTYAUX_MAJOR, 0), NULL, "tty");

 cdev_init(&console_cdev, &console_fops);
 if (cdev_add(&console_cdev, MKDEV(TTYAUX_MAJOR, 1), 1) ||
     register_chrdev_region(MKDEV(TTYAUX_MAJOR, 1), 1, "/dev/console") < 0)
  panic("Couldn't register /dev/console driver\n");
 consdev = device_create_with_groups(tty_class, NULL,
         MKDEV(TTYAUX_MAJOR, 1), NULL,
         cons_dev_groups, "console");
 if (IS_ERR(consdev))
  consdev = NULL;

#ifdef CONFIG_VT
 vty_init(&console_fops);
#endif
 return 0;
}

/* Use TTY_DRIVER_* flags below */
#define tty_alloc_driver(lines, flags) \
  __tty_alloc_driver(lines, THIS_MODULE, flags)

/**
 * __tty_alloc_driver -- allocate tty driver
 * @lines: count of lines this driver can handle at most
 * @owner: module which is repsonsible for this driver
 * @flags: some of TTY_DRIVER_* flags, will be set in driver->flags
 *
 * This should not be called directly, some of the provided macros should be
 * used instead. Use IS_ERR and friends on @retval.
 */
struct tty_driver *__tty_alloc_driver(unsigned int lines, struct module *owner,
  unsigned long flags)
{
 struct tty_driver *driver;
 unsigned int cdevs = 1;
 int err;

 if (!lines || (flags & TTY_DRIVER_UNNUMBERED_NODE && lines > 1))
  return ERR_PTR(-EINVAL);
 
    /*分配一个 struct tty_driver 结构体，并对其中的一些字段进行初始化，包括 num、owner、flags 等*/
 driver = kzalloc(sizeof(struct tty_driver), GFP_KERNEL);
 if (!driver)
  return ERR_PTR(-ENOMEM);

 kref_init(&driver->kref);
 driver->magic = TTY_DRIVER_MAGIC;
 driver->num = lines;
 driver->owner = owner;
 driver->flags = flags;
    
 /*如果 TTY_DRIVER_DEVPTS_MEM 标志位没有被设置，那么函数会分配 driver->ttys 和 driver->termios，否则不需要分配*/
 if (!(flags & TTY_DRIVER_DEVPTS_MEM)) {
  driver->ttys = kcalloc(lines, sizeof(*driver->ttys),
    GFP_KERNEL);
  driver->termios = kcalloc(lines, sizeof(*driver->termios),
    GFP_KERNEL);
  if (!driver->ttys || !driver->termios) {
   err = -ENOMEM;
   goto err_free_all;
  }
 }
 
    /*如果 TTY_DRIVER_DYNAMIC_ALLOC 标志位没有被设置，那么函数会分配 driver->ports，否则不需要分配*/
 if (!(flags & TTY_DRIVER_DYNAMIC_ALLOC)) {
  driver->ports = kcalloc(lines, sizeof(*driver->ports),
    GFP_KERNEL);
  if (!driver->ports) {
   err = -ENOMEM;
   goto err_free_all;
  }
  cdevs = lines;
 }
    
 /*函数会根据 lines 的值分配相应数量的 driver->cdevs*/
 driver->cdevs = kcalloc(cdevs, sizeof(*driver->cdevs), GFP_KERNEL);
 if (!driver->cdevs) {
  err = -ENOMEM;
  goto err_free_all;
 }

 return driver;
err_free_all:
 kfree(driver->ports);
 kfree(driver->ttys);
 kfree(driver->termios);
 kfree(driver->cdevs);
 kfree(driver);
 return ERR_PTR(err);
}

/*
 * Called by a tty driver to register itself.
 */
int tty_register_driver(struct tty_driver *driver)
{
 int error;
 int i;
 dev_t dev;
 struct device *d;
    
 /*确认是否要内核动态分配主设备号*/
 if (!driver->major) {
        /*函数调用 alloc_chrdev_region 函数来动态分配主设备号，并将分配的主设备号和次设备号保存在 driver->major 和 driver->minor_start 字段中*/
  error = alloc_chrdev_region(&dev, driver->minor_start,
      driver->num, driver->name);
  if (!error) {
   driver->major = MAJOR(dev);
   driver->minor_start = MINOR(dev);
  }
 } else {
        /*已经预先分配了主设备号，函数调用 register_chrdev_region 函数来注册设备号*/
  dev = MKDEV(driver->major, driver->minor_start);
  error = register_chrdev_region(dev, driver->num, driver->name);
 }
 if (error < 0)
  goto err;
 /*判断是否设置了 TTY_DRIVER_DYNAMIC_ALLOC 标志位*/
 if (driver->flags & TTY_DRIVER_DYNAMIC_ALLOC) {
        /*需要动态分配 tty 设备号，函数调用 tty_cdev_add 函数来添加 tty 设备号，并将每个 tty 设备的字符设备注册到内核中*/
  error = tty_cdev_add(driver, dev, 0, driver->num);
  if (error)
   goto err_unreg_char;
 }

 mutex_lock(&tty_mutex);
    /*将 driver 添加到链表 tty_drivers 中*/
 list_add(&driver->tty_drivers, &tty_drivers);
 mutex_unlock(&tty_mutex);
    
 /*判断 TTY_DRIVER_DYNAMIC_DEV 标志位是否设置*/
 if (!(driver->flags & TTY_DRIVER_DYNAMIC_DEV)) {
  for (i = 0; i < driver->num; i++) {
            /*需要注册固定的 tty 设备号，函数在循环中调用 tty_register_device 函数来注册每个 tty 设备号，并将每个 tty 设备注册到内核中*/
   d = tty_register_device(driver, i, NULL);
   if (IS_ERR(d)) {
    error = PTR_ERR(d);
    goto err_unreg_devs;
   }
  }
 }
    /*注册 /proc/tty/drivers 目录中的信息*/
 proc_tty_register_driver(driver);
    /*将 driver 结构体中的 flags 字段设置为 TTY_DRIVER_INSTALLED，表示该驱动程序已经被成功注册到内核中*/
 driver->flags |= TTY_DRIVER_INSTALLED;
 return 0;

err_unreg_devs:
 for (i--; i >= 0; i--)
  tty_unregister_device(driver, i);

 mutex_lock(&tty_mutex);
 list_del(&driver->tty_drivers);
 mutex_unlock(&tty_mutex);

err_unreg_char:
 unregister_chrdev_region(dev, driver->num);
err:
 return error;
}

/**
 *  tty_unregister_device - unregister a tty device
 *  @driver: the tty driver that describes the tty device
 *  @index: the index in the tty driver for this tty device
 *
 *  If a tty device is registered with a call to tty_register_device() then
 * this function must be called when the tty device is gone.
 *
 * Locking: ??
 */

void tty_unregister_device(struct tty_driver *driver, unsigned index)
{
 device_destroy(tty_class,
  MKDEV(driver->major, driver->minor_start) + index);
 if (!(driver->flags & TTY_DRIVER_DYNAMIC_ALLOC)) {
  cdev_del(driver->cdevs[index]);
  driver->cdevs[index] = NULL;
 }
}

/**
 * get_tty_driver  - find device of a tty
 * @dev_t: device identifier
 * @index: returns the index of the tty
 *
 * This routine returns a tty driver structure, given a device number
 * and also passes back the index number.
 *
 * Locking: caller must hold tty_mutex
 */

static struct tty_driver *get_tty_driver(dev_t device, int *index)
{
 struct tty_driver *p;
 
    /**/
 list_for_each_entry(p, &tty_drivers, tty_drivers) {
  dev_t base = MKDEV(p->major, p->minor_start);
  if (device < base || device >= base + p->num)
   continue;
  *index = device - base;
  return tty_driver_kref_get(p);
 }
 return NULL;
}

/**
 * tty_open  - open a tty device
 * @inode: inode of device file
 * @filp: file pointer to tty
 *
 * tty_open and tty_release keep up the tty count that contains the
 * number of opens done on a tty. We cannot use the inode-count, as
 * different inodes might point to the same tty.
 *
 * Open-counting is needed for pty masters, as well as for keeping
 * track of serial lines: DTR is dropped when the last close happens.
 * (This is not done solely through tty->count, now.  - Ted 1/27/92)
 *
 * The termios state of a pty is reset on first open so that
 * settings don't persist across reuse.
 *
 * Locking: tty_mutex protects tty, tty_lookup_driver and tty_init_dev.
 *   tty->count should protect the rest.
 *   ->siglock protects ->signal/->sighand
 *
 * Note: the tty_unlock/lock cases without a ref are only safe due to
 * tty_mutex
 */

static int tty_open(struct inode *inode, struct file *filp)
{
 struct tty_struct *tty;
 int noctty, retval;
 struct tty_driver *driver = NULL;
 int index;
 dev_t device = inode->i_rdev;
 unsigned saved_flags = filp->f_flags;

 nonseekable_open(inode, filp);

retry_open:
    /*分配一个 tty 结构体*/
 retval = tty_alloc_file(filp);
 if (retval)
  return -ENOMEM;
 
    /*检查文件的标志位，如果包含 O_NOCTTY 标志，则禁止将该 tty 设备设置为控制终端*/
 noctty = filp->f_flags & O_NOCTTY;
 index  = -1;
 retval = 0;
 /*尝试打开当前的 tty 设备*/
 tty = tty_open_current_tty(device, filp);
 if (!tty) {
  mutex_lock(&tty_mutex);
        /*根据设备号来查找对应的 tty 驱动程序，并初始化该 tty 设备，将找到的 tty 驱动程序保存到 driver 变量中*/
  driver = tty_lookup_driver(device, filp, &noctty, &index);
  if (IS_ERR(driver)) {
   retval = PTR_ERR(driver);
   goto err_unlock;
  }

  /* check whether we're reopening an existing tty */
        /*查找对应的 tty 设备，并将找到的 tty 设备结构体指针保存到 tty 变量中*/
  tty = tty_driver_lookup_tty(driver, inode, index);
  if (IS_ERR(tty)) {
   retval = PTR_ERR(tty);
   goto err_unlock;
  }

  if (tty) {
            /*如果找到了该 tty 设备，则需要重新打开该 tty 设备*/
   mutex_unlock(&tty_mutex);
   retval = tty_lock_interruptible(tty);
   tty_kref_put(tty);  /* drop kref from tty_driver_lookup_tty() */
   if (retval) {
    if (retval == -EINTR)
     retval = -ERESTARTSYS;
    goto err_unref;
   }
   retval = tty_reopen(tty);
   if (retval < 0) {
    tty_unlock(tty);
    tty = ERR_PTR(retval);
   }
  } else { /* Returns with the tty_lock held for now */
            /*需要初始化该 tty 设备*/
   tty = tty_init_dev(driver, index);
            /*为该 tty 设备分配一个 tty 结构体，并对其进行初始化*/
   mutex_unlock(&tty_mutex);
  }

  tty_driver_kref_put(driver);
 }

 if (IS_ERR(tty)) {
  retval = PTR_ERR(tty);
  if (retval != -EAGAIN || signal_pending(current))
   goto err_file;
  tty_free_file(filp);
  schedule();
  goto retry_open;
 }
 /*将该 tty 设备与文件结构体相关联*/
 tty_add_file(tty, filp);

 check_tty_count(tty, __func__);
    /*如果该 tty 设备是一个伪终端主设备，则需要将 noctty 标志设置为 1*/
 if (tty->driver->type == TTY_DRIVER_TYPE_PTY &&
     tty->driver->subtype == PTY_TYPE_MASTER)
  noctty = 1;

 tty_debug_hangup(tty, "(tty count=%d)\n", tty->count);
 
    /*调用 tty 设备的 open 函数*/
 if (tty->ops->open)
  retval = tty->ops->open(tty, filp);
 else
  retval = -ENODEV;
 filp->f_flags = saved_flags;

 if (retval) {
  tty_debug_hangup(tty, "error %d, releasing...\n", retval);

  tty_unlock(tty); /* need to call tty_release without BTM */
  tty_release(inode, filp);
  if (retval != -ERESTARTSYS)
   return retval;

  if (signal_pending(current))
   return retval;

  schedule();
  /*
   * Need to reset f_op in case a hangup happened.
   */
  if (tty_hung_up_p(filp))
   filp->f_op = &tty_fops;
  goto retry_open;
 }
 clear_bit(TTY_HUPPED, &tty->flags);


 read_lock(&tasklist_lock);
 spin_lock_irq(&current->sighand->siglock);
 if (!noctty &&
     current->signal->leader &&
     !current->signal->tty &&
     tty->session == NULL) {
  /*
   * Don't let a process that only has write access to the tty
   * obtain the privileges associated with having a tty as
   * controlling terminal (being able to reopen it with full
   * access through /dev/tty, being able to perform pushback).
   * Many distributions set the group of all ttys to "tty" and
   * grant write-only access to all terminals for setgid tty
   * binaries, which should not imply full privileges on all ttys.
   *
   * This could theoretically break old code that performs open()
   * on a write-only file descriptor. In that case, it might be
   * necessary to also permit this if
   * inode_permission(inode, MAY_READ) == 0.
   */
  if (filp->f_mode & FMODE_READ)
   __proc_set_tty(tty);
 }
 spin_unlock_irq(&current->sighand->siglock);
 read_unlock(&tasklist_lock);
 tty_unlock(tty);
 return 0;
err_unlock:
 mutex_unlock(&tty_mutex);
err_unref:
 /* after locks to avoid deadlock */
 if (!IS_ERR_OR_NULL(driver))
  tty_driver_kref_put(driver);
err_file:
 tty_free_file(filp);
 return retval;
}

/**
 * tty_write  - write method for tty device file
 * @file: tty file pointer
 * @buf: user data to write
 * @count: bytes to write
 * @ppos: unused
 *
 * Write data to a tty device via the line discipline.
 *
 * Locking:
 *  Locks the line discipline as required
 *  Writes to the tty driver are serialized by the atomic_write_lock
 * and are then processed in chunks to the device. The line discipline
 * write method will not be invoked in parallel for each device.
 */

static ssize_t tty_write(struct file *file, const char __user *buf,
      size_t count, loff_t *ppos)
{
 struct tty_struct *tty = file_tty(file);
  struct tty_ldisc *ld;
 ssize_t ret;

 if (tty_paranoia_check(tty, file_inode(file), "tty_write"))
  return -EIO;
 if (!tty || !tty->ops->write ||
  (test_bit(TTY_IO_ERROR, &tty->flags)))
   return -EIO;
 /* Short term debug to catch buggy drivers */
 if (tty->ops->write_room == NULL)
  printk(KERN_ERR "tty driver %s lacks a write_room method.\n",
   tty->driver->name);
 ld = tty_ldisc_ref_wait(tty);
 if (!ld->ops->write)
  ret = -EIO;
 else
  ret = do_tty_write(ld->ops->write, tty, file, buf, count);
 tty_ldisc_deref(ld);
 return ret;
}

/**
 * tty_read - read method for tty device files
 * @file: pointer to tty file
 * @buf: user buffer
 * @count: size of user buffer
 * @ppos: unused
 *
 * Perform the read system call function on this terminal device. Checks
 * for hung up devices before calling the line discipline method.
 *
 * Locking:
 *  Locks the line discipline internally while needed. Multiple
 * read calls may be outstanding in parallel.
 */

static ssize_t tty_read(struct file *file, char __user *buf, size_t count,
   loff_t *ppos)
{
 int i;
 struct inode *inode = file_inode(file);
 struct tty_struct *tty = file_tty(file);
 struct tty_ldisc *ld;

 if (tty_paranoia_check(tty, inode, "tty_read"))
  return -EIO;
 if (!tty || (test_bit(TTY_IO_ERROR, &tty->flags)))
  return -EIO;

 /* We want to wait for the line discipline to sort out in this
    situation */
 ld = tty_ldisc_ref_wait(tty);
 if (ld->ops->read)
  i = ld->ops->read(tty, file, buf, count);
 else
  i = -EIO;
 tty_ldisc_deref(ld);

 if (i > 0)
  tty_update_time(&inode->i_atime);

 return i;
}