\

\ 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

\

\

\ ident "%Z%%M% %I% %E% SMI"

\ Copyright 2008 Sun Microsystems, Inc. All rights reserved.

\ Use is subject to license terms.

\

id: %Z%%M% %I% %E% SMI

purpose: utility words

copyright: Copyright 2007 Sun Microsystems, Inc. All Rights Reserved

[ifdef] doheaders

headers

[else]

headerless

[then]

d# 256 constant /buf-len

\

\ useful counting words

\

: roundup ( x y -- x' ) 1- tuck + swap invert and ;

\

\ various useful string manipulation words

\

: cstrlen ( cstr -- len )

dup begin

dup c@

while

char+

repeat swap -

;

: cscount ( cstr -- adr,len ) dup cstrlen ;

\ Append str1 to the end of str2

: $append ( adr,len1 adr,len2 -- )

2over 2over ca+ swap move ( adr,len1 adr,len2 )

rot + ca+ 0 swap c! drop ( )

;

: $= ( str1$ str2$ -- same? )

rot tuck <> if

3drop false exit

then comp 0=

;

\ advance str by 1

: str++ ( adr len -- adr' len' )

swap 1+ swap 1-

;

: die ( str -- )

cr type cr abort

;

: diag-cr? ( -- ) diagnostic-mode? if cr then ;

: find-abort ( name$ -- )

cr ." Can't find " type cr abort

;

: get-package ( pkg$ -- ph )

2dup find-package 0= if

find-abort

then ( pkg$ ph )

nip nip ( ph )

;

\

\ CIF words for I/O and memory

\

" /openprom/client-services" get-package constant cif-ph

instance defer cif-open ( dev$ -- ihandle|0 )

instance defer cif-close ( ihandle -- )

instance defer cif-read ( len adr ihandle -- #read )

instance defer cif-seek ( low high ihandle -- -1|0|1 )

instance defer cif-release ( size virt -- )

: find-cif-method ( adr,len -- acf )

2dup cif-ph find-method 0= if ( adr,len )

find-abort

then ( adr,len acf )

nip nip ( acf )

;

" open" find-cif-method to cif-open

" close" find-cif-method to cif-close

" read" find-cif-method to cif-read

" seek" find-cif-method to cif-seek

" release" find-cif-method to cif-release

" /chosen" get-package constant chosen-ph

: get-property ( name$ ph -- prop$ )

>r 2dup r> get-package-property if ( name$ )

find-abort

then ( name$ prop$ )

2swap 2drop ( prop$ )

;

: get-string-prop ( name$ ph -- val$ )

get-property decode-string ( prop$' val$ )

2swap 2drop ( val$ )

;

: get-int-prop ( name$ ph -- n )

get-property decode-int ( prop$' n )

nip nip ( n )

;

\

\ memory allocation

\ we bypass cif claim so we can do large page

\ allocations like promif can

\

" mmu" chosen-ph get-int-prop constant mmu-ih

" memory" chosen-ph get-int-prop constant mem-ih

: mmu-claim ( [ virt ] size align -- base )

" claim" mmu-ih $call-method

;

: mmu-map ( phys.lo phys.hi virt size -- )

-1 " map" mmu-ih $call-method

;

: mem-claim ( size align -- phys.lo phys.hi )

" claim" mem-ih $call-method

;

: (mem-alloc) ( size virt align -- virt )

\ claim memory first since it may throw if fragmented

rot 2dup swap mem-claim ( virt align size phys.lo phys.hi )

>r >r rot ?dup if ( align size virt r: phys.lo phys.hi )

\ we picked virt - zero alignment

over 0 mmu-claim ( align size virt r: phys.lo phys.hi )

else ( align size r: phys.lo phys.hi )

\ OBP picks virt - pass alignment

2dup swap mmu-claim ( align size virt r: phys.lo phys.hi )

then ( align size virt r: phys.lo phys.hi )

r> r> 2over swap mmu-map ( align size virt )

nip nip ( virt )

;

: vmem-alloc ( size virt -- virt )

swap h# 2000 roundup swap

1 (mem-alloc)

;

: mem-alloc ( size -- virt )

h# 2000 roundup

0 1 (mem-alloc)

;

: mem-free ( virt size -- )

h# 2000 roundup

swap cif-release ( )

;

\ put ramdisk fcode 256 bytes from end of bootblk

\ (currently 244 bytes in size)

d# 256 constant /rd-fcode

d# 8192 /rd-fcode - constant rd-offset

: open-abort ( file$ -- )

cr ." Can't open " type cr abort

;

/buf-len buffer: open-cstr

: dev-open ( dev$ -- ih | 0 )

\ copy to C string for open

0 over open-cstr + c!

open-cstr swap move

open-cstr cif-open

;

: dev-close ( ih -- )

cif-close

;

: read-disk ( adr len off ih -- )

dup >r 0 swap cif-seek if ( adr len r: ih )

" seek failed" die

then

tuck swap r> cif-read <> if ( )

" read failed" die

then

;