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