arch/um/drivers/chan_kern.c

   1 /*
   2  * Copyright (C) 2000, 2001, 2002 Jeff Dike (jdike@karaya.com)
   3  * Licensed under the GPL
   4  */
   5
   6 #include <linux/stddef.h>
   7 #include <linux/kernel.h>
   8 #include <linux/list.h>
   9 #include <linux/slab.h>
  10 #include <linux/tty.h>
  11 #include <linux/string.h>
  12 #include <linux/tty_flip.h>
  13 #include <asm/irq.h>
  14 #include "chan_kern.h"
  15 #include "kern.h"
  16 #include "irq_user.h"
  17 #include "sigio.h"
  18 #include "line.h"
  19 #include "os.h"
  20
  21 #ifdef CONFIG_NOCONFIG_CHAN
  22 static void *not_configged_init(char *str, int device,
  23                                 const struct chan_opts *opts)
  24 {
  25         printk("Using a channel type which is configured out of "
  26                "UML\n");
  27         return NULL;
  28 }
  29
  30 static int not_configged_open(int input, int output, int primary, void *data,
  31                               char **dev_out)
  32 {
  33         printk("Using a channel type which is configured out of "
  34                "UML\n");
  35         return -ENODEV;
  36 }
  37
  38 static void not_configged_close(int fd, void *data)
  39 {
  40         printk("Using a channel type which is configured out of "
  41                "UML\n");
  42 }
  43
  44 static int not_configged_read(int fd, char *c_out, void *data)
  45 {
  46         printk("Using a channel type which is configured out of "
  47                "UML\n");
  48         return -EIO;
  49 }
  50
  51 static int not_configged_write(int fd, const char *buf, int len, void *data)
  52 {
  53         printk("Using a channel type which is configured out of "
  54                "UML\n");
  55         return -EIO;
  56 }
  57
  58 static int not_configged_console_write(int fd, const char *buf, int len)
  59 {
  60         printk("Using a channel type which is configured out of "
  61                "UML\n");
  62         return -EIO;
  63 }
  64
  65 static int not_configged_window_size(int fd, void *data, unsigned short *rows,
  66                                      unsigned short *cols)
  67 {
  68         printk("Using a channel type which is configured out of "
  69                "UML\n");
  70         return -ENODEV;
  71 }
  72
  73 static void not_configged_free(void *data)
  74 {
  75         printk("Using a channel type which is configured out of "
  76                "UML\n");
  77 }
  78
  79 static const struct chan_ops not_configged_ops = {
  80         .init           = not_configged_init,
  81         .open           = not_configged_open,
  82         .close          = not_configged_close,
  83         .read           = not_configged_read,
  84         .write          = not_configged_write,
  85         .console_write  = not_configged_console_write,
  86         .window_size    = not_configged_window_size,
  87         .free           = not_configged_free,
  88         .winch          = 0,
  89 };
  90 #endif /* CONFIG_NOCONFIG_CHAN */
  91
  92 static void tty_receive_char(struct tty_struct *tty, char ch)
  93 {
  94         if(tty == NULL) return;
  95
  96         if(I_IXON(tty) && !I_IXOFF(tty) && !tty->raw) {
  97                 if(ch == STOP_CHAR(tty)){
  98                         stop_tty(tty);
  99                         return;
 100                 }
 101                 else if(ch == START_CHAR(tty)){
 102                         start_tty(tty);
 103                         return;
 104                 }
 105         }
 106
 107         tty_insert_flip_char(tty, ch, TTY_NORMAL);
 108 }
 109
 110 static int open_one_chan(struct chan *chan)
 111 {
 112         int fd, err;
 113
 114         if(chan->opened)
 115                 return 0;
 116
 117         if(chan->ops->open == NULL)
 118                 fd = 0;
 119         else fd = (*chan->ops->open)(chan->input, chan->output, chan->primary,
 120                                      chan->data, &chan->dev);
 121         if(fd < 0)
 122                 return fd;
 123
 124         err = os_set_fd_block(fd, 0);
 125         if (err) {
 126                 (*chan->ops->close)(fd, chan->data);
 127                 return err;
 128         }
 129
 130         chan->fd = fd;
 131
 132         chan->opened = 1;
 133         return 0;
 134 }
 135
 136 int open_chan(struct list_head *chans)
 137 {
 138         struct list_head *ele;
 139         struct chan *chan;
 140         int ret, err = 0;
 141
 142         list_for_each(ele, chans){
 143                 chan = list_entry(ele, struct chan, list);
 144                 ret = open_one_chan(chan);
 145                 if(chan->primary)
 146                         err = ret;
 147         }
 148         return err;
 149 }
 150
 151 void chan_enable_winch(struct list_head *chans, struct tty_struct *tty)
 152 {
 153         struct list_head *ele;
 154         struct chan *chan;
 155
 156         list_for_each(ele, chans){
 157                 chan = list_entry(ele, struct chan, list);
 158                 if(chan->primary && chan->output && chan->ops->winch){
 159                         register_winch(chan->fd, tty);
 160                         return;
 161                 }
 162         }
 163 }
 164
 165 int enable_chan(struct line *line)
 166 {
 167         struct list_head *ele;
 168         struct chan *chan;
 169         int err;
 170
 171         list_for_each(ele, &line->chan_list){
 172                 chan = list_entry(ele, struct chan, list);
 173                 err = open_one_chan(chan);
 174                 if (err) {
 175                         if (chan->primary)
 176                                 goto out_close;
 177
 178                         continue;
 179                 }
 180
 181                 if(chan->enabled)
 182                         continue;
 183                 err = line_setup_irq(chan->fd, chan->input, chan->output, line,
 184                                      chan);
 185                 if (err)
 186                         goto out_close;
 187
 188                 chan->enabled = 1;
 189         }
 190
 191         return 0;
 192
 193  out_close:
 194         close_chan(&line->chan_list, 0);
 195         return err;
 196 }
 197
 198 /* Items are added in IRQ context, when free_irq can't be called, and
 199  * removed in process context, when it can.
 200  * This handles interrupt sources which disappear, and which need to
 201  * be permanently disabled.  This is discovered in IRQ context, but
 202  * the freeing of the IRQ must be done later.
 203  */
 204 static DEFINE_SPINLOCK(irqs_to_free_lock);
 205 static LIST_HEAD(irqs_to_free);
 206
 207 void free_irqs(void)
 208 {
 209         struct chan *chan;
 210         LIST_HEAD(list);
 211         struct list_head *ele;
 212         unsigned long flags;
 213
 214         spin_lock_irqsave(&irqs_to_free_lock, flags);
 215         list_splice_init(&irqs_to_free, &list);
 216         spin_unlock_irqrestore(&irqs_to_free_lock, flags);
 217
 218         list_for_each(ele, &list){
 219                 chan = list_entry(ele, struct chan, free_list);
 220
 221                 if(chan->input)
 222                         free_irq(chan->line->driver->read_irq, chan);
 223                 if(chan->output)
 224                         free_irq(chan->line->driver->write_irq, chan);
 225                 chan->enabled = 0;
 226         }
 227 }
 228
 229 static void close_one_chan(struct chan *chan, int delay_free_irq)
 230 {
 231         unsigned long flags;
 232
 233         if(!chan->opened)
 234                 return;
 235
 236         if(delay_free_irq){
 237                 spin_lock_irqsave(&irqs_to_free_lock, flags);
 238                 list_add(&chan->free_list, &irqs_to_free);
 239                 spin_unlock_irqrestore(&irqs_to_free_lock, flags);
 240         }
 241         else {
 242                 if(chan->input)
 243                         free_irq(chan->line->driver->read_irq, chan);
 244                 if(chan->output)
 245                         free_irq(chan->line->driver->write_irq, chan);
 246                 chan->enabled = 0;
 247         }
 248         if(chan->ops->close != NULL)
 249                 (*chan->ops->close)(chan->fd, chan->data);
 250
 251         chan->opened = 0;
 252         chan->fd = -1;
 253 }
 254
 255 void close_chan(struct list_head *chans, int delay_free_irq)
 256 {
 257         struct chan *chan;
 258
 259         /* Close in reverse order as open in case more than one of them
 260          * refers to the same device and they save and restore that device's
 261          * state.  Then, the first one opened will have the original state,
 262          * so it must be the last closed.
 263          */
 264         list_for_each_entry_reverse(chan, chans, list) {
 265                 close_one_chan(chan, delay_free_irq);
 266         }
 267 }
 268
 269 void deactivate_chan(struct list_head *chans, int irq)
 270 {
 271         struct list_head *ele;
 272
 273         struct chan *chan;
 274         list_for_each(ele, chans) {
 275                 chan = list_entry(ele, struct chan, list);
 276
 277                 if(chan->enabled && chan->input)
 278                         deactivate_fd(chan->fd, irq);
 279         }
 280 }
 281
 282 void reactivate_chan(struct list_head *chans, int irq)
 283 {
 284         struct list_head *ele;
 285         struct chan *chan;
 286
 287         list_for_each(ele, chans) {
 288                 chan = list_entry(ele, struct chan, list);
 289
 290                 if(chan->enabled && chan->input)
 291                         reactivate_fd(chan->fd, irq);
 292         }
 293 }
 294
 295 int write_chan(struct list_head *chans, const char *buf, int len,
 296                int write_irq)
 297 {
 298         struct list_head *ele;
 299         struct chan *chan = NULL;
 300         int n, ret = 0;
 301
 302         list_for_each(ele, chans) {
 303                 chan = list_entry(ele, struct chan, list);
 304                 if (!chan->output || (chan->ops->write == NULL))
 305                         continue;
 306                 n = chan->ops->write(chan->fd, buf, len, chan->data);
 307                 if (chan->primary) {
 308                         ret = n;
 309                         if ((ret == -EAGAIN) || ((ret >= 0) && (ret < len)))
 310                                 reactivate_fd(chan->fd, write_irq);
 311                 }
 312         }
 313         return ret;
 314 }
 315
 316 int console_write_chan(struct list_head *chans, const char *buf, int len)
 317 {
 318         struct list_head *ele;
 319         struct chan *chan;
 320         int n, ret = 0;
 321
 322         list_for_each(ele, chans){
 323                 chan = list_entry(ele, struct chan, list);
 324                 if(!chan->output || (chan->ops->console_write == NULL))
 325                         continue;
 326                 n = chan->ops->console_write(chan->fd, buf, len);
 327                 if(chan->primary) ret = n;
 328         }
 329         return ret;
 330 }
 331
 332 int console_open_chan(struct line *line, struct console *co)
 333 {
 334         int err;
 335
 336         err = open_chan(&line->chan_list);
 337         if(err)
 338                 return err;
 339
 340         printk("Console initialized on /dev/%s%d\n", co->name, co->index);
 341         return 0;
 342 }
 343
 344 int chan_window_size(struct list_head *chans, unsigned short *rows_out,
 345                       unsigned short *cols_out)
 346 {
 347         struct list_head *ele;
 348         struct chan *chan;
 349
 350         list_for_each(ele, chans){
 351                 chan = list_entry(ele, struct chan, list);
 352                 if(chan->primary){
 353                         if(chan->ops->window_size == NULL)
 354                                 return 0;
 355                         return chan->ops->window_size(chan->fd, chan->data,
 356                                                       rows_out, cols_out);
 357                 }
 358         }
 359         return 0;
 360 }
 361
 362 static void free_one_chan(struct chan *chan, int delay_free_irq)
 363 {
 364         list_del(&chan->list);
 365
 366         close_one_chan(chan, delay_free_irq);
 367
 368         if(chan->ops->free != NULL)
 369                 (*chan->ops->free)(chan->data);
 370
 371         if(chan->primary && chan->output) ignore_sigio_fd(chan->fd);
 372         kfree(chan);
 373 }
 374
 375 static void free_chan(struct list_head *chans, int delay_free_irq)
 376 {
 377         struct list_head *ele, *next;
 378         struct chan *chan;
 379
 380         list_for_each_safe(ele, next, chans){
 381                 chan = list_entry(ele, struct chan, list);
 382                 free_one_chan(chan, delay_free_irq);
 383         }
 384 }
 385
 386 static int one_chan_config_string(struct chan *chan, char *str, int size,
 387                                   char **error_out)
 388 {
 389         int n = 0;
 390
 391         if(chan == NULL){
 392                 CONFIG_CHUNK(str, size, n, "none", 1);
 393                 return n;
 394         }
 395
 396         CONFIG_CHUNK(str, size, n, chan->ops->type, 0);
 397
 398         if(chan->dev == NULL){
 399                 CONFIG_CHUNK(str, size, n, "", 1);
 400                 return n;
 401         }
 402
 403         CONFIG_CHUNK(str, size, n, ":", 0);
 404         CONFIG_CHUNK(str, size, n, chan->dev, 0);
 405
 406         return n;
 407 }
 408
 409 static int chan_pair_config_string(struct chan *in, struct chan *out,
 410                                    char *str, int size, char **error_out)
 411 {
 412         int n;
 413
 414         n = one_chan_config_string(in, str, size, error_out);
 415         str += n;
 416         size -= n;
 417
 418         if(in == out){
 419                 CONFIG_CHUNK(str, size, n, "", 1);
 420                 return n;
 421         }
 422
 423         CONFIG_CHUNK(str, size, n, ",", 1);
 424         n = one_chan_config_string(out, str, size, error_out);
 425         str += n;
 426         size -= n;
 427         CONFIG_CHUNK(str, size, n, "", 1);
 428
 429         return n;
 430 }
 431
 432 int chan_config_string(struct list_head *chans, char *str, int size,
 433                        char **error_out)
 434 {
 435         struct list_head *ele;
 436         struct chan *chan, *in = NULL, *out = NULL;
 437
 438         list_for_each(ele, chans){
 439                 chan = list_entry(ele, struct chan, list);
 440                 if(!chan->primary)
 441                         continue;
 442                 if(chan->input)
 443                         in = chan;
 444                 if(chan->output)
 445                         out = chan;
 446         }
 447
 448         return chan_pair_config_string(in, out, str, size, error_out);
 449 }
 450
 451 struct chan_type {
 452         char *key;
 453         const struct chan_ops *ops;
 454 };
 455
 456 static const struct chan_type chan_table[] = {
 457         { "fd", &fd_ops },
 458
 459 #ifdef CONFIG_NULL_CHAN
 460         { "null", &null_ops },
 461 #else
 462         { "null", &not_configged_ops },
 463 #endif
 464
 465 #ifdef CONFIG_PORT_CHAN
 466         { "port", &port_ops },
 467 #else
 468         { "port", &not_configged_ops },
 469 #endif
 470
 471 #ifdef CONFIG_PTY_CHAN
 472         { "pty", &pty_ops },
 473         { "pts", &pts_ops },
 474 #else
 475         { "pty", &not_configged_ops },
 476         { "pts", &not_configged_ops },
 477 #endif
 478
 479 #ifdef CONFIG_TTY_CHAN
 480         { "tty", &tty_ops },
 481 #else
 482         { "tty", &not_configged_ops },
 483 #endif
 484
 485 #ifdef CONFIG_XTERM_CHAN
 486         { "xterm", &xterm_ops },
 487 #else
 488         { "xterm", &not_configged_ops },
 489 #endif
 490 };
 491
 492 static struct chan *parse_chan(struct line *line, char *str, int device,
 493                                const struct chan_opts *opts, char **error_out)
 494 {
 495         const struct chan_type *entry;
 496         const struct chan_ops *ops;
 497         struct chan *chan;
 498         void *data;
 499         int i;
 500
 501         ops = NULL;
 502         data = NULL;
 503         for(i = 0; i < ARRAY_SIZE(chan_table); i++){
 504                 entry = &chan_table[i];
 505                 if(!strncmp(str, entry->key, strlen(entry->key))){
 506                         ops = entry->ops;
 507                         str += strlen(entry->key);
 508                         break;
 509                 }
 510         }
 511         if(ops == NULL){
 512                 *error_out = "No match for configured backends";
 513                 return NULL;
 514         }
 515
 516         data = (*ops->init)(str, device, opts);
 517         if(data == NULL){
 518                 *error_out = "Configuration failed";
 519                 return NULL;
 520         }
 521
 522         chan = kmalloc(sizeof(*chan), GFP_ATOMIC);
 523         if(chan == NULL){
 524                 *error_out = "Memory allocation failed";
 525                 return NULL;
 526         }
 527         *chan = ((struct chan) { .list          = LIST_HEAD_INIT(chan->list),
 528                                  .free_list     =
 529                                         LIST_HEAD_INIT(chan->free_list),
 530                                  .line          = line,
 531                                  .primary       = 1,
 532                                  .input         = 0,
 533                                  .output        = 0,
 534                                  .opened        = 0,
 535                                  .enabled       = 0,
 536                                  .fd            = -1,
 537                                  .ops           = ops,
 538                                  .data          = data });
 539         return chan;
 540 }
 541
 542 int parse_chan_pair(char *str, struct line *line, int device,
 543                     const struct chan_opts *opts, char **error_out)
 544 {
 545         struct list_head *chans = &line->chan_list;
 546         struct chan *new, *chan;
 547         char *in, *out;
 548
 549         if(!list_empty(chans)){
 550                 chan = list_entry(chans->next, struct chan, list);
 551                 free_chan(chans, 0);
 552                 INIT_LIST_HEAD(chans);
 553         }
 554
 555         out = strchr(str, ',');
 556         if(out != NULL){
 557                 in = str;
 558                 *out = '\0';
 559                 out++;
 560                 new = parse_chan(line, in, device, opts, error_out);
 561                 if(new == NULL)
 562                         return -1;
 563
 564                 new->input = 1;
 565                 list_add(&new->list, chans);
 566
 567                 new = parse_chan(line, out, device, opts, error_out);
 568                 if(new == NULL)
 569                         return -1;
 570
 571                 list_add(&new->list, chans);
 572                 new->output = 1;
 573         }
 574         else {
 575                 new = parse_chan(line, str, device, opts, error_out);
 576                 if(new == NULL)
 577                         return -1;
 578
 579                 list_add(&new->list, chans);
 580                 new->input = 1;
 581                 new->output = 1;
 582         }
 583         return 0;
 584 }
 585
 586 int chan_out_fd(struct list_head *chans)
 587 {
 588         struct list_head *ele;
 589         struct chan *chan;
 590
 591         list_for_each(ele, chans){
 592                 chan = list_entry(ele, struct chan, list);
 593                 if(chan->primary && chan->output)
 594                         return chan->fd;
 595         }
 596         return -1;
 597 }
 598
 599 void chan_interrupt(struct list_head *chans, struct delayed_work *task,
 600                     struct tty_struct *tty, int irq)
 601 {
 602         struct list_head *ele, *next;
 603         struct chan *chan;
 604         int err;
 605         char c;
 606
 607         list_for_each_safe(ele, next, chans){
 608                 chan = list_entry(ele, struct chan, list);
 609                 if(!chan->input || (chan->ops->read == NULL)) continue;
 610                 do {
 611                         if (tty && !tty_buffer_request_room(tty, 1)) {
 612                                 schedule_delayed_work(task, 1);
 613                                 goto out;
 614                         }
 615                         err = chan->ops->read(chan->fd, &c, chan->data);
 616                         if(err > 0)
 617                                 tty_receive_char(tty, c);
 618                 } while(err > 0);
 619
 620                 if(err == 0) reactivate_fd(chan->fd, irq);
 621                 if(err == -EIO){
 622                         if(chan->primary){
 623                                 if(tty != NULL)
 624                                         tty_hangup(tty);
 625                                 close_chan(chans, 1);
 626                                 return;
 627                         }
 628                         else close_one_chan(chan, 1);
 629                 }
 630         }
 631  out:
 632         if(tty) tty_flip_buffer_push(tty);
 633 }