ofw_if.m

Go to the documentation of this file.

#-
# Copyright (c) 2008 Nathan Whitehorn
# All rights reserved.
#
# Redistribution and use in source and binary forms, with or without
# modification, are permitted provided that the following conditions
# are met:
# 1. Redistributions of source code must retain the above copyright
#    notice, this list of conditions and the following disclaimer.
# 2. Redistributions in binary form must reproduce the above copyright
#    notice, this list of conditions and the following disclaimer in the
#    documentation and/or other materials provided with the distribution.
#
# THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
# ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
# ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
# FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
# DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
# OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
# HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
# LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
# OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
# SUCH DAMAGE.
#
# $FreeBSD$
#
 
#include <dev/ofw/openfirm.h>
#include <dev/ofw/ofwvar.h>
 
INTERFACE ofw;
 
METHOD int init {
        ofw_t           _ofw;
        void            *_cookie;
};
 
METHOD phandle_t peer {
        ofw_t           _ofw;
        phandle_t       _node;
};
 
METHOD phandle_t parent {
        ofw_t           _ofw;
        phandle_t       _node;
};
 
METHOD phandle_t child {
        ofw_t           _ofw;
        phandle_t       _node;
};
 
METHOD phandle_t instance_to_package {
        ofw_t           _ofw;
        ihandle_t       _handle;
};
 
METHOD ssize_t getproplen {
        ofw_t           _ofw;
        phandle_t       _node;
        const char      *_prop;
};
 
METHOD ssize_t getprop {
        ofw_t           _ofw;
        phandle_t       _node;
        const char      *_prop;
        void            *_buf;
        size_t          _size;
};
 
METHOD int nextprop {
        ofw_t           _ofw;
        phandle_t       _node;
        const char      *_prop;
        char            *_buf;
        size_t          _size;
};
 
METHOD int setprop {
        ofw_t           _ofw;
        phandle_t       _node;
        const char      *_prop;
        const void      *_buf;
        size_t          _size;
};
 
METHOD ssize_t canon {
        ofw_t           _ofw;
        const char      *_path;
        char            *_buf;
        size_t          _size;
};
 
METHOD phandle_t finddevice {
        ofw_t           _ofw;
        const char      *_path;
};
 
METHOD ssize_t instance_to_path {
        ofw_t           _ofw;
        ihandle_t       _handle;
        char            *_path;
        size_t          _size;
};
 
METHOD ssize_t package_to_path {
        ofw_t           _ofw;
        phandle_t       _node;
        char            *_path;
        size_t          _size;
};
 
# Methods for OF method calls (optional)
 
METHOD int test {
        ofw_t           _ofw;
        const char      *_name;
};
 
METHOD int call_method {
        ofw_t           _ofw;
        ihandle_t       _instance;
        const char      *_method;
        int             _nargs;
        int             _nreturns;
 
        cell_t          *_args_and_returns;
};
 
METHOD int interpret {
        ofw_t           _ofw;
        const char      *_cmd;
        int             _nreturns;
        cell_t          *_returns;
};
 
# Device I/O Functions (optional)
 
METHOD ihandle_t open {
        ofw_t           _ofw;
        const char      *_path;
}
 
METHOD void close {
        ofw_t           _ofw;
        ihandle_t       _instance;
}
 
METHOD ssize_t read {
        ofw_t           _ofw;
        ihandle_t       _instance;
        void            *_buf;
        size_t          size;
}
 
METHOD ssize_t write {
        ofw_t           _ofw;
        ihandle_t       _instance;
        const void      *_buf;
        size_t          size;
}
 
METHOD int seek {
        ofw_t           _ofw;
        ihandle_t       _instance;
        uint64_t        _off;
}
 
# Open Firmware memory management
 
METHOD caddr_t claim {
        ofw_t           _ofw;
        void            *_addr;
        size_t          _size;
        u_int           _align;
}
 
METHOD void release {
        ofw_t           _ofw;
        void            *_addr;
        size_t          _size;
};
 
# Commands for returning control to the firmware
 
METHOD void enter {
        ofw_t           _ofw;
};
 
METHOD void exit {
        ofw_t           _ofw;
};