1 /*
2 * CDDL HEADER START
3 *
4 * The contents of this file are subject to the terms of the
5 * Common Development and Distribution License (the "License").
6 * You may not use this file except in compliance with the License.
7 *
8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9 * or http://www.opensolaris.org/os/licensing.
10 * See the License for the specific language governing permissions
11 * and limitations under the License.
12 *
13 * When distributing Covered Code, include this CDDL HEADER in each
14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15 * If applicable, add the following below this CDDL HEADER, with the
16 * fields enclosed by brackets "[]" replaced with your own identifying
17 * information: Portions Copyright [yyyy] [name of copyright owner]
18 *
19 * CDDL HEADER END
20 */
21
22 /*
23 * Copyright 2006 Sun Microsystems, Inc. All rights reserved.
24 * Use is subject to license terms.
25 */
26
27 #pragma ident "%Z%%M% %I% %E% SMI"
28
29 #include <sys/promif.h>
30 #include <sys/promimpl.h>
31
32 /*
33 * The functions in this file are used to control the pre- and post-processing
34 * functions that bracket calls to the OBP CIF handler. One set, promif_preprom
35 * and promif_postprom, are provided for general kernel use. The other set,
36 * promif_preout and promif_postout, are used by the power management subsystem
37 * to ensure that the framebuffer is active when PROM functions that interact
38 * with the console are invoked.
39 *
40 * In some cases, the operation of these functions must be suppressed. As such,
41 * this file provides the ability to suspend and resume use of both sets
42 * simultaneously. Complicating matters is the fact that both current uses of
43 * the pre- and post-processor suspension and resume facilities, kmdb and CPR
44 * may be used simultaneously. We therefore support normal operation and two
45 * levels of suspension. The pre- and post-processing functions are only
46 * called during normal operation. With each suspension request, this
47 * subsystem enters the first suspension level, or passes to the second
48 * suspension level, as appropriate. Resume calls decrement the suspension
49 * level. Only two nested suspensions are supported.
50 *
51 * As indicated above, the two current users are CPR and kmdb. CPR must prevent
52 * kernel accesses outside of the nucleus page during the late stages of system
53 * suspension and during the early stages of system resumption. As such, the
54 * PM-related processing must not occur during these times.
55 *
56 * The platform-specific portions of kmdb live in the platmods, and thus execute
57 * in the linker environment of the platmods. That is, any promif calls they
58 * may make are executed by the kernel copies of those functions, rather than
59 * the versions included with kmdb. The only difference between the two copies
60 * being the nonuse of the pre- and post-processing functions in the kmdb
61 * versions, we must ensure that these functions are not used when the kmdb
62 * platmod code executes. Accordingly, kmdb disables the pre- and post-
63 * processing functions via the KDI prior to passing control to the platmod
64 * debugger code.
65 */
66
67 static int promif_suspendlevel;
68
69 static promif_preprom_f *promif_preprom_fn;
70 static promif_postprom_f *promif_postprom_fn;
71
72 /*
73 * When this is set, the PROM output functions attempt to
74 * redirect output to the kernel terminal emulator.
75 */
76 promif_redir_t promif_redirect;
77 promif_redir_arg_t promif_redirect_arg;
78
79 /*
80 * Sets new callback and argument, returns previous callback.
81 */
82 void
prom_set_stdout_redirect(promif_redir_t new_fn,promif_redir_arg_t opaque_arg)83 prom_set_stdout_redirect(promif_redir_t new_fn, promif_redir_arg_t opaque_arg)
84 {
85 promif_redirect_arg = opaque_arg;
86 promif_redirect = new_fn;
87 }
88
89 void
prom_set_preprom(promif_preprom_f * new)90 prom_set_preprom(promif_preprom_f *new)
91 {
92 promif_preprom_fn = new;
93 }
94
95 void
prom_set_postprom(promif_postprom_f * new)96 prom_set_postprom(promif_postprom_f *new)
97 {
98 promif_postprom_fn = new;
99 }
100
101 void
promif_preprom(void)102 promif_preprom(void)
103 {
104 if (promif_suspendlevel == 0 && promif_preprom_fn != NULL)
105 promif_preprom_fn();
106 }
107
108 void
promif_postprom(void)109 promif_postprom(void)
110 {
111 if (promif_suspendlevel == 0 && promif_postprom_fn != NULL)
112 promif_postprom_fn();
113 }
114
115 /*
116 * The reader will note that the layout and calling conventions of the
117 * prom_preout and prom_postout functions differ from the prom_preprom and
118 * prom_postprom functions, above. At the time the preout and postout
119 * functions are initialized, kernel startup is well underway. There exists
120 * a race condition whereby a PROM call may begin before preout has been
121 * initialized, and may end after postout has been initialized. In such
122 * cases, there will be a call to postout without a corresponding preout
123 * call. The preprom and postprom calls above are initialized early enough
124 * that this race condition does not occur.
125 *
126 * To avoid the race condition, the preout/postout functions are designed
127 * such that the initialization is atomic. Further, the preout call returns
128 * a data structure that includes a pointer to the postout function that
129 * corresponds to the invoked preout function. This ensures that the preout
130 * and postout functions will only be used as a matched set.
131 */
132
133 static void
null_outfunc(void)134 null_outfunc(void)
135 {
136 }
137
138 static promif_owrap_t nullwrapper =
139 {
140 null_outfunc,
141 null_outfunc
142 };
143
144 static promif_owrap_t *wrapper = &nullwrapper;
145 static promif_owrap_t pmwrapper;
146
147 promif_owrap_t
promif_preout(void)148 *promif_preout(void)
149 {
150 promif_owrap_t *ow;
151
152 if (promif_suspendlevel > 0)
153 return (&nullwrapper);
154
155 ow = wrapper;
156 if (ow->preout != NULL)
157 (ow->preout)();
158 return (ow);
159 }
160
161 void
promif_postout(promif_owrap_t * ow)162 promif_postout(promif_owrap_t *ow)
163 {
164 if (ow->postout != NULL)
165 (ow->postout)();
166 }
167
168 void
prom_set_outfuncs(void (* pref)(void),void (* postf)(void))169 prom_set_outfuncs(void (*pref)(void), void (*postf)(void))
170 {
171 pmwrapper.preout = pref;
172 pmwrapper.postout = postf;
173 wrapper = &pmwrapper;
174 }
175
176 void
prom_suspend_prepost(void)177 prom_suspend_prepost(void)
178 {
179 ASSERT(promif_suspendlevel < 2);
180
181 promif_suspendlevel++;
182 }
183
184 void
prom_resume_prepost(void)185 prom_resume_prepost(void)
186 {
187 ASSERT(promif_suspendlevel >= 0);
188
189 promif_suspendlevel--;
190 }
191