Client Interface

Open Firmware's "client interface" provides a well-defined interface
for operating systems and other "client" programs to obtain system
configuration information that was gathered through the device
interface.

After an operating system has been loaded, while the OS is configuring
and initializing itself, it may need to use Open Firmware
services. The Open Firmware client interface allows the OS to examine
the device tree, temporarily use Open Firmware device drivers, display
progress messages on the console device, allocate memory, and utilize
other Open Firmware services. Usually, after the OS is fully
initialized, it assumes responsibility for most of these tasks, and
Open Firmware is no longer needed until the machine is rebooted.

The Open Firmware services provided through the client interface are
also frequently used by secondary boot programs. In some cases, Open
Firmware can load the operating system directly. In other systems,
Open Firmware loads and executes a "secondary boot" program which then
loads the operating system, perhaps from some special file system
structure. Such secondary booters usually need drivers for the
devices they use, and the Open Firmware client interface allows them
to use the Open Firmware device drivers.

Open Firmware device drivers are rarely used by the primary operating
system, except temporarily during OS initialization. In principle, it
would be possible for an OS to continue using Open Firmware drivers,
but that is rarely done because Open Firmware drivers are generally
optimized for simplicity and small size, whereas OS drivers are often
optimized for performance and complete functionality.

The client interface specifies the services available to operating
systems or other software loaded and invokes by the firmware. The
client interface also specifies the calling convention required by any
processor family, providing client programs a
platform-and-operating-system-neutral interface to firmware services.
For most processor families, the client interface is implemented as a
subroutine call with a simple argument-passing convention.