bus_if.m

Go to the documentation of this file.

#-
# Copyright (c) 1998-2004 Doug Rabson
# 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.
#
# $BSDSUniX$
#

#include <sys/types.h>
#include <sys/systm.h>
#include <sys/bus.h>

INTERFACE bus;

#
# Default implementations of some methods.
#
CODE {
        static struct resource *
        null_alloc_resource(device_t dev, device_t child,
            int type, int *rid, u_long start, u_long end,
            u_long count, u_int flags)
        {
            return (0);
        }

        static int
        null_remap_intr(device_t bus, device_t dev, u_int irq)
        {

                if (dev != NULL)
                        return (BUS_REMAP_INTR(dev, NULL, irq));
                return (ENXIO);
        }

        static device_t
        null_add_child(device_t bus, int order, const char *name,
            int unit)
        {

                panic("bus_add_child is not implemented");
        }
};

METHOD int print_child {
        device_t _dev;
        device_t _child;
} DEFAULT bus_generic_print_child;

METHOD void probe_nomatch {
        device_t _dev;
        device_t _child;
};

METHOD int read_ivar {
        device_t _dev;
        device_t _child;
        int _index;
        uintptr_t *_result;
};

METHOD int write_ivar {
        device_t _dev;
        device_t _child;
        int _indx;
        uintptr_t _value;
};

METHOD void child_deleted {
        device_t _dev;
        device_t _child;
};

METHOD void child_detached {
        device_t _dev;
        device_t _child;
};

METHOD void driver_added {
        device_t _dev;
        driver_t *_driver;
} DEFAULT bus_generic_driver_added;

METHOD device_t add_child {
        device_t _dev;
        u_int _order;
        const char *_name;
        int _unit;
} DEFAULT null_add_child;

METHOD struct resource * alloc_resource {
        device_t        _dev;
        device_t        _child;
        int             _type;
        int            *_rid;
        u_long          _start;
        u_long          _end;
        u_long          _count;
        u_int           _flags;
} DEFAULT null_alloc_resource;

METHOD int activate_resource {
        device_t        _dev;
        device_t        _child;
        int             _type;
        int             _rid;
        struct resource *_r;
};

METHOD int deactivate_resource {
        device_t        _dev;
        device_t        _child;
        int             _type;
        int             _rid;
        struct resource *_r;
};

METHOD int adjust_resource {
        device_t        _dev;
        device_t        _child;
        int             _type;
        struct resource *_res;
        u_long          _start;
        u_long          _end;
};

METHOD int release_resource {
        device_t        _dev;
        device_t        _child;
        int             _type;
        int             _rid;
        struct resource *_res;
};

METHOD int setup_intr {
        device_t        _dev;
        device_t        _child;
        struct resource *_irq;
        int             _flags;
        driver_filter_t *_filter;
        driver_intr_t   *_intr;
        void            *_arg;
        void            **_cookiep;
};

METHOD int teardown_intr {
        device_t        _dev;
        device_t        _child;
        struct resource *_irq;
        void            *_cookie;
};

METHOD int set_resource {
        device_t        _dev;
        device_t        _child;
        int             _type;
        int             _rid;
        u_long          _start;
        u_long          _count;
};

METHOD int get_resource {
        device_t        _dev;
        device_t        _child;
        int             _type;
        int             _rid;
        u_long          *_startp;
        u_long          *_countp;
};

METHOD void delete_resource {
        device_t        _dev;
        device_t        _child;
        int             _type;
        int             _rid;
};

METHOD struct resource_list * get_resource_list {
        device_t        _dev;
        device_t        _child;
} DEFAULT bus_generic_get_resource_list;

METHOD int child_present {
        device_t        _dev;
        device_t        _child;
} DEFAULT bus_generic_child_present;

METHOD int child_pnpinfo_str {
        device_t        _dev;
        device_t        _child;
        char            *_buf;
        size_t          _buflen;
};

METHOD int child_location_str {
        device_t        _dev;
        device_t        _child;
        char            *_buf;
        size_t          _buflen;
};

METHOD int bind_intr {
        device_t        _dev;
        device_t        _child;
        struct resource *_irq;
        int             _cpu;
} DEFAULT bus_generic_bind_intr;

METHOD int config_intr {
        device_t        _dev;
        int             _irq;
        enum intr_trigger _trig;
        enum intr_polarity _pol;
} DEFAULT bus_generic_config_intr;

METHOD int describe_intr {
        device_t        _dev;
        device_t        _child;
        struct resource *_irq;
        void            *_cookie;
        const char      *_descr;
} DEFAULT bus_generic_describe_intr;

METHOD void hinted_child {
        device_t        _dev;
        const char      *_dname;
        int             _dunit;
};

METHOD bus_dma_tag_t get_dma_tag {
        device_t        _dev;
        device_t        _child;
} DEFAULT bus_generic_get_dma_tag;

METHOD void hint_device_unit {
        device_t        _dev;
        device_t        _child;
        const char      *_name;
        int             *_unitp;
};

METHOD void new_pass {
        device_t        _dev;
} DEFAULT bus_generic_new_pass;

METHOD int remap_intr {
        device_t        _dev;
        device_t        _child;
        u_int           _irq;
} DEFAULT null_remap_intr;