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