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.
#
# $FreeBSD$
#
 
#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, rman_res_t start, rman_res_t end,
            rman_res_t 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");
        }
 
        static int null_reset_post(device_t bus, device_t dev)
        {
                return (0);
        }
 
        static int null_reset_prepare(device_t bus, device_t dev)
        {
                return (0);
        }
 
};
 
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 int rescan {
        device_t _dev;
}
 
METHOD struct resource * alloc_resource {
        device_t        _dev;
        device_t        _child;
        int             _type;
        int            *_rid;
        rman_res_t      _start;
        rman_res_t      _end;
        rman_res_t      _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 map_resource {
        device_t        _dev;
        device_t        _child;
        int             _type;
        struct resource *_r;
        struct resource_map_request *_args;
        struct resource_map *_map;
} DEFAULT bus_generic_map_resource;
 
 
METHOD int unmap_resource {
        device_t        _dev;
        device_t        _child;
        int             _type;
        struct resource *_r;
        struct resource_map *_map;
} DEFAULT bus_generic_unmap_resource;
 
 
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;
        rman_res_t      _start;
        rman_res_t      _end;
};
 
METHOD int translate_resource {
        device_t        _dev;
        int             _type;
        rman_res_t      _start;
        rman_res_t      *_newstart;
} DEFAULT bus_generic_translate_resource;
 
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 suspend_intr {
        device_t        _dev;
        device_t        _child;
        struct resource *_irq;
} DEFAULT bus_generic_suspend_intr;
 
METHOD int resume_intr {
        device_t        _dev;
        device_t        _child;
        struct resource *_irq;
} DEFAULT bus_generic_resume_intr;
 
METHOD int set_resource {
        device_t        _dev;
        device_t        _child;
        int             _type;
        int             _rid;
        rman_res_t      _start;
        rman_res_t      _count;
};
 
METHOD int get_resource {
        device_t        _dev;
        device_t        _child;
        int             _type;
        int             _rid;
        rman_res_t      *_startp;
        rman_res_t      *_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 {
        device_t        _dev;
        device_t        _child;
        struct sbuf     *_sb;
} DEFAULT bus_generic_child_pnpinfo;
 
METHOD int child_location {
        device_t        _dev;
        device_t        _child;
        struct sbuf     *_sb;
} DEFAULT bus_generic_child_location;
 
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 bus_space_tag_t get_bus_tag {
        device_t        _dev;
        device_t        _child;
} DEFAULT bus_generic_get_bus_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;
 
METHOD int suspend_child {
        device_t        _dev;
        device_t        _child;
} DEFAULT bus_generic_suspend_child;
 
METHOD int resume_child {
        device_t        _dev;
        device_t        _child;
} DEFAULT bus_generic_resume_child;
 
METHOD int get_domain {
        device_t        _dev;
        device_t        _child;
        int             *_domain;
} DEFAULT bus_generic_get_domain;
 
METHOD int get_cpus {
        device_t        _dev;
        device_t        _child;
        enum cpu_sets   _op;
        size_t          _setsize;
        struct _cpuset  *_cpuset;
} DEFAULT bus_generic_get_cpus;
 
METHOD int reset_prepare {
        device_t _dev;
        device_t _child;
} DEFAULT null_reset_prepare;
 
METHOD int reset_post {
        device_t _dev;
        device_t _child;
} DEFAULT null_reset_post;
 
METHOD int reset_child {
        device_t _dev;
        device_t _child;
        int _flags;
};
 
METHOD ssize_t get_property {
        device_t _dev;
        device_t _child;
        const char *_propname;
        void *_propvalue;
        size_t _size;
        device_property_type_t type;
} DEFAULT bus_generic_get_property;
 
METHOD int get_device_path {
        device_t _bus;
        device_t _child;
        const char *_locator;
        struct sbuf *_sb;
} DEFAULT bus_generic_get_device_path;