]> git.karo-electronics.de Git - karo-tx-linux.git/blob - drivers/s390/char/con3215.c
Merge remote-tracking branch 'usb-chipidea-next/ci-for-usb-next'
[karo-tx-linux.git] / drivers / s390 / char / con3215.c
1 /*
2  * 3215 line mode terminal driver.
3  *
4  * Copyright IBM Corp. 1999, 2009
5  * Author(s): Martin Schwidefsky <schwidefsky@de.ibm.com>
6  *
7  * Updated:
8  *  Aug-2000: Added tab support
9  *            Dan Morrison, IBM Corporation <dmorriso@cse.buffalo.edu>
10  */
11
12 #include <linux/module.h>
13 #include <linux/types.h>
14 #include <linux/kdev_t.h>
15 #include <linux/tty.h>
16 #include <linux/tty_flip.h>
17 #include <linux/vt_kern.h>
18 #include <linux/init.h>
19 #include <linux/console.h>
20 #include <linux/interrupt.h>
21 #include <linux/err.h>
22 #include <linux/reboot.h>
23 #include <linux/serial.h> /* ASYNC_* flags */
24 #include <linux/slab.h>
25 #include <asm/ccwdev.h>
26 #include <asm/cio.h>
27 #include <asm/io.h>
28 #include <asm/ebcdic.h>
29 #include <asm/uaccess.h>
30 #include <asm/delay.h>
31 #include <asm/cpcmd.h>
32 #include <asm/setup.h>
33
34 #include "ctrlchar.h"
35
36 #define NR_3215             1
37 #define NR_3215_REQ         (4*NR_3215)
38 #define RAW3215_BUFFER_SIZE 65536     /* output buffer size */
39 #define RAW3215_INBUF_SIZE  256       /* input buffer size */
40 #define RAW3215_MIN_SPACE   128       /* minimum free space for wakeup */
41 #define RAW3215_MIN_WRITE   1024      /* min. length for immediate output */
42 #define RAW3215_MAX_BYTES   3968      /* max. bytes to write with one ssch */
43 #define RAW3215_MAX_NEWLINE 50        /* max. lines to write with one ssch */
44 #define RAW3215_NR_CCWS     3
45 #define RAW3215_TIMEOUT     HZ/10     /* time for delayed output */
46
47 #define RAW3215_FIXED       1         /* 3215 console device is not be freed */
48 #define RAW3215_WORKING     4         /* set if a request is being worked on */
49 #define RAW3215_THROTTLED   8         /* set if reading is disabled */
50 #define RAW3215_STOPPED     16        /* set if writing is disabled */
51 #define RAW3215_TIMER_RUNS  64        /* set if the output delay timer is on */
52 #define RAW3215_FLUSHING    128       /* set to flush buffer (no delay) */
53
54 #define TAB_STOP_SIZE       8         /* tab stop size */
55
56 /*
57  * Request types for a 3215 device
58  */
59 enum raw3215_type {
60         RAW3215_FREE, RAW3215_READ, RAW3215_WRITE
61 };
62
63 /*
64  * Request structure for a 3215 device
65  */
66 struct raw3215_req {
67         enum raw3215_type type;       /* type of the request */
68         int start, len;               /* start index & len in output buffer */
69         int delayable;                /* indication to wait for more data */
70         int residual;                 /* residual count for read request */
71         struct ccw1 ccws[RAW3215_NR_CCWS]; /* space for the channel program */
72         struct raw3215_info *info;    /* pointer to main structure */
73         struct raw3215_req *next;     /* pointer to next request */
74 } __attribute__ ((aligned(8)));
75
76 struct raw3215_info {
77         struct tty_port port;
78         struct ccw_device *cdev;      /* device for tty driver */
79         spinlock_t *lock;             /* pointer to irq lock */
80         int flags;                    /* state flags */
81         char *buffer;                 /* pointer to output buffer */
82         char *inbuf;                  /* pointer to input buffer */
83         int head;                     /* first free byte in output buffer */
84         int count;                    /* number of bytes in output buffer */
85         int written;                  /* number of bytes in write requests */
86         struct raw3215_req *queued_read; /* pointer to queued read requests */
87         struct raw3215_req *queued_write;/* pointer to queued write requests */
88         struct tasklet_struct tlet;   /* tasklet to invoke tty_wakeup */
89         wait_queue_head_t empty_wait; /* wait queue for flushing */
90         struct timer_list timer;      /* timer for delayed output */
91         int line_pos;                 /* position on the line (for tabs) */
92         char ubuffer[80];             /* copy_from_user buffer */
93 };
94
95 /* array of 3215 devices structures */
96 static struct raw3215_info *raw3215[NR_3215];
97 /* spinlock to protect the raw3215 array */
98 static DEFINE_SPINLOCK(raw3215_device_lock);
99 /* list of free request structures */
100 static struct raw3215_req *raw3215_freelist;
101 /* spinlock to protect free list */
102 static spinlock_t raw3215_freelist_lock;
103
104 static struct tty_driver *tty3215_driver;
105
106 /*
107  * Get a request structure from the free list
108  */
109 static inline struct raw3215_req *raw3215_alloc_req(void)
110 {
111         struct raw3215_req *req;
112         unsigned long flags;
113
114         spin_lock_irqsave(&raw3215_freelist_lock, flags);
115         req = raw3215_freelist;
116         raw3215_freelist = req->next;
117         spin_unlock_irqrestore(&raw3215_freelist_lock, flags);
118         return req;
119 }
120
121 /*
122  * Put a request structure back to the free list
123  */
124 static inline void raw3215_free_req(struct raw3215_req *req)
125 {
126         unsigned long flags;
127
128         if (req->type == RAW3215_FREE)
129                 return;         /* don't free a free request */
130         req->type = RAW3215_FREE;
131         spin_lock_irqsave(&raw3215_freelist_lock, flags);
132         req->next = raw3215_freelist;
133         raw3215_freelist = req;
134         spin_unlock_irqrestore(&raw3215_freelist_lock, flags);
135 }
136
137 /*
138  * Set up a read request that reads up to 160 byte from the 3215 device.
139  * If there is a queued read request it is used, but that shouldn't happen
140  * because a 3215 terminal won't accept a new read before the old one is
141  * completed.
142  */
143 static void raw3215_mk_read_req(struct raw3215_info *raw)
144 {
145         struct raw3215_req *req;
146         struct ccw1 *ccw;
147
148         /* there can only be ONE read request at a time */
149         req = raw->queued_read;
150         if (req == NULL) {
151                 /* no queued read request, use new req structure */
152                 req = raw3215_alloc_req();
153                 req->type = RAW3215_READ;
154                 req->info = raw;
155                 raw->queued_read = req;
156         }
157
158         ccw = req->ccws;
159         ccw->cmd_code = 0x0A; /* read inquiry */
160         ccw->flags = 0x20;    /* ignore incorrect length */
161         ccw->count = 160;
162         ccw->cda = (__u32) __pa(raw->inbuf);
163 }
164
165 /*
166  * Set up a write request with the information from the main structure.
167  * A ccw chain is created that writes as much as possible from the output
168  * buffer to the 3215 device. If a queued write exists it is replaced by
169  * the new, probably lengthened request.
170  */
171 static void raw3215_mk_write_req(struct raw3215_info *raw)
172 {
173         struct raw3215_req *req;
174         struct ccw1 *ccw;
175         int len, count, ix, lines;
176
177         if (raw->count <= raw->written)
178                 return;
179         /* check if there is a queued write request */
180         req = raw->queued_write;
181         if (req == NULL) {
182                 /* no queued write request, use new req structure */
183                 req = raw3215_alloc_req();
184                 req->type = RAW3215_WRITE;
185                 req->info = raw;
186                 raw->queued_write = req;
187         } else {
188                 raw->written -= req->len;
189         }
190
191         ccw = req->ccws;
192         req->start = (raw->head - raw->count + raw->written) &
193                      (RAW3215_BUFFER_SIZE - 1);
194         /*
195          * now we have to count newlines. We can at max accept
196          * RAW3215_MAX_NEWLINE newlines in a single ssch due to
197          * a restriction in VM
198          */
199         lines = 0;
200         ix = req->start;
201         while (lines < RAW3215_MAX_NEWLINE && ix != raw->head) {
202                 if (raw->buffer[ix] == 0x15)
203                         lines++;
204                 ix = (ix + 1) & (RAW3215_BUFFER_SIZE - 1);
205         }
206         len = ((ix - 1 - req->start) & (RAW3215_BUFFER_SIZE - 1)) + 1;
207         if (len > RAW3215_MAX_BYTES)
208                 len = RAW3215_MAX_BYTES;
209         req->len = len;
210         raw->written += len;
211
212         /* set the indication if we should try to enlarge this request */
213         req->delayable = (ix == raw->head) && (len < RAW3215_MIN_WRITE);
214
215         ix = req->start;
216         while (len > 0) {
217                 if (ccw > req->ccws)
218                         ccw[-1].flags |= 0x40; /* use command chaining */
219                 ccw->cmd_code = 0x01; /* write, auto carrier return */
220                 ccw->flags = 0x20;    /* ignore incorrect length ind.  */
221                 ccw->cda =
222                         (__u32) __pa(raw->buffer + ix);
223                 count = len;
224                 if (ix + count > RAW3215_BUFFER_SIZE)
225                         count = RAW3215_BUFFER_SIZE - ix;
226                 ccw->count = count;
227                 len -= count;
228                 ix = (ix + count) & (RAW3215_BUFFER_SIZE - 1);
229                 ccw++;
230         }
231         /*
232          * Add a NOP to the channel program. 3215 devices are purely
233          * emulated and its much better to avoid the channel end
234          * interrupt in this case.
235          */
236         if (ccw > req->ccws)
237                 ccw[-1].flags |= 0x40; /* use command chaining */
238         ccw->cmd_code = 0x03; /* NOP */
239         ccw->flags = 0;
240         ccw->cda = 0;
241         ccw->count = 1;
242 }
243
244 /*
245  * Start a read or a write request
246  */
247 static void raw3215_start_io(struct raw3215_info *raw)
248 {
249         struct raw3215_req *req;
250         int res;
251
252         req = raw->queued_read;
253         if (req != NULL &&
254             !(raw->flags & (RAW3215_WORKING | RAW3215_THROTTLED))) {
255                 /* dequeue request */
256                 raw->queued_read = NULL;
257                 res = ccw_device_start(raw->cdev, req->ccws,
258                                        (unsigned long) req, 0, 0);
259                 if (res != 0) {
260                         /* do_IO failed, put request back to queue */
261                         raw->queued_read = req;
262                 } else {
263                         raw->flags |= RAW3215_WORKING;
264                 }
265         }
266         req = raw->queued_write;
267         if (req != NULL &&
268             !(raw->flags & (RAW3215_WORKING | RAW3215_STOPPED))) {
269                 /* dequeue request */
270                 raw->queued_write = NULL;
271                 res = ccw_device_start(raw->cdev, req->ccws,
272                                        (unsigned long) req, 0, 0);
273                 if (res != 0) {
274                         /* do_IO failed, put request back to queue */
275                         raw->queued_write = req;
276                 } else {
277                         raw->flags |= RAW3215_WORKING;
278                 }
279         }
280 }
281
282 /*
283  * Function to start a delayed output after RAW3215_TIMEOUT seconds
284  */
285 static void raw3215_timeout(unsigned long __data)
286 {
287         struct raw3215_info *raw = (struct raw3215_info *) __data;
288         unsigned long flags;
289
290         spin_lock_irqsave(get_ccwdev_lock(raw->cdev), flags);
291         raw->flags &= ~RAW3215_TIMER_RUNS;
292         if (!(raw->port.flags & ASYNC_SUSPENDED)) {
293                 raw3215_mk_write_req(raw);
294                 raw3215_start_io(raw);
295                 if ((raw->queued_read || raw->queued_write) &&
296                     !(raw->flags & RAW3215_WORKING) &&
297                     !(raw->flags & RAW3215_TIMER_RUNS)) {
298                         raw->timer.expires = RAW3215_TIMEOUT + jiffies;
299                         add_timer(&raw->timer);
300                         raw->flags |= RAW3215_TIMER_RUNS;
301                 }
302         }
303         spin_unlock_irqrestore(get_ccwdev_lock(raw->cdev), flags);
304 }
305
306 /*
307  * Function to conditionally start an IO. A read is started immediately,
308  * a write is only started immediately if the flush flag is on or the
309  * amount of data is bigger than RAW3215_MIN_WRITE. If a write is not
310  * done immediately a timer is started with a delay of RAW3215_TIMEOUT.
311  */
312 static inline void raw3215_try_io(struct raw3215_info *raw)
313 {
314         if (!(raw->port.flags & ASYNC_INITIALIZED) ||
315                         (raw->port.flags & ASYNC_SUSPENDED))
316                 return;
317         if (raw->queued_read != NULL)
318                 raw3215_start_io(raw);
319         else if (raw->queued_write != NULL) {
320                 if ((raw->queued_write->delayable == 0) ||
321                     (raw->flags & RAW3215_FLUSHING)) {
322                         /* execute write requests bigger than minimum size */
323                         raw3215_start_io(raw);
324                 }
325         }
326         if ((raw->queued_read || raw->queued_write) &&
327             !(raw->flags & RAW3215_WORKING) &&
328             !(raw->flags & RAW3215_TIMER_RUNS)) {
329                 raw->timer.expires = RAW3215_TIMEOUT + jiffies;
330                 add_timer(&raw->timer);
331                 raw->flags |= RAW3215_TIMER_RUNS;
332         }
333 }
334
335 /*
336  * Call tty_wakeup from tasklet context
337  */
338 static void raw3215_wakeup(unsigned long data)
339 {
340         struct raw3215_info *raw = (struct raw3215_info *) data;
341         struct tty_struct *tty;
342
343         tty = tty_port_tty_get(&raw->port);
344         if (tty) {
345                 tty_wakeup(tty);
346                 tty_kref_put(tty);
347         }
348 }
349
350 /*
351  * Try to start the next IO and wake up processes waiting on the tty.
352  */
353 static void raw3215_next_io(struct raw3215_info *raw, struct tty_struct *tty)
354 {
355         raw3215_mk_write_req(raw);
356         raw3215_try_io(raw);
357         if (tty && RAW3215_BUFFER_SIZE - raw->count >= RAW3215_MIN_SPACE)
358                 tasklet_schedule(&raw->tlet);
359 }
360
361 /*
362  * Interrupt routine, called from common io layer
363  */
364 static void raw3215_irq(struct ccw_device *cdev, unsigned long intparm,
365                         struct irb *irb)
366 {
367         struct raw3215_info *raw;
368         struct raw3215_req *req;
369         struct tty_struct *tty;
370         int cstat, dstat;
371         int count;
372
373         raw = dev_get_drvdata(&cdev->dev);
374         req = (struct raw3215_req *) intparm;
375         tty = tty_port_tty_get(&raw->port);
376         cstat = irb->scsw.cmd.cstat;
377         dstat = irb->scsw.cmd.dstat;
378         if (cstat != 0)
379                 raw3215_next_io(raw, tty);
380         if (dstat & 0x01) { /* we got a unit exception */
381                 dstat &= ~0x01;  /* we can ignore it */
382         }
383         switch (dstat) {
384         case 0x80:
385                 if (cstat != 0)
386                         break;
387                 /* Attention interrupt, someone hit the enter key */
388                 raw3215_mk_read_req(raw);
389                 raw3215_next_io(raw, tty);
390                 break;
391         case 0x08:
392         case 0x0C:
393                 /* Channel end interrupt. */
394                 if ((raw = req->info) == NULL)
395                         goto put_tty;        /* That shouldn't happen ... */
396                 if (req->type == RAW3215_READ) {
397                         /* store residual count, then wait for device end */
398                         req->residual = irb->scsw.cmd.count;
399                 }
400                 if (dstat == 0x08)
401                         break;
402         case 0x04:
403                 /* Device end interrupt. */
404                 if ((raw = req->info) == NULL)
405                         goto put_tty;        /* That shouldn't happen ... */
406                 if (req->type == RAW3215_READ && tty != NULL) {
407                         unsigned int cchar;
408
409                         count = 160 - req->residual;
410                         EBCASC(raw->inbuf, count);
411                         cchar = ctrlchar_handle(raw->inbuf, count, tty);
412                         switch (cchar & CTRLCHAR_MASK) {
413                         case CTRLCHAR_SYSRQ:
414                                 break;
415
416                         case CTRLCHAR_CTRL:
417                                 tty_insert_flip_char(&raw->port, cchar,
418                                                 TTY_NORMAL);
419                                 tty_flip_buffer_push(&raw->port);
420                                 break;
421
422                         case CTRLCHAR_NONE:
423                                 if (count < 2 ||
424                                     (strncmp(raw->inbuf+count-2, "\252n", 2) &&
425                                      strncmp(raw->inbuf+count-2, "^n", 2)) ) {
426                                         /* add the auto \n */
427                                         raw->inbuf[count] = '\n';
428                                         count++;
429                                 } else
430                                         count -= 2;
431                                 tty_insert_flip_string(&raw->port, raw->inbuf,
432                                                 count);
433                                 tty_flip_buffer_push(&raw->port);
434                                 break;
435                         }
436                 } else if (req->type == RAW3215_WRITE) {
437                         raw->count -= req->len;
438                         raw->written -= req->len;
439                 }
440                 raw->flags &= ~RAW3215_WORKING;
441                 raw3215_free_req(req);
442                 /* check for empty wait */
443                 if (waitqueue_active(&raw->empty_wait) &&
444                     raw->queued_write == NULL &&
445                     raw->queued_read == NULL) {
446                         wake_up_interruptible(&raw->empty_wait);
447                 }
448                 raw3215_next_io(raw, tty);
449                 break;
450         default:
451                 /* Strange interrupt, I'll do my best to clean up */
452                 if (req != NULL && req->type != RAW3215_FREE) {
453                         if (req->type == RAW3215_WRITE) {
454                                 raw->count -= req->len;
455                                 raw->written -= req->len;
456                         }
457                         raw->flags &= ~RAW3215_WORKING;
458                         raw3215_free_req(req);
459                 }
460                 raw3215_next_io(raw, tty);
461         }
462 put_tty:
463         tty_kref_put(tty);
464 }
465
466 /*
467  * Drop the oldest line from the output buffer.
468  */
469 static void raw3215_drop_line(struct raw3215_info *raw)
470 {
471         int ix;
472         char ch;
473
474         BUG_ON(raw->written != 0);
475         ix = (raw->head - raw->count) & (RAW3215_BUFFER_SIZE - 1);
476         while (raw->count > 0) {
477                 ch = raw->buffer[ix];
478                 ix = (ix + 1) & (RAW3215_BUFFER_SIZE - 1);
479                 raw->count--;
480                 if (ch == 0x15)
481                         break;
482         }
483         raw->head = ix;
484 }
485
486 /*
487  * Wait until length bytes are available int the output buffer.
488  * Has to be called with the s390irq lock held. Can be called
489  * disabled.
490  */
491 static void raw3215_make_room(struct raw3215_info *raw, unsigned int length)
492 {
493         while (RAW3215_BUFFER_SIZE - raw->count < length) {
494                 /* While console is frozen for suspend we have no other
495                  * choice but to drop message from the buffer to make
496                  * room for even more messages. */
497                 if (raw->port.flags & ASYNC_SUSPENDED) {
498                         raw3215_drop_line(raw);
499                         continue;
500                 }
501                 /* there might be a request pending */
502                 raw->flags |= RAW3215_FLUSHING;
503                 raw3215_mk_write_req(raw);
504                 raw3215_try_io(raw);
505                 raw->flags &= ~RAW3215_FLUSHING;
506 #ifdef CONFIG_TN3215_CONSOLE
507                 ccw_device_wait_idle(raw->cdev);
508 #endif
509                 /* Enough room freed up ? */
510                 if (RAW3215_BUFFER_SIZE - raw->count >= length)
511                         break;
512                 /* there might be another cpu waiting for the lock */
513                 spin_unlock(get_ccwdev_lock(raw->cdev));
514                 udelay(100);
515                 spin_lock(get_ccwdev_lock(raw->cdev));
516         }
517 }
518
519 /*
520  * String write routine for 3215 devices
521  */
522 static void raw3215_write(struct raw3215_info *raw, const char *str,
523                           unsigned int length)
524 {
525         unsigned long flags;
526         int c, count;
527
528         while (length > 0) {
529                 spin_lock_irqsave(get_ccwdev_lock(raw->cdev), flags);
530                 count = (length > RAW3215_BUFFER_SIZE) ?
531                                              RAW3215_BUFFER_SIZE : length;
532                 length -= count;
533
534                 raw3215_make_room(raw, count);
535
536                 /* copy string to output buffer and convert it to EBCDIC */
537                 while (1) {
538                         c = min_t(int, count,
539                                   min(RAW3215_BUFFER_SIZE - raw->count,
540                                       RAW3215_BUFFER_SIZE - raw->head));
541                         if (c <= 0)
542                                 break;
543                         memcpy(raw->buffer + raw->head, str, c);
544                         ASCEBC(raw->buffer + raw->head, c);
545                         raw->head = (raw->head + c) & (RAW3215_BUFFER_SIZE - 1);
546                         raw->count += c;
547                         raw->line_pos += c;
548                         str += c;
549                         count -= c;
550                 }
551                 if (!(raw->flags & RAW3215_WORKING)) {
552                         raw3215_mk_write_req(raw);
553                         /* start or queue request */
554                         raw3215_try_io(raw);
555                 }
556                 spin_unlock_irqrestore(get_ccwdev_lock(raw->cdev), flags);
557         }
558 }
559
560 /*
561  * Put character routine for 3215 devices
562  */
563 static void raw3215_putchar(struct raw3215_info *raw, unsigned char ch)
564 {
565         unsigned long flags;
566         unsigned int length, i;
567
568         spin_lock_irqsave(get_ccwdev_lock(raw->cdev), flags);
569         if (ch == '\t') {
570                 length = TAB_STOP_SIZE - (raw->line_pos%TAB_STOP_SIZE);
571                 raw->line_pos += length;
572                 ch = ' ';
573         } else if (ch == '\n') {
574                 length = 1;
575                 raw->line_pos = 0;
576         } else {
577                 length = 1;
578                 raw->line_pos++;
579         }
580         raw3215_make_room(raw, length);
581
582         for (i = 0; i < length; i++) {
583                 raw->buffer[raw->head] = (char) _ascebc[(int) ch];
584                 raw->head = (raw->head + 1) & (RAW3215_BUFFER_SIZE - 1);
585                 raw->count++;
586         }
587         if (!(raw->flags & RAW3215_WORKING)) {
588                 raw3215_mk_write_req(raw);
589                 /* start or queue request */
590                 raw3215_try_io(raw);
591         }
592         spin_unlock_irqrestore(get_ccwdev_lock(raw->cdev), flags);
593 }
594
595 /*
596  * Flush routine, it simply sets the flush flag and tries to start
597  * pending IO.
598  */
599 static void raw3215_flush_buffer(struct raw3215_info *raw)
600 {
601         unsigned long flags;
602
603         spin_lock_irqsave(get_ccwdev_lock(raw->cdev), flags);
604         if (raw->count > 0) {
605                 raw->flags |= RAW3215_FLUSHING;
606                 raw3215_try_io(raw);
607                 raw->flags &= ~RAW3215_FLUSHING;
608         }
609         spin_unlock_irqrestore(get_ccwdev_lock(raw->cdev), flags);
610 }
611
612 /*
613  * Fire up a 3215 device.
614  */
615 static int raw3215_startup(struct raw3215_info *raw)
616 {
617         unsigned long flags;
618
619         if (raw->port.flags & ASYNC_INITIALIZED)
620                 return 0;
621         raw->line_pos = 0;
622         raw->port.flags |= ASYNC_INITIALIZED;
623         spin_lock_irqsave(get_ccwdev_lock(raw->cdev), flags);
624         raw3215_try_io(raw);
625         spin_unlock_irqrestore(get_ccwdev_lock(raw->cdev), flags);
626
627         return 0;
628 }
629
630 /*
631  * Shutdown a 3215 device.
632  */
633 static void raw3215_shutdown(struct raw3215_info *raw)
634 {
635         DECLARE_WAITQUEUE(wait, current);
636         unsigned long flags;
637
638         if (!(raw->port.flags & ASYNC_INITIALIZED) ||
639             (raw->flags & RAW3215_FIXED))
640                 return;
641         /* Wait for outstanding requests, then free irq */
642         spin_lock_irqsave(get_ccwdev_lock(raw->cdev), flags);
643         if ((raw->flags & RAW3215_WORKING) ||
644             raw->queued_write != NULL ||
645             raw->queued_read != NULL) {
646                 add_wait_queue(&raw->empty_wait, &wait);
647                 set_current_state(TASK_INTERRUPTIBLE);
648                 spin_unlock_irqrestore(get_ccwdev_lock(raw->cdev), flags);
649                 schedule();
650                 spin_lock_irqsave(get_ccwdev_lock(raw->cdev), flags);
651                 remove_wait_queue(&raw->empty_wait, &wait);
652                 set_current_state(TASK_RUNNING);
653                 raw->port.flags &= ~ASYNC_INITIALIZED;
654         }
655         spin_unlock_irqrestore(get_ccwdev_lock(raw->cdev), flags);
656 }
657
658 static struct raw3215_info *raw3215_alloc_info(void)
659 {
660         struct raw3215_info *info;
661
662         info = kzalloc(sizeof(struct raw3215_info), GFP_KERNEL | GFP_DMA);
663         if (!info)
664                 return NULL;
665
666         info->buffer = kzalloc(RAW3215_BUFFER_SIZE, GFP_KERNEL | GFP_DMA);
667         info->inbuf = kzalloc(RAW3215_INBUF_SIZE, GFP_KERNEL | GFP_DMA);
668         if (!info->buffer || !info->inbuf) {
669                 kfree(info->inbuf);
670                 kfree(info->buffer);
671                 kfree(info);
672                 return NULL;
673         }
674
675         setup_timer(&info->timer, raw3215_timeout, (unsigned long)info);
676         init_waitqueue_head(&info->empty_wait);
677         tasklet_init(&info->tlet, raw3215_wakeup, (unsigned long)info);
678         tty_port_init(&info->port);
679
680         return info;
681 }
682
683 static void raw3215_free_info(struct raw3215_info *raw)
684 {
685         kfree(raw->inbuf);
686         kfree(raw->buffer);
687         tty_port_destroy(&raw->port);
688         kfree(raw);
689 }
690
691 static int raw3215_probe (struct ccw_device *cdev)
692 {
693         struct raw3215_info *raw;
694         int line;
695
696         /* Console is special. */
697         if (raw3215[0] && (raw3215[0] == dev_get_drvdata(&cdev->dev)))
698                 return 0;
699
700         raw = raw3215_alloc_info();
701         if (raw == NULL)
702                 return -ENOMEM;
703
704         raw->cdev = cdev;
705         dev_set_drvdata(&cdev->dev, raw);
706         cdev->handler = raw3215_irq;
707
708         spin_lock(&raw3215_device_lock);
709         for (line = 0; line < NR_3215; line++) {
710                 if (!raw3215[line]) {
711                         raw3215[line] = raw;
712                         break;
713                 }
714         }
715         spin_unlock(&raw3215_device_lock);
716         if (line == NR_3215) {
717                 raw3215_free_info(raw);
718                 return -ENODEV;
719         }
720
721         return 0;
722 }
723
724 static void raw3215_remove (struct ccw_device *cdev)
725 {
726         struct raw3215_info *raw;
727         unsigned int line;
728
729         ccw_device_set_offline(cdev);
730         raw = dev_get_drvdata(&cdev->dev);
731         if (raw) {
732                 spin_lock(&raw3215_device_lock);
733                 for (line = 0; line < NR_3215; line++)
734                         if (raw3215[line] == raw)
735                                 break;
736                 raw3215[line] = NULL;
737                 spin_unlock(&raw3215_device_lock);
738                 dev_set_drvdata(&cdev->dev, NULL);
739                 raw3215_free_info(raw);
740         }
741 }
742
743 static int raw3215_set_online (struct ccw_device *cdev)
744 {
745         struct raw3215_info *raw;
746
747         raw = dev_get_drvdata(&cdev->dev);
748         if (!raw)
749                 return -ENODEV;
750
751         return raw3215_startup(raw);
752 }
753
754 static int raw3215_set_offline (struct ccw_device *cdev)
755 {
756         struct raw3215_info *raw;
757
758         raw = dev_get_drvdata(&cdev->dev);
759         if (!raw)
760                 return -ENODEV;
761
762         raw3215_shutdown(raw);
763
764         return 0;
765 }
766
767 static int raw3215_pm_stop(struct ccw_device *cdev)
768 {
769         struct raw3215_info *raw;
770         unsigned long flags;
771
772         /* Empty the output buffer, then prevent new I/O. */
773         raw = dev_get_drvdata(&cdev->dev);
774         spin_lock_irqsave(get_ccwdev_lock(raw->cdev), flags);
775         raw3215_make_room(raw, RAW3215_BUFFER_SIZE);
776         raw->port.flags |= ASYNC_SUSPENDED;
777         spin_unlock_irqrestore(get_ccwdev_lock(raw->cdev), flags);
778         return 0;
779 }
780
781 static int raw3215_pm_start(struct ccw_device *cdev)
782 {
783         struct raw3215_info *raw;
784         unsigned long flags;
785
786         /* Allow I/O again and flush output buffer. */
787         raw = dev_get_drvdata(&cdev->dev);
788         spin_lock_irqsave(get_ccwdev_lock(raw->cdev), flags);
789         raw->port.flags &= ~ASYNC_SUSPENDED;
790         raw->flags |= RAW3215_FLUSHING;
791         raw3215_try_io(raw);
792         raw->flags &= ~RAW3215_FLUSHING;
793         spin_unlock_irqrestore(get_ccwdev_lock(raw->cdev), flags);
794         return 0;
795 }
796
797 static struct ccw_device_id raw3215_id[] = {
798         { CCW_DEVICE(0x3215, 0) },
799         { /* end of list */ },
800 };
801
802 static struct ccw_driver raw3215_ccw_driver = {
803         .driver = {
804                 .name   = "3215",
805                 .owner  = THIS_MODULE,
806         },
807         .ids            = raw3215_id,
808         .probe          = &raw3215_probe,
809         .remove         = &raw3215_remove,
810         .set_online     = &raw3215_set_online,
811         .set_offline    = &raw3215_set_offline,
812         .freeze         = &raw3215_pm_stop,
813         .thaw           = &raw3215_pm_start,
814         .restore        = &raw3215_pm_start,
815         .int_class      = IRQIO_C15,
816 };
817
818 #ifdef CONFIG_TN3215_CONSOLE
819 /*
820  * Write a string to the 3215 console
821  */
822 static void con3215_write(struct console *co, const char *str,
823                           unsigned int count)
824 {
825         struct raw3215_info *raw;
826         int i;
827
828         if (count <= 0)
829                 return;
830         raw = raw3215[0];       /* console 3215 is the first one */
831         while (count > 0) {
832                 for (i = 0; i < count; i++)
833                         if (str[i] == '\t' || str[i] == '\n')
834                                 break;
835                 raw3215_write(raw, str, i);
836                 count -= i;
837                 str += i;
838                 if (count > 0) {
839                         raw3215_putchar(raw, *str);
840                         count--;
841                         str++;
842                 }
843         }
844 }
845
846 static struct tty_driver *con3215_device(struct console *c, int *index)
847 {
848         *index = c->index;
849         return tty3215_driver;
850 }
851
852 /*
853  * panic() calls con3215_flush through a panic_notifier
854  * before the system enters a disabled, endless loop.
855  */
856 static void con3215_flush(void)
857 {
858         struct raw3215_info *raw;
859         unsigned long flags;
860
861         raw = raw3215[0];  /* console 3215 is the first one */
862         if (raw->port.flags & ASYNC_SUSPENDED)
863                 /* The console is still frozen for suspend. */
864                 if (ccw_device_force_console(raw->cdev))
865                         /* Forcing didn't work, no panic message .. */
866                         return;
867         spin_lock_irqsave(get_ccwdev_lock(raw->cdev), flags);
868         raw3215_make_room(raw, RAW3215_BUFFER_SIZE);
869         spin_unlock_irqrestore(get_ccwdev_lock(raw->cdev), flags);
870 }
871
872 static int con3215_notify(struct notifier_block *self,
873                           unsigned long event, void *data)
874 {
875         con3215_flush();
876         return NOTIFY_OK;
877 }
878
879 static struct notifier_block on_panic_nb = {
880         .notifier_call = con3215_notify,
881         .priority = 0,
882 };
883
884 static struct notifier_block on_reboot_nb = {
885         .notifier_call = con3215_notify,
886         .priority = 0,
887 };
888
889 /*
890  *  The console structure for the 3215 console
891  */
892 static struct console con3215 = {
893         .name    = "ttyS",
894         .write   = con3215_write,
895         .device  = con3215_device,
896         .flags   = CON_PRINTBUFFER,
897 };
898
899 /*
900  * 3215 console initialization code called from console_init().
901  */
902 static int __init con3215_init(void)
903 {
904         struct ccw_device *cdev;
905         struct raw3215_info *raw;
906         struct raw3215_req *req;
907         int i;
908
909         /* Check if 3215 is to be the console */
910         if (!CONSOLE_IS_3215)
911                 return -ENODEV;
912
913         /* Set the console mode for VM */
914         if (MACHINE_IS_VM) {
915                 cpcmd("TERM CONMODE 3215", NULL, 0, NULL);
916                 cpcmd("TERM AUTOCR OFF", NULL, 0, NULL);
917         }
918
919         /* allocate 3215 request structures */
920         raw3215_freelist = NULL;
921         spin_lock_init(&raw3215_freelist_lock);
922         for (i = 0; i < NR_3215_REQ; i++) {
923                 req = kzalloc(sizeof(struct raw3215_req), GFP_KERNEL | GFP_DMA);
924                 if (!req)
925                         return -ENOMEM;
926                 req->next = raw3215_freelist;
927                 raw3215_freelist = req;
928         }
929
930         cdev = ccw_device_create_console(&raw3215_ccw_driver);
931         if (IS_ERR(cdev))
932                 return -ENODEV;
933
934         raw3215[0] = raw = raw3215_alloc_info();
935         raw->cdev = cdev;
936         dev_set_drvdata(&cdev->dev, raw);
937         cdev->handler = raw3215_irq;
938
939         raw->flags |= RAW3215_FIXED;
940         if (ccw_device_enable_console(cdev)) {
941                 ccw_device_destroy_console(cdev);
942                 raw3215_free_info(raw);
943                 raw3215[0] = NULL;
944                 return -ENODEV;
945         }
946
947         /* Request the console irq */
948         if (raw3215_startup(raw) != 0) {
949                 raw3215_free_info(raw);
950                 raw3215[0] = NULL;
951                 return -ENODEV;
952         }
953         atomic_notifier_chain_register(&panic_notifier_list, &on_panic_nb);
954         register_reboot_notifier(&on_reboot_nb);
955         register_console(&con3215);
956         return 0;
957 }
958 console_initcall(con3215_init);
959 #endif
960
961 static int tty3215_install(struct tty_driver *driver, struct tty_struct *tty)
962 {
963         struct raw3215_info *raw;
964
965         raw = raw3215[tty->index];
966         if (raw == NULL)
967                 return -ENODEV;
968
969         tty->driver_data = raw;
970
971         return tty_port_install(&raw->port, driver, tty);
972 }
973
974 /*
975  * tty3215_open
976  *
977  * This routine is called whenever a 3215 tty is opened.
978  */
979 static int tty3215_open(struct tty_struct *tty, struct file * filp)
980 {
981         struct raw3215_info *raw = tty->driver_data;
982         int retval;
983
984         tty_port_tty_set(&raw->port, tty);
985
986         raw->port.low_latency = 0; /* don't use bottom half for pushing chars */
987         /*
988          * Start up 3215 device
989          */
990         retval = raw3215_startup(raw);
991         if (retval)
992                 return retval;
993
994         return 0;
995 }
996
997 /*
998  * tty3215_close()
999  *
1000  * This routine is called when the 3215 tty is closed. We wait
1001  * for the remaining request to be completed. Then we clean up.
1002  */
1003 static void tty3215_close(struct tty_struct *tty, struct file * filp)
1004 {
1005         struct raw3215_info *raw;
1006
1007         raw = (struct raw3215_info *) tty->driver_data;
1008         if (raw == NULL || tty->count > 1)
1009                 return;
1010         tty->closing = 1;
1011         /* Shutdown the terminal */
1012         raw3215_shutdown(raw);
1013         tasklet_kill(&raw->tlet);
1014         tty->closing = 0;
1015         tty_port_tty_set(&raw->port, NULL);
1016 }
1017
1018 /*
1019  * Returns the amount of free space in the output buffer.
1020  */
1021 static int tty3215_write_room(struct tty_struct *tty)
1022 {
1023         struct raw3215_info *raw;
1024
1025         raw = (struct raw3215_info *) tty->driver_data;
1026
1027         /* Subtract TAB_STOP_SIZE to allow for a tab, 8 <<< 64K */
1028         if ((RAW3215_BUFFER_SIZE - raw->count - TAB_STOP_SIZE) >= 0)
1029                 return RAW3215_BUFFER_SIZE - raw->count - TAB_STOP_SIZE;
1030         else
1031                 return 0;
1032 }
1033
1034 /*
1035  * String write routine for 3215 ttys
1036  */
1037 static int tty3215_write(struct tty_struct * tty,
1038                          const unsigned char *buf, int count)
1039 {
1040         struct raw3215_info *raw;
1041         int i, written;
1042
1043         if (!tty)
1044                 return 0;
1045         raw = (struct raw3215_info *) tty->driver_data;
1046         written = count;
1047         while (count > 0) {
1048                 for (i = 0; i < count; i++)
1049                         if (buf[i] == '\t' || buf[i] == '\n')
1050                                 break;
1051                 raw3215_write(raw, buf, i);
1052                 count -= i;
1053                 buf += i;
1054                 if (count > 0) {
1055                         raw3215_putchar(raw, *buf);
1056                         count--;
1057                         buf++;
1058                 }
1059         }
1060         return written;
1061 }
1062
1063 /*
1064  * Put character routine for 3215 ttys
1065  */
1066 static int tty3215_put_char(struct tty_struct *tty, unsigned char ch)
1067 {
1068         struct raw3215_info *raw;
1069
1070         if (!tty)
1071                 return 0;
1072         raw = (struct raw3215_info *) tty->driver_data;
1073         raw3215_putchar(raw, ch);
1074         return 1;
1075 }
1076
1077 static void tty3215_flush_chars(struct tty_struct *tty)
1078 {
1079 }
1080
1081 /*
1082  * Returns the number of characters in the output buffer
1083  */
1084 static int tty3215_chars_in_buffer(struct tty_struct *tty)
1085 {
1086         struct raw3215_info *raw;
1087
1088         raw = (struct raw3215_info *) tty->driver_data;
1089         return raw->count;
1090 }
1091
1092 static void tty3215_flush_buffer(struct tty_struct *tty)
1093 {
1094         struct raw3215_info *raw;
1095
1096         raw = (struct raw3215_info *) tty->driver_data;
1097         raw3215_flush_buffer(raw);
1098         tty_wakeup(tty);
1099 }
1100
1101 /*
1102  * Disable reading from a 3215 tty
1103  */
1104 static void tty3215_throttle(struct tty_struct * tty)
1105 {
1106         struct raw3215_info *raw;
1107
1108         raw = (struct raw3215_info *) tty->driver_data;
1109         raw->flags |= RAW3215_THROTTLED;
1110 }
1111
1112 /*
1113  * Enable reading from a 3215 tty
1114  */
1115 static void tty3215_unthrottle(struct tty_struct * tty)
1116 {
1117         struct raw3215_info *raw;
1118         unsigned long flags;
1119
1120         raw = (struct raw3215_info *) tty->driver_data;
1121         if (raw->flags & RAW3215_THROTTLED) {
1122                 spin_lock_irqsave(get_ccwdev_lock(raw->cdev), flags);
1123                 raw->flags &= ~RAW3215_THROTTLED;
1124                 raw3215_try_io(raw);
1125                 spin_unlock_irqrestore(get_ccwdev_lock(raw->cdev), flags);
1126         }
1127 }
1128
1129 /*
1130  * Disable writing to a 3215 tty
1131  */
1132 static void tty3215_stop(struct tty_struct *tty)
1133 {
1134         struct raw3215_info *raw;
1135
1136         raw = (struct raw3215_info *) tty->driver_data;
1137         raw->flags |= RAW3215_STOPPED;
1138 }
1139
1140 /*
1141  * Enable writing to a 3215 tty
1142  */
1143 static void tty3215_start(struct tty_struct *tty)
1144 {
1145         struct raw3215_info *raw;
1146         unsigned long flags;
1147
1148         raw = (struct raw3215_info *) tty->driver_data;
1149         if (raw->flags & RAW3215_STOPPED) {
1150                 spin_lock_irqsave(get_ccwdev_lock(raw->cdev), flags);
1151                 raw->flags &= ~RAW3215_STOPPED;
1152                 raw3215_try_io(raw);
1153                 spin_unlock_irqrestore(get_ccwdev_lock(raw->cdev), flags);
1154         }
1155 }
1156
1157 static const struct tty_operations tty3215_ops = {
1158         .install = tty3215_install,
1159         .open = tty3215_open,
1160         .close = tty3215_close,
1161         .write = tty3215_write,
1162         .put_char = tty3215_put_char,
1163         .flush_chars = tty3215_flush_chars,
1164         .write_room = tty3215_write_room,
1165         .chars_in_buffer = tty3215_chars_in_buffer,
1166         .flush_buffer = tty3215_flush_buffer,
1167         .throttle = tty3215_throttle,
1168         .unthrottle = tty3215_unthrottle,
1169         .stop = tty3215_stop,
1170         .start = tty3215_start,
1171 };
1172
1173 /*
1174  * 3215 tty registration code called from tty_init().
1175  * Most kernel services (incl. kmalloc) are available at this poimt.
1176  */
1177 static int __init tty3215_init(void)
1178 {
1179         struct tty_driver *driver;
1180         int ret;
1181
1182         if (!CONSOLE_IS_3215)
1183                 return 0;
1184
1185         driver = alloc_tty_driver(NR_3215);
1186         if (!driver)
1187                 return -ENOMEM;
1188
1189         ret = ccw_driver_register(&raw3215_ccw_driver);
1190         if (ret) {
1191                 put_tty_driver(driver);
1192                 return ret;
1193         }
1194         /*
1195          * Initialize the tty_driver structure
1196          * Entries in tty3215_driver that are NOT initialized:
1197          * proc_entry, set_termios, flush_buffer, set_ldisc, write_proc
1198          */
1199
1200         driver->driver_name = "tty3215";
1201         driver->name = "ttyS";
1202         driver->major = TTY_MAJOR;
1203         driver->minor_start = 64;
1204         driver->type = TTY_DRIVER_TYPE_SYSTEM;
1205         driver->subtype = SYSTEM_TYPE_TTY;
1206         driver->init_termios = tty_std_termios;
1207         driver->init_termios.c_iflag = IGNBRK | IGNPAR;
1208         driver->init_termios.c_oflag = ONLCR;
1209         driver->init_termios.c_lflag = ISIG;
1210         driver->flags = TTY_DRIVER_REAL_RAW;
1211         tty_set_operations(driver, &tty3215_ops);
1212         ret = tty_register_driver(driver);
1213         if (ret) {
1214                 put_tty_driver(driver);
1215                 return ret;
1216         }
1217         tty3215_driver = driver;
1218         return 0;
1219 }
1220
1221 static void __exit tty3215_exit(void)
1222 {
1223         tty_unregister_driver(tty3215_driver);
1224         put_tty_driver(tty3215_driver);
1225         ccw_driver_unregister(&raw3215_ccw_driver);
1226 }
1227
1228 module_init(tty3215_init);
1229 module_exit(tty3215_exit);