/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License, Version 1.0 only
 * (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
 */
/*
 * Copyright 2003 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

#pragma ident	"%Z%%M%	%I%	%E% SMI"

#include <sys/conf.h>
#include <sys/sysmacros.h>
#include <sys/async.h>

static bus_func_desc_t *bfd_list = NULL; /* list of busfunc descriptors */
kmutex_t bfd_lock;		/* lock protecting bfd_list */

/*
 * Register a new bus function.  We expect this function to be called from a
 * driver attach or detach routine, so we can safely perform a sleeping
 * allocation here.  We just insert the new element at the head of the list.
 * For more information on bus_func semantics, refer to sun4u/sys/async.h.
 */
void
bus_func_register(int type, busfunc_t func, void *arg)
{
	bus_func_desc_t *bfd = kmem_alloc(sizeof (bus_func_desc_t), KM_SLEEP);

	bfd->bf_type = type;
	bfd->bf_func = func;
	bfd->bf_arg = arg;

	mutex_enter(&bfd_lock);
	bfd->bf_next = bfd_list;
	bfd_list = bfd;
	mutex_exit(&bfd_lock);
}

/*
 * Unregister the specified bus function.  We only delete an element that
 * exactly matches the specified (type, func, arg) tuple.  We expect this
 * function to only be called from driver detach context.
 */
void
bus_func_unregister(int type, busfunc_t func, void *arg)
{
	bus_func_desc_t *bfd, **pp;

	mutex_enter(&bfd_lock);
	pp = &bfd_list;

	for (bfd = bfd_list; bfd != NULL; bfd = bfd->bf_next) {
		if (bfd->bf_type == type && bfd->bf_func == func &&
		    bfd->bf_arg == arg) {
			*pp = bfd->bf_next;
			break;
		}
		pp = &bfd->bf_next;
	}

	mutex_exit(&bfd_lock);

	if (bfd != NULL)
		kmem_free(bfd, sizeof (bus_func_desc_t));
}

/*
 * Invoke the registered bus functions of the specified type.  We return the
 * maximum of the result values (e.g. BF_FATAL if any call returned BF_FATAL).
 * This function assumes that (1) the BF_* constants are defined so that the
 * most fatal error has the highest numerical value, and (2) that the bf_func
 * callbacks obey the rules described in async.h.
 */
uint_t
bus_func_invoke(int type)
{
	bus_func_desc_t *bfd;
	uint_t err = BF_NONE;

	mutex_enter(&bfd_lock);

	for (bfd = bfd_list; bfd != NULL; bfd = bfd->bf_next) {
		if (bfd->bf_type == type) {
			uint_t status = bfd->bf_func(bfd->bf_arg);
			err = MAX(err, status);
		}
	}

	mutex_exit(&bfd_lock);
	return (err);
}