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