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 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 90 prom_set_preprom(promif_preprom_f *new) 91 { 92 promif_preprom_fn = new; 93 } 94 95 void 96 prom_set_postprom(promif_postprom_f *new) 97 { 98 promif_postprom_fn = new; 99 } 100 101 void 102 promif_preprom(void) 103 { 104 if (promif_suspendlevel == 0 && promif_preprom_fn != NULL) 105 promif_preprom_fn(); 106 } 107 108 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 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 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 162 promif_postout(promif_owrap_t *ow) 163 { 164 if (ow->postout != NULL) 165 (ow->postout)(); 166 } 167 168 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 177 prom_suspend_prepost(void) 178 { 179 ASSERT(promif_suspendlevel < 2); 180 181 promif_suspendlevel++; 182 } 183 184 void 185 prom_resume_prepost(void) 186 { 187 ASSERT(promif_suspendlevel >= 0); 188 189 promif_suspendlevel--; 190 } 191