/*
* unmap virt, then map virt to new phys;
* see remap definition below
*/
int
prom_remap(size_t size, caddr_t virt, physaddr_t phys)
{
ihandle_t immu;
cell_t ci[8];
int rv;
immu = prom_mmu_ihandle();
if (immu == (ihandle_t)-1)
return (ERR);
ci[0] = p1275_ptr2cell("call-method"); /* Service name */
ci[1] = (cell_t)5; /* #argument cells */
ci[2] = (cell_t)0; /* #result cells */
ci[3] = p1275_ptr2cell("remap"); /* Arg1: Method name */
ci[4] = p1275_ihandle2cell(immu); /* Arg2: memory ihandle */
ci[5] = p1275_size2cell(size); /* remap arg0 */
ci[6] = p1275_ptr2cell(virt); /* remap arg1 */
ci[7] = p1275_ull2cell_low(phys); /* remap arg2 */
promif_preprom();
rv = p1275_cif_handler(ci);
promif_postprom();
if (rv)
return (rv); /* Service "call-method" failed */
return (0);
}
/*
* Allocate physical memory, unmapped and possibly aligned.
* Returns 0: Success; Non-zero: failure.
* Returns *physaddr only if successful.
*
* This routine is suitable for platforms with 2-cell physical addresses
* and a single size cell in the "memory" node.
*/
int
prom_allocate_phys(size_t size, uint32_t align, u_longlong_t *physaddr)
{
cell_t ci[10];
int32_t rv;
ihandle_t imemory = prom_memory_ihandle();
if ((imemory == (ihandle_t)-1))
return (-1);
if (align == 0)
align = (uint32_t)1;
ci[0] = p1275_ptr2cell("call-method"); /* Service name */
ci[1] = (cell_t)4; /* #argument cells */
ci[2] = (cell_t)3; /* #result cells */
ci[3] = p1275_ptr2cell("claim"); /* Arg1: Method name */
ci[4] = p1275_ihandle2cell(imemory); /* Arg2: memory ihandle */
ci[5] = p1275_uint2cell(align); /* Arg3: SA1: align */
ci[6] = p1275_size2cell(size); /* Arg4: SA2: size */
rv = p1275_cif_handler(&ci);
if (rv != 0)
return (rv);
if (p1275_cell2int(ci[7]) != 0) /* Res1: Catch result */
return (-1);
*physaddr = p1275_cells2ull(ci[8], ci[9]);
/* Res2: SR1: phys.hi ... Res3: SR2: phys.lo */
return (0);
}
/*
* Claim a region of physical memory, unmapped.
* Returns 0: Success; Non-zero: failure.
*
* This routine is suitable for platforms with 2-cell physical addresses
* and a single size cell in the "memory" node.
*/
int
prom_claim_phys(size_t size, u_longlong_t physaddr)
{
cell_t ci[10];
int32_t rv;
ihandle_t imemory = prom_memory_ihandle();
if ((imemory == (ihandle_t)-1))
return (-1);
ci[0] = p1275_ptr2cell("call-method"); /* Service name */
ci[1] = (cell_t)6; /* #argument cells */
ci[2] = (cell_t)1; /* #result cells */
ci[3] = p1275_ptr2cell("claim"); /* Arg1: Method name */
ci[4] = p1275_ihandle2cell(imemory); /* Arg2: mmu ihandle */
ci[5] = 0; /* Arg3: SA1: align */
ci[6] = p1275_size2cell(size); /* Arg4: SA2: len */
ci[7] = p1275_ull2cell_high(physaddr); /* Arg5: SA3: phys.hi */
ci[8] = p1275_ull2cell_low(physaddr); /* Arg6: SA4: phys.lo */
rv = p1275_cif_handler(&ci);
if (rv != 0)
return (rv);
if (p1275_cell2int(ci[9]) != 0) /* Res1: Catch result */
return (-1);
return (0);
}
/*
* Free physical memory (no unmapping is done).
* This routine is suitable for platforms with 2-cell physical addresses
* with a single size cell.
*/
void
prom_free_phys(size_t size, u_longlong_t physaddr)
{
cell_t ci[8];
ihandle_t imemory = prom_memory_ihandle();
if ((imemory == (ihandle_t)-1))
return;
ci[0] = p1275_ptr2cell("call-method"); /* Service name */
ci[1] = (cell_t)5; /* #argument cells */
ci[2] = (cell_t)0; /* #return cells */
ci[3] = p1275_ptr2cell("release"); /* Arg1: Method name */
ci[4] = p1275_ihandle2cell(imemory); /* Arg2: memory ihandle */
ci[5] = p1275_size2cell(size); /* Arg3: SA1: size */
ci[6] = p1275_ull2cell_high(physaddr); /* Arg4: SA2: phys.hi */
ci[7] = p1275_ull2cell_low(physaddr); /* Arg5: SA3: phys.lo */
(void) p1275_cif_handler(&ci);
}
/*ARGSUSED3*/
ssize_t
prom_read(ihandle_t fd, caddr_t buf, size_t len, uint_t startblk, char devtype)
{
cell_t ci[7];
promif_owrap_t *ow;
#ifdef PROM_32BIT_ADDRS
caddr_t obuf = NULL;
if ((uintptr_t)buf > (uint32_t)-1) {
obuf = buf;
buf = promplat_alloc(len);
if (buf == NULL)
return (-1);
}
#endif
ow = promif_preout();
promif_preprom();
ci[0] = p1275_ptr2cell("read"); /* Service name */
ci[1] = (cell_t)3; /* #argument cells */
ci[2] = (cell_t)1; /* #result cells */
ci[3] = p1275_size2cell((uint_t)fd); /* Arg1: ihandle */
ci[4] = p1275_ptr2cell(buf); /* Arg2: buffer address */
ci[5] = p1275_uint2cell(len); /* Arg3: buffer length */
ci[6] = (cell_t)-1; /* Res1: Prime result */
(void) p1275_cif_handler(&ci);
promif_postprom();
promif_postout(ow);
#ifdef PROM_32BIT_ADDRS
if (obuf != NULL) {
promplat_bcopy(buf, obuf, len);
promplat_free(buf, len);
}
#endif
return (p1275_cell2size(ci[6])); /* Res1: actual length */
}
/*ARGSUSED3*/
ssize_t
prom_write(ihandle_t fd, caddr_t buf, size_t len, uint_t startblk, char devtype)
{
cell_t ci[7];
promif_owrap_t *ow;
ssize_t rlen;
#ifdef PROM_32BIT_ADDRS
caddr_t obuf = NULL;
static char smallbuf[256];
ASSERT(buf);
#endif
/*
* If the callback address is set, attempt to redirect
* console output back into kernel terminal emulator.
*/
if (promif_redirect != NULL && fd == prom_stdout_ihandle()) {
ow = promif_preout();
rlen = promif_redirect(promif_redirect_arg, (uchar_t *)buf,
len);
promif_postout(ow);
return (rlen);
}
#ifdef PROM_32BIT_ADDRS
if ((uintptr_t)buf > (uint32_t)-1) {
/*
* This is a hack for kernel message output.
* By avoiding calls to promplat_alloc (and
* using smallbuf instead) when memory is low
* we can print shortish kernel messages without
* deadlocking. smallbuf should be at least as
* large as the automatic buffer in
* prom_printf.c:_doprint()'s stack frame.
* promplat_alloc() can block on a mutex and so
* is called here before calling promif_preprom().
*/
if (len > sizeof (smallbuf)) {
obuf = buf;
buf = promplat_alloc(len);
if (buf == NULL) {
return (-1);
}
promplat_bcopy(obuf, buf, len);
}
}
#endif
/*
* Normally we'd call promif_preprom() just before
* calling into the prom (to enforce single-threaded
* access) but here we need to call it before accessing
* smallbuf, since smallbuf is statically allocated and
* hence can only be accessed by one thread at a time.
*/
ow = promif_preout();
promif_preprom();
#ifdef PROM_32BIT_ADDRS
if ((uintptr_t)buf > (uint32_t)-1) {
/*
* If buf is small enough, use smallbuf
* instead of promplat_alloc() (see above)
* smallbuf is static, so single thread
* access to it by using it only after
* promif_preprom()
*/
if (len <= sizeof (smallbuf)) {
promplat_bcopy(buf, smallbuf, len);
buf = smallbuf;
}
}
#endif
ci[0] = p1275_ptr2cell("write"); /* Service name */
ci[1] = (cell_t)3; /* #argument cells */
ci[2] = (cell_t)1; /* #result cells */
ci[3] = p1275_uint2cell((uint_t)fd); /* Arg1: ihandle */
ci[4] = p1275_ptr2cell(buf); /* Arg2: buffer addr */
ci[5] = p1275_size2cell(len); /* Arg3: buffer len */
ci[6] = (cell_t)-1; /* Res1: Prime result */
(void) p1275_cif_handler(&ci);
rlen = p1275_cell2size(ci[6]); /* Res1: actual len */
promif_postprom();
promif_postout(ow);
#ifdef PROM_32BIT_ADDRS
if (obuf != NULL)
promplat_free(buf, len);
#endif
return (rlen);
}
