![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to serial_console.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Apple XNU] / XNU / osfmk / ppc|
Return to serial_console.c CVS log | Up to [Apple XNU] / XNU / osfmk / ppc |
1.1 root 1: /*
2: * Copyright (c) 2000 Apple Computer, Inc. All rights reserved.
3: *
4: * @APPLE_LICENSE_HEADER_START@
5: *
6: * The contents of this file constitute Original Code as defined in and
7: * are subject to the Apple Public Source License Version 1.1 (the
8: * "License"). You may not use this file except in compliance with the
9: * License. Please obtain a copy of the License at
10: * http://www.apple.com/publicsource and read it before using this file.
11: *
12: * This Original Code and all software distributed under the License are
13: * distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER
14: * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
15: * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
16: * FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT. Please see the
17: * License for the specific language governing rights and limitations
18: * under the License.
19: *
20: * @APPLE_LICENSE_HEADER_END@
21: */
22: /*
23: * @OSF_COPYRIGHT@
24: */
25: /*
26: * @APPLE_FREE_COPYRIGHT@
27: */
28:
29: #include <mach_kdb.h>
30: #include <platforms.h>
31: #include <serial_console_default.h>
32:
33: #include <kern/spl.h>
34: #include <machine/machparam.h> /* spl definitions */
35: #include <types.h>
36: #include <ppc/POWERMAC/video_console_entries.h>
37: #include <ppc/misc_protos.h>
38: #include <ppc/POWERMAC/serial_io.h>
39: #include <ppc/POWERMAC/mp/mp.h>
40: #include <kern/cpu_number.h>
41: #include <ppc/Firmware.h>
42: #include <ppc/proc_reg.h>
43: #include <pexpert/pexpert.h>
44:
45: /*
46: * A machine MUST have a console. In our case
47: * things are a little complicated by the graphic
48: * display: people expect it to be their "console",
49: * but we'd like to be able to live without it.
50: * This is not to be confused with the "rconsole" thing:
51: * that just duplicates the console I/O to
52: * another place (for debugging/logging purposes).
53: */
54:
55: const int console_unit = 0;
56: const int console_chan_default = CONSOLE_PORT;
57: #define console_chan (console_chan_default) /* ^ cpu_number()) */
58:
59: #define OPS(putc, getc, nosplputc, nosplgetc) putc, getc
60:
61: const struct console_ops {
62: int (*putc)(int, int, int);
63: int (*getc)(int, int, boolean_t, boolean_t);
64: } cons_ops[] = {
65: #define SCC_CONS_OPS 0
66: {OPS(scc_putc, scc_getc, no_spl_scputc, no_spl_scgetc)},
67: #define VC_CONS_OPS 1
68: {OPS(vcputc, vcgetc, no_spl_vcputc, no_spl_vcgetc)},
69: };
70: #define NCONSOPS (sizeof cons_ops / sizeof cons_ops[0])
71:
72: #if SERIAL_CONSOLE_DEFAULT
73: #define CONS_OPS SCC_CONS_OPS
74: #define CONS_NAME "com"
75: #else
76: #define CONS_OPS VC_CONS_OPS
77: #define CONS_NAME "vc"
78: #endif
79:
80: #define MP_SAFE_CONSOLE 1 /* Set this to 1 to allow more than 1 processor to print at once */
81: #if MP_SAFE_CONSOLE
82:
83: struct ppcbfr { /* Controls multiple processor output */
84: unsigned int pos; /* Current position in buffer */
85: unsigned int noprompt; /* Set if we skip the prompt */
86: unsigned int echo; /* Control character echoing */
87: char buffer[256]; /* Fairly big buffer */
88: };
89: typedef struct ppcbfr ppcbfr;
90: ppcbfr cbfr[NCPUS]; /* Get one of these for each processor */
91: volatile unsigned int cbfpend; /* A buffer is pending output */
92: volatile unsigned int sconowner=-1; /* Mark who's actually writing */
93:
94: #endif
95:
96:
97: unsigned int cons_ops_index = CONS_OPS;
98: unsigned int killprint = 0;
99: unsigned int debcnputc = 0;
100: extern unsigned int mappingdeb0;
101: extern int debugger_holdoff[NCPUS];
102:
103: static void _cnputc(char c)
104: {
105: cons_ops[cons_ops_index].putc(console_unit, console_chan, c);
106: }
107:
108: void cnputcusr(char c) { /* Echo input character directly */
109:
110: unsigned int cpu;
111:
112: if (cpu_data[master_cpu].active_thread) cpu = cpu_number(); /* If we're started up, use the current CPU */
113: else cpu = master_cpu; /* Otherwise use the master_cpu */
114:
115: hw_atomic_add(&debugger_holdoff[cpu], 1); /* Don't allow debugger entry just now (this is a HACK) */
116:
117: _cnputc( c); /* Echo the character */
118: if(c=='\n') _cnputc( '\r'); /* Add a return if we had a new line */
119:
120: hw_atomic_sub(&debugger_holdoff[cpu], 1); /* Don't allow debugger entry just now (this is a HACK) */
121: return;
122: }
123:
124: void
125: cnputc(char c)
126: {
127:
128: unsigned int oldpend, i, cpu, ourbit, sccpu;
129: spl_t s;
130:
131: #if MP_SAFE_CONSOLE
132:
133: /*
134: * Handle multiple CPU console output.
135: * Note: this thing has gotten god-awful complicated. We need a better way.
136: */
137:
138:
139: if(killprint) {
140: return; /* If printing is disabled, bail... */
141: }
142:
143: if (cpu_data[master_cpu].active_thread) cpu = cpu_number(); /* If we're started up, use the current CPU */
144: else cpu = master_cpu; /* Otherwise use the master_cpu */
145:
146: hw_atomic_add(&debugger_holdoff[cpu], 1); /* Don't allow debugger entry just now (this is a HACK) */
147:
148: ourbit = 1 << cpu; /* Make a mask for just us */
149: if(debugger_cpu != -1) { /* Are we in the debugger with empty buffers? */
150:
151: while(sconowner != cpu) { /* Anyone but us? */
152: hw_compare_and_store(-1, cpu, (unsigned int *)&sconowner); /* Try to mark it for us if idle */
153: }
154:
155: _cnputc( c); /* Yeah, just write it */
156: if(c=='\n') /* Did we just write a new line? */
157: _cnputc( '\r'); /* Yeah, just add a return */
158:
159: sconowner=-1; /* Mark it idle */
160: hw_atomic_sub(&debugger_holdoff[cpu], 1); /* Don't allow debugger entry just now (this is a HACK) */
161:
162: return; /* Leave... */
163: }
164:
165: s=splhigh(); /* Don't bother me */
166:
167: while(ourbit&cbfpend); /* We aren't "double buffered," so we'll just wait until the buffers are written */
168: isync(); /* Just in case we had to wait */
169:
170: if(c) { /* If the character is not null */
171: cbfr[cpu].buffer[cbfr[cpu].pos]=c; /* Fill in the buffer for our CPU */
172: cbfr[cpu].pos++; /* Up the count */
173: if(cbfr[cpu].pos > 253) { /* Is the buffer full? */
174: cbfr[cpu].buffer[254]='\n'; /* Yeah, set the second to last as a LF */
175: cbfr[cpu].buffer[255]='\r'; /* And the last to a CR */
176: cbfr[cpu].pos=256; /* Push the buffer to the end */
177: c='\r'; /* Set character to a CR */
178: }
179: }
180:
181: if(c == '\n') { /* Are we finishing a line? */
182: cbfr[cpu].buffer[cbfr[cpu].pos]='\r'; /* And the last to a CR */
183: cbfr[cpu].pos++; /* Up the count */
184: c='\r'; /* Set character to a CR */
185: }
186:
187: #if 1
188: if(cbfr[cpu].echo == 1) { /* Did we hit an escape last time? */
189: if(c == 'K') { /* Is it a partial clear? */
190: cbfr[cpu].echo = 2; /* Yes, enter echo mode */
191: }
192: else cbfr[cpu].echo = 0; /* Otherwise reset escape */
193: }
194: else if(cbfr[cpu].echo == 0) { /* Not in escape sequence, see if we should enter */
195: cbfr[cpu].echo = 1; /* Set that we are in escape sequence */
196: }
197: #endif
198:
199: if((c == 0x00) || (c == '\r') || (cbfr[cpu].echo == 2)) { /* Try to push out all buffers if we see CR or null */
200:
201: while(1) { /* Loop until we see who's doing this */
202: oldpend=cbfpend; /* Get the currentest pending buffer flags */
203: if(hw_compare_and_store(oldpend, oldpend|ourbit, (unsigned int *)&cbfpend)) /* Swap ours on if no change */
204: break; /* Bail the loop if it worked */
205: }
206:
207: if(!hw_compare_and_store(-1, cpu, (unsigned int *)&sconowner)) { /* See if someone else has this, and take it if not */
208: debugger_holdoff[cpu] = 0; /* Allow debugger entry (this is a HACK) */
209: splx(s); /* Let's take some 'rupts now */
210: return; /* We leave here, 'cause another processor is already writing the buffers */
211: }
212:
213: while(1) { /* Loop to dump out all of the finished buffers */
214: oldpend=cbfpend; /* Get the most current finished buffers */
215: for(sccpu=0; sccpu<NCPUS; sccpu++) { /* Cycle through all CPUs buffers */
216:
217: if(oldpend&(1<<sccpu)) { /* Does this guy have a buffer to do? */
218:
219: #if 0
220: if(!cbfr[sccpu].noprompt) { /* Don't prompt if there was not CR before */
221: _cnputc( '{'); /* Mark CPU number */
222: _cnputc( '0'+sccpu); /* Mark CPU number */
223: _cnputc( '.'); /* (TEST/DEBUG) */
224: _cnputc( '0'+cpu); /* (TEST/DEBUG) */
225: _cnputc( '}'); /* Mark CPU number */
226: _cnputc( ' '); /* Mark CPU number */
227: }
228: #endif
229:
230: for(i=0; i<cbfr[sccpu].pos; i++) { /* Do the whole buffer */
231: _cnputc( cbfr[sccpu].buffer[i]); /* Write it */
232: }
233:
234: if(cbfr[sccpu].buffer[cbfr[sccpu].pos-1]!='\r') { /* Was the last character a return? */
235: cbfr[sccpu].noprompt = 1; /* Remember not to prompt */
236: }
237: else { /* Last was a return */
238: cbfr[sccpu].noprompt = 0; /* Otherwise remember to prompt */
239: cbfr[sccpu].echo = 0; /* And clear echo */
240: }
241:
242: cbfr[sccpu].pos=0; /* Reset the buffer pointer */
243:
244: while(!hw_compare_and_store(cbfpend, cbfpend&~(1<<sccpu), (unsigned int *)&cbfpend)); /* Swap it off */
245: }
246: }
247: sconowner=-1; /* Set the writer to idle */
248: sync(); /* Insure that everything's done */
249: if(hw_compare_and_store(0, 0, (unsigned int *)&cbfpend)) break; /* If there are no new buffers, we are done... */
250: if(!hw_compare_and_store(-1, cpu, (unsigned int *)&sconowner)) break; /* If this isn't idle anymore, we're done */
251:
252: }
253: }
254: hw_atomic_sub(&debugger_holdoff[cpu], 1); /* Don't allow debugger entry just now (this is a HACK) */
255: splx(s); /* Let's take some 'rupts now */
256:
257: #else /* MP_SAFE_CONSOLE */
258: _cnputc( c);
259: if (c == '\n')
260: _cnputc('\r');
261: #endif /* MP_SAFE_CONSOLE */
262:
263: }
264:
265: int
266: cngetc()
267: {
268: return cons_ops[cons_ops_index].getc(console_unit, console_chan,
269: TRUE, FALSE);
270: }
271:
272: int
273: cnmaygetc()
274: {
275: return cons_ops[cons_ops_index].getc(console_unit, console_chan,
276: FALSE, FALSE);
277: }
278:
279: boolean_t console_is_serial()
280: {
281: return cons_ops_index == SCC_CONS_OPS;
282: }
283:
284: int
285: switch_to_video_console()
286: {
287: int old_cons_ops = cons_ops_index;
288: cons_ops_index = VC_CONS_OPS;
289: return old_cons_ops;
290: }
291:
292: int
293: switch_to_serial_console()
294: {
295: int old_cons_ops = cons_ops_index;
296: cons_ops_index = SCC_CONS_OPS;
297: return old_cons_ops;
298: }
299:
300: /* The switch_to_{video,serial,kgdb}_console functions return a cookie that
301: can be used to restore the console to whatever it was before, in the
302: same way that splwhatever() and splx() work. */
303: void
304: switch_to_old_console(int old_console)
305: {
306: static boolean_t squawked;
307: unsigned int ops = old_console;
308:
309: if (ops >= NCONSOPS && !squawked) {
310: squawked = TRUE;
311: printf("switch_to_old_console: unknown ops %d\n", ops);
312: } else
313: cons_ops_index = ops;
314: }
315:
316:
317: int
318: vcgetc(int l, int u, boolean_t wait, boolean_t raw)
319: {
320: char c;
321:
322: if( 0 == (*PE_poll_input)( 0, &c))
323: return( c);
324: else
325: return( 0);
326: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.