Differential D20647 Diff 59309 sys/dev/fdt/simple_mfd.c

Changeset View

Standalone View

sys/dev/fdt/simple_mfd.c

Context not available.
	#include <sys/systm.h>	#include <sys/systm.h>
	#include <sys/bus.h>	#include <sys/bus.h>
	#include <sys/kernel.h>	#include <sys/kernel.h>
		#include <sys/lock.h>
	#include <sys/module.h>	#include <sys/module.h>
		#include <sys/mutex.h>
		#include <sys/rman.h>

		manuUnsubmitted Not Done Inline Actions you need sys/mutex.h too otherwise it doesn't compile manu: you need sys/mutex.h too otherwise it doesn't compile
	#include <machine/bus.h>	#include <machine/bus.h>

Context not available.
	#include <dev/ofw/ofw_bus.h>	#include <dev/ofw/ofw_bus.h>
	#include <dev/ofw/ofw_bus_subr.h>	#include <dev/ofw/ofw_bus_subr.h>

	struct simple_mfd_softc {	#include <dev/fdt/simple_mfd.h>
		manuUnsubmitted Not Done Inline Actions #include <dev/fdt/simple_mfd.h> manu: #include <dev/fdt/simple_mfd.h>
	struct simplebus_softc sc;
	};

	device_t simple_mfd_add_device(device_t dev, phandle_t node, u_int order,	device_t simple_mfd_add_device(device_t dev, phandle_t node, u_int order,
	const char name, int unit, struct simplebus_devinfo di);	const char name, int unit, struct simplebus_devinfo di);
	struct simplebus_devinfo simple_mfd_setup_dinfo(device_t dev, phandle_t node, struct simplebus_devinfo di);	struct simplebus_devinfo simple_mfd_setup_dinfo(device_t dev, phandle_t node, struct simplebus_devinfo di);

		#include "syscon_if.h"
		#include <dev/extres/syscon/syscon.h>

		MALLOC_DECLARE(M_SYSCON);

		static uint32_t simple_mfd_syscon_read_4(struct syscon *syscon, bus_size_t offset);
		static int simple_mfd_syscon_write_4(struct syscon *syscon, bus_size_t offset,
		uint32_t val);
		static int simple_mfd_syscon_modify_4(struct syscon *syscon, bus_size_t offset,
		uint32_t clear_bits, uint32_t set_bits);

		#define SYSCON_LOCK(_sc) mtx_lock_spin(&(_sc)->mtx)
		#define SYSCON_UNLOCK(_sc) mtx_unlock_spin(&(_sc)->mtx)
		#define SYSCON_LOCK_INIT(_sc) mtx_init(&(_sc)->mtx, \
		device_get_nameunit((_sc)->dev), "syscon", MTX_SPIN)
		#define SYSCON_LOCK_DESTROY(_sc) mtx_destroy(&(_sc)->mtx);
		#define SYSCON_ASSERT_LOCKED(_sc) mtx_assert(&(_sc)->mtx, MA_OWNED);
		#define SYSCON_ASSERT_UNLOCKED(_sc) mtx_assert(&(_sc)->mtx, MA_NOTOWNED);

		static syscon_method_t simple_mfd_syscon_methods[] = {
		SYSCONMETHOD(syscon_read_4, simple_mfd_syscon_read_4),
		SYSCONMETHOD(syscon_write_4, simple_mfd_syscon_write_4),
		SYSCONMETHOD(syscon_modify_4, simple_mfd_syscon_modify_4),

		SYSCONMETHOD_END
		};
		DEFINE_CLASS_1(simple_mfd_syscon, simple_mfd_syscon_class,
		simple_mfd_syscon_methods, 0, syscon_class);

		static uint32_t
		simple_mfd_syscon_read_4(struct syscon *syscon, bus_size_t offset)
		{
		struct simple_mfd_softc *sc;
		uint32_t val;

		sc = device_get_softc(syscon->pdev);

		SYSCON_LOCK(sc);
		val = bus_read_4(sc->mem_res, offset);
		SYSCON_UNLOCK(sc);
		return (val);
		}

	static int	static int
		simple_mfd_syscon_write_4(struct syscon *syscon, bus_size_t offset,
		uint32_t val)
		{
		struct simple_mfd_softc *sc;

		sc = device_get_softc(syscon->pdev);

		SYSCON_LOCK(sc);
		bus_write_4(sc->mem_res, offset, val);
		SYSCON_UNLOCK(sc);
		return (0);
		}

		static int
		simple_mfd_syscon_modify_4(struct syscon *syscon, bus_size_t offset,
		uint32_t clear_bits, uint32_t set_bits)
		{
		struct simple_mfd_softc *sc;
		uint32_t val;

		sc = device_get_softc(syscon->pdev);

		SYSCON_LOCK(sc);
		val = bus_read_4(sc->mem_res, offset);
		val &= ~clear_bits;
		val \|= set_bits;
		bus_write_4(sc->mem_res, offset, val);
		SYSCON_UNLOCK(sc);
		return (0);
		}

		static int
	simple_mfd_probe(device_t dev)	simple_mfd_probe(device_t dev)
	{	{

Context not available.
	struct simple_mfd_softc *sc;	struct simple_mfd_softc *sc;
	phandle_t node, child;	phandle_t node, child;
	device_t cdev;	device_t cdev;
		int rid;

	sc = device_get_softc(dev);	sc = device_get_softc(dev);
	node = ofw_bus_get_node(dev);	node = ofw_bus_get_node(dev);

		sc->dev = dev;
		rid = 0;
		manuUnsubmitted Not Done Inline Actions The rid variable isn't needed manu: The rid variable isn't needed

	/* Parse address-cells and size-cells from the parent node as a fallback */	/* Parse address-cells and size-cells from the parent node as a fallback */
	if (OF_getencprop(node, "#address-cells", &sc->sc.acells,	if (OF_getencprop(node, "#address-cells", &sc->sc.acells,
	sizeof(sc->sc.acells)) == -1) {	sizeof(sc->sc.acells)) == -1) {
Context not available.
	device_probe_and_attach(cdev);	device_probe_and_attach(cdev);
	}	}

		if (ofw_bus_is_compatible(dev, "syscon")) {
		sc->mem_res = bus_alloc_resource_any(dev, SYS_RES_MEMORY, &rid,
		RF_ACTIVE);
		if (sc->mem_res == NULL) {
		device_printf(dev,
		"Cannot allocate memory resource\n");
		return (ENXIO);
		}

		SYSCON_LOCK_INIT(sc);
		sc->syscon = syscon_create_ofw_node(dev,
		&simple_mfd_syscon_class, ofw_bus_get_node(dev));
		if (sc->syscon == NULL) {
		device_printf(dev,
		"Failed to create/register syscon\n");
		return (ENXIO);
		}
		}
	return (bus_generic_attach(dev));	return (bus_generic_attach(dev));
	}	}

		static int
		simple_mfd_detach(device_t dev)
		{
		struct simple_mfd_softc *sc;

		sc = device_get_softc(dev);
		if (ofw_bus_is_compatible(dev, "syscon")) {
		if (sc->syscon != NULL) {
		syscon_unregister(sc->syscon);
		free(sc->syscon, M_SYSCON);
		}

		SYSCON_LOCK_DESTROY(sc);

		if (sc->mem_res != NULL)
		bus_release_resource(dev, SYS_RES_MEMORY, 0,
		sc->mem_res);
		}
		return (0);
		}

	struct simplebus_devinfo *	struct simplebus_devinfo *
	simple_mfd_setup_dinfo(device_t dev, phandle_t node,	simple_mfd_setup_dinfo(device_t dev, phandle_t node,
	struct simplebus_devinfo *di)	struct simplebus_devinfo *di)
Context not available.
	/* Device interface */	/* Device interface */
	DEVMETHOD(device_probe, simple_mfd_probe),	DEVMETHOD(device_probe, simple_mfd_probe),
	DEVMETHOD(device_attach, simple_mfd_attach),	DEVMETHOD(device_attach, simple_mfd_attach),
		DEVMETHOD(device_detach, simple_mfd_detach),

	DEVMETHOD_END	DEVMETHOD_END
	};	};
Context not available.