/*
* 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
* 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 2008 Sun Microsystems, Inc. All rights reserved.
* Use is subject to license terms.
*/
#include <sys/sysmacros.h>
#include <sys/machsystm.h>
#include <sys/archsystm.h>
#include <sys/prom_isa.h>
#include <sys/privregs.h>
#include <sys/kdi_machimpl.h>
/*
* We are called with a pointer to a cell-sized argument array.
* The service name (the first element of the argument array) is
* the name of the callback being invoked. When called, we are
* running on the firmwares trap table as a trusted subroutine
* of the firmware.
*
* We define entry points to allow callback handlers to be dynamically
* added and removed, to support obpsym, which is a separate module
* and can be dynamically loaded and unloaded and registers its
* callback handlers dynamically.
*
* Note: The actual callback handler we register, is the assembly lang.
* glue, callback_handler, which takes care of switching from a 64
* bit stack and environment to a 32 bit stack and environment, and
* back again, if the callback handler returns. callback_handler calls
* vx_handler to process the callback.
*/
#define ENDADDR(a) &a[sizeof (a) / sizeof (a[0])]
static struct vx_cmd {
void
init_vx_handler(void)
{
/*
* initialize the lock protecting additions and deletions from
* the vx_cmd table. At callback time we don't need to grab
* this lock. Callback handlers do not need to modify the
* callback handler table.
*/
/*
* Tell OBP about our callback handler.
*/
(void) prom_set_callback((void *)callback_handler);
}
/*
* Add a kernel callback handler to the kernel's list.
* The table is static, so if you add a callback handler, increase
* the value of VX_CMD_MAX. Find the first empty slot and use it.
*/
void
{
return;
}
}
#ifdef DEBUG
/*
* There must be enough entries to handle all callback entries.
* Increase VX_CMD_MAX if this happens. This shouldn't happen.
*/
/* NOTREACHED */
#else /* DEBUG */
name);
#endif /* DEBUG */
}
/*
* Remove a vx_handler function -- find the name string in the table,
* and clear it.
*/
void
{
continue;
continue;
return;
}
}
int
{
char *name;
void *old_tba;
continue;
continue;
if (tba_taken_over != 0)
}
return (0); /* Service name was known */
}
return (-1); /* Service name unknown */
}
/*
* PROM Locking Primitives
*
* These routines are called immediately before and immediately after calling
* into the firmware. The firmware is single-threaded and assumes that the
* kernel will implement locking to prevent simultaneous service calls. In
* addition, some service calls (particularly character rendering) can be
* slow, so we would like to sleep if we cannot acquire the lock to allow the
* caller's CPU to continue to perform useful work in the interim. Service
* routines may also be called early in boot as part of slave CPU startup
* when mutexes and cvs are not yet available (i.e. they are still running on
* the prom's TLB handlers and cannot touch curthread). Therefore, these
* routines must reduce to a simple compare-and-swap spin lock when necessary.
* Finally, kernel code may wish to acquire the firmware lock before executing
* a block of code that includes service calls, so we also allow the firmware
* lock to be acquired recursively by the owning CPU after disabling preemption.
*
* To meet these constraints, the lock itself is implemented as a compare-and-
* swap spin lock on the global prom_cpu pointer. We implement recursion by
* atomically incrementing the integer prom_holdcnt after acquiring the lock.
* If the current CPU is an "adult" (determined by testing cpu_m.mutex_ready),
* we disable preemption before acquiring the lock and leave it disabled once
* the lock is held. The kern_postprom() routine then enables preemption if
* we drop the lock and prom_holdcnt returns to zero. If the current CPU is
* an adult and the lock is held by another adult CPU, we can safely sleep
* until the lock is released. To do so, we acquire the adaptive prom_mutex
* and then sleep on prom_cv. Therefore, service routines must not be called
* from above LOCK_LEVEL on any adult CPU. Finally, if recursive entry is
* attempted on an adult CPU, we must also verify that curthread matches the
* saved prom_thread (the original owner) to ensure that low-level interrupt
* threads do not step on other threads running on the same CPU.
*/
/*
* The debugger uses PROM services, and is thus unable to run if any of the
* CPUs on the system are executing in the PROM at the time of debugger entry.
* If a CPU is determined to be in the PROM when the debugger is entered,
* prom_return_enter_debugger will be set, thus triggering a programmed debugger
* entry when the given CPU returns from the PROM. That CPU is then released by
* the debugger, and is allowed to complete PROM-related work.
*/
void
kern_preprom(void)
{
for (;;) {
/*
* Load the current CPU pointer and examine the mutex_ready bit.
* It doesn't matter if we are preempted here because we are
* only trying to determine if we are in the *set* of mutex
* ready CPUs. We cannot disable preemption until we confirm
* that we are running on a CPU in this set, since a call to
* kpreempt_disable() requires access to curthread.
*/
if (panicstr)
return; /* just return if we are currently panicking */
/*
* Disable premption, and reload the current CPU. We
* can't move from a mutex_ready cpu to a non-ready cpu
* so we don't need to re-check cp->cpu_m.mutex_ready.
*/
/*
* Try the lock. If we don't get the lock, re-enable
* preemption and see if we should sleep. If we are
* already the lock holder, remove the effect of the
* previous kpreempt_disable() before returning since
* preemption was disabled by an earlier kern_preprom.
*/
break;
}
/*
* We have to be very careful here since both prom_cpu
* and prcp->cpu_m.mutex_ready can be changed at any
* time by a non mutex_ready cpu holding the lock.
* If the owner is mutex_ready, holding prom_mutex
* prevents kern_postprom() from completing. If the
* owner isn't mutex_ready, we only know it will clear
* prom_cpu before changing cpu_m.mutex_ready, so we
* issue a membar after checking mutex_ready and then
* re-verify that prom_cpu is still held by the same
* cpu before actually proceeding to cv_wait().
*/
}
} else {
/*
* If we are not yet mutex_ready, just attempt to grab
* the lock. If we get it or already hold it, break.
*/
break;
}
}
/*
* We now hold the prom_cpu lock. Increment the hold count by one
* and assert our current state before returning to the caller.
*/
}
/*
* Drop the prom lock if it is held by the current CPU. If the lock is held
* recursively, return without clearing prom_cpu. If the hold count is now
* zero, clear prom_cpu and cv_signal any waiting CPU.
*/
void
kern_postprom(void)
{
if (panicstr)
return; /* do not modify lock further if we have panicked */
panic("kern_postprom: not owner, cp=%p owner=%p",
if (prom_holdcnt == 0)
panic("kern_postprom: prom_holdcnt == 0, owner=%p",
(void *)prom_cpu);
if (atomic_dec_32_nv(&prom_holdcnt) != 0)
return; /* prom lock is held recursively by this CPU */
kmdb_enter();
prom_thread = NULL;
}
}
/*
* If the frame buffer device is busy, briefly capture the other CPUs so that
* another CPU executing code to manipulate the device does not execute at the
* same time we are rendering characters. Refer to the comments and code in
*
* Notice that we explicitly acquire the PROM lock using kern_preprom() prior
* to idling other CPUs. The idling mechanism will cross-trap the other CPUs
* and have them spin at MAX(%pil, XCALL_PIL), so we must be sure that none of
* them are holding the PROM lock before we idle them and then call into the
* PROM routines that render characters to the frame buffer.
*/
int
{
int s = 0;
kern_preprom();
s = splhi();
}
return (s);
}
void
{
}
}
/*
* This routine is a special form of pause_cpus(). It ensures that
* prom functions are callable while the cpus are paused.
*/
void
promsafe_pause_cpus(void)
{
/* If some other cpu is entering or is in the prom, spin */
start_cpus();
/* Wait for other cpu to exit prom */
while (prom_cpu)
}
/* At this point all cpus are paused and none are in the prom */
}
/*
* This routine is a special form of xc_attention(). It ensures that
* prom functions are callable while the cpus are at attention.
*/
void
{
/* If some other cpu is entering or is in the prom, spin */
/* Wait for other cpu to exit prom */
while (prom_cpu)
}
/* At this point all cpus are paused and none are in the prom */
}
#if defined(PROM_32BIT_ADDRS)
#include <sys/promimpl.h>
#include <vm/seg_kmem.h>
#include <sys/bootconf.h>
/*
* These routines are only used to workaround "poor feature interaction"
* in OBP. See bug 4115680 for details.
*
* Many of the promif routines need to allocate temporary buffers
* of the buffers is extremely short, they are allocated and freed
* around the CIF call. We use vmem_alloc() to cache 32-bit memory.
*
* Note the code in promplat_free() to prevent exhausting the 32 bit
* heap during boot.
*/
void *
{
if (promplat_arena == NULL) {
}
}
/*
* Delaying the free() of small allocations gets more mileage
* calls could burn through available heap32 space too quickly.
*/
void
{
/*
* If VM is initialized, clean up any delayed free().
*/
promplat_last_size = 0;
}
}
/*
* Do the free if VM is initialized or it's a large allocation.
*/
return;
}
/*
* Otherwise, do the last free request and delay this one.
*/
if (promplat_last_free != NULL) {
}
promplat_last_free = p;
}
void
{
}
#endif /* PROM_32BIT_ADDRS */
int
{
/*
* If the tree has changed since the caller last accessed it
* pass 1 as the second argument to the callback function,
* otherwise 0.
*/
*ckp = prom_tree_gen;
chg = 1;
} else
chg = 0;
return (rv);
}
int
{
int rv;
return (rv);
}