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