tty_alloc_driver

　　/inclue/linux/tty_driver.h

/* Use TTY_DRIVER_* flags below */

#define tty_alloc_driver(lines, flags) \

                __tty_alloc_driver(lines, THIS_MODULE, flags)

/*

 * DEPRECATED Do not use this in new code, use tty_alloc_driver instead.

 * 不赞成使用这个新代码，通常使用tty_alloc_driver来代替。其实他们实际意义是一样的

 * (And change the return value checks.)

 */

static inline struct tty_driver *alloc_tty_driver(unsigned int lines)

{

    struct tty_driver *ret = tty_alloc_driver(lines, 0);

//当看到代码中调用alloc_tty_driver时，flag默认为0

    if (IS_ERR(ret))

        return NULL;

    return ret;

}

----------------------------------------------------------------------

/*

 * tty driver flags

 * 　　

 * TTY_DRIVER_RESET_TERMIOS --- requests the tty layer to reset the

 *      termios setting when the last process has closed the device.

 *      Used for PTY's, in particular.

 * 当设备关闭时，请求复位termios。通常使用PTY

 * 

 * TTY_DRIVER_REAL_RAW --- if set, indicates that the driver will

 *      guarantee never not to set any special character handling

 *      flags if ((IGNBRK || (!BRKINT && !PARMRK)) && (IGNPAR ||

 *      !INPCK)).  That is, if there is no reason for the driver to

 *      send notifications of parity and break characters up to the

 *      line driver, it won't do so.  This allows the line driver to

 *      optimize for this case if this flag is set.  (Note that there

 *      is also a promise, if the above case is true, not to signal

 *      overruns, either.)

 * 如果设置，驱动将不会设置任何特殊的字符处理标志 

 * 意味着，如果没有原因，驱动将不会将通知送给线驱动

 * 如果设置了，可以使线驱动优化这一处理程序

 *

 * TTY_DRIVER_DYNAMIC_DEV --- if set, the individual tty devices need

 *      to be registered with a call to tty_register_device() when the

 *      device is found in the system and unregistered with a call to

 *      tty_unregister_device() so the devices will be show up

 *      properly in sysfs.  If not set, driver->num entries will be

 *      created by the tty core in sysfs when tty_register_driver() is

 *      called.  This is to be used by drivers that have tty devices

 *      that can appear and disappear while the main tty driver is

 *      registered with the tty core.

 * 如果设置，特别的tty设备将在其被发现时注册 和 调用注销函数时注销

 * 如果不设置，当注册函数被调用时，sysfs的tty核心层会自动创建driver->num

 * 这个flag通常使用在主tty驱动被tty核心注册，且tty设备可能出现和消失

 * 

 * TTY_DRIVER_DEVPTS_MEM -- don't use the standard arrays, instead

 *      use dynamic memory keyed through the devpts filesystem.  This

 *      is only applicable to the pty driver.

 * 不使用标准数组， 而是使用devpts文件系统的动态记忆链

 * 这个是给pty驱动使用的

 *

 * TTY_DRIVER_HARDWARE_BREAK -- hardware handles break signals. Pass

 *      the requested timeout to the caller instead of using a simple

 *      on/off interface.

 * 硬件处理断点信号。发送暂时休息（timeout）请求而不是简单地打开/关闭接口

 *

 * TTY_DRIVER_DYNAMIC_ALLOC -- do not allocate structures which are

 *      needed per line for this driver as it would waste memory.

 *      The driver will take care.

 * 不每条线都分配结构，因其会浪费内存。使用这个flag，驱动将注意这一情况

 *

 * TTY_DRIVER_UNNUMBERED_NODE -- do not create numbered /dev nodes. In

 *      other words create /dev/ttyprintk and not /dev/ttyprintk0.

 *      Applicable only when a driver for a single tty device is

 *      being allocated.

 * 不创建已经分配的/dev节点。

 * 意思是创建/dev/ttyprintk 而非创建/dev/ttyprintk0

 * 只用在一个驱动为了一个单独的且已经被分配tty设备注册时

 */

#define TTY_DRIVER_INSTALLED            0x0001

#define TTY_DRIVER_RESET_TERMIOS        0x0002

#define TTY_DRIVER_REAL_RAW             0x0004

#define TTY_DRIVER_DYNAMIC_DEV          0x0008

#define TTY_DRIVER_DEVPTS_MEM           0x0010

#define TTY_DRIVER_HARDWARE_BREAK       0x0020

#define TTY_DRIVER_DYNAMIC_ALLOC        0x0040

#define TTY_DRIVER_UNNUMBERED_NODE      0x0080

　　在看分配函数之前，先来看一下tty_driver这个结构体

　　/include/linux/tty/tty_driver.h

struct tty_driver {

    int     magic;          /* magic number for this structure */

    struct kref kref;       /* Reference management */

    struct cdev *cdevs;

    struct module   *owner;

    const char      *driver_name;

    const char      *name;

    int     name_base;      /* offset of printed name */

    int     major;          /* major device number */

    int     minor_start;    /* start of minor device number */

    unsigned int    num;    /* number of devices allocated */

    short   type;           /* type of tty driver */

    short   subtype;        /* subtype of tty driver */

    struct ktermios init_termios; /* Initial termios */

    unsigned long   flags;          /* tty driver flags */

    struct proc_dir_entry *proc_entry; /* /proc fs entry */

    struct tty_driver *other; /* only used for the PTY driver */



    /*

     * Pointer to the tty data structures

     */

    struct tty_struct **ttys;

    struct tty_port **ports;

    struct ktermios **termios;

    void *driver_state;



    /*

     * Driver methods

     */



    const struct tty_operations *ops;

    struct list_head tty_drivers;

};

　　 分配tty驱动函数

　　/drivers/tty/tty_io.c

/**

 * __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))

//The priority is '&' higher than '&&'

//当设置flag为TTY_DRIVER_UNNUMBERD_NODE或lines为0的时候，返回-EINVAL

//means -E(rror)IN(put)VAL(ue)

        return ERR_PTR(-EINVAL);



    driver = kzalloc(sizeof(struct tty_driver), GFP_KERNEL);

    if (!driver)  //若分配失败，返回-ENOMEM

        return ERR_PTR(-ENOMEM);



    kref_init(&driver->kref);

    driver->magic = TTY_DRIVER_MAGIC;

    driver->num = lines;

    driver->owner = owner;

    driver->flags = flags;



//看看声明的flags有什么特点就知道这个 & 的作用了

    if (!(flags & TTY_DRIVER_DEVPTS_MEM)) {

//若没设置TTY_DRIVER_DEVPTS_MEM

//使用标准数组

        driver->ttys = kcalloc(lines, sizeof(*driver->ttys),

                GFP_KERNEL);

//定义为struct tty_struct **tty, kcalloc分配成功返回0

        driver->termios = kcalloc(lines, sizeof(*driver->termios),

                GFP_KERNEL);

//定义为struct ktermios **termios

        if (!driver->ttys || !driver->termios) {

//ttys和termios任一成功才继续往下

            err = -ENOMEM;

            goto err_free_all;

        }

    }



    if (!(flags & TTY_DRIVER_DYNAMIC_ALLOC)) {

//若没设置TTY_DRIVER_DYNAMIC_ALLOC, 则为每条线都分配结构

        driver->ports = kcalloc(lines, sizeof(*driver->ports),

                GFP_KERNEL);

        if (!driver->ports) {

            err = -ENOMEM;

            goto err_free_all;

        }

        cdevs = lines;

    }



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

    return ERR_PTR(err);

}

EXPORT_SYMBOL(__tty_alloc_driver);