Differential D20640 Diff 65423 head/sys/powerpc/ofw/ofw_real.c

Changeset View

Standalone View

head/sys/powerpc/ofw/ofw_real.c

Show First 20 Lines • Show All 162 Lines • ▼ Show 20 Lines	static MALLOC_DEFINE(M_OFWREAL, "ofwreal",
"Open Firmware Real Mode Bounce Page");		"Open Firmware Real Mode Bounce Page");

static int (openfirmware)(void );		static int (openfirmware)(void );

static vm_offset_t of_bounce_phys;		static vm_offset_t of_bounce_phys;
static caddr_t of_bounce_virt;		static caddr_t of_bounce_virt;
static off_t of_bounce_offset;		static off_t of_bounce_offset;
static size_t of_bounce_size;		static size_t of_bounce_size;

		/*
		* To be able to use OFW console on PPC, that requires real mode OFW,
		* the mutex that guards the mapping/unmapping of virtual to physical
		* buffers (of_real_mtx) must be of SPIN type. This is needed because
		* kernel console first locks a SPIN mutex before calling OFW real.
		* By default, of_real_mtx is a sleepable mutex. To make it of SPIN
		* type, use the following tunnable:
		* machdep.ofw.mtx_spin=1
		*
		* Besides that, a few more tunables are needed to select and use the
		* OFW console with real mode OFW.
		*
		* In order to disable the use of OFW FrameBuffer and fallback to the
		* OFW console, use:
		* hw.ofwfb.disable=1
		*
		* To disable the use of FDT (that doesn't support OFW read/write methods)
		* and use real OFW instead, unset the following loader variable:
		* unset usefdt
		*
		* OFW is put in quiesce state in early kernel boot, which usually disables
		* OFW read/write capabilities (in QEMU write continue to work, but
		* read doesn't). To avoid OFW quiesce, use:
		* debug.quiesce_ofw=0
		*
		* Note that disabling OFW quiesce can cause conflicts between kernel and
		* OFW trying to control the same hardware. Thus, it must be used with care.
		* Some conflicts can be avoided by disabling kernel drivers with hints.
		* For instance, to disable a xhci controller and an USB keyboard connected
		* to it, that may be already being used for input by OFW, use:
		* hint.xhci.0.disabled=1
		*/

static struct mtx of_bounce_mtx;		static struct mtx of_bounce_mtx;
		static struct mtx of_spin_mtx;
		static struct mtx *of_real_mtx;
		static void (*of_mtx_lock)(void);
		static void (*of_mtx_unlock)(void);

extern int ofw_real_mode;		extern int ofw_real_mode;

/*		/*
* After the VM is up, allocate a wired, low memory bounce page.		* After the VM is up, allocate a wired, low memory bounce page.
*/		*/

static void ofw_real_bounce_alloc(void *);		static void ofw_real_bounce_alloc(void *);

SYSINIT(ofw_real_bounce_alloc, SI_SUB_KMEM, SI_ORDER_ANY,		SYSINIT(ofw_real_bounce_alloc, SI_SUB_KMEM, SI_ORDER_ANY,
ofw_real_bounce_alloc, NULL);		ofw_real_bounce_alloc, NULL);

static void		static void
		ofw_real_mtx_lock_spin(void)
		{
		mtx_lock_spin(of_real_mtx);
		}

		static void
		ofw_real_mtx_lock(void)
		{
		mtx_lock(of_real_mtx);
		}

		static void
		ofw_real_mtx_unlock_spin(void)
		{
		mtx_unlock_spin(of_real_mtx);
		}

		static void
		ofw_real_mtx_unlock(void)
		{
		mtx_unlock(of_real_mtx);
		}

		static void
ofw_real_start(void)		ofw_real_start(void)
{		{
mtx_lock(&of_bounce_mtx);		(*of_mtx_lock)();
of_bounce_offset = 0;		of_bounce_offset = 0;
}		}

static void		static void
ofw_real_stop(void)		ofw_real_stop(void)
{		{
mtx_unlock(&of_bounce_mtx);		(*of_mtx_unlock)();
}		}

static void		static void
ofw_real_bounce_alloc(void *junk)		ofw_real_bounce_alloc(void *junk)
{		{
caddr_t temp;		caddr_t temp;

/*		/*
Show All 20 Lines	ofw_real_bounce_alloc(void *junk)
of_bounce_phys = vtophys(of_bounce_virt);		of_bounce_phys = vtophys(of_bounce_virt);
of_bounce_size = 4 * PAGE_SIZE;		of_bounce_size = 4 * PAGE_SIZE;

/*		/*
* For virtual-mode OF, direct map this physical address so that		* For virtual-mode OF, direct map this physical address so that
* we have a 32-bit virtual address to give OF.		* we have a 32-bit virtual address to give OF.
*/		*/

if (!ofw_real_mode && (!hw_direct_map \|\| DMAP_BASE_ADDRESS != 0))		if (!ofw_real_mode && (!hw_direct_map \|\| DMAP_BASE_ADDRESS != 0))
pmap_kenter(of_bounce_phys, of_bounce_phys);		pmap_kenter(of_bounce_phys, of_bounce_phys);

mtx_unlock(&of_bounce_mtx);		mtx_unlock(&of_bounce_mtx);
}		}

static cell_t		static cell_t
ofw_real_map(const void *buf, size_t len)		ofw_real_map(const void *buf, size_t len)
{		{
static char emergency_buffer[255];		static char emergency_buffer[255];
cell_t phys;		cell_t phys;

mtx_assert(&of_bounce_mtx, MA_OWNED);		mtx_assert(of_real_mtx, MA_OWNED);

if (of_bounce_virt == NULL) {		if (of_bounce_virt == NULL) {
/*		/*
* If we haven't set up the MMU, then buf is guaranteed		* If we haven't set up the MMU, then buf is guaranteed
* to be accessible to OF, because the only memory we		* to be accessible to OF, because the only memory we
* can use right now is memory mapped by firmware.		* can use right now is memory mapped by firmware.
*/		*/
if (!pmap_bootstrapped)		if (!pmap_bootstrapped)
Show All 33 Lines	ofw_real_map(const void *buf, size_t len)
of_bounce_offset += len;		of_bounce_offset += len;

return (phys);		return (phys);
}		}

static void		static void
ofw_real_unmap(cell_t physaddr, void *buf, size_t len)		ofw_real_unmap(cell_t physaddr, void *buf, size_t len)
{		{
mtx_assert(&of_bounce_mtx, MA_OWNED);		mtx_assert(of_real_mtx, MA_OWNED);

if (of_bounce_virt == NULL)		if (of_bounce_virt == NULL)
return;		return;

if (physaddr == 0)		if (physaddr == 0)
return;		return;

memcpy(buf,of_bounce_virt + (physaddr - of_bounce_phys),len);		memcpy(buf,of_bounce_virt + (physaddr - of_bounce_phys),len);
}		}

/* Initialiser */		/* Initialiser */

static int		static int
ofw_real_init(ofw_t ofw, void *openfirm)		ofw_real_init(ofw_t ofw, void *openfirm)
{		{
openfirmware = (int ()(void ))openfirm;		int mtx_spin;

		openfirmware = (int ()(void ))openfirm;
mtx_init(&of_bounce_mtx, "OF Bounce Page", NULL, MTX_DEF);		mtx_init(&of_bounce_mtx, "OF Bounce Page", NULL, MTX_DEF);

		mtx_spin = 0;
		TUNABLE_INT_FETCH("machdep.ofw.mtx_spin", &mtx_spin);
		if (mtx_spin) {
		mtx_init(&of_spin_mtx, "OF Real", NULL, MTX_SPIN);
		of_real_mtx = &of_spin_mtx;
		of_mtx_lock = ofw_real_mtx_lock_spin;
		of_mtx_unlock = ofw_real_mtx_unlock_spin;
		} else {
		of_real_mtx = &of_bounce_mtx;
		of_mtx_lock = ofw_real_mtx_lock;
		of_mtx_unlock = ofw_real_mtx_unlock;
		}

of_bounce_virt = NULL;		of_bounce_virt = NULL;
return (0);		return (0);
}		}

/*		/*
* Generic functions		* Generic functions
*/		*/

▲ Show 20 Lines • Show All 791 Lines • Show Last 20 Lines