Jeff Dike | 165dc59 | 2006-01-06 00:18:57 -0800 | [diff] [blame] | 1 | /* |
Jeff Dike | 2f8a2dc | 2007-10-16 01:26:43 -0700 | [diff] [blame] | 2 | * Copyright (C) 2001 - 2007 Jeff Dike (jdike@{addtoit,linux.intel}.com) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 3 | * Licensed under the GPL |
| 4 | */ |
| 5 | |
Al Viro | 37185b3 | 2012-10-08 03:27:32 +0100 | [diff] [blame] | 6 | #include <linux/irqreturn.h> |
| 7 | #include <linux/kd.h> |
Ingo Molnar | 3f07c01 | 2017-02-08 18:51:30 +0100 | [diff] [blame] | 8 | #include <linux/sched/signal.h> |
Al Viro | 37185b3 | 2012-10-08 03:27:32 +0100 | [diff] [blame] | 9 | #include <linux/slab.h> |
Ingo Molnar | 3f07c01 | 2017-02-08 18:51:30 +0100 | [diff] [blame] | 10 | |
Al Viro | 510c72a3 | 2011-08-18 20:08:29 +0100 | [diff] [blame] | 11 | #include "chan.h" |
Al Viro | 37185b3 | 2012-10-08 03:27:32 +0100 | [diff] [blame] | 12 | #include <irq_kern.h> |
| 13 | #include <irq_user.h> |
| 14 | #include <kern_util.h> |
| 15 | #include <os.h> |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 16 | |
| 17 | #define LINE_BUFSIZE 4096 |
| 18 | |
Al Viro | 7bea96f | 2006-10-08 22:49:34 +0100 | [diff] [blame] | 19 | static irqreturn_t line_interrupt(int irq, void *data) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 20 | { |
Jeff Dike | 165dc59 | 2006-01-06 00:18:57 -0800 | [diff] [blame] | 21 | struct chan *chan = data; |
| 22 | struct line *line = chan->line; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 23 | |
| 24 | if (line) |
Jiri Slaby | 2e124b4 | 2013-01-03 15:53:06 +0100 | [diff] [blame] | 25 | chan_interrupt(line, irq); |
| 26 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 27 | return IRQ_HANDLED; |
| 28 | } |
| 29 | |
Jeff Dike | 2f8a2dc | 2007-10-16 01:26:43 -0700 | [diff] [blame] | 30 | /* |
| 31 | * Returns the free space inside the ring buffer of this line. |
Paolo 'Blaisorblade' Giarrusso | b97b77c | 2005-05-01 08:58:56 -0700 | [diff] [blame] | 32 | * |
Simon Arlott | b60745b | 2007-10-20 01:23:03 +0200 | [diff] [blame] | 33 | * Should be called while holding line->lock (this does not modify data). |
Paolo 'Blaisorblade' Giarrusso | b97b77c | 2005-05-01 08:58:56 -0700 | [diff] [blame] | 34 | */ |
| 35 | static int write_room(struct line *line) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 36 | { |
| 37 | int n; |
| 38 | |
Paolo 'Blaisorblade' Giarrusso | b97b77c | 2005-05-01 08:58:56 -0700 | [diff] [blame] | 39 | if (line->buffer == NULL) |
| 40 | return LINE_BUFSIZE - 1; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 41 | |
Paolo 'Blaisorblade' Giarrusso | b97b77c | 2005-05-01 08:58:56 -0700 | [diff] [blame] | 42 | /* This is for the case where the buffer is wrapped! */ |
| 43 | n = line->head - line->tail; |
| 44 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 45 | if (n <= 0) |
Jeff Dike | acb2cf3 | 2008-02-04 22:30:42 -0800 | [diff] [blame] | 46 | n += LINE_BUFSIZE; /* The other case */ |
Paolo 'Blaisorblade' Giarrusso | b97b77c | 2005-05-01 08:58:56 -0700 | [diff] [blame] | 47 | return n - 1; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 48 | } |
| 49 | |
Paolo 'Blaisorblade' Giarrusso | b97b77c | 2005-05-01 08:58:56 -0700 | [diff] [blame] | 50 | int line_write_room(struct tty_struct *tty) |
| 51 | { |
| 52 | struct line *line = tty->driver_data; |
| 53 | unsigned long flags; |
| 54 | int room; |
| 55 | |
Paolo 'Blaisorblade' Giarrusso | b97b77c | 2005-05-01 08:58:56 -0700 | [diff] [blame] | 56 | spin_lock_irqsave(&line->lock, flags); |
| 57 | room = write_room(line); |
| 58 | spin_unlock_irqrestore(&line->lock, flags); |
| 59 | |
Paolo 'Blaisorblade' Giarrusso | b97b77c | 2005-05-01 08:58:56 -0700 | [diff] [blame] | 60 | return room; |
| 61 | } |
| 62 | |
| 63 | int line_chars_in_buffer(struct tty_struct *tty) |
| 64 | { |
| 65 | struct line *line = tty->driver_data; |
| 66 | unsigned long flags; |
| 67 | int ret; |
| 68 | |
| 69 | spin_lock_irqsave(&line->lock, flags); |
Jeff Dike | acb2cf3 | 2008-02-04 22:30:42 -0800 | [diff] [blame] | 70 | /* write_room subtracts 1 for the needed NULL, so we readd it.*/ |
Paolo 'Blaisorblade' Giarrusso | b97b77c | 2005-05-01 08:58:56 -0700 | [diff] [blame] | 71 | ret = LINE_BUFSIZE - (write_room(line) + 1); |
| 72 | spin_unlock_irqrestore(&line->lock, flags); |
| 73 | |
| 74 | return ret; |
| 75 | } |
| 76 | |
| 77 | /* |
| 78 | * This copies the content of buf into the circular buffer associated with |
| 79 | * this line. |
| 80 | * The return value is the number of characters actually copied, i.e. the ones |
| 81 | * for which there was space: this function is not supposed to ever flush out |
| 82 | * the circular buffer. |
| 83 | * |
| 84 | * Must be called while holding line->lock! |
| 85 | */ |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 86 | static int buffer_data(struct line *line, const char *buf, int len) |
| 87 | { |
| 88 | int end, room; |
| 89 | |
Jeff Dike | 2f8a2dc | 2007-10-16 01:26:43 -0700 | [diff] [blame] | 90 | if (line->buffer == NULL) { |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 91 | line->buffer = kmalloc(LINE_BUFSIZE, GFP_ATOMIC); |
| 92 | if (line->buffer == NULL) { |
Jeff Dike | 2f8a2dc | 2007-10-16 01:26:43 -0700 | [diff] [blame] | 93 | printk(KERN_ERR "buffer_data - atomic allocation " |
| 94 | "failed\n"); |
| 95 | return 0; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 96 | } |
| 97 | line->head = line->buffer; |
| 98 | line->tail = line->buffer; |
| 99 | } |
| 100 | |
| 101 | room = write_room(line); |
| 102 | len = (len > room) ? room : len; |
| 103 | |
| 104 | end = line->buffer + LINE_BUFSIZE - line->tail; |
Paolo 'Blaisorblade' Giarrusso | b97b77c | 2005-05-01 08:58:56 -0700 | [diff] [blame] | 105 | |
Jeff Dike | 2f8a2dc | 2007-10-16 01:26:43 -0700 | [diff] [blame] | 106 | if (len < end) { |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 107 | memcpy(line->tail, buf, len); |
| 108 | line->tail += len; |
Jeff Dike | d50084a | 2006-01-06 00:18:50 -0800 | [diff] [blame] | 109 | } |
| 110 | else { |
Paolo 'Blaisorblade' Giarrusso | b97b77c | 2005-05-01 08:58:56 -0700 | [diff] [blame] | 111 | /* The circular buffer is wrapping */ |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 112 | memcpy(line->tail, buf, end); |
| 113 | buf += end; |
| 114 | memcpy(line->buffer, buf, len - end); |
| 115 | line->tail = line->buffer + len - end; |
| 116 | } |
| 117 | |
Paolo 'Blaisorblade' Giarrusso | b97b77c | 2005-05-01 08:58:56 -0700 | [diff] [blame] | 118 | return len; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 119 | } |
| 120 | |
Paolo 'Blaisorblade' Giarrusso | b97b77c | 2005-05-01 08:58:56 -0700 | [diff] [blame] | 121 | /* |
| 122 | * Flushes the ring buffer to the output channels. That is, write_chan is |
| 123 | * called, passing it line->head as buffer, and an appropriate count. |
| 124 | * |
| 125 | * On exit, returns 1 when the buffer is empty, |
| 126 | * 0 when the buffer is not empty on exit, |
| 127 | * and -errno when an error occurred. |
| 128 | * |
| 129 | * Must be called while holding line->lock!*/ |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 130 | static int flush_buffer(struct line *line) |
| 131 | { |
| 132 | int n, count; |
| 133 | |
| 134 | if ((line->buffer == NULL) || (line->head == line->tail)) |
Paolo 'Blaisorblade' Giarrusso | b97b77c | 2005-05-01 08:58:56 -0700 | [diff] [blame] | 135 | return 1; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 136 | |
| 137 | if (line->tail < line->head) { |
Paolo 'Blaisorblade' Giarrusso | b97b77c | 2005-05-01 08:58:56 -0700 | [diff] [blame] | 138 | /* line->buffer + LINE_BUFSIZE is the end of the buffer! */ |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 139 | count = line->buffer + LINE_BUFSIZE - line->head; |
Paolo 'Blaisorblade' Giarrusso | b97b77c | 2005-05-01 08:58:56 -0700 | [diff] [blame] | 140 | |
Al Viro | bed5e39 | 2011-09-08 10:49:34 -0400 | [diff] [blame] | 141 | n = write_chan(line->chan_out, line->head, count, |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 142 | line->driver->write_irq); |
| 143 | if (n < 0) |
Paolo 'Blaisorblade' Giarrusso | b97b77c | 2005-05-01 08:58:56 -0700 | [diff] [blame] | 144 | return n; |
| 145 | if (n == count) { |
Jeff Dike | 2f8a2dc | 2007-10-16 01:26:43 -0700 | [diff] [blame] | 146 | /* |
| 147 | * We have flushed from ->head to buffer end, now we |
| 148 | * must flush only from the beginning to ->tail. |
| 149 | */ |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 150 | line->head = line->buffer; |
Paolo 'Blaisorblade' Giarrusso | b97b77c | 2005-05-01 08:58:56 -0700 | [diff] [blame] | 151 | } else { |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 152 | line->head += n; |
Paolo 'Blaisorblade' Giarrusso | b97b77c | 2005-05-01 08:58:56 -0700 | [diff] [blame] | 153 | return 0; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 154 | } |
| 155 | } |
| 156 | |
| 157 | count = line->tail - line->head; |
Al Viro | bed5e39 | 2011-09-08 10:49:34 -0400 | [diff] [blame] | 158 | n = write_chan(line->chan_out, line->head, count, |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 159 | line->driver->write_irq); |
Paolo 'Blaisorblade' Giarrusso | b97b77c | 2005-05-01 08:58:56 -0700 | [diff] [blame] | 160 | |
Jeff Dike | 2f8a2dc | 2007-10-16 01:26:43 -0700 | [diff] [blame] | 161 | if (n < 0) |
Paolo 'Blaisorblade' Giarrusso | b97b77c | 2005-05-01 08:58:56 -0700 | [diff] [blame] | 162 | return n; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 163 | |
| 164 | line->head += n; |
Paolo 'Blaisorblade' Giarrusso | b97b77c | 2005-05-01 08:58:56 -0700 | [diff] [blame] | 165 | return line->head == line->tail; |
| 166 | } |
| 167 | |
| 168 | void line_flush_buffer(struct tty_struct *tty) |
| 169 | { |
| 170 | struct line *line = tty->driver_data; |
| 171 | unsigned long flags; |
Paolo 'Blaisorblade' Giarrusso | b97b77c | 2005-05-01 08:58:56 -0700 | [diff] [blame] | 172 | |
Paolo 'Blaisorblade' Giarrusso | b97b77c | 2005-05-01 08:58:56 -0700 | [diff] [blame] | 173 | spin_lock_irqsave(&line->lock, flags); |
Richard Weinberger | f1c93e4 | 2011-07-25 17:12:55 -0700 | [diff] [blame] | 174 | flush_buffer(line); |
Paolo 'Blaisorblade' Giarrusso | b97b77c | 2005-05-01 08:58:56 -0700 | [diff] [blame] | 175 | spin_unlock_irqrestore(&line->lock, flags); |
Paolo 'Blaisorblade' Giarrusso | b97b77c | 2005-05-01 08:58:56 -0700 | [diff] [blame] | 176 | } |
| 177 | |
Jeff Dike | 2f8a2dc | 2007-10-16 01:26:43 -0700 | [diff] [blame] | 178 | /* |
| 179 | * We map both ->flush_chars and ->put_char (which go in pair) onto |
| 180 | * ->flush_buffer and ->write. Hope it's not that bad. |
| 181 | */ |
Paolo 'Blaisorblade' Giarrusso | b97b77c | 2005-05-01 08:58:56 -0700 | [diff] [blame] | 182 | void line_flush_chars(struct tty_struct *tty) |
| 183 | { |
| 184 | line_flush_buffer(tty); |
| 185 | } |
| 186 | |
WANG Cong | 3168cb9 | 2008-05-06 20:42:33 -0700 | [diff] [blame] | 187 | int line_put_char(struct tty_struct *tty, unsigned char ch) |
Paolo 'Blaisorblade' Giarrusso | b97b77c | 2005-05-01 08:58:56 -0700 | [diff] [blame] | 188 | { |
WANG Cong | 3168cb9 | 2008-05-06 20:42:33 -0700 | [diff] [blame] | 189 | return line_write(tty, &ch, sizeof(ch)); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 190 | } |
| 191 | |
| 192 | int line_write(struct tty_struct *tty, const unsigned char *buf, int len) |
| 193 | { |
| 194 | struct line *line = tty->driver_data; |
| 195 | unsigned long flags; |
Jeff Dike | c59dbca | 2007-10-16 01:26:42 -0700 | [diff] [blame] | 196 | int n, ret = 0; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 197 | |
Paolo 'Blaisorblade' Giarrusso | b97b77c | 2005-05-01 08:58:56 -0700 | [diff] [blame] | 198 | spin_lock_irqsave(&line->lock, flags); |
Jeff Dike | c59dbca | 2007-10-16 01:26:42 -0700 | [diff] [blame] | 199 | if (line->head != line->tail) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 200 | ret = buffer_data(line, buf, len); |
Jeff Dike | c59dbca | 2007-10-16 01:26:42 -0700 | [diff] [blame] | 201 | else { |
Al Viro | bed5e39 | 2011-09-08 10:49:34 -0400 | [diff] [blame] | 202 | n = write_chan(line->chan_out, buf, len, |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 203 | line->driver->write_irq); |
Paolo 'Blaisorblade' Giarrusso | b97b77c | 2005-05-01 08:58:56 -0700 | [diff] [blame] | 204 | if (n < 0) { |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 205 | ret = n; |
| 206 | goto out_up; |
| 207 | } |
| 208 | |
| 209 | len -= n; |
| 210 | ret += n; |
Paolo 'Blaisorblade' Giarrusso | b97b77c | 2005-05-01 08:58:56 -0700 | [diff] [blame] | 211 | if (len > 0) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 212 | ret += buffer_data(line, buf + n, len); |
| 213 | } |
Paolo 'Blaisorblade' Giarrusso | b97b77c | 2005-05-01 08:58:56 -0700 | [diff] [blame] | 214 | out_up: |
| 215 | spin_unlock_irqrestore(&line->lock, flags); |
| 216 | return ret; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 217 | } |
| 218 | |
Alan Cox | 606d099 | 2006-12-08 02:38:45 -0800 | [diff] [blame] | 219 | void line_set_termios(struct tty_struct *tty, struct ktermios * old) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 220 | { |
| 221 | /* nothing */ |
| 222 | } |
| 223 | |
Jeff Dike | e4dcee8 | 2006-01-06 00:18:58 -0800 | [diff] [blame] | 224 | void line_throttle(struct tty_struct *tty) |
| 225 | { |
| 226 | struct line *line = tty->driver_data; |
| 227 | |
Al Viro | bed5e39 | 2011-09-08 10:49:34 -0400 | [diff] [blame] | 228 | deactivate_chan(line->chan_in, line->driver->read_irq); |
Jeff Dike | e4dcee8 | 2006-01-06 00:18:58 -0800 | [diff] [blame] | 229 | line->throttled = 1; |
| 230 | } |
| 231 | |
| 232 | void line_unthrottle(struct tty_struct *tty) |
| 233 | { |
| 234 | struct line *line = tty->driver_data; |
| 235 | |
| 236 | line->throttled = 0; |
Jiri Slaby | 2e124b4 | 2013-01-03 15:53:06 +0100 | [diff] [blame] | 237 | chan_interrupt(line, line->driver->read_irq); |
Jeff Dike | e4dcee8 | 2006-01-06 00:18:58 -0800 | [diff] [blame] | 238 | |
Jeff Dike | 2f8a2dc | 2007-10-16 01:26:43 -0700 | [diff] [blame] | 239 | /* |
| 240 | * Maybe there is enough stuff pending that calling the interrupt |
Jeff Dike | e4dcee8 | 2006-01-06 00:18:58 -0800 | [diff] [blame] | 241 | * throttles us again. In this case, line->throttled will be 1 |
| 242 | * again and we shouldn't turn the interrupt back on. |
| 243 | */ |
Jeff Dike | 2f8a2dc | 2007-10-16 01:26:43 -0700 | [diff] [blame] | 244 | if (!line->throttled) |
Al Viro | bed5e39 | 2011-09-08 10:49:34 -0400 | [diff] [blame] | 245 | reactivate_chan(line->chan_in, line->driver->read_irq); |
Jeff Dike | e4dcee8 | 2006-01-06 00:18:58 -0800 | [diff] [blame] | 246 | } |
| 247 | |
Al Viro | 7bea96f | 2006-10-08 22:49:34 +0100 | [diff] [blame] | 248 | static irqreturn_t line_write_interrupt(int irq, void *data) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 249 | { |
Jeff Dike | 165dc59 | 2006-01-06 00:18:57 -0800 | [diff] [blame] | 250 | struct chan *chan = data; |
| 251 | struct line *line = chan->line; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 252 | int err; |
| 253 | |
Jeff Dike | 2f8a2dc | 2007-10-16 01:26:43 -0700 | [diff] [blame] | 254 | /* |
Yong Zhang | c0b79a9 | 2011-09-22 16:58:46 +0800 | [diff] [blame] | 255 | * Interrupts are disabled here because genirq keep irqs disabled when |
| 256 | * calling the action handler. |
Jeff Dike | 2f8a2dc | 2007-10-16 01:26:43 -0700 | [diff] [blame] | 257 | */ |
Paolo 'Blaisorblade' Giarrusso | b97b77c | 2005-05-01 08:58:56 -0700 | [diff] [blame] | 258 | |
Paolo 'Blaisorblade' Giarrusso | ec0ac8a | 2007-03-07 20:41:12 -0800 | [diff] [blame] | 259 | spin_lock(&line->lock); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 260 | err = flush_buffer(line); |
Paolo 'Blaisorblade' Giarrusso | b97b77c | 2005-05-01 08:58:56 -0700 | [diff] [blame] | 261 | if (err == 0) { |
Al Viro | 199eebb | 2012-02-11 03:05:32 -0500 | [diff] [blame] | 262 | spin_unlock(&line->lock); |
Paolo 'Blaisorblade' Giarrusso | b97b77c | 2005-05-01 08:58:56 -0700 | [diff] [blame] | 263 | return IRQ_NONE; |
Jeff Dike | 2f8a2dc | 2007-10-16 01:26:43 -0700 | [diff] [blame] | 264 | } else if (err < 0) { |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 265 | line->head = line->buffer; |
| 266 | line->tail = line->buffer; |
| 267 | } |
Paolo 'Blaisorblade' Giarrusso | ec0ac8a | 2007-03-07 20:41:12 -0800 | [diff] [blame] | 268 | spin_unlock(&line->lock); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 269 | |
Jiri Slaby | 6aad04f | 2013-03-07 13:12:29 +0100 | [diff] [blame] | 270 | tty_port_tty_wakeup(&line->port); |
Jiri Slaby | 6fc5884 | 2012-06-04 13:35:27 +0200 | [diff] [blame] | 271 | |
Paolo 'Blaisorblade' Giarrusso | b97b77c | 2005-05-01 08:58:56 -0700 | [diff] [blame] | 272 | return IRQ_HANDLED; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 273 | } |
| 274 | |
Jeff Dike | 165dc59 | 2006-01-06 00:18:57 -0800 | [diff] [blame] | 275 | int line_setup_irq(int fd, int input, int output, struct line *line, void *data) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 276 | { |
Jeff Dike | 5e7672e | 2006-09-27 01:50:33 -0700 | [diff] [blame] | 277 | const struct line_driver *driver = line->driver; |
Theodore Ts'o | aab9446 | 2012-07-17 14:18:23 -0400 | [diff] [blame] | 278 | int err = 0; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 279 | |
Paolo 'Blaisorblade' Giarrusso | b97b77c | 2005-05-01 08:58:56 -0700 | [diff] [blame] | 280 | if (input) |
| 281 | err = um_request_irq(driver->read_irq, fd, IRQ_READ, |
Theodore Ts'o | aab9446 | 2012-07-17 14:18:23 -0400 | [diff] [blame] | 282 | line_interrupt, IRQF_SHARED, |
| 283 | driver->read_irq_name, data); |
Paolo 'Blaisorblade' Giarrusso | b97b77c | 2005-05-01 08:58:56 -0700 | [diff] [blame] | 284 | if (err) |
| 285 | return err; |
| 286 | if (output) |
Anton Ivanov | ff6a179 | 2017-11-20 21:17:58 +0000 | [diff] [blame] | 287 | err = um_request_irq(driver->write_irq, fd, IRQ_NONE, |
Theodore Ts'o | aab9446 | 2012-07-17 14:18:23 -0400 | [diff] [blame] | 288 | line_write_interrupt, IRQF_SHARED, |
| 289 | driver->write_irq_name, data); |
Paolo 'Blaisorblade' Giarrusso | b97b77c | 2005-05-01 08:58:56 -0700 | [diff] [blame] | 290 | return err; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 291 | } |
| 292 | |
Richard Weinberger | 79e0273 | 2012-06-04 21:57:24 +0200 | [diff] [blame] | 293 | static int line_activate(struct tty_port *port, struct tty_struct *tty) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 294 | { |
Richard Weinberger | 79e0273 | 2012-06-04 21:57:24 +0200 | [diff] [blame] | 295 | int ret; |
| 296 | struct line *line = tty->driver_data; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 297 | |
Richard Weinberger | 79e0273 | 2012-06-04 21:57:24 +0200 | [diff] [blame] | 298 | ret = enable_chan(line); |
| 299 | if (ret) |
| 300 | return ret; |
Jeff Dike | d14ad81 | 2007-07-15 23:38:54 -0700 | [diff] [blame] | 301 | |
Jeff Dike | 2f8a2dc | 2007-10-16 01:26:43 -0700 | [diff] [blame] | 302 | if (!line->sigio) { |
Richard Weinberger | 2116bda | 2013-03-11 10:05:45 +0100 | [diff] [blame] | 303 | chan_enable_winch(line->chan_out, port); |
Jeff Dike | d79a580 | 2007-02-10 01:43:52 -0800 | [diff] [blame] | 304 | line->sigio = 1; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 305 | } |
| 306 | |
Al Viro | bed5e39 | 2011-09-08 10:49:34 -0400 | [diff] [blame] | 307 | chan_window_size(line, &tty->winsize.ws_row, |
Richard Weinberger | 79e0273 | 2012-06-04 21:57:24 +0200 | [diff] [blame] | 308 | &tty->winsize.ws_col); |
| 309 | |
| 310 | return 0; |
| 311 | } |
| 312 | |
Richard Weinberger | cc4f024 | 2013-03-11 10:03:42 +0100 | [diff] [blame] | 313 | static void unregister_winch(struct tty_struct *tty); |
| 314 | |
| 315 | static void line_destruct(struct tty_port *port) |
| 316 | { |
| 317 | struct tty_struct *tty = tty_port_tty_get(port); |
| 318 | struct line *line = tty->driver_data; |
| 319 | |
| 320 | if (line->sigio) { |
| 321 | unregister_winch(tty); |
| 322 | line->sigio = 0; |
| 323 | } |
| 324 | } |
| 325 | |
Richard Weinberger | 79e0273 | 2012-06-04 21:57:24 +0200 | [diff] [blame] | 326 | static const struct tty_port_operations line_port_ops = { |
| 327 | .activate = line_activate, |
Richard Weinberger | cc4f024 | 2013-03-11 10:03:42 +0100 | [diff] [blame] | 328 | .destruct = line_destruct, |
Richard Weinberger | 79e0273 | 2012-06-04 21:57:24 +0200 | [diff] [blame] | 329 | }; |
| 330 | |
| 331 | int line_open(struct tty_struct *tty, struct file *filp) |
| 332 | { |
| 333 | struct line *line = tty->driver_data; |
| 334 | |
| 335 | return tty_port_open(&line->port, tty, filp); |
| 336 | } |
| 337 | |
| 338 | int line_install(struct tty_driver *driver, struct tty_struct *tty, |
| 339 | struct line *line) |
| 340 | { |
| 341 | int ret; |
| 342 | |
| 343 | ret = tty_standard_install(driver, tty); |
| 344 | if (ret) |
| 345 | return ret; |
| 346 | |
| 347 | tty->driver_data = line; |
| 348 | |
| 349 | return 0; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 350 | } |
| 351 | |
Richard Weinberger | 79e0273 | 2012-06-04 21:57:24 +0200 | [diff] [blame] | 352 | void line_close(struct tty_struct *tty, struct file * filp) |
| 353 | { |
| 354 | struct line *line = tty->driver_data; |
| 355 | |
| 356 | tty_port_close(&line->port, tty, filp); |
| 357 | } |
| 358 | |
| 359 | void line_hangup(struct tty_struct *tty) |
| 360 | { |
| 361 | struct line *line = tty->driver_data; |
| 362 | |
| 363 | tty_port_hangup(&line->port); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 364 | } |
| 365 | |
| 366 | void close_lines(struct line *lines, int nlines) |
| 367 | { |
| 368 | int i; |
| 369 | |
| 370 | for(i = 0; i < nlines; i++) |
Al Viro | 10c890c0 | 2011-09-10 08:39:18 -0400 | [diff] [blame] | 371 | close_chan(&lines[i]); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 372 | } |
| 373 | |
Al Viro | 04292b2 | 2011-09-09 20:07:05 -0400 | [diff] [blame] | 374 | int setup_one_line(struct line *lines, int n, char *init, |
| 375 | const struct chan_opts *opts, char **error_out) |
Jeff Dike | d79a580 | 2007-02-10 01:43:52 -0800 | [diff] [blame] | 376 | { |
| 377 | struct line *line = &lines[n]; |
Al Viro | cfe6b7c | 2011-09-09 19:45:42 -0400 | [diff] [blame] | 378 | struct tty_driver *driver = line->driver->driver; |
Jeff Dike | f28169d | 2007-02-10 01:43:53 -0800 | [diff] [blame] | 379 | int err = -EINVAL; |
Jeff Dike | d79a580 | 2007-02-10 01:43:52 -0800 | [diff] [blame] | 380 | |
Jiri Slaby | 060ed31 | 2012-06-04 13:35:26 +0200 | [diff] [blame] | 381 | if (line->port.count) { |
Jeff Dike | f28169d | 2007-02-10 01:43:53 -0800 | [diff] [blame] | 382 | *error_out = "Device is already open"; |
Jeff Dike | d79a580 | 2007-02-10 01:43:52 -0800 | [diff] [blame] | 383 | goto out; |
| 384 | } |
| 385 | |
Al Viro | 31efceb | 2011-09-09 19:14:02 -0400 | [diff] [blame] | 386 | if (!strcmp(init, "none")) { |
| 387 | if (line->valid) { |
| 388 | line->valid = 0; |
| 389 | kfree(line->init_str); |
Al Viro | cfe6b7c | 2011-09-09 19:45:42 -0400 | [diff] [blame] | 390 | tty_unregister_device(driver, n); |
Al Viro | 31efceb | 2011-09-09 19:14:02 -0400 | [diff] [blame] | 391 | parse_chan_pair(NULL, line, n, opts, error_out); |
| 392 | err = 0; |
| 393 | } |
| 394 | } else { |
| 395 | char *new = kstrdup(init, GFP_KERNEL); |
| 396 | if (!new) { |
| 397 | *error_out = "Failed to allocate memory"; |
| 398 | return -ENOMEM; |
| 399 | } |
Al Viro | c8e2876 | 2011-09-09 20:08:48 -0400 | [diff] [blame] | 400 | if (line->valid) { |
Al Viro | cfe6b7c | 2011-09-09 19:45:42 -0400 | [diff] [blame] | 401 | tty_unregister_device(driver, n); |
Al Viro | c8e2876 | 2011-09-09 20:08:48 -0400 | [diff] [blame] | 402 | kfree(line->init_str); |
| 403 | } |
Al Viro | 31efceb | 2011-09-09 19:14:02 -0400 | [diff] [blame] | 404 | line->init_str = new; |
Al Viro | 43574c1 | 2011-09-09 17:25:00 -0400 | [diff] [blame] | 405 | line->valid = 1; |
Al Viro | 31efceb | 2011-09-09 19:14:02 -0400 | [diff] [blame] | 406 | err = parse_chan_pair(new, line, n, opts, error_out); |
Al Viro | cfe6b7c | 2011-09-09 19:45:42 -0400 | [diff] [blame] | 407 | if (!err) { |
Jiri Slaby | 734cc17 | 2012-08-07 21:47:47 +0200 | [diff] [blame] | 408 | struct device *d = tty_port_register_device(&line->port, |
| 409 | driver, n, NULL); |
Al Viro | cfe6b7c | 2011-09-09 19:45:42 -0400 | [diff] [blame] | 410 | if (IS_ERR(d)) { |
| 411 | *error_out = "Failed to register device"; |
| 412 | err = PTR_ERR(d); |
| 413 | parse_chan_pair(NULL, line, n, opts, error_out); |
| 414 | } |
| 415 | } |
Al Viro | 31efceb | 2011-09-09 19:14:02 -0400 | [diff] [blame] | 416 | if (err) { |
| 417 | line->init_str = NULL; |
| 418 | line->valid = 0; |
| 419 | kfree(new); |
| 420 | } |
Jeff Dike | d79a580 | 2007-02-10 01:43:52 -0800 | [diff] [blame] | 421 | } |
| 422 | out: |
Jeff Dike | f28169d | 2007-02-10 01:43:53 -0800 | [diff] [blame] | 423 | return err; |
Jeff Dike | d79a580 | 2007-02-10 01:43:52 -0800 | [diff] [blame] | 424 | } |
| 425 | |
Jeff Dike | 2f8a2dc | 2007-10-16 01:26:43 -0700 | [diff] [blame] | 426 | /* |
| 427 | * Common setup code for both startup command line and mconsole initialization. |
Matt LaPlante | 4b3f686 | 2006-10-03 22:21:02 +0200 | [diff] [blame] | 428 | * @lines contains the array (of size @num) to modify; |
Paolo 'Blaisorblade' Giarrusso | b97b77c | 2005-05-01 08:58:56 -0700 | [diff] [blame] | 429 | * @init is the setup string; |
Jeff Dike | f28169d | 2007-02-10 01:43:53 -0800 | [diff] [blame] | 430 | * @error_out is an error string in the case of failure; |
Jeff Dike | d571cd1 | 2006-01-06 00:18:53 -0800 | [diff] [blame] | 431 | */ |
Paolo 'Blaisorblade' Giarrusso | b97b77c | 2005-05-01 08:58:56 -0700 | [diff] [blame] | 432 | |
Al Viro | 43574c1 | 2011-09-09 17:25:00 -0400 | [diff] [blame] | 433 | int line_setup(char **conf, unsigned int num, char **def, |
| 434 | char *init, char *name) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 435 | { |
Al Viro | 43574c1 | 2011-09-09 17:25:00 -0400 | [diff] [blame] | 436 | char *error; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 437 | |
Jeff Dike | 2f8a2dc | 2007-10-16 01:26:43 -0700 | [diff] [blame] | 438 | if (*init == '=') { |
| 439 | /* |
| 440 | * We said con=/ssl= instead of con#=, so we are configuring all |
| 441 | * consoles at once. |
| 442 | */ |
Al Viro | 43574c1 | 2011-09-09 17:25:00 -0400 | [diff] [blame] | 443 | *def = init + 1; |
| 444 | } else { |
| 445 | char *end; |
| 446 | unsigned n = simple_strtoul(init, &end, 0); |
Paolo 'Blaisorblade' Giarrusso | b97b77c | 2005-05-01 08:58:56 -0700 | [diff] [blame] | 447 | |
Al Viro | 43574c1 | 2011-09-09 17:25:00 -0400 | [diff] [blame] | 448 | if (*end != '=') { |
| 449 | error = "Couldn't parse device number"; |
| 450 | goto out; |
Jeff Dike | f28169d | 2007-02-10 01:43:53 -0800 | [diff] [blame] | 451 | } |
Al Viro | 43574c1 | 2011-09-09 17:25:00 -0400 | [diff] [blame] | 452 | if (n >= num) { |
| 453 | error = "Device number out of range"; |
| 454 | goto out; |
| 455 | } |
| 456 | conf[n] = end + 1; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 457 | } |
Al Viro | 43574c1 | 2011-09-09 17:25:00 -0400 | [diff] [blame] | 458 | return 0; |
| 459 | |
| 460 | out: |
| 461 | printk(KERN_ERR "Failed to set up %s with " |
| 462 | "configuration string \"%s\" : %s\n", name, init, error); |
| 463 | return -EINVAL; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 464 | } |
| 465 | |
Jeff Dike | 1f80171 | 2006-01-06 00:18:55 -0800 | [diff] [blame] | 466 | int line_config(struct line *lines, unsigned int num, char *str, |
Jeff Dike | f28169d | 2007-02-10 01:43:53 -0800 | [diff] [blame] | 467 | const struct chan_opts *opts, char **error_out) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 468 | { |
Al Viro | fe9a6b0 | 2011-09-08 20:44:06 -0400 | [diff] [blame] | 469 | char *end; |
Al Viro | 31efceb | 2011-09-09 19:14:02 -0400 | [diff] [blame] | 470 | int n; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 471 | |
Jeff Dike | 2f8a2dc | 2007-10-16 01:26:43 -0700 | [diff] [blame] | 472 | if (*str == '=') { |
Jeff Dike | f28169d | 2007-02-10 01:43:53 -0800 | [diff] [blame] | 473 | *error_out = "Can't configure all devices from mconsole"; |
| 474 | return -EINVAL; |
Jeff Dike | d571cd1 | 2006-01-06 00:18:53 -0800 | [diff] [blame] | 475 | } |
| 476 | |
Al Viro | fe9a6b0 | 2011-09-08 20:44:06 -0400 | [diff] [blame] | 477 | n = simple_strtoul(str, &end, 0); |
| 478 | if (*end++ != '=') { |
| 479 | *error_out = "Couldn't parse device number"; |
| 480 | return -EINVAL; |
| 481 | } |
| 482 | if (n >= num) { |
| 483 | *error_out = "Device number out of range"; |
| 484 | return -EINVAL; |
| 485 | } |
| 486 | |
Al Viro | 31efceb | 2011-09-09 19:14:02 -0400 | [diff] [blame] | 487 | return setup_one_line(lines, n, end, opts, error_out); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 488 | } |
| 489 | |
Paolo 'Blaisorblade' Giarrusso | b97b77c | 2005-05-01 08:58:56 -0700 | [diff] [blame] | 490 | int line_get_config(char *name, struct line *lines, unsigned int num, char *str, |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 491 | int size, char **error_out) |
| 492 | { |
| 493 | struct line *line; |
| 494 | char *end; |
| 495 | int dev, n = 0; |
| 496 | |
| 497 | dev = simple_strtoul(name, &end, 0); |
Jeff Dike | 2f8a2dc | 2007-10-16 01:26:43 -0700 | [diff] [blame] | 498 | if ((*end != '\0') || (end == name)) { |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 499 | *error_out = "line_get_config failed to parse device number"; |
Paolo 'Blaisorblade' Giarrusso | b97b77c | 2005-05-01 08:58:56 -0700 | [diff] [blame] | 500 | return 0; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 501 | } |
| 502 | |
Jeff Dike | 2f8a2dc | 2007-10-16 01:26:43 -0700 | [diff] [blame] | 503 | if ((dev < 0) || (dev >= num)) { |
Paolo 'Blaisorblade' Giarrusso | b97b77c | 2005-05-01 08:58:56 -0700 | [diff] [blame] | 504 | *error_out = "device number out of range"; |
| 505 | return 0; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 506 | } |
| 507 | |
| 508 | line = &lines[dev]; |
| 509 | |
Jeff Dike | 2f8a2dc | 2007-10-16 01:26:43 -0700 | [diff] [blame] | 510 | if (!line->valid) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 511 | CONFIG_CHUNK(str, size, n, "none", 1); |
Jiri Slaby | 6fc5884 | 2012-06-04 13:35:27 +0200 | [diff] [blame] | 512 | else { |
| 513 | struct tty_struct *tty = tty_port_tty_get(&line->port); |
| 514 | if (tty == NULL) { |
| 515 | CONFIG_CHUNK(str, size, n, line->init_str, 1); |
| 516 | } else { |
| 517 | n = chan_config_string(line, str, size, error_out); |
| 518 | tty_kref_put(tty); |
| 519 | } |
| 520 | } |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 521 | |
Paolo 'Blaisorblade' Giarrusso | b97b77c | 2005-05-01 08:58:56 -0700 | [diff] [blame] | 522 | return n; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 523 | } |
| 524 | |
Jeff Dike | 29d56cf | 2005-06-25 14:55:25 -0700 | [diff] [blame] | 525 | int line_id(char **str, int *start_out, int *end_out) |
| 526 | { |
| 527 | char *end; |
Jeff Dike | 2f8a2dc | 2007-10-16 01:26:43 -0700 | [diff] [blame] | 528 | int n; |
Jeff Dike | 29d56cf | 2005-06-25 14:55:25 -0700 | [diff] [blame] | 529 | |
| 530 | n = simple_strtoul(*str, &end, 0); |
Jeff Dike | 2f8a2dc | 2007-10-16 01:26:43 -0700 | [diff] [blame] | 531 | if ((*end != '\0') || (end == *str)) |
| 532 | return -1; |
Jeff Dike | 29d56cf | 2005-06-25 14:55:25 -0700 | [diff] [blame] | 533 | |
Jeff Dike | 2f8a2dc | 2007-10-16 01:26:43 -0700 | [diff] [blame] | 534 | *str = end; |
| 535 | *start_out = n; |
| 536 | *end_out = n; |
| 537 | return n; |
Jeff Dike | 29d56cf | 2005-06-25 14:55:25 -0700 | [diff] [blame] | 538 | } |
| 539 | |
Jeff Dike | f28169d | 2007-02-10 01:43:53 -0800 | [diff] [blame] | 540 | int line_remove(struct line *lines, unsigned int num, int n, char **error_out) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 541 | { |
Al Viro | da645f3 | 2011-09-08 20:34:52 -0400 | [diff] [blame] | 542 | if (n >= num) { |
| 543 | *error_out = "Device number out of range"; |
| 544 | return -EINVAL; |
| 545 | } |
Al Viro | 31efceb | 2011-09-09 19:14:02 -0400 | [diff] [blame] | 546 | return setup_one_line(lines, n, "none", NULL, error_out); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 547 | } |
| 548 | |
Al Viro | cfe6b7c | 2011-09-09 19:45:42 -0400 | [diff] [blame] | 549 | int register_lines(struct line_driver *line_driver, |
| 550 | const struct tty_operations *ops, |
| 551 | struct line *lines, int nlines) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 552 | { |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 553 | struct tty_driver *driver = alloc_tty_driver(nlines); |
Al Viro | cfe6b7c | 2011-09-09 19:45:42 -0400 | [diff] [blame] | 554 | int err; |
Al Viro | 04292b2 | 2011-09-09 20:07:05 -0400 | [diff] [blame] | 555 | int i; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 556 | |
| 557 | if (!driver) |
Al Viro | cfe6b7c | 2011-09-09 19:45:42 -0400 | [diff] [blame] | 558 | return -ENOMEM; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 559 | |
| 560 | driver->driver_name = line_driver->name; |
| 561 | driver->name = line_driver->device_name; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 562 | driver->major = line_driver->major; |
| 563 | driver->minor_start = line_driver->minor_start; |
| 564 | driver->type = line_driver->type; |
| 565 | driver->subtype = line_driver->subtype; |
Al Viro | cfe6b7c | 2011-09-09 19:45:42 -0400 | [diff] [blame] | 566 | driver->flags = TTY_DRIVER_REAL_RAW | TTY_DRIVER_DYNAMIC_DEV; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 567 | driver->init_termios = tty_std_termios; |
Al Viro | 04292b2 | 2011-09-09 20:07:05 -0400 | [diff] [blame] | 568 | |
| 569 | for (i = 0; i < nlines; i++) { |
Jiri Slaby | 060ed31 | 2012-06-04 13:35:26 +0200 | [diff] [blame] | 570 | tty_port_init(&lines[i].port); |
Richard Weinberger | 79e0273 | 2012-06-04 21:57:24 +0200 | [diff] [blame] | 571 | lines[i].port.ops = &line_port_ops; |
Al Viro | 04292b2 | 2011-09-09 20:07:05 -0400 | [diff] [blame] | 572 | spin_lock_init(&lines[i].lock); |
Al Viro | 04292b2 | 2011-09-09 20:07:05 -0400 | [diff] [blame] | 573 | lines[i].driver = line_driver; |
| 574 | INIT_LIST_HEAD(&lines[i].chan_list); |
| 575 | } |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 576 | tty_set_operations(driver, ops); |
| 577 | |
Al Viro | cfe6b7c | 2011-09-09 19:45:42 -0400 | [diff] [blame] | 578 | err = tty_register_driver(driver); |
| 579 | if (err) { |
Jeff Dike | 2f8a2dc | 2007-10-16 01:26:43 -0700 | [diff] [blame] | 580 | printk(KERN_ERR "register_lines : can't register %s driver\n", |
| 581 | line_driver->name); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 582 | put_tty_driver(driver); |
Jiri Slaby | 191c5f1 | 2012-11-15 09:49:56 +0100 | [diff] [blame] | 583 | for (i = 0; i < nlines; i++) |
| 584 | tty_port_destroy(&lines[i].port); |
Al Viro | cfe6b7c | 2011-09-09 19:45:42 -0400 | [diff] [blame] | 585 | return err; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 586 | } |
| 587 | |
Al Viro | cfe6b7c | 2011-09-09 19:45:42 -0400 | [diff] [blame] | 588 | line_driver->driver = driver; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 589 | mconsole_register_dev(&line_driver->mc); |
Al Viro | cfe6b7c | 2011-09-09 19:45:42 -0400 | [diff] [blame] | 590 | return 0; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 591 | } |
| 592 | |
Jeff Dike | 9010772 | 2006-01-06 00:18:54 -0800 | [diff] [blame] | 593 | static DEFINE_SPINLOCK(winch_handler_lock); |
| 594 | static LIST_HEAD(winch_handlers); |
Paolo 'Blaisorblade' Giarrusso | 605a69a | 2005-07-07 17:56:52 -0700 | [diff] [blame] | 595 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 596 | struct winch { |
| 597 | struct list_head list; |
| 598 | int fd; |
| 599 | int tty_fd; |
| 600 | int pid; |
Richard Weinberger | 2116bda | 2013-03-11 10:05:45 +0100 | [diff] [blame] | 601 | struct tty_port *port; |
Jeff Dike | 42a359e | 2007-07-15 23:38:55 -0700 | [diff] [blame] | 602 | unsigned long stack; |
Al Viro | 7cf3cf2 | 2011-09-14 16:21:31 -0700 | [diff] [blame] | 603 | struct work_struct work; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 604 | }; |
| 605 | |
Al Viro | 7cf3cf2 | 2011-09-14 16:21:31 -0700 | [diff] [blame] | 606 | static void __free_winch(struct work_struct *work) |
Jeff Dike | 42a359e | 2007-07-15 23:38:55 -0700 | [diff] [blame] | 607 | { |
Al Viro | 7cf3cf2 | 2011-09-14 16:21:31 -0700 | [diff] [blame] | 608 | struct winch *winch = container_of(work, struct winch, work); |
Richard Weinberger | fa7a044 | 2012-04-17 22:37:13 +0200 | [diff] [blame] | 609 | um_free_irq(WINCH_IRQ, winch); |
Jeff Dike | 42a359e | 2007-07-15 23:38:55 -0700 | [diff] [blame] | 610 | |
| 611 | if (winch->pid != -1) |
| 612 | os_kill_process(winch->pid, 1); |
Jeff Dike | 42a359e | 2007-07-15 23:38:55 -0700 | [diff] [blame] | 613 | if (winch->stack != 0) |
| 614 | free_stack(winch->stack, 0); |
Jeff Dike | 42a359e | 2007-07-15 23:38:55 -0700 | [diff] [blame] | 615 | kfree(winch); |
| 616 | } |
| 617 | |
Al Viro | 7cf3cf2 | 2011-09-14 16:21:31 -0700 | [diff] [blame] | 618 | static void free_winch(struct winch *winch) |
| 619 | { |
| 620 | int fd = winch->fd; |
| 621 | winch->fd = -1; |
| 622 | if (fd != -1) |
| 623 | os_close_file(fd); |
| 624 | list_del(&winch->list); |
| 625 | __free_winch(&winch->work); |
| 626 | } |
| 627 | |
Al Viro | 7bea96f | 2006-10-08 22:49:34 +0100 | [diff] [blame] | 628 | static irqreturn_t winch_interrupt(int irq, void *data) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 629 | { |
| 630 | struct winch *winch = data; |
| 631 | struct tty_struct *tty; |
| 632 | struct line *line; |
Al Viro | 7cf3cf2 | 2011-09-14 16:21:31 -0700 | [diff] [blame] | 633 | int fd = winch->fd; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 634 | int err; |
| 635 | char c; |
Peter Hurley | 8a8a551 | 2014-10-16 14:59:44 -0400 | [diff] [blame] | 636 | struct pid *pgrp; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 637 | |
Al Viro | 7cf3cf2 | 2011-09-14 16:21:31 -0700 | [diff] [blame] | 638 | if (fd != -1) { |
| 639 | err = generic_read(fd, &c, NULL); |
Jeff Dike | 2f8a2dc | 2007-10-16 01:26:43 -0700 | [diff] [blame] | 640 | if (err < 0) { |
| 641 | if (err != -EAGAIN) { |
Al Viro | 7cf3cf2 | 2011-09-14 16:21:31 -0700 | [diff] [blame] | 642 | winch->fd = -1; |
| 643 | list_del(&winch->list); |
| 644 | os_close_file(fd); |
Jeff Dike | 2f8a2dc | 2007-10-16 01:26:43 -0700 | [diff] [blame] | 645 | printk(KERN_ERR "winch_interrupt : " |
| 646 | "read failed, errno = %d\n", -err); |
| 647 | printk(KERN_ERR "fd %d is losing SIGWINCH " |
| 648 | "support\n", winch->tty_fd); |
Al Viro | 7cf3cf2 | 2011-09-14 16:21:31 -0700 | [diff] [blame] | 649 | INIT_WORK(&winch->work, __free_winch); |
| 650 | schedule_work(&winch->work); |
Paolo 'Blaisorblade' Giarrusso | b97b77c | 2005-05-01 08:58:56 -0700 | [diff] [blame] | 651 | return IRQ_HANDLED; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 652 | } |
| 653 | goto out; |
| 654 | } |
| 655 | } |
Richard Weinberger | 2116bda | 2013-03-11 10:05:45 +0100 | [diff] [blame] | 656 | tty = tty_port_tty_get(winch->port); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 657 | if (tty != NULL) { |
| 658 | line = tty->driver_data; |
Jeff Dike | 438ee67 | 2008-02-04 22:31:19 -0800 | [diff] [blame] | 659 | if (line != NULL) { |
Al Viro | bed5e39 | 2011-09-08 10:49:34 -0400 | [diff] [blame] | 660 | chan_window_size(line, &tty->winsize.ws_row, |
Jeff Dike | 438ee67 | 2008-02-04 22:31:19 -0800 | [diff] [blame] | 661 | &tty->winsize.ws_col); |
Peter Hurley | 8a8a551 | 2014-10-16 14:59:44 -0400 | [diff] [blame] | 662 | pgrp = tty_get_pgrp(tty); |
| 663 | if (pgrp) |
| 664 | kill_pgrp(pgrp, SIGWINCH, 1); |
| 665 | put_pid(pgrp); |
Jeff Dike | 438ee67 | 2008-02-04 22:31:19 -0800 | [diff] [blame] | 666 | } |
Richard Weinberger | 2116bda | 2013-03-11 10:05:45 +0100 | [diff] [blame] | 667 | tty_kref_put(tty); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 668 | } |
| 669 | out: |
Jeff Dike | 2f8a2dc | 2007-10-16 01:26:43 -0700 | [diff] [blame] | 670 | if (winch->fd != -1) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 671 | reactivate_fd(winch->fd, WINCH_IRQ); |
Paolo 'Blaisorblade' Giarrusso | b97b77c | 2005-05-01 08:58:56 -0700 | [diff] [blame] | 672 | return IRQ_HANDLED; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 673 | } |
| 674 | |
Richard Weinberger | 2116bda | 2013-03-11 10:05:45 +0100 | [diff] [blame] | 675 | void register_winch_irq(int fd, int tty_fd, int pid, struct tty_port *port, |
Jeff Dike | 42a359e | 2007-07-15 23:38:55 -0700 | [diff] [blame] | 676 | unsigned long stack) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 677 | { |
| 678 | struct winch *winch; |
| 679 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 680 | winch = kmalloc(sizeof(*winch), GFP_KERNEL); |
| 681 | if (winch == NULL) { |
Jeff Dike | 2f8a2dc | 2007-10-16 01:26:43 -0700 | [diff] [blame] | 682 | printk(KERN_ERR "register_winch_irq - kmalloc failed\n"); |
Jeff Dike | 42a359e | 2007-07-15 23:38:55 -0700 | [diff] [blame] | 683 | goto cleanup; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 684 | } |
Paolo 'Blaisorblade' Giarrusso | 605a69a | 2005-07-07 17:56:52 -0700 | [diff] [blame] | 685 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 686 | *winch = ((struct winch) { .list = LIST_HEAD_INIT(winch->list), |
| 687 | .fd = fd, |
| 688 | .tty_fd = tty_fd, |
| 689 | .pid = pid, |
Richard Weinberger | 2116bda | 2013-03-11 10:05:45 +0100 | [diff] [blame] | 690 | .port = port, |
Jeff Dike | 42a359e | 2007-07-15 23:38:55 -0700 | [diff] [blame] | 691 | .stack = stack }); |
| 692 | |
| 693 | if (um_request_irq(WINCH_IRQ, fd, IRQ_READ, winch_interrupt, |
Theodore Ts'o | aab9446 | 2012-07-17 14:18:23 -0400 | [diff] [blame] | 694 | IRQF_SHARED, "winch", winch) < 0) { |
Jeff Dike | 2f8a2dc | 2007-10-16 01:26:43 -0700 | [diff] [blame] | 695 | printk(KERN_ERR "register_winch_irq - failed to register " |
| 696 | "IRQ\n"); |
Jeff Dike | 42a359e | 2007-07-15 23:38:55 -0700 | [diff] [blame] | 697 | goto out_free; |
| 698 | } |
Paolo 'Blaisorblade' Giarrusso | 605a69a | 2005-07-07 17:56:52 -0700 | [diff] [blame] | 699 | |
| 700 | spin_lock(&winch_handler_lock); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 701 | list_add(&winch->list, &winch_handlers); |
Paolo 'Blaisorblade' Giarrusso | 605a69a | 2005-07-07 17:56:52 -0700 | [diff] [blame] | 702 | spin_unlock(&winch_handler_lock); |
| 703 | |
Jeff Dike | 42a359e | 2007-07-15 23:38:55 -0700 | [diff] [blame] | 704 | return; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 705 | |
Jeff Dike | 42a359e | 2007-07-15 23:38:55 -0700 | [diff] [blame] | 706 | out_free: |
Jeff Dike | e464bf2 | 2006-01-06 00:19:01 -0800 | [diff] [blame] | 707 | kfree(winch); |
Jeff Dike | 42a359e | 2007-07-15 23:38:55 -0700 | [diff] [blame] | 708 | cleanup: |
| 709 | os_kill_process(pid, 1); |
| 710 | os_close_file(fd); |
| 711 | if (stack != 0) |
| 712 | free_stack(stack, 0); |
Jeff Dike | cd2ee4a | 2005-05-05 16:15:32 -0700 | [diff] [blame] | 713 | } |
| 714 | |
Jeff Dike | e464bf2 | 2006-01-06 00:19:01 -0800 | [diff] [blame] | 715 | static void unregister_winch(struct tty_struct *tty) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 716 | { |
Will Newton | 48a0b74 | 2011-01-12 16:59:26 -0800 | [diff] [blame] | 717 | struct list_head *ele, *next; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 718 | struct winch *winch; |
Richard Weinberger | 2116bda | 2013-03-11 10:05:45 +0100 | [diff] [blame] | 719 | struct tty_struct *wtty; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 720 | |
Jeff Dike | e464bf2 | 2006-01-06 00:19:01 -0800 | [diff] [blame] | 721 | spin_lock(&winch_handler_lock); |
| 722 | |
Will Newton | 48a0b74 | 2011-01-12 16:59:26 -0800 | [diff] [blame] | 723 | list_for_each_safe(ele, next, &winch_handlers) { |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 724 | winch = list_entry(ele, struct winch, list); |
Richard Weinberger | 2116bda | 2013-03-11 10:05:45 +0100 | [diff] [blame] | 725 | wtty = tty_port_tty_get(winch->port); |
| 726 | if (wtty == tty) { |
Al Viro | 7cf3cf2 | 2011-09-14 16:21:31 -0700 | [diff] [blame] | 727 | free_winch(winch); |
Jeff Dike | e464bf2 | 2006-01-06 00:19:01 -0800 | [diff] [blame] | 728 | break; |
Jeff Dike | 2f8a2dc | 2007-10-16 01:26:43 -0700 | [diff] [blame] | 729 | } |
Richard Weinberger | 2116bda | 2013-03-11 10:05:45 +0100 | [diff] [blame] | 730 | tty_kref_put(wtty); |
Jeff Dike | 2f8a2dc | 2007-10-16 01:26:43 -0700 | [diff] [blame] | 731 | } |
Jeff Dike | e464bf2 | 2006-01-06 00:19:01 -0800 | [diff] [blame] | 732 | spin_unlock(&winch_handler_lock); |
| 733 | } |
| 734 | |
| 735 | static void winch_cleanup(void) |
| 736 | { |
| 737 | struct list_head *ele, *next; |
| 738 | struct winch *winch; |
| 739 | |
| 740 | spin_lock(&winch_handler_lock); |
| 741 | |
Jeff Dike | 2f8a2dc | 2007-10-16 01:26:43 -0700 | [diff] [blame] | 742 | list_for_each_safe(ele, next, &winch_handlers) { |
Jeff Dike | e464bf2 | 2006-01-06 00:19:01 -0800 | [diff] [blame] | 743 | winch = list_entry(ele, struct winch, list); |
Al Viro | 7cf3cf2 | 2011-09-14 16:21:31 -0700 | [diff] [blame] | 744 | free_winch(winch); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 745 | } |
Jeff Dike | e464bf2 | 2006-01-06 00:19:01 -0800 | [diff] [blame] | 746 | |
| 747 | spin_unlock(&winch_handler_lock); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 748 | } |
| 749 | __uml_exitcall(winch_cleanup); |
| 750 | |
| 751 | char *add_xterm_umid(char *base) |
| 752 | { |
| 753 | char *umid, *title; |
| 754 | int len; |
| 755 | |
Jeff Dike | 7eebe8a | 2006-01-06 00:19:01 -0800 | [diff] [blame] | 756 | umid = get_umid(); |
Jeff Dike | 2f8a2dc | 2007-10-16 01:26:43 -0700 | [diff] [blame] | 757 | if (*umid == '\0') |
Paolo 'Blaisorblade' Giarrusso | b97b77c | 2005-05-01 08:58:56 -0700 | [diff] [blame] | 758 | return base; |
Jeff Dike | 165dc59 | 2006-01-06 00:18:57 -0800 | [diff] [blame] | 759 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 760 | len = strlen(base) + strlen(" ()") + strlen(umid) + 1; |
| 761 | title = kmalloc(len, GFP_KERNEL); |
Jeff Dike | 2f8a2dc | 2007-10-16 01:26:43 -0700 | [diff] [blame] | 762 | if (title == NULL) { |
| 763 | printk(KERN_ERR "Failed to allocate buffer for xterm title\n"); |
Paolo 'Blaisorblade' Giarrusso | b97b77c | 2005-05-01 08:58:56 -0700 | [diff] [blame] | 764 | return base; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 765 | } |
| 766 | |
| 767 | snprintf(title, len, "%s (%s)", base, umid); |
Paolo 'Blaisorblade' Giarrusso | b97b77c | 2005-05-01 08:58:56 -0700 | [diff] [blame] | 768 | return title; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 769 | } |