[PATCH] m68knommu: remove FP conditionals in ucontext struct
[linux-2.6.git] / arch / sparc / prom / console.c
1 /* $Id: console.c,v 1.25 2001/10/30 04:54:22 davem Exp $
2  * console.c: Routines that deal with sending and receiving IO
3  *            to/from the current console device using the PROM.
4  *
5  * Copyright (C) 1995 David S. Miller (davem@caip.rutgers.edu)
6  * Copyright (C) 1998 Pete Zaitcev <zaitcev@yahoo.com>
7  */
8
9 #include <linux/types.h>
10 #include <linux/kernel.h>
11 #include <linux/sched.h>
12 #include <asm/openprom.h>
13 #include <asm/sun4prom.h>
14 #include <asm/oplib.h>
15 #include <asm/system.h>
16 #include <linux/string.h>
17
18 extern void restore_current(void);
19
20 static char con_name_jmc[] = "/obio/su@"; /* "/obio/su@0,3002f8"; */
21 #define CON_SIZE_JMC    (sizeof(con_name_jmc))
22
23 /* Non blocking get character from console input device, returns -1
24  * if no input was taken.  This can be used for polling.
25  */
26 int
27 prom_nbgetchar(void)
28 {
29         static char inc;
30         int i = -1;
31         unsigned long flags;
32
33         spin_lock_irqsave(&prom_lock, flags);
34         switch(prom_vers) {
35         case PROM_V0:
36         case PROM_SUN4:
37                 i = (*(romvec->pv_nbgetchar))();
38                 break;
39         case PROM_V2:
40         case PROM_V3:
41                 if( (*(romvec->pv_v2devops).v2_dev_read)(*romvec->pv_v2bootargs.fd_stdin , &inc, 0x1) == 1) {
42                         i = inc;
43                 } else {
44                         i = -1;
45                 }
46                 break;
47         default:
48                 i = -1;
49                 break;
50         };
51         restore_current();
52         spin_unlock_irqrestore(&prom_lock, flags);
53         return i; /* Ugh, we could spin forever on unsupported proms ;( */
54 }
55
56 /* Non blocking put character to console device, returns -1 if
57  * unsuccessful.
58  */
59 int
60 prom_nbputchar(char c)
61 {
62         static char outc;
63         unsigned long flags;
64         int i = -1;
65
66         spin_lock_irqsave(&prom_lock, flags);
67         switch(prom_vers) {
68         case PROM_V0:
69         case PROM_SUN4:
70                 i = (*(romvec->pv_nbputchar))(c);
71                 break;
72         case PROM_V2:
73         case PROM_V3:
74                 outc = c;
75                 if( (*(romvec->pv_v2devops).v2_dev_write)(*romvec->pv_v2bootargs.fd_stdout, &outc, 0x1) == 1)
76                         i = 0;
77                 else
78                         i = -1;
79                 break;
80         default:
81                 i = -1;
82                 break;
83         };
84         restore_current();
85         spin_unlock_irqrestore(&prom_lock, flags);
86         return i; /* Ugh, we could spin forever on unsupported proms ;( */
87 }
88
89 /* Blocking version of get character routine above. */
90 char
91 prom_getchar(void)
92 {
93         int character;
94         while((character = prom_nbgetchar()) == -1) ;
95         return (char) character;
96 }
97
98 /* Blocking version of put character routine above. */
99 void
100 prom_putchar(char c)
101 {
102         while(prom_nbputchar(c) == -1) ;
103         return;
104 }
105
106 /* Query for input device type */
107 enum prom_input_device
108 prom_query_input_device(void)
109 {
110         unsigned long flags;
111         int st_p;
112         char propb[64];
113         char *p;
114         int propl;
115
116         switch(prom_vers) {
117         case PROM_V0:
118         case PROM_V2:
119         case PROM_SUN4:
120         default:
121                 switch(*romvec->pv_stdin) {
122                 case PROMDEV_KBD:       return PROMDEV_IKBD;
123                 case PROMDEV_TTYA:      return PROMDEV_ITTYA;
124                 case PROMDEV_TTYB:      return PROMDEV_ITTYB;
125                 default:
126                         return PROMDEV_I_UNK;
127                 };
128         case PROM_V3:
129                 spin_lock_irqsave(&prom_lock, flags);
130                 st_p = (*romvec->pv_v2devops.v2_inst2pkg)(*romvec->pv_v2bootargs.fd_stdin);
131                 restore_current();
132                 spin_unlock_irqrestore(&prom_lock, flags);
133                 if(prom_node_has_property(st_p, "keyboard"))
134                         return PROMDEV_IKBD;
135                 if (prom_getproperty(st_p, "name", propb, sizeof(propb)) != -1) {
136                         if(strncmp(propb, "keyboard", sizeof("serial")) == 0)
137                                 return PROMDEV_IKBD;
138                 }
139                 if (prom_getproperty(st_p, "device_type", propb, sizeof(propb)) != -1) {
140                 if(strncmp(propb, "serial", sizeof("serial")))
141                         return PROMDEV_I_UNK;
142                 }
143                 propl = prom_getproperty(prom_root_node, "stdin-path", propb, sizeof(propb));
144                 if(propl > 2) {
145                         p = propb;
146                         while(*p) p++; p -= 2;
147                         if(p[0] == ':') {
148                                 if(p[1] == 'a')
149                                         return PROMDEV_ITTYA;
150                                 else if(p[1] == 'b')
151                                         return PROMDEV_ITTYB;
152                         }
153                 }
154                 return PROMDEV_I_UNK;
155         }
156 }
157
158 /* Query for output device type */
159
160 enum prom_output_device
161 prom_query_output_device(void)
162 {
163         unsigned long flags;
164         int st_p;
165         char propb[64];
166         char *p;
167         int propl;
168
169         switch(prom_vers) {
170         case PROM_V0:
171         case PROM_SUN4:
172                 switch(*romvec->pv_stdin) {
173                 case PROMDEV_SCREEN:    return PROMDEV_OSCREEN;
174                 case PROMDEV_TTYA:      return PROMDEV_OTTYA;
175                 case PROMDEV_TTYB:      return PROMDEV_OTTYB;
176                 };
177                 break;
178         case PROM_V2:
179         case PROM_V3:
180                 spin_lock_irqsave(&prom_lock, flags);
181                 st_p = (*romvec->pv_v2devops.v2_inst2pkg)(*romvec->pv_v2bootargs.fd_stdout);
182                 restore_current();
183                 spin_unlock_irqrestore(&prom_lock, flags);
184                 propl = prom_getproperty(st_p, "device_type", propb, sizeof(propb));
185                 if (propl == sizeof("display") &&
186                         strncmp("display", propb, sizeof("display")) == 0)
187                 {
188                         return PROMDEV_OSCREEN;
189                 }
190                 if(prom_vers == PROM_V3) {
191                         if(propl >= 0 &&
192                             strncmp("serial", propb, sizeof("serial")) != 0)
193                                 return PROMDEV_O_UNK;
194                         propl = prom_getproperty(prom_root_node, "stdout-path",
195                                                  propb, sizeof(propb));
196                         if(propl == CON_SIZE_JMC &&
197                             strncmp(propb, con_name_jmc, CON_SIZE_JMC) == 0)
198                                 return PROMDEV_OTTYA;
199                         if(propl > 2) {
200                                 p = propb;
201                                 while(*p) p++; p-= 2;
202                                 if(p[0]==':') {
203                                         if(p[1] == 'a')
204                                                 return PROMDEV_OTTYA;
205                                         else if(p[1] == 'b')
206                                                 return PROMDEV_OTTYB;
207                                 }
208                         }
209                 } else {
210                         switch(*romvec->pv_stdin) {
211                         case PROMDEV_TTYA:      return PROMDEV_OTTYA;
212                         case PROMDEV_TTYB:      return PROMDEV_OTTYB;
213                         };
214                 }
215                 break;
216         default:
217                 ;
218         };
219         return PROMDEV_O_UNK;
220 }