include/linux/tty_ldisc.h

   1 /* SPDX-License-Identifier: GPL-2.0 */
   2 #ifndef _LINUX_TTY_LDISC_H
   3 #define _LINUX_TTY_LDISC_H
   4
   5 struct tty_struct;
   6
   7 /*
   8  * This structure defines the interface between the tty line discipline
   9  * implementation and the tty routines.  The following routines can be
  10  * defined; unless noted otherwise, they are optional, and can be
  11  * filled in with a null pointer.
  12  *
  13  * int  (*open)(struct tty_struct *);
  14  *
  15  *      This function is called when the line discipline is associated
  16  *      with the tty.  The line discipline can use this as an
  17  *      opportunity to initialize any state needed by the ldisc routines.
  18  *
  19  * void (*close)(struct tty_struct *);
  20  *
  21  *      This function is called when the line discipline is being
  22  *      shutdown, either because the tty is being closed or because
  23  *      the tty is being changed to use a new line discipline
  24  *
  25  * void (*flush_buffer)(struct tty_struct *tty);
  26  *
  27  *      This function instructs the line discipline to clear its
  28  *      buffers of any input characters it may have queued to be
  29  *      delivered to the user mode process.
  30  *
  31  * ssize_t (*read)(struct tty_struct * tty, struct file * file,
  32  *                 unsigned char * buf, size_t nr);
  33  *
  34  *      This function is called when the user requests to read from
  35  *      the tty.  The line discipline will return whatever characters
  36  *      it has buffered up for the user.  If this function is not
  37  *      defined, the user will receive an EIO error.
  38  *
  39  * ssize_t (*write)(struct tty_struct * tty, struct file * file,
  40  *                  const unsigned char * buf, size_t nr);
  41  *
  42  *      This function is called when the user requests to write to the
  43  *      tty.  The line discipline will deliver the characters to the
  44  *      low-level tty device for transmission, optionally performing
  45  *      some processing on the characters first.  If this function is
  46  *      not defined, the user will receive an EIO error.
  47  *
  48  * int  (*ioctl)(struct tty_struct * tty, struct file * file,
  49  *               unsigned int cmd, unsigned long arg);
  50  *
  51  *      This function is called when the user requests an ioctl which
  52  *      is not handled by the tty layer or the low-level tty driver.
  53  *      It is intended for ioctls which affect line discpline
  54  *      operation.  Note that the search order for ioctls is (1) tty
  55  *      layer, (2) tty low-level driver, (3) line discpline.  So a
  56  *      low-level driver can "grab" an ioctl request before the line
  57  *      discpline has a chance to see it.
  58  *
  59  * int  (*compat_ioctl)(struct tty_struct * tty, struct file * file,
  60  *                      unsigned int cmd, unsigned long arg);
  61  *
  62  *      Process ioctl calls from 32-bit process on 64-bit system
  63  *
  64  *      NOTE: only ioctls that are neither "pointer to compatible
  65  *      structure" nor tty-generic.  Something private that takes
  66  *      an integer or a pointer to wordsize-sensitive structure
  67  *      belongs here, but most of ldiscs will happily leave
  68  *      it NULL.
  69  *
  70  * void (*set_termios)(struct tty_struct *tty, struct ktermios * old);
  71  *
  72  *      This function notifies the line discpline that a change has
  73  *      been made to the termios structure.
  74  *
  75  * int  (*poll)(struct tty_struct * tty, struct file * file,
  76  *                poll_table *wait);
  77  *
  78  *      This function is called when a user attempts to select/poll on a
  79  *      tty device.  It is solely the responsibility of the line
  80  *      discipline to handle poll requests.
  81  *
  82  * void (*receive_buf)(struct tty_struct *, const unsigned char *cp,
  83  *                     char *fp, int count);
  84  *
  85  *      This function is called by the low-level tty driver to send
  86  *      characters received by the hardware to the line discpline for
  87  *      processing.  <cp> is a pointer to the buffer of input
  88  *      character received by the device.  <fp> is a pointer to a
  89  *      pointer of flag bytes which indicate whether a character was
  90  *      received with a parity error, etc. <fp> may be NULL to indicate
  91  *      all data received is TTY_NORMAL.
  92  *
  93  * void (*write_wakeup)(struct tty_struct *);
  94  *
  95  *      This function is called by the low-level tty driver to signal
  96  *      that line discpline should try to send more characters to the
  97  *      low-level driver for transmission.  If the line discpline does
  98  *      not have any more data to send, it can just return. If the line
  99  *      discipline does have some data to send, please arise a tasklet
 100  *      or workqueue to do the real data transfer. Do not send data in
 101  *      this hook, it may leads to a deadlock.
 102  *
 103  * int (*hangup)(struct tty_struct *)
 104  *
 105  *      Called on a hangup. Tells the discipline that it should
 106  *      cease I/O to the tty driver. Can sleep. The driver should
 107  *      seek to perform this action quickly but should wait until
 108  *      any pending driver I/O is completed.
 109  *
 110  * void (*dcd_change)(struct tty_struct *tty, unsigned int status)
 111  *
 112  *      Tells the discipline that the DCD pin has changed its status.
 113  *      Used exclusively by the N_PPS (Pulse-Per-Second) line discipline.
 114  *
 115  * int  (*receive_buf2)(struct tty_struct *, const unsigned char *cp,
 116  *                      char *fp, int count);
 117  *
 118  *      This function is called by the low-level tty driver to send
 119  *      characters received by the hardware to the line discpline for
 120  *      processing.  <cp> is a pointer to the buffer of input
 121  *      character received by the device.  <fp> is a pointer to a
 122  *      pointer of flag bytes which indicate whether a character was
 123  *      received with a parity error, etc. <fp> may be NULL to indicate
 124  *      all data received is TTY_NORMAL.
 125  *      If assigned, prefer this function for automatic flow control.
 126  */
 127
 128 #include <linux/fs.h>
 129 #include <linux/wait.h>
 130 #include <linux/atomic.h>
 131 #include <linux/list.h>
 132 #include <linux/lockdep.h>
 133 #include <linux/seq_file.h>
 134
 135 /*
 136  * the semaphore definition
 137  */
 138 struct ld_semaphore {
 139         atomic_long_t           count;
 140         raw_spinlock_t          wait_lock;
 141         unsigned int            wait_readers;
 142         struct list_head        read_wait;
 143         struct list_head        write_wait;
 144 #ifdef CONFIG_DEBUG_LOCK_ALLOC
 145         struct lockdep_map      dep_map;
 146 #endif
 147 };
 148
 149 extern void __init_ldsem(struct ld_semaphore *sem, const char *name,
 150                          struct lock_class_key *key);
 151
 152 #define init_ldsem(sem)                                         \
 153 do {                                                            \
 154         static struct lock_class_key __key;                     \
 155                                                                 \
 156         __init_ldsem((sem), #sem, &__key);                      \
 157 } while (0)
 158
 159
 160 extern int ldsem_down_read(struct ld_semaphore *sem, long timeout);
 161 extern int ldsem_down_read_trylock(struct ld_semaphore *sem);
 162 extern int ldsem_down_write(struct ld_semaphore *sem, long timeout);
 163 extern int ldsem_down_write_trylock(struct ld_semaphore *sem);
 164 extern void ldsem_up_read(struct ld_semaphore *sem);
 165 extern void ldsem_up_write(struct ld_semaphore *sem);
 166
 167 #ifdef CONFIG_DEBUG_LOCK_ALLOC
 168 extern int ldsem_down_read_nested(struct ld_semaphore *sem, int subclass,
 169                                   long timeout);
 170 extern int ldsem_down_write_nested(struct ld_semaphore *sem, int subclass,
 171                                    long timeout);
 172 #else
 173 # define ldsem_down_read_nested(sem, subclass, timeout)         \
 174                 ldsem_down_read(sem, timeout)
 175 # define ldsem_down_write_nested(sem, subclass, timeout)        \
 176                 ldsem_down_write(sem, timeout)
 177 #endif
 178
 179
 180 struct tty_ldisc_ops {
 181         char    *name;
 182         int     num;
 183         int     flags;
 184
 185         /*
 186          * The following routines are called from above.
 187          */
 188         int     (*open)(struct tty_struct *);
 189         void    (*close)(struct tty_struct *);
 190         void    (*flush_buffer)(struct tty_struct *tty);
 191         ssize_t (*read)(struct tty_struct *tty, struct file *file,
 192                         unsigned char *buf, size_t nr,
 193                         void **cookie, unsigned long offset);
 194         ssize_t (*write)(struct tty_struct *tty, struct file *file,
 195                          const unsigned char *buf, size_t nr);
 196         int     (*ioctl)(struct tty_struct *tty, struct file *file,
 197                          unsigned int cmd, unsigned long arg);
 198         int     (*compat_ioctl)(struct tty_struct *tty, struct file *file,
 199                                 unsigned int cmd, unsigned long arg);
 200         void    (*set_termios)(struct tty_struct *tty, struct ktermios *old);
 201         __poll_t (*poll)(struct tty_struct *, struct file *,
 202                              struct poll_table_struct *);
 203         int     (*hangup)(struct tty_struct *tty);
 204
 205         /*
 206          * The following routines are called from below.
 207          */
 208         void    (*receive_buf)(struct tty_struct *, const unsigned char *cp,
 209                                const char *fp, int count);
 210         void    (*write_wakeup)(struct tty_struct *);
 211         void    (*dcd_change)(struct tty_struct *, unsigned int);
 212         int     (*receive_buf2)(struct tty_struct *, const unsigned char *cp,
 213                                 const char *fp, int count);
 214
 215         struct  module *owner;
 216 };
 217
 218 struct tty_ldisc {
 219         struct tty_ldisc_ops *ops;
 220         struct tty_struct *tty;
 221 };
 222
 223 #define LDISC_FLAG_DEFINED      0x00000001
 224
 225 #define MODULE_ALIAS_LDISC(ldisc) \
 226         MODULE_ALIAS("tty-ldisc-" __stringify(ldisc))
 227
 228 extern const struct seq_operations tty_ldiscs_seq_ops;
 229
 230 struct tty_ldisc *tty_ldisc_ref(struct tty_struct *);
 231 void tty_ldisc_deref(struct tty_ldisc *);
 232 struct tty_ldisc *tty_ldisc_ref_wait(struct tty_struct *);
 233
 234 void tty_ldisc_flush(struct tty_struct *tty);
 235
 236 int tty_register_ldisc(struct tty_ldisc_ops *new_ldisc);
 237 void tty_unregister_ldisc(struct tty_ldisc_ops *ldisc);
 238 int tty_set_ldisc(struct tty_struct *tty, int disc);
 239
 240 #endif /* _LINUX_TTY_LDISC_H */