1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40#include <linux/interrupt.h>
41#include <linux/tty.h>
42#include <linux/tty_flip.h>
43#include <linux/serial.h>
44#include <linux/console.h>
45#include <linux/init.h>
46#include <linux/sysrq.h>
47#include <linux/circ_buf.h>
48#include <linux/serial_reg.h>
49#include <linux/delay.h>
50#include <linux/miscdevice.h>
51#include <linux/serial_core.h>
52
53#include <asm/io.h>
54#include <asm/sn/simulator.h>
55#include <asm/sn/sn_sal.h>
56
57
58#define SN_SAL_MAX_CHARS 120
59
60
61
62#define SN_SAL_BUFFER_SIZE (64 * (1 << 10))
63
64#define SN_SAL_UART_FIFO_DEPTH 16
65#define SN_SAL_UART_FIFO_SPEED_CPS (9600/10)
66
67
68#define TRANSMIT_BUFFERED 0
69#define TRANSMIT_RAW 1
70
71
72
73
74#define USE_DYNAMIC_MINOR 0
75
76
77#define DEVICE_NAME "ttySG"
78#define DEVICE_NAME_DYNAMIC "ttySG0"
79
80#define DEVICE_MAJOR 204
81#define DEVICE_MINOR 40
82
83#ifdef CONFIG_MAGIC_SYSRQ
84static char sysrq_serial_str[] = "\eSYS";
85static char *sysrq_serial_ptr = sysrq_serial_str;
86static unsigned long sysrq_requested;
87#endif
88
89
90
91
92struct sn_cons_port {
93 struct timer_list sc_timer;
94 struct uart_port sc_port;
95 struct sn_sal_ops {
96 int (*sal_puts_raw) (const char *s, int len);
97 int (*sal_puts) (const char *s, int len);
98 int (*sal_getc) (void);
99 int (*sal_input_pending) (void);
100 void (*sal_wakeup_transmit) (struct sn_cons_port *, int);
101 } *sc_ops;
102 unsigned long sc_interrupt_timeout;
103 int sc_is_asynch;
104};
105
106static struct sn_cons_port sal_console_port;
107static int sn_process_input;
108
109
110static struct miscdevice misc;
111
112extern void early_sn_setup(void);
113
114#undef DEBUG
115#ifdef DEBUG
116static int sn_debug_printf(const char *fmt, ...);
117#define DPRINTF(x...) sn_debug_printf(x)
118#else
119#define DPRINTF(x...) do { } while (0)
120#endif
121
122
123static int snt_hw_puts_raw(const char *, int);
124static int snt_hw_puts_buffered(const char *, int);
125static int snt_poll_getc(void);
126static int snt_poll_input_pending(void);
127static int snt_intr_getc(void);
128static int snt_intr_input_pending(void);
129static void sn_transmit_chars(struct sn_cons_port *, int);
130
131
132
133static struct sn_sal_ops poll_ops = {
134 .sal_puts_raw = snt_hw_puts_raw,
135 .sal_puts = snt_hw_puts_raw,
136 .sal_getc = snt_poll_getc,
137 .sal_input_pending = snt_poll_input_pending
138};
139
140
141static struct sn_sal_ops intr_ops = {
142 .sal_puts_raw = snt_hw_puts_raw,
143 .sal_puts = snt_hw_puts_buffered,
144 .sal_getc = snt_intr_getc,
145 .sal_input_pending = snt_intr_input_pending,
146 .sal_wakeup_transmit = sn_transmit_chars
147};
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166static int snt_poll_getc(void)
167{
168 int ch;
169
170 ia64_sn_console_getc(&ch);
171 return ch;
172}
173
174
175
176
177
178static int snt_poll_input_pending(void)
179{
180 int status, input;
181
182 status = ia64_sn_console_check(&input);
183 return !status && input;
184}
185
186
187
188
189
190
191
192static int snt_intr_getc(void)
193{
194 return ia64_sn_console_readc();
195}
196
197
198
199
200
201static int snt_intr_input_pending(void)
202{
203 return ia64_sn_console_intr_status() & SAL_CONSOLE_INTR_RECV;
204}
205
206
207
208
209
210
211
212
213
214static int snt_hw_puts_raw(const char *s, int len)
215{
216
217 return ia64_sn_console_putb(s, len);
218}
219
220
221
222
223
224
225
226static int snt_hw_puts_buffered(const char *s, int len)
227{
228
229 return ia64_sn_console_xmit_chars((char *)s, len);
230}
231
232
233
234
235
236
237
238
239
240
241
242
243
244static const char *snp_type(struct uart_port *port)
245{
246 return ("SGI SN L1");
247}
248
249
250
251
252
253
254static unsigned int snp_tx_empty(struct uart_port *port)
255{
256 return 1;
257}
258
259
260
261
262
263
264static void snp_stop_tx(struct uart_port *port)
265{
266}
267
268
269
270
271
272
273static void snp_release_port(struct uart_port *port)
274{
275}
276
277
278
279
280
281
282static void snp_shutdown(struct uart_port *port)
283{
284}
285
286
287
288
289
290
291
292static void snp_set_mctrl(struct uart_port *port, unsigned int mctrl)
293{
294}
295
296
297
298
299
300
301static unsigned int snp_get_mctrl(struct uart_port *port)
302{
303 return TIOCM_CAR | TIOCM_RNG | TIOCM_DSR | TIOCM_CTS;
304}
305
306
307
308
309
310
311static void snp_stop_rx(struct uart_port *port)
312{
313}
314
315
316
317
318
319
320static void snp_start_tx(struct uart_port *port)
321{
322 if (sal_console_port.sc_ops->sal_wakeup_transmit)
323 sal_console_port.sc_ops->sal_wakeup_transmit(&sal_console_port,
324 TRANSMIT_BUFFERED);
325
326}
327
328
329
330
331
332
333
334static void snp_break_ctl(struct uart_port *port, int break_state)
335{
336}
337
338
339
340
341
342
343static int snp_startup(struct uart_port *port)
344{
345 return 0;
346}
347
348
349
350
351
352
353
354
355static void
356snp_set_termios(struct uart_port *port, struct ktermios *termios,
357 struct ktermios *old)
358{
359}
360
361
362
363
364
365
366static int snp_request_port(struct uart_port *port)
367{
368 return 0;
369}
370
371
372
373
374
375
376
377static void snp_config_port(struct uart_port *port, int flags)
378{
379}
380
381
382
383static struct uart_ops sn_console_ops = {
384 .tx_empty = snp_tx_empty,
385 .set_mctrl = snp_set_mctrl,
386 .get_mctrl = snp_get_mctrl,
387 .stop_tx = snp_stop_tx,
388 .start_tx = snp_start_tx,
389 .stop_rx = snp_stop_rx,
390 .break_ctl = snp_break_ctl,
391 .startup = snp_startup,
392 .shutdown = snp_shutdown,
393 .set_termios = snp_set_termios,
394 .pm = NULL,
395 .type = snp_type,
396 .release_port = snp_release_port,
397 .request_port = snp_request_port,
398 .config_port = snp_config_port,
399 .verify_port = NULL,
400};
401
402
403
404#ifdef DEBUG
405
406
407
408
409
410
411
412
413
414static int sn_debug_printf(const char *fmt, ...)
415{
416 static char printk_buf[1024];
417 int printed_len;
418 va_list args;
419
420 va_start(args, fmt);
421 printed_len = vsnprintf(printk_buf, sizeof(printk_buf), fmt, args);
422
423 if (!sal_console_port.sc_ops) {
424 sal_console_port.sc_ops = &poll_ops;
425 early_sn_setup();
426 }
427 sal_console_port.sc_ops->sal_puts_raw(printk_buf, printed_len);
428
429 va_end(args);
430 return printed_len;
431}
432#endif
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447static void
448sn_receive_chars(struct sn_cons_port *port, unsigned long flags)
449{
450 struct tty_port *tport = NULL;
451 int ch;
452
453 if (!port) {
454 printk(KERN_ERR "sn_receive_chars - port NULL so can't receive\n");
455 return;
456 }
457
458 if (!port->sc_ops) {
459 printk(KERN_ERR "sn_receive_chars - port->sc_ops NULL so can't receive\n");
460 return;
461 }
462
463 if (port->sc_port.state) {
464
465 tport = &port->sc_port.state->port;
466 }
467
468 while (port->sc_ops->sal_input_pending()) {
469 ch = port->sc_ops->sal_getc();
470 if (ch < 0) {
471 printk(KERN_ERR "sn_console: An error occurred while "
472 "obtaining data from the console (0x%0x)\n", ch);
473 break;
474 }
475#ifdef CONFIG_MAGIC_SYSRQ
476 if (sysrq_requested) {
477 unsigned long sysrq_timeout = sysrq_requested + HZ*5;
478
479 sysrq_requested = 0;
480 if (ch && time_before(jiffies, sysrq_timeout)) {
481 spin_unlock_irqrestore(&port->sc_port.lock, flags);
482 handle_sysrq(ch);
483 spin_lock_irqsave(&port->sc_port.lock, flags);
484
485 continue;
486 }
487 }
488 if (ch == *sysrq_serial_ptr) {
489 if (!(*++sysrq_serial_ptr)) {
490 sysrq_requested = jiffies;
491 sysrq_serial_ptr = sysrq_serial_str;
492 }
493
494
495
496
497 if (ch != '\e')
498 continue;
499 }
500 else
501 sysrq_serial_ptr = sysrq_serial_str;
502#endif
503
504
505 if (tport) {
506 if (tty_insert_flip_char(tport, ch, TTY_NORMAL) == 0)
507 break;
508 }
509 port->sc_port.icount.rx++;
510 }
511
512 if (tport)
513 tty_flip_buffer_push(tport);
514}
515
516
517
518
519
520
521
522
523
524
525
526
527
528static void sn_transmit_chars(struct sn_cons_port *port, int raw)
529{
530 int xmit_count, tail, head, loops, ii;
531 int result;
532 char *start;
533 struct circ_buf *xmit;
534
535 if (!port)
536 return;
537
538 BUG_ON(!port->sc_is_asynch);
539
540 if (port->sc_port.state) {
541
542 xmit = &port->sc_port.state->xmit;
543 } else {
544
545
546
547
548 return;
549 }
550
551 if (uart_circ_empty(xmit) || uart_tx_stopped(&port->sc_port)) {
552
553 ia64_sn_console_intr_disable(SAL_CONSOLE_INTR_XMIT);
554 return;
555 }
556
557 head = xmit->head;
558 tail = xmit->tail;
559 start = &xmit->buf[tail];
560
561
562
563 loops = (head < tail) ? 2 : 1;
564
565 for (ii = 0; ii < loops; ii++) {
566 xmit_count = (head < tail) ?
567 (UART_XMIT_SIZE - tail) : (head - tail);
568
569 if (xmit_count > 0) {
570 if (raw == TRANSMIT_RAW)
571 result =
572 port->sc_ops->sal_puts_raw(start,
573 xmit_count);
574 else
575 result =
576 port->sc_ops->sal_puts(start, xmit_count);
577#ifdef DEBUG
578 if (!result)
579 DPRINTF("`");
580#endif
581 if (result > 0) {
582 xmit_count -= result;
583 port->sc_port.icount.tx += result;
584 tail += result;
585 tail &= UART_XMIT_SIZE - 1;
586 xmit->tail = tail;
587 start = &xmit->buf[tail];
588 }
589 }
590 }
591
592 if (uart_circ_chars_pending(xmit) < WAKEUP_CHARS)
593 uart_write_wakeup(&port->sc_port);
594
595 if (uart_circ_empty(xmit))
596 snp_stop_tx(&port->sc_port);
597}
598
599
600
601
602
603
604
605static irqreturn_t sn_sal_interrupt(int irq, void *dev_id)
606{
607 struct sn_cons_port *port = (struct sn_cons_port *)dev_id;
608 unsigned long flags;
609 int status = ia64_sn_console_intr_status();
610
611 if (!port)
612 return IRQ_NONE;
613
614 spin_lock_irqsave(&port->sc_port.lock, flags);
615 if (status & SAL_CONSOLE_INTR_RECV) {
616 sn_receive_chars(port, flags);
617 }
618 if (status & SAL_CONSOLE_INTR_XMIT) {
619 sn_transmit_chars(port, TRANSMIT_BUFFERED);
620 }
621 spin_unlock_irqrestore(&port->sc_port.lock, flags);
622 return IRQ_HANDLED;
623}
624
625
626
627
628
629
630
631
632
633
634static void sn_sal_timer_poll(unsigned long data)
635{
636 struct sn_cons_port *port = (struct sn_cons_port *)data;
637 unsigned long flags;
638
639 if (!port)
640 return;
641
642 if (!port->sc_port.irq) {
643 spin_lock_irqsave(&port->sc_port.lock, flags);
644 if (sn_process_input)
645 sn_receive_chars(port, flags);
646 sn_transmit_chars(port, TRANSMIT_RAW);
647 spin_unlock_irqrestore(&port->sc_port.lock, flags);
648 mod_timer(&port->sc_timer,
649 jiffies + port->sc_interrupt_timeout);
650 }
651}
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667static void __init sn_sal_switch_to_asynch(struct sn_cons_port *port)
668{
669 unsigned long flags;
670
671 if (!port)
672 return;
673
674 DPRINTF("sn_console: about to switch to asynchronous console\n");
675
676
677
678
679 spin_lock_irqsave(&port->sc_port.lock, flags);
680
681
682 if (!port->sc_ops)
683 port->sc_ops = &poll_ops;
684
685
686
687
688
689
690 init_timer(&port->sc_timer);
691 port->sc_timer.function = sn_sal_timer_poll;
692 port->sc_timer.data = (unsigned long)port;
693
694 if (IS_RUNNING_ON_SIMULATOR())
695 port->sc_interrupt_timeout = 6;
696 else {
697
698
699 port->sc_interrupt_timeout =
700 HZ * SN_SAL_UART_FIFO_DEPTH / SN_SAL_UART_FIFO_SPEED_CPS;
701 }
702 mod_timer(&port->sc_timer, jiffies + port->sc_interrupt_timeout);
703
704 port->sc_is_asynch = 1;
705 spin_unlock_irqrestore(&port->sc_port.lock, flags);
706}
707
708
709
710
711
712
713
714
715
716
717
718
719static void __init sn_sal_switch_to_interrupts(struct sn_cons_port *port)
720{
721 unsigned long flags;
722
723 if (port) {
724 DPRINTF("sn_console: switching to interrupt driven console\n");
725
726 if (request_irq(SGI_UART_VECTOR, sn_sal_interrupt,
727 IRQF_SHARED,
728 "SAL console driver", port) >= 0) {
729 spin_lock_irqsave(&port->sc_port.lock, flags);
730 port->sc_port.irq = SGI_UART_VECTOR;
731 port->sc_ops = &intr_ops;
732 irq_set_handler(port->sc_port.irq, handle_level_irq);
733
734
735 ia64_sn_console_intr_enable(SAL_CONSOLE_INTR_RECV);
736 spin_unlock_irqrestore(&port->sc_port.lock, flags);
737 }
738 else {
739 printk(KERN_INFO
740 "sn_console: console proceeding in polled mode\n");
741 }
742 }
743}
744
745
746
747
748
749static void sn_sal_console_write(struct console *, const char *, unsigned);
750static int sn_sal_console_setup(struct console *, char *);
751static struct uart_driver sal_console_uart;
752extern struct tty_driver *uart_console_device(struct console *, int *);
753
754static struct console sal_console = {
755 .name = DEVICE_NAME,
756 .write = sn_sal_console_write,
757 .device = uart_console_device,
758 .setup = sn_sal_console_setup,
759 .index = -1,
760 .data = &sal_console_uart,
761};
762
763#define SAL_CONSOLE &sal_console
764
765static struct uart_driver sal_console_uart = {
766 .owner = THIS_MODULE,
767 .driver_name = "sn_console",
768 .dev_name = DEVICE_NAME,
769 .major = 0,
770 .minor = 0,
771 .nr = 1,
772 .cons = SAL_CONSOLE,
773};
774
775
776
777
778
779
780
781
782
783
784static int __init sn_sal_init(void)
785{
786 int retval;
787
788 if (!ia64_platform_is("sn2"))
789 return 0;
790
791 printk(KERN_INFO "sn_console: Console driver init\n");
792
793 if (USE_DYNAMIC_MINOR == 1) {
794 misc.minor = MISC_DYNAMIC_MINOR;
795 misc.name = DEVICE_NAME_DYNAMIC;
796 retval = misc_register(&misc);
797 if (retval != 0) {
798 printk(KERN_WARNING "Failed to register console "
799 "device using misc_register.\n");
800 return -ENODEV;
801 }
802 sal_console_uart.major = MISC_MAJOR;
803 sal_console_uart.minor = misc.minor;
804 } else {
805 sal_console_uart.major = DEVICE_MAJOR;
806 sal_console_uart.minor = DEVICE_MINOR;
807 }
808
809
810
811
812 if (uart_register_driver(&sal_console_uart) < 0) {
813 printk
814 ("ERROR sn_sal_init failed uart_register_driver, line %d\n",
815 __LINE__);
816 return -ENODEV;
817 }
818
819 spin_lock_init(&sal_console_port.sc_port.lock);
820
821
822 sal_console_port.sc_port.membase = (char *)1;
823 sal_console_port.sc_port.type = PORT_16550A;
824 sal_console_port.sc_port.fifosize = SN_SAL_MAX_CHARS;
825 sal_console_port.sc_port.ops = &sn_console_ops;
826 sal_console_port.sc_port.line = 0;
827
828 if (uart_add_one_port(&sal_console_uart, &sal_console_port.sc_port) < 0) {
829
830 printk(KERN_ERR "%s: unable to add port\n", __func__);
831 }
832
833
834
835
836 if (!sal_console_port.sc_is_asynch) {
837 sn_sal_switch_to_asynch(&sal_console_port);
838 }
839
840
841 if (!IS_RUNNING_ON_SIMULATOR()) {
842 sn_sal_switch_to_interrupts(&sal_console_port);
843 }
844 sn_process_input = 1;
845 return 0;
846}
847device_initcall(sn_sal_init);
848
849
850
851
852
853
854
855
856
857
858
859
860static void puts_raw_fixed(int (*puts_raw) (const char *s, int len),
861 const char *s, int count)
862{
863 const char *s1;
864
865
866 while ((s1 = memchr(s, '\n', count)) != NULL) {
867 puts_raw(s, s1 - s);
868 puts_raw("\r\n", 2);
869 count -= s1 + 1 - s;
870 s = s1 + 1;
871 }
872 puts_raw(s, count);
873}
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892static void
893sn_sal_console_write(struct console *co, const char *s, unsigned count)
894{
895 unsigned long flags = 0;
896 struct sn_cons_port *port = &sal_console_port;
897 static int stole_lock = 0;
898
899 BUG_ON(!port->sc_is_asynch);
900
901
902
903
904 if (!port->sc_port.state) {
905
906 puts_raw_fixed(port->sc_ops->sal_puts_raw, s, count);
907 return;
908 }
909
910
911
912 if (spin_is_locked(&port->sc_port.lock)) {
913 int lhead = port->sc_port.state->xmit.head;
914 int ltail = port->sc_port.state->xmit.tail;
915 int counter, got_lock = 0;
916
917
918
919
920
921
922
923
924
925
926
927
928 for (counter = 0; counter < 150; mdelay(125), counter++) {
929 if (!spin_is_locked(&port->sc_port.lock)
930 || stole_lock) {
931 if (!stole_lock) {
932 spin_lock_irqsave(&port->sc_port.lock,
933 flags);
934 got_lock = 1;
935 }
936 break;
937 } else {
938
939 if ((lhead != port->sc_port.state->xmit.head)
940 || (ltail !=
941 port->sc_port.state->xmit.tail)) {
942 lhead =
943 port->sc_port.state->xmit.head;
944 ltail =
945 port->sc_port.state->xmit.tail;
946 counter = 0;
947 }
948 }
949 }
950
951 sn_transmit_chars(port, 1);
952 if (got_lock) {
953 spin_unlock_irqrestore(&port->sc_port.lock, flags);
954 stole_lock = 0;
955 } else {
956
957 stole_lock = 1;
958 }
959 puts_raw_fixed(port->sc_ops->sal_puts_raw, s, count);
960 } else {
961 stole_lock = 0;
962 spin_lock_irqsave(&port->sc_port.lock, flags);
963 sn_transmit_chars(port, 1);
964 spin_unlock_irqrestore(&port->sc_port.lock, flags);
965
966 puts_raw_fixed(port->sc_ops->sal_puts_raw, s, count);
967 }
968}
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983static int sn_sal_console_setup(struct console *co, char *options)
984{
985 return 0;
986}
987
988
989
990
991
992
993
994
995
996
997
998
999static void __init
1000sn_sal_console_write_early(struct console *co, const char *s, unsigned count)
1001{
1002 puts_raw_fixed(sal_console_port.sc_ops->sal_puts_raw, s, count);
1003}
1004
1005
1006
1007static struct console sal_console_early __initdata = {
1008 .name = "sn_sal",
1009 .write = sn_sal_console_write_early,
1010 .flags = CON_PRINTBUFFER,
1011 .index = -1,
1012};
1013
1014
1015
1016
1017
1018
1019
1020
1021
1022
1023int __init sn_serial_console_early_setup(void)
1024{
1025 if (!ia64_platform_is("sn2"))
1026 return -1;
1027
1028 sal_console_port.sc_ops = &poll_ops;
1029 spin_lock_init(&sal_console_port.sc_port.lock);
1030 early_sn_setup();
1031 register_console(&sal_console_early);
1032
1033 return 0;
1034}
1035
1036
1037
1038
1039
1040
1041
1042
1043
1044
1045
1046
1047
1048static int __init sn_sal_serial_console_init(void)
1049{
1050 if (ia64_platform_is("sn2")) {
1051 sn_sal_switch_to_asynch(&sal_console_port);
1052 DPRINTF("sn_sal_serial_console_init : register console\n");
1053 register_console(&sal_console);
1054 unregister_console(&sal_console_early);
1055 }
1056 return 0;
1057}
1058
1059console_initcall(sn_sal_serial_console_init);
1060