/* * CDDL HEADER START * * The contents of this file are subject to the terms of the * Common Development and Distribution License (the "License"). * You may not use this file except in compliance with the License. * * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE * or http://www.opensolaris.org/os/licensing. * See the License for the specific language governing permissions * and limitations under the License. * * When distributing Covered Code, include this CDDL HEADER in each * file and include the License file at usr/src/OPENSOLARIS.LICENSE. * If applicable, add the following below this CDDL HEADER, with the * fields enclosed by brackets "[]" replaced with your own identifying * information: Portions Copyright [yyyy] [name of copyright owner] * * CDDL HEADER END */ /* * Copyright 2006 Sun Microsystems, Inc. All rights reserved. * Use is subject to license terms. */ #pragma ident "%Z%%M% %I% %E% SMI" #include #include /* * The functions in this file are used to control the pre- and post-processing * functions that bracket calls to the OBP CIF handler. One set, promif_preprom * and promif_postprom, are provided for general kernel use. The other set, * promif_preout and promif_postout, are used by the power management subsystem * to ensure that the framebuffer is active when PROM functions that interact * with the console are invoked. * * In some cases, the operation of these functions must be suppressed. As such, * this file provides the ability to suspend and resume use of both sets * simultaneously. Complicating matters is the fact that both current uses of * the pre- and post-processor suspension and resume facilities, kmdb and CPR * may be used simultaneously. We therefore support normal operation and two * levels of suspension. The pre- and post-processing functions are only * called during normal operation. With each suspension request, this * subsystem enters the first suspension level, or passes to the second * suspension level, as appropriate. Resume calls decrement the suspension * level. Only two nested suspensions are supported. * * As indicated above, the two current users are CPR and kmdb. CPR must prevent * kernel accesses outside of the nucleus page during the late stages of system * suspension and during the early stages of system resumption. As such, the * PM-related processing must not occur during these times. * * The platform-specific portions of kmdb live in the platmods, and thus execute * in the linker environment of the platmods. That is, any promif calls they * may make are executed by the kernel copies of those functions, rather than * the versions included with kmdb. The only difference between the two copies * being the nonuse of the pre- and post-processing functions in the kmdb * versions, we must ensure that these functions are not used when the kmdb * platmod code executes. Accordingly, kmdb disables the pre- and post- * processing functions via the KDI prior to passing control to the platmod * debugger code. */ static int promif_suspendlevel; static promif_preprom_f *promif_preprom_fn; static promif_postprom_f *promif_postprom_fn; /* * When this is set, the PROM output functions attempt to * redirect output to the kernel terminal emulator. */ promif_redir_t promif_redirect; promif_redir_arg_t promif_redirect_arg; /* * Sets new callback and argument, returns previous callback. */ void prom_set_stdout_redirect(promif_redir_t new_fn, promif_redir_arg_t opaque_arg) { promif_redirect_arg = opaque_arg; promif_redirect = new_fn; } void prom_set_preprom(promif_preprom_f *new) { promif_preprom_fn = new; } void prom_set_postprom(promif_postprom_f *new) { promif_postprom_fn = new; } void promif_preprom(void) { if (promif_suspendlevel == 0 && promif_preprom_fn != NULL) promif_preprom_fn(); } void promif_postprom(void) { if (promif_suspendlevel == 0 && promif_postprom_fn != NULL) promif_postprom_fn(); } /* * The reader will note that the layout and calling conventions of the * prom_preout and prom_postout functions differ from the prom_preprom and * prom_postprom functions, above. At the time the preout and postout * functions are initialized, kernel startup is well underway. There exists * a race condition whereby a PROM call may begin before preout has been * initialized, and may end after postout has been initialized. In such * cases, there will be a call to postout without a corresponding preout * call. The preprom and postprom calls above are initialized early enough * that this race condition does not occur. * * To avoid the race condition, the preout/postout functions are designed * such that the initialization is atomic. Further, the preout call returns * a data structure that includes a pointer to the postout function that * corresponds to the invoked preout function. This ensures that the preout * and postout functions will only be used as a matched set. */ static void null_outfunc(void) { } static promif_owrap_t nullwrapper = { null_outfunc, null_outfunc }; static promif_owrap_t *wrapper = &nullwrapper; static promif_owrap_t pmwrapper; promif_owrap_t *promif_preout(void) { promif_owrap_t *ow; if (promif_suspendlevel > 0) return (&nullwrapper); ow = wrapper; if (ow->preout != NULL) (ow->preout)(); return (ow); } void promif_postout(promif_owrap_t *ow) { if (ow->postout != NULL) (ow->postout)(); } void prom_set_outfuncs(void (*pref)(void), void (*postf)(void)) { pmwrapper.preout = pref; pmwrapper.postout = postf; wrapper = &pmwrapper; } void prom_suspend_prepost(void) { ASSERT(promif_suspendlevel < 2); promif_suspendlevel++; } void prom_resume_prepost(void) { ASSERT(promif_suspendlevel >= 0); promif_suspendlevel--; }