include/linux/tty_flip.h

   1 /* SPDX-License-Identifier: GPL-2.0 */
   2 #ifndef _LINUX_TTY_FLIP_H
   3 #define _LINUX_TTY_FLIP_H
   4
   5 #include <linux/tty_buffer.h>
   6 #include <linux/tty_port.h>
   7
   8 struct tty_ldisc;
   9
  10 int tty_buffer_set_limit(struct tty_port *port, int limit);
  11 unsigned int tty_buffer_space_avail(struct tty_port *port);
  12 int tty_buffer_request_room(struct tty_port *port, size_t size);
  13 size_t __tty_insert_flip_string_flags(struct tty_port *port, const u8 *chars,
  14                                       const u8 *flags, bool mutable_flags,
  15                                       size_t size);
  16 size_t tty_prepare_flip_string(struct tty_port *port, u8 **chars, size_t size);
  17 void tty_flip_buffer_push(struct tty_port *port);
  18
  19 /**
  20  * tty_insert_flip_string_fixed_flag - add characters to the tty buffer
  21  * @port: tty port
  22  * @chars: characters
  23  * @flag: flag value for each character
  24  * @size: size
  25  *
  26  * Queue a series of bytes to the tty buffering. All the characters passed are
  27  * marked with the supplied flag.
  28  *
  29  * Returns: the number added.
  30  */
  31 static inline size_t tty_insert_flip_string_fixed_flag(struct tty_port *port,
  32                                                        const u8 *chars, u8 flag,
  33                                                        size_t size)
  34 {
  35         return __tty_insert_flip_string_flags(port, chars, &flag, false, size);
  36 }
  37
  38 /**
  39  * tty_insert_flip_string_flags - add characters to the tty buffer
  40  * @port: tty port
  41  * @chars: characters
  42  * @flags: flag bytes
  43  * @size: size
  44  *
  45  * Queue a series of bytes to the tty buffering. For each character the flags
  46  * array indicates the status of the character.
  47  *
  48  * Returns: the number added.
  49  */
  50 static inline size_t tty_insert_flip_string_flags(struct tty_port *port,
  51                                                   const u8 *chars,
  52                                                   const u8 *flags, size_t size)
  53 {
  54         return __tty_insert_flip_string_flags(port, chars, flags, true, size);
  55 }
  56
  57 /**
  58  * tty_insert_flip_char - add one character to the tty buffer
  59  * @port: tty port
  60  * @ch: character
  61  * @flag: flag byte
  62  *
  63  * Queue a single byte @ch to the tty buffering, with an optional flag.
  64  */
  65 static inline size_t tty_insert_flip_char(struct tty_port *port, u8 ch, u8 flag)
  66 {
  67         struct tty_buffer *tb = port->buf.tail;
  68         int change;
  69
  70         change = !tb->flags && (flag != TTY_NORMAL);
  71         if (!change && tb->used < tb->size) {
  72                 if (tb->flags)
  73                         *flag_buf_ptr(tb, tb->used) = flag;
  74                 *char_buf_ptr(tb, tb->used++) = ch;
  75                 return 1;
  76         }
  77         return __tty_insert_flip_string_flags(port, &ch, &flag, false, 1);
  78 }
  79
  80 static inline size_t tty_insert_flip_string(struct tty_port *port,
  81                                             const u8 *chars, size_t size)
  82 {
  83         return tty_insert_flip_string_fixed_flag(port, chars, TTY_NORMAL, size);
  84 }
  85
  86 size_t tty_ldisc_receive_buf(struct tty_ldisc *ld, const u8 *p, const u8 *f,
  87                              size_t count);
  88
  89 void tty_buffer_lock_exclusive(struct tty_port *port);
  90 void tty_buffer_unlock_exclusive(struct tty_port *port);
  91
  92 #endif /* _LINUX_TTY_FLIP_H */