io/gpio/kgpio.c

/*
 * This file and its contents are supplied under the terms of the
 * Common Development and Distribution License ("CDDL"), version 1.0.
 * You may only use this file in accordance with the terms of version
 * 1.0 of the CDDL.
 *
 * A full copy of the text of the CDDL should have accompanied this
 * source.  A copy of the CDDL is also available via the Internet at
 * http://www.illumos.org/license/CDDL.
 */

/*
 * Copyright 2022 Oxide Computer Company
 */

/*
 * Kernel GPIO Framework
 * ---------------------
 *
 * This driver, kgpio(4D), implements the general kernel general purpose I/O
 * (GPIO) and dedicated purpose I/O (dpio) framework discussed in gpio(7).
 * Before we jump into the organization and specifics here, let's go into a few
 * definitions and overviews of what all is going on:
 *
 * GPIO -- General Purpose I/O
 *
 *	A GPIO is something that allows software to directly understand and
 *	manipulate the state of a particular pin on an ASIC. For example, this
 *	allows software to do things like to read the logical level on a pin or
 *	to set the logical output value. In addition, there are often other
 *	properties that can be changed such as things like whether internal pull
 *	ups are used, controls around interrupt behavior, drive strength, etc.
 *	Each of these different controls vary from controller to controller.
 *	Each of these is represented as an 'attribute', which is defined below.
 *
 * GPIO CONTROLLER / PROVIDER
 *
 *	A GPIO controller is a piece of hardware that provides accesses to and
 *	control over GPIOs. In the OS, we call a device driver for a GPIO
 *	controller a kgpio provider, as it provides access to and the
 *	functionality around this. Device drivers themselves use the
 *	<sys/gpio/kgpio_provider.h> header and related functions.
 *
 *	Each controller is exposed to userland through its own character device
 *	in /devices. There are not entries in /dev for these. The providing
 *	device driver does not have to worry about this and this takes care of
 *	ensuring that the provider is present, allowing them to detach like
 *	other classes of loadable modules.
 *
 * ATTRIBUTE
 *
 *	An attribute refers to a setting or property of a GPIO. While many
 *	controllers have similar attributes, in many cases the actual set of
 *	valid values varies between them (or potentially even from GPIO to GPIO
 *	on a device). Attributes are stored inside of nvlist_t's (more on that
 *	later) and consist of a few different pieces of information:
 *
 *	  o Name	This is how software and humans generally refer to a
 *			name for this attribute. The attribute name is generally
 *			made up of two parts: the provider's name and then the
 *			actual name. This allows different providers to not
 *			conflict with one another. These are both separated by
 *			a ':' character. Examples here are things like
 *			'sim:pull' which is used by the gpio_sim driver. Here
 *			'sim' refers to the provider and 'pull' the name.
 *
 *	  o Value	This is the actual value of the attribute for a given
 *			GPIO. It generally is a uint32_t (representing an enum)
 *			or a string.
 *
 *	  o Protection	This indicates whether the attribute is read-only or
 *			read-write. A read-write attribute can be updated by a
 *			consumer.
 *
 *	  o Possible	This is an array of values that are valid for this
 *			particular attribute. This information is specific to a
 *			GPIO.
 *
 * DPIO -- Dedicated Purpose I/O
 *
 *	A DPIO is a construct that wraps up a GPIO, constraining what it can do
 *	and freezing the ability to set all of its attributes except a small
 *	set. Their reason for existence is to try and solve the problem that
 *	while a GPIO controller is specific to a given piece of hardware (like a
 *	specific CPU or ASIC), what is safe to use depends entirely on the
 *	specifics of the way that is used. For example, which GPIOs are safe to
 *	use on a CPU depends on the specific motherboard it's found in and the
 *	surrounding pieces. Instead, this is where we offer the idea of the DPIO
 *	as its purpose is dedicated.
 *
 *	DPIOs show up to the system as their own character device with basic
 *	semantics around read(2), write(2), and poll(2). The DPIO devices show
 *	up in /dev/dpio/<name> and all of the specifics of them are defined in
 *	their own header <sys/gpio/dpio.h>.
 *
 *	An important part that we'll get into in the driver organization is that
 *	each DPIO points to its corresponding GPIO controller.
 *
 * IOMUX -- I/O Multiplexer
 *
 *	An I/O multiplexer is something that exists in hardware that maps which
 *	peripherals are actually connected to which pins. Many SoCs are designed
 *	such that an actual pin on the device can be pointed at one of several
 *	different peripherals.
 *
 *	Right now, the GPIO framework is not integrated into any kind of I/O or
 *	pin muxing framework. This means that GPIOs that are visible may or may
 *	not do anything based on the state of that mux. This is a known missing
 *	piece and is something that will see further consolidation.
 *
 * -------------------
 * Driver Organization
 * -------------------
 *
 * To understand how this driver is organized, it's worth going into a bit more
 * detail about the framework and what entities we track.
 *
 * Fundamentally a GPIO controller and is mapped to its provider driver. More
 * specifically, the dev_info_t is the key that we used to build up and manage a
 * controller in the kgpio_t structure. These providers will register with the
 * kgpio kernel module when they call attach(9E) and detach(9E).
 *
 * When a provider registers with us, they tell us how many GPIOs they support.
 * This gives us a set of unsigned integer GPIO IDs that are in the set [0,
 * kgpio_ngpios). The general framework always refers to a GPIO on a controller
 * by its numeric ID.  This ID space is contiguous, which may not be true of the
 * actual hardware. It is not our intent that this is the same thing. Instead,
 * for more semantics, GPIOs have a common 'name' attribute which providers fill
 * in that userland can consume. However, the kernel identifies all GPIOs by
 * their controller and a provider-supplied opaque ID. The kgpio driver does
 * not track individual GPIOs.
 *
 * Because we need to provide character devices ourselves, the kgpio driver has
 * its own instance which is a child of the pseudo nexus. Importantly, krtld
 * guarantees that our module is loaded before anything that would call into us;
 * however, it does not guarantee anything about whether a particular instance
 * will be present. This in turn leads to us keeping global structure and state
 * in the driver which is independent from our actual instance because the
 * instance may come and go.
 *
 * In turn, the framework does keep track of all of the DPIOs that are created
 * because these are independent character devices and minors. These are stored
 * in data that isn't tied to the instance mostly for the reason as the core of
 * the GPIO framework. Each DPIO's information is tracked in a 'dpio_t'
 * structure.
 *
 * To facilitate the fact that the character device entry points all operate in
 * terms of minors, we have a shared structure that is embedded in both the
 * kgpio_t and dpio_t called a kgpio_minor_t. These are stored in a global
 * avl_tree_t and is how minors are mapped back to their device type and actual
 * information.
 *
 * The organization of data is roughly as follows (some members elided):
 *
 *
 *     +-----------------------+
 *     | Global DPIO List      |
 *     |                       |       +-------------+   +-------------+
 *     | list_t kgpio_g_dpios -+------>| DPIO dpio_t |-->| DPIO dpio_t |--> ...
 *     +-----------------------+       | "foo"       |   | "bar"       |
 *                                     |             |   |             |
 *                                     | gpio ID     |   | gpio ID     |
 *  +--------------------------------->| kgpio_t *   |   | kgpio_t *   |
 *  |                                  +-------------+   +-------------+
 *  |                                      |                |
 *  |  +------------------------+          |   +------------+
 *  |  | Global Controller List |          v   v
 *  |  |                        |     +-------------+   +-------------+
 *  |  | list_t kgpio_g_gpios --+---->| kgpio_t     |-->| kgpio_t     |--> ...
 *  |  +------------------------+     |             |   |             |
 *  |                                 | dev_info_t  |   | dev_info_t  |
 *  +-------------------------------->| kgpio_ops_t |   | kgpio_ops_t |
 *  |                                 +-------------+   +-------------+
 *  |                                                      |
 *  |  +-------------------------+                         |
 *  |  | Global Minor Tracking   |                         v
 *  |  |                         |                    +---------------------+
 *  +--| avl_tree_t kgpio_minors |                    | GPIO Provider       |
 *     +-------------------------+                    |                     |
 *                                                    | A hardware-specific |
 *                                                    | driver              |
 *                                                    +---------------------+
 *
 * In more detail, all of our global data is protected by the kgpio_g_mutex and
 * all such data is prefixed with 'kgpio_g_'. As GPIO Provider drivers register
 * with kgpio framework via kgpio_register(), we create a kgpio_t for them and
 * insert them into the global kgpio_g_dpios list. At that point, we do a few
 * additional things:
 *
 *   o If our main kgpio(4D) instance is attached, then we will go through and
 *     create a minor node for the controller. If not, this will be deferred
 *     until it does attach.
 *
 *   o We will register a DDI callback for when the module is removed from the
 *     system, which is a step past being detached. This is what allows us to
 *     call back a provider when someone wants to use it, just as the /devices
 *     devfs file system normally does.
 *
 * At that point, we will flow data and back and forth via ioctls on the
 * controller minor nodes. As information is asked for by userland, the kgpio
 * driver will call back into the provider with the provided kgpio_ops_t
 * operations vector and the driver's private data (both passed in at
 * registration time).
 *
 * Only when a user comes and asks to create a DPIO via the
 * KGPIO_IOC_DPIO_CREATE ioctl will we go through and at that point create a
 * dpio_t. The dpio_t is stored in its own global list and each dpio_t points to
 * the corresponding kgpio_t controller and contains the GPIO that it should
 * use. In addition, there are a number of fields set at creation time which
 * relate to the capabilities of the DPIO which are what govern whether the DPIO
 * supports read(9E), write(9E), etc.
 *
 * When a DPIO is created a minor node is created with the type
 * DDI_NT_GPIO_DPIO. While users can give a DPIO any name they want, we prefix
 * each name in /devices with 'dpio:'. This ensures that a user's name for a
 * DPIO will not conflict with any controllers that may come and go in the
 * system. The devfsadm(8) plugs for GPIO subsystem will ensure that a DPIO is
 * created under /dev/dpio with the user's requested name. The 'dpio:' leading
 * portion of the /devices minor node will not be present.
 *
 * There is one final type of minor node that exists, which is called 'dpinfo'
 * which is used to provide static, creation-time based information about DPIOs.
 * This exists because we generally want to support the ability to both create
 * DPIOs that honor O_EXCL/FEXCL and DPIOs that only the kernel can open. As
 * such, this minor can be used to query about basic information about a DPIO
 * without requiring one to be able to open it (which may not be possible).
 *
 * ---------
 * Data Flow
 * ---------
 *
 * There are two different high-leveling goals in the data design in this
 * system:
 *
 *   o Hardware should be the single source of truth (where possible) for the
 *     current values of a GPIO's attributes. That is why there is no caching of
 *     data either in this driver or in the individual providers. Doing
 *     anything else allows for things to get out of sync.
 *
 *   o Where possible, all data about a GPIO should be something that we can
 *     atomically change. In general, it can be very hard to trace a series of
 *     valid steps from point a to point b for a GPIO, if you cannot change
 *     multiple attributes at once. While there are always complications here
 *     because of pin and I/O muxing, this is why there is no individual
 *     attribute get and set routines.
 *
 * When getting and setting information, a GPIO's attributes are all stored in a
 * single nvlist_t. Here, each key is the name of an attribute which points to
 * its corresponding value -- generally a string or uint32_t. In addition, there
 * is an embedded metadata nvlist_t that has information such as the protection
 * or supported values for a given GPIO.
 *
 * All of this information is considered GPIO-specific because each GPIO in a
 * system may have readily different capabilities and functionality. While there
 * are common attributes which are defined in <sys/gpio/kgpio_provider.h>, the
 * expectation is that each provider defines its own attributes (other than
 * name) in their own header file that generally should be found in
 * <sys/gpio/driver.h>, where driver is the name of the driver. Let's look at an
 * example of this structure if we had four attributes present:
 *
 * nvlist_t
 *	"name"		-> string
 *	"zen:output"	-> uint32
 *	"zen:input"	-> uint32
 *	"zen:pull"	-> uint32
 *	"metadata"	-> nvlist_t
 *			"name"		-> nvlist_t
 *					"protection"	-> uint32
 *			"zen:output":	-> nvlist_t
 *					"protection"	-> uint32
 *					"possible"	-> uint32[]
 *			"zen:input":	-> nvlist_t
 *					"protection"	-> uint32
 *					"possible"	-> uint32[]
 *			"zen:pull":	-> nvlist_t
 *					"protection"	-> uint32
 *					"possible"	-> uint32[]
 *
 * Basically what we see here is that every attribute is a top-level key. The
 * metadata is an nvlist_t where each key is the of an attribute which points to
 * an nvlist_t. The type of "possible" will match its underlying data type. The
 * metadata information is only provided by providers themselves when getting an
 * attribute. When an attribute is set, there is no metadata present. As in the
 * case of "name", something like the possible values can be omitted (in this
 * case because it's read-only). While metadata is strictly optional, it is
 * useful to include as it helps users understand what is going on.
 *
 * When coming up with attributes, there is no need for there to be a strict 1:1
 * mapping with hardware fields. In fact, providers should try to phrase things
 * such that people cannot create a state that is unsupported. For example, some
 * hardware may have two register settings: one for whether something is level
 * triggered and one for which edges should generate the interrupt. In this
 * case, if done simply, one could set an illegal value which is level triggered
 * on both the rising and falling edge which the hardware warns against. Rather
 * than allowing this to happen, the provider should instead come up with a
 * single semantic attribute so that way users can't end up in illegal states.
 *
 * Next we should turn our attention to the data flow for DPIOs. Where as GPIOs
 * allow the provider to define everything about them, DPIOs are different.
 * Instead, our DPIO operation vectors are all about taking narrowly defined
 * types in <sys/gpio/dpio.h> such as the dpio_input_t and the dpio_output_t and
 * having the provider map that to hardware states. Right now we have a limited
 * number of input and output values. Providers may not have a way to map every
 * possible state to one of our values. Similarly, there may be values that they
 * cannot represent in their hardware implementation. In these cases, providers
 * must fail the various DPIO requests. We require that consumers always read
 * and write a uint32_t value and that is enforced for providers. This is done
 * to give us future flexibility in the set of values we may support.
 *
 * ------------------------------------------
 * Provider Lifecycle, Locking, and Lifetimes
 * ------------------------------------------
 *
 * The most nuanced piece of this driver and framework is that we have to refer
 * to other driver's dev_info_t data structures and we want to allow those
 * things to be detached normally. A normal driver would attach and create minor
 * nodes, then detach when it no longer exists. However, when this detach is not
 * the driver being removed, devfs would notice this and when a minor node is
 * accessed bring it back to life. While this is a nice feature, like with the
 * kernel sensor subsystem, we end up having to do a bunch of this ourselves
 * because we are responsible for all the minors.
 *
 * This tradeoff centralizes the complexity in one spot rather than having each
 * provider have to reimplement cb_ops and more that they otherwise wouldn't
 * even need to or have to think about minors (which helps if they have their
 * own for any reason). With that in mind, it's worth laying out some
 * understanding of how this works and when we need to check and worry about
 * this:
 *
 *   o If a GPIO controller is actively open, that is someone called open(9E) on
 *     its minor, then we know that the dev_info_t is attached and present.
 *
 *   o Whenever a DPIO exists, it always has a hold on its underlying
 *     controller, regardless of whether the controller is open or not.
 *
 *   o When a GPIO provider driver detaches, it will call back into us. At that
 *     point we consider it invalid.
 *
 *   o When a GPIO provider driver registers with us, we know it is valid.
 *
 *   o The DDI will call back into us when the device driver is actually removed
 *     from the system (e.g. rem_drv), giving us a cue as to when everything is
 *     fully gone and we can finally tear down our state.
 *
 * With this in mind, our actual task and rules are fairly straightforward and
 * can be summarized as: when we are in open(9E) and are opening a controller,
 * we must check if it is valid (KGPIO_F_VALID) and if not, attempt to make it
 * valid again. Any other character device operation that is coming in we don't
 * have to worry about it because it is in that state by definition. This state
 * diagram can be summarized as:
 *
 *           |
 *           +-------<-----------------------------------<---------+
 *           |                                                     |
 *           | . . driver calls kgpio_register()                   |
 *           v                                                     |
 *       +-------+                                                 |
 *       | Valid |                                                 |
 *       +-------+                                                 ^
 *           |                                                     |
 *           | . . driver calls kgpio_unregister().                |
 *           v                                                     |
 *      +---------+                                                |
 *      | Invalid |                                                |
 *      +---------+                                                |
 *        |     |                                                  |
 *        |     | . . user calls open on a controller              |
 *        |     |     minor node                                   |
 *        |     +------------------+                               |
 *        |                        |                               ^
 *        |                        |                               |
 *        |                        v                               |
 *        |               +-------------------+                    |
 *        |               | ndi_devi_config() |-->-.---------------+
 *        |               +-------------------+    . . driver attach(9E) called
 *        |                                |
 *        | . . DDI's unbind callback      |
 *        |     fires as driver is         |
 *        |     being removed              |
 *        v                                | . . attach failed or there
 *   +---------+                           |     was no call to
 *   | kgpio_t |<--------------------------+     kgpio_register() again
 *   | Deleted |
 *   +---------+
 *
 * The heavy lifting is done in the rather involved function, kgpio_hold_by_id.
 * In that, if we find that the KGPIO_F_VALID and KGPIO_F_HELD are both present,
 * then we're in the earlier simple case described above. Otherwise, if not, we
 * then have to consider the fact that multiple threads may all be trying to get
 * here for some reason (e.g. concurrent calls to open(9E)).
 *
 * The first thread that takes control of the process of validating something
 * sets the KGPIO_F_META_WORK flag. Any other thread that finds this flag set
 * simply waits on it to finish. When these blocked threads are signaled, they
 * restart the entire validation process again. Once the meta flag is owned, we
 * proceed to take the NDI hold which ensures that the dev_info_t shouldn't be
 * able to go away. At that point, we will attempt to attach the driver if it's
 * not attached. If it is, then we are done.
 *
 * The NDI hold will persist as long as the device is open. Similarly, as
 * mentioned above, each DPIO that exists puts a similar NDI hold on the
 * underlying dev_info_t.
 *
 * The benefit of this whole dance is that it guarantees that an open controller
 * node cannot disappear at all during any other cb_ops, simplifying lifetime
 * considerations. Basically when calling open(9E) we need to consider it, but
 * once open, we're good until close(9E).
 *
 * This ties in directly into the locking hierarchy in the system. There are
 * three classes of locks that exist, which are ordered by the order in which
 * they should be taken.
 *
 *  1. The global kgpio_g_mutex, which protects all of the global data
 *     structures.
 *  2. The mutex embedded in the dpio_t structure.
 *  3. The mutex embedded in the kgpio_t structure.
 *
 * When dealing with locking, one must always take the kgpio_g_mutex before one
 * ever takes either of the kgpio_mutex or dpio_mutex inside the kgpio_t and
 * dpio_t. Most of the data that is required for the DPIO to perform I/O on the
 * underlying GPIO is read-only data. In general, one should not hold both a
 * dpio_t and kgpio_t mutex at the same time. Finally, if you need to call into
 * the NDI or enter a parent, none of our locks should be held.
 *
 * The lifetime of the dpio_t structure is tied to someone creating and
 * destroying it with ioctls (KGPIO_IOC_DPIO_CREATE and KGPIO_IOC_DPIO_DESTROY).
 * A DPIO cannot be destroyed if someone is using it. This means that like the
 * kgpio_t, once you get through the open(9E) call, you can assume that it will
 * always be valid. In addition, the kgpio_t that is attached to it always will
 * be. Unlike the kgpio_t, the dpio_t hold process is much simpler. As long as
 * the dpio is findable in the global list (with the global mutex held), then it
 * is valid.
 *
 * Ideally, the combination of these two pieces leads to making the actual
 * design and implementation here much simpler in other parts and ultimately,
 * makes the system easier to reason about.
 *
 * ---------------------------------
 * Future Integrations, Shortcomings
 * ---------------------------------
 *
 * At this time, the implementation of the framework has been designed around
 * erring on the side of simplicity and enabling end to end functionality.
 * Several of the choices such as using nvlist_t's, the presence of metadata,
 * and the design of DPIOs are focused on that. Here are things that this
 * currently doesn't do and may have varying degrees of challenges:
 *
 *   o The attribute and DPIO interface are not designed around the need to
 *     sometimes implement various peripherals via bit-banging GPIOs. For such
 *     cases, an alternative set of interfaces which allows a consumer to batch
 *     up a series of changes to a GPIO with any optional delays that are all
 *     executed at once is probably what should be used. Because the initial
 *     needs do not require this, we have not pretended to come up with a good
 *     consumerless API.
 *
 *   o Right now we are using simple intrusive lists for DPIOs and GPIOs. There
 *     is no easy way to go from a GPIO and see which DPIOs point into it. When
 *     this becomes a bottelneck (e.g. as part of delivering polling results),
 *     then that would be the time to improve things here and add something akin
 *     to an AVL to the kgpio_t that includes all of its DPIOs.
 *
 *   o We currently don't support any chpoll(9E) interfaces. The intent here is
 *     that there would be a single pollhead per dpio_t that is shared between
 *     anyone who calls chpoll(9E) on the dpio_t. This would be paired with a
 *     callback function for a provider to call back into us. Importantly
 *     though, when that is added, we should ensure that the providers are
 *     instructed not to hold any locks across the call.
 *
 *   o Right now there is no integration with pin and I/O muxing, meaning that
 *     it is possible that anything set in the GPIO controller's hardware may
 *     have no effect. This is an area of future research and work.
 *
 *   o There is currently a forced 1:1 relationship between the provider and the
 *     dev_info_t. The provider also can't determine its own name. While these
 *     are simpler problems to solve, the broader problem (which extends beyond
 *     just the GPIO framework) is how to name and relate providers to semantic
 *     things that a user actually knows about and may not have a stable
 *     /devices path for the consumer to rely upon.
 */

#include <sys/types.h>
#include <sys/file.h>
#include <sys/errno.h>
#include <sys/open.h>
#include <sys/cred.h>
#include <sys/ddi.h>
#include <sys/sunddi.h>
#include <sys/stat.h>
#include <sys/conf.h>
#include <sys/devops.h>
#include <sys/cmn_err.h>
#include <sys/list.h>
#include <sys/stddef.h>
#include <sys/sunndi.h>
#include <sys/esunddi.h>
#include <sys/taskq.h>
#include <sys/id_space.h>
#include <sys/sysmacros.h>
#include <sys/avl.h>
#include <sys/stdbool.h>
#include <sys/ctype.h>
#include <sys/fs/dv_node.h>

#include <sys/gpio/kgpio_provider.h>
#include <sys/gpio/kgpio.h>
#include <sys/gpio/dpio.h>

#define	KGPIO_CTRL_NAMELEN	DPIO_NAMELEN

typedef enum {
	/*
	 * This flag is used to indicate that the minor node is registered. It
	 * is possible for this not to happen if a provider comes in before the
	 * kgpio instance is force attached.
	 */
	KGPIO_F_MINOR_VALID	= 1 << 0,
	/*
	 * This flag tracks the notion of whether or not we believe the
	 * underlying driver instance is active and attached. When the producer
	 * is deatching this will be cleared and this is our call to try to open
	 * it up again.
	 */
	KGPIO_F_VALID		= 1 << 1,
	/*
	 * This indicates that the underlying driver instance represented by the
	 * kgpio_t has a DDI hold on it. This is established in a controller's
	 * first open and removed when it is closed. Note, this is used as part
	 * of manipulating the controller node. DPIOs will also have holds on
	 * the underlying dev_info_t that are tracked with their lifetime.
	 */
	KGPIO_F_HELD		= 1 << 2,
	/*
	 * This flag is a stage beyond having cleared KGPIO_F_VALID. At this
	 * point, the driver this is associated with is actually going away and
	 * therefore this truly is getting cleaned up.
	 */
	KGPIO_F_REMOVED		= 1 << 3,
	/*
	 * This flag is used to synchronize the act of holding and/or attaching
	 * a given kgpio. There can only be one at a time. This is only ever
	 * used in open. close(9E) does not require this because of the
	 * exclusion guarantees of the kernel.
	 */
	KGPIO_F_META_WORK	= 1 << 4
} kgpio_flags_t;

struct kgpio;
struct dpio;

typedef enum {
	/*
	 * This is a GPIO controller. It is represented by a kgpio_t.
	 */
	KGPIO_MINOR_T_CTRL,
	/*
	 * This is a DPIO entry. It is represented by a dpio_t.
	 */
	KGPIO_MINOR_T_DPIO,
	/*
	 * This is a general interface that is used to get static information
	 * about DPIOs. Nothing in the kminor_data is valid.
	 */
	KGPIO_MINOR_T_DPINFO
} kgpio_minor_type_t;

typedef struct kgpio_minor {
	avl_node_t kminor_avl;
	id_t kminor_id;
	kgpio_minor_type_t kminor_type;
	union {
		struct dpio *kminor_dpio;
		struct kgpio *kminor_ctrl;
	} kminor_data;
} kgpio_minor_t;

typedef struct kgpio {
	kgpio_minor_t kgpio_minor;
	list_node_t kgpio_link;
	dev_info_t *kgpio_dip;
	uint32_t kgpio_ngpios;
	const kgpio_ops_t *kgpio_ops;
	void *kgpio_drv;
	ddi_unbind_callback_t kgpio_cb;
	char kgpio_mname[KGPIO_CTRL_NAMELEN];
	kmutex_t kgpio_mutex;
	kcondvar_t kgpio_cv;
	kgpio_flags_t kgpio_flags;
	uint32_t kgpio_ndpios;
} kgpio_t;

/*
 * This is designed to give us space for 'dpio:' and then whatever name
 * the user gives us. This is done to avoid having someone try to create a dpio
 * that would conflict with a controller name.
 */
#define	KGPIO_DPIO_INT_NAMELEN	(KGPIO_DPIO_NAMELEN + 8)

typedef enum {
	/*
	 * This is used to indicate that the dpio is actually open.
	 */
	DPIO_S_OPEN		= 1 << 0,
	/*
	 * This indicates that the DPIO is open exclusively right now.
	 */
	DPIO_S_EXCL		= 1 << 1
} dpio_status_t;

typedef struct dpio {
	kgpio_minor_t dpio_minor;
	list_node_t dpio_link;
	char dpio_name[KGPIO_DPIO_INT_NAMELEN];
	kgpio_t *dpio_kgpio;
	uint32_t dpio_gpio_num;
	dpio_caps_t dpio_caps;
	dpio_flags_t dpio_flags;
	/*
	 * All fields above this point are read-only and set at DPIO creation
	 * time.
	 */
	kmutex_t dpio_mutex;
	hrtime_t dpio_last_intr;
	hrtime_t dpio_last_write;
	dpio_status_t dpio_status;
} dpio_t;

/*
 * Various definitions related to minor numbers. The first minor is what we use
 * for the kgpio id_space. This starts at two as we reserve the minor number 1
 * for the dpinfo entry and we assume that 0 is reserved to aid in debugging /
 * initialization.
 */
#define	KGPIO_MINOR_DPINFO	1
#define	KGPIO_MINOR_FIRST	2
#define	KGPIO_MINOR_NAME_DPINFO	"dpinfo"

/*
 * This is the maximum size of a user nvlist_t that we're willing to consider in
 * the kernel. This value is a rough swag of what we think the maximum size
 * nvlist would ever be for a single GPIO with headroom. This is here in case
 * someone has need to tune it to unblock something.
 */
size_t kgpio_max_user_nvl = 512 * 1024;

static dev_info_t *kgpio_g_dip;
static kmutex_t kgpio_g_mutex;
static list_t kgpio_g_gpios;
static list_t kgpio_g_dpios;
static avl_tree_t kgpio_g_minors;
static id_space_t *kgpio_g_ids;
static kgpio_minor_t kgpio_g_dpinfo;

static int
kgpio_minor_comparator(const void *l, const void *r)
{
	const kgpio_minor_t *kml = l;
	const kgpio_minor_t *kmr = r;

	if (kml->kminor_id > kmr->kminor_id) {
		return (1);
	} else if (kml->kminor_id < kmr->kminor_id) {
		return (-1);
	} else {
		return (0);
	}
}

static kgpio_t *
kgpio_find_by_dip(dev_info_t *dip)
{
	kgpio_t *k;

	ASSERT(MUTEX_HELD(&kgpio_g_mutex));
	for (k = list_head(&kgpio_g_gpios); k != NULL;
	    k = list_next(&kgpio_g_gpios, k)) {
		if (k->kgpio_dip == dip) {
			return (k);
		}
	}

	return (NULL);
}

static kgpio_minor_t *
kgpio_minor_find(id_t minor)
{
	kgpio_minor_t idx = { 0 };

	ASSERT(MUTEX_HELD(&kgpio_g_mutex));
	idx.kminor_id = minor;

	return (avl_find(&kgpio_g_minors, &idx, NULL));
}

static void
kgpio_dpio_cleanup(dpio_t *dpio)
{
	if (dpio->dpio_minor.kminor_id > 0) {
		id_free(kgpio_g_ids, dpio->dpio_minor.kminor_id);
		dpio->dpio_minor.kminor_id = 0;
	}
	ddi_remove_minor_node(kgpio_g_dip, dpio->dpio_name);
	mutex_destroy(&dpio->dpio_mutex);
	kmem_free(dpio, sizeof (dpio_t));
}

static void
kgpio_cleanup(kgpio_t *kgpio)
{
	if (kgpio->kgpio_minor.kminor_id > 0) {
		id_free(kgpio_g_ids, kgpio->kgpio_minor.kminor_id);
		kgpio->kgpio_minor.kminor_id = 0;
	}
	cv_destroy(&kgpio->kgpio_cv);
	mutex_destroy(&kgpio->kgpio_mutex);
	kmem_free(kgpio, sizeof (kgpio_t));
}

static void
kgpio_unbind_taskq(void *arg)
{
	kgpio_t *kgpio = arg;

	mutex_enter(&kgpio_g_mutex);
	if ((kgpio->kgpio_flags & KGPIO_F_MINOR_VALID) != 0) {
		kgpio->kgpio_flags &= ~KGPIO_F_MINOR_VALID;
		(void) ddi_remove_minor_node(kgpio_g_dip, kgpio->kgpio_mname);
	}
	mutex_exit(&kgpio_g_mutex);

	kgpio_cleanup(kgpio);
}

static void
kgpio_unbind_cb(void *arg, dev_info_t *dip)
{
	kgpio_t *kgpio = arg;

	/*
	 * We have reached here because a driver that was registered with us is
	 * actually going away. As such it is now time for us to finally let go
	 * of it and free it so as to no longer attempt to keep it around and
	 * reattach it. At this point in time we are still in the context of the
	 * detaching thread in the devinfo tree. As such, here we note that it
	 * is going away and in the system taskq do the work to finish cleaning
	 * it up. After this point it cannot be looked up and held, so only
	 * existing opens that are racing with us will be here.
	 */
	mutex_enter(&kgpio_g_mutex);
	list_remove(&kgpio_g_gpios, kgpio);
	avl_remove(&kgpio_g_minors, &kgpio->kgpio_minor);
	kgpio->kgpio_flags |= KGPIO_F_REMOVED;
	mutex_exit(&kgpio_g_mutex);

	(void) taskq_dispatch(system_taskq, kgpio_unbind_taskq, kgpio,
	    TQ_SLEEP);
}

int
kgpio_unregister(dev_info_t *dip)
{
	kgpio_t *kgpio;

	if (dip == NULL) {
		return (EINVAL);
	}

	if (!DEVI_IS_ATTACHING(dip) && !DEVI_IS_DETACHING(dip)) {
		return (EAGAIN);
	}

	mutex_enter(&kgpio_g_mutex);
	kgpio = kgpio_find_by_dip(dip);
	if (kgpio == NULL) {
		mutex_exit(&kgpio_g_mutex);
		return (ENOENT);
	}
	kgpio->kgpio_flags &= ~KGPIO_F_VALID;
	mutex_exit(&kgpio_g_mutex);

	return (0);
}

/*
 * Attempt to create a minor node for the kgpio. Because of the fact that the
 * producer can register before we have a dev_info_t there's not a lot we can do
 * other than complain and hope someone notices on failure.
 */
static void
kgpio_create_minor(kgpio_t *kgpio)
{
	ASSERT(MUTEX_HELD(&kgpio->kgpio_mutex));

	if (ddi_create_minor_node(kgpio_g_dip, kgpio->kgpio_mname, S_IFCHR,
	    (minor_t)kgpio->kgpio_minor.kminor_id, DDI_NT_GPIO_CTRL, 0) != 0) {
		dev_err(kgpio_g_dip, CE_WARN, "failed to create minor node "
		    "%s", kgpio->kgpio_mname);
	} else {
		kgpio->kgpio_flags |= KGPIO_F_MINOR_VALID;
	}
}

int
kgpio_register(dev_info_t *dip, const kgpio_ops_t *ops, void *arg,
    uint32_t ngpio)
{
	kgpio_t *kgpio;

	if (dip == NULL || ops == NULL || ops->kgo_get == NULL ||
	    ops->kgo_set == NULL || ngpio == 0) {
		return (EINVAL);
	}

	if (!DEVI_IS_ATTACHING(dip)) {
		return (EAGAIN);
	}

	mutex_enter(&kgpio_g_mutex);
	kgpio = kgpio_find_by_dip(dip);
	if (kgpio != NULL) {
		mutex_enter(&kgpio->kgpio_mutex);
		if ((kgpio->kgpio_flags & KGPIO_F_VALID) != 0) {
			mutex_exit(&kgpio->kgpio_mutex);
			mutex_exit(&kgpio_g_mutex);
			return (EEXIST);
		}

		if (kgpio->kgpio_ngpios != ngpio) {
			dev_err(dip, CE_WARN, "failed to register with gpio "
			    "framework, number of GPIOs changed from %u to %u",
			    kgpio->kgpio_ngpios, ngpio);
			mutex_exit(&kgpio->kgpio_mutex);
			mutex_exit(&kgpio_g_mutex);
			return (ESTALE);
		}

		/*
		 * We've found a match for this gpio. Assume that the pointers
		 * it's given us have changed, but otherwise, we don't need to
		 * recreate anything in the kgpio_t.
		 */
		kgpio->kgpio_flags |= KGPIO_F_VALID;
		kgpio->kgpio_ops = ops;
		kgpio->kgpio_drv = arg;
		mutex_exit(&kgpio->kgpio_mutex);
		mutex_exit(&kgpio_g_mutex);
		return (0);
	}

	kgpio = kmem_zalloc(sizeof (kgpio_t), KM_SLEEP);
	kgpio->kgpio_dip = dip;
	kgpio->kgpio_ngpios = ngpio;
	kgpio->kgpio_ops = ops;
	kgpio->kgpio_drv = arg;

	mutex_init(&kgpio->kgpio_mutex, NULL, MUTEX_DRIVER, NULL);
	cv_init(&kgpio->kgpio_cv, NULL, CV_DRIVER, NULL);

	if (snprintf(kgpio->kgpio_mname, sizeof (kgpio->kgpio_mname), "%s%d",
	    ddi_driver_name(dip), ddi_get_instance(dip)) >=
	    sizeof (kgpio->kgpio_mname)) {
		mutex_exit(&kgpio_g_mutex);
		dev_err(dip, CE_WARN, "failed to register with gpio framework: "
		    "controller minor name overflow");
		kgpio_cleanup(kgpio);
		return (EOVERFLOW);
	}

	kgpio->kgpio_minor.kminor_id = id_alloc_nosleep(kgpio_g_ids);
	if (kgpio->kgpio_minor.kminor_id == -1) {
		mutex_exit(&kgpio_g_mutex);
		kgpio_cleanup(kgpio);
		return (ENOSPC);
	}
	kgpio->kgpio_minor.kminor_type = KGPIO_MINOR_T_CTRL;
	kgpio->kgpio_minor.kminor_data.kminor_ctrl = kgpio;

	kgpio->kgpio_cb.ddiub_cb = kgpio_unbind_cb;
	kgpio->kgpio_cb.ddiub_arg = kgpio;
	e_ddi_register_unbind_callback(dip, &kgpio->kgpio_cb);
	kgpio->kgpio_flags |= KGPIO_F_VALID;

	/*
	 * At this point the kgpio_t is set up. The last thing we need to see is
	 * if we actually have our dev_info_t so we can create minors. It is
	 * possible for this not to be the case when the first gpio provider is
	 * attaching because the krtld reference only guarantees that the kgpio
	 * _init() entry point has been called and not attach. We attempt to use
	 * a ddi-forceattach attribute to make this less likely.
	 */
	if (kgpio_g_dip != NULL) {
		mutex_enter(&kgpio->kgpio_mutex);
		kgpio_create_minor(kgpio);
		mutex_exit(&kgpio->kgpio_mutex);
	}

	list_insert_tail(&kgpio_g_gpios, kgpio);
	avl_add(&kgpio_g_minors, &kgpio->kgpio_minor);

	mutex_exit(&kgpio_g_mutex);

	return (0);
}

void
kgpio_nvl_attr_fill_str(nvlist_t *nvl, nvlist_t *meta, const char *key,
    const char *val, uint_t npos, char *const *pos, kgpio_prot_t prot)
{
	nvlist_t *info = fnvlist_alloc();

	fnvlist_add_string(nvl, key, val);

	fnvlist_add_uint32(info, KGPIO_ATTR_PROT, (uint32_t)prot);
	if (npos > 0) {
		fnvlist_add_string_array(info, KGPIO_ATTR_POS, pos, npos);
	}
	fnvlist_add_nvlist(meta, key, info);
	fnvlist_free(info);

}

void
kgpio_nvl_attr_fill_u32(nvlist_t *nvl, nvlist_t *meta, const char *key,
    uint32_t val, uint_t npos, uint32_t *pos, kgpio_prot_t prot)
{
	nvlist_t *info = fnvlist_alloc();

	fnvlist_add_uint32(nvl, key, val);

	fnvlist_add_uint32(info, KGPIO_ATTR_PROT, (uint32_t)prot);
	if (npos > 0) {
		fnvlist_add_uint32_array(info, KGPIO_ATTR_POS, pos, npos);
	}
	fnvlist_add_nvlist(meta, key, info);
	fnvlist_free(info);
}

static void
kgpio_release(kgpio_t *kgpio)
{
	ddi_release_devi(kgpio->kgpio_dip);

	mutex_enter(&kgpio->kgpio_mutex);
	VERIFY(kgpio->kgpio_flags & KGPIO_F_HELD);
	kgpio->kgpio_flags &= ~KGPIO_F_HELD;
	mutex_exit(&kgpio->kgpio_mutex);
}

static void
kgpio_release_meta(kgpio_t *kgpio)
{
	mutex_enter(&kgpio->kgpio_mutex);
	VERIFY(kgpio->kgpio_flags & KGPIO_F_META_WORK);
	kgpio->kgpio_flags &= ~KGPIO_F_META_WORK;
	cv_broadcast(&kgpio->kgpio_cv);
	mutex_exit(&kgpio->kgpio_mutex);
}

static int
kgpio_hold_by_id(id_t id)
{
	kgpio_t *kgpio;
	dev_info_t *pdip;
	kgpio_minor_t *minor;

restart:
	mutex_enter(&kgpio_g_mutex);
	minor = kgpio_minor_find(id);
	if (minor == NULL) {
		mutex_exit(&kgpio_g_mutex);
		return (ESTALE);
	}
	if (minor->kminor_type != KGPIO_MINOR_T_CTRL) {
		mutex_exit(&kgpio_g_mutex);
		return (ENXIO);
	}
	kgpio = minor->kminor_data.kminor_ctrl;

	mutex_enter(&kgpio->kgpio_mutex);
	if ((kgpio->kgpio_flags & KGPIO_F_REMOVED) != 0) {
		mutex_exit(&kgpio->kgpio_mutex);
		mutex_exit(&kgpio_g_mutex);
		return (ESTALE);
	}

	/*
	 * First, check if the node that we're looking at is both active and
	 * held. If it is then there is nothing more that we need to do and can
	 * acknowledge the open. We don't need to account for how many folks
	 * have opened it due to the kernel's accounting.
	 */
	if ((kgpio->kgpio_flags & (KGPIO_F_VALID | KGPIO_F_HELD)) ==
	    (KGPIO_F_VALID | KGPIO_F_HELD)) {
		mutex_exit(&kgpio->kgpio_mutex);
		mutex_exit(&kgpio_g_mutex);
		return (0);
	}

	/*
	 * This driver is either inactive and needs to be attached or it's not
	 * held. In either case we need to make sure that only one open(9E) can
	 * end up in here at a time. Note, while doing all this we drop the
	 * global and local lock. This will cause us to restart this entire
	 * loop.
	 */
	if ((kgpio->kgpio_flags & KGPIO_F_META_WORK) != 0) {
		mutex_exit(&kgpio_g_mutex);
		while ((kgpio->kgpio_flags & KGPIO_F_META_WORK) != 0) {
			int cv = cv_wait_sig(&kgpio->kgpio_cv,
			    &kgpio->kgpio_mutex);
			if (cv == 0) {
				mutex_exit(&kgpio->kgpio_mutex);
				return (EINTR);
			}
		}

		/*
		 * We're no longer waiting. However, we basically have to take
		 * another lap through here to check through all the core state
		 * again because we dropped the kgpio_g_mutex.
		 */
		mutex_exit(&kgpio->kgpio_mutex);
		goto restart;
	}

	/*
	 * At this point we can obtain ownership for performing meta work on
	 * this kgpio. Once we claim this we will need to drop our locks and
	 * related to perform all of the related NDI operations. However,
	 * because the meta work flag is set, this structure can't disappear.
	 */
	kgpio->kgpio_flags |= KGPIO_F_META_WORK;
	pdip = ddi_get_parent(kgpio->kgpio_dip);
	mutex_exit(&kgpio->kgpio_mutex);
	mutex_exit(&kgpio_g_mutex);

	/*
	 * This is required to ensure that the driver can't go away.
	 */
	ndi_devi_enter(pdip);
	e_ddi_hold_devi(kgpio->kgpio_dip);
	ndi_devi_exit(pdip);

	/*
	 * Because we dropped the main lock, we need to see if we lost a race
	 * again and if so unwind.
	 */
	mutex_enter(&kgpio->kgpio_mutex);
	kgpio->kgpio_flags |= KGPIO_F_HELD;
	if ((kgpio->kgpio_flags & KGPIO_F_REMOVED) != 0) {
		mutex_exit(&kgpio->kgpio_mutex);
		kgpio_release(kgpio);
		kgpio_release_meta(kgpio);
		return (ESTALE);
	}

	/*
	 * If the instance isn't valid yet, try to go and prod it via the NDI to
	 * wake up. This needs to happen if an instance gets detached, for
	 * example.
	 */
	if ((kgpio->kgpio_flags & KGPIO_F_VALID) == 0) {
		mutex_exit(&kgpio->kgpio_mutex);
		(void) ndi_devi_config(pdip, NDI_NO_EVENT);
		mutex_enter(&kgpio->kgpio_mutex);

		/*
		 * Check one last time for validity. If this has failed or its
		 * been removed, finally give up.
		 */
		ASSERT(kgpio->kgpio_flags & KGPIO_F_META_WORK);
		if ((kgpio->kgpio_flags & KGPIO_F_REMOVED) != 0 ||
		    (kgpio->kgpio_flags & KGPIO_F_VALID) == 0) {
			mutex_exit(&kgpio->kgpio_mutex);
			kgpio_release(kgpio);
			kgpio_release_meta(kgpio);
			return (ESTALE);
		}
	}

	/*
	 * OK, at this point we actually did it. We should be both VALID and
	 * HELD. We can release the meta work flag and we now should be good to
	 * go.
	 */
	ASSERT(kgpio->kgpio_flags & KGPIO_F_META_WORK);
	ASSERT(kgpio->kgpio_flags & KGPIO_F_HELD);
	ASSERT(kgpio->kgpio_flags & KGPIO_F_VALID);
	mutex_exit(&kgpio->kgpio_mutex);

	kgpio_release_meta(kgpio);

	return (0);
}

static int
kgpio_open(dev_t *devp, int flag, int otyp, cred_t *credp)
{
	kgpio_minor_t *minor;
	dpio_t *dpio;

	if (drv_priv(credp) != 0)
		return (EPERM);

	mutex_enter(&kgpio_g_mutex);
	minor = kgpio_minor_find((id_t)getminor(*devp));
	if (minor == NULL) {
		mutex_exit(&kgpio_g_mutex);
		return (ESTALE);
	}

	switch (minor->kminor_type) {
	case KGPIO_MINOR_T_CTRL:
		/*
		 * Opening a controller is awkward. By definition we have a
		 * valid minor number and we have kgpio; however, depending on
		 * the state of the actual controller it may not be held right
		 * now. In addition, while we have found a minor right now for
		 * this, when we go to potentially reattach it, if required, it
		 * may disappear. So, as weird as this is, now that we believe
		 * that this is a controller, we're going to call into the kgpio
		 * hold logic, which will itself end up taking and dropping the
		 * global locks across ndi calls. This mean that we're going to
		 * drop the lock and must ignore the minor we just found. This
		 * is ok, because the hold logic will validate the type and
		 * related again.
		 */
		mutex_exit(&kgpio_g_mutex);

		if (otyp != OTYP_CHR)
			return (ENOTSUP);

		if ((flag & (FNDELAY | FNONBLOCK | FEXCL)) != 0)
			return (EINVAL);

		if ((flag & FREAD) != FREAD)
			return (EINVAL);

		return (kgpio_hold_by_id((id_t)getminor(*devp)));
	case KGPIO_MINOR_T_DPIO:
		dpio = minor->kminor_data.kminor_dpio;
		mutex_enter(&dpio->dpio_mutex);
		mutex_exit(&kgpio_g_mutex);

		/*
		 * Verify the basics that we expect for a DPIO.
		 *  o It must be a character device.
		 *  o If a DPIO has been flagged with requiring kernel access
		 *    then FKLYR must be specified. If it is not, then it is an
		 *    error.
		 *  o We don't care about FNDELAY | FNONBLOCK, they will be
		 *    honored for read(9E) and write(9E) and checked in the
		 *    uio(9S).
		 *  o If the DPIO_S_EXCL status flag is set, then we have to
		 *    return that this device is already busy.
		 *  o If someone has asked for FEXCL, it is only allowed to
		 *    succeed if the device isn't already open.
		 */
		if ((dpio->dpio_flags & DPIO_F_KERNEL) != 0 &&
		    (flag & FKLYR) == 0) {
			mutex_exit(&dpio->dpio_mutex);
			return (EPERM);
		}

		if (otyp != OTYP_CHR) {
			mutex_exit(&dpio->dpio_mutex);
			return (ENOTSUP);
		}

		if ((dpio->dpio_status & DPIO_S_EXCL) != 0) {
			mutex_exit(&dpio->dpio_mutex);
			return (EBUSY);
		}

		if ((flag & FEXCL) != 0) {
			if ((dpio->dpio_status & DPIO_S_OPEN) != 0) {
				mutex_exit(&dpio->dpio_mutex);
				return (EBUSY);
			}
			dpio->dpio_status |= DPIO_S_EXCL;
		}

		dpio->dpio_status |= DPIO_S_OPEN;
		mutex_exit(&dpio->dpio_mutex);
		return (0);
	case KGPIO_MINOR_T_DPINFO:
		mutex_exit(&kgpio_g_mutex);

		/*
		 * For the DPIO Information device, this really just is used to
		 * get information and read-only ioctls. There is no special
		 * support for anything here. We do require read access as
		 * without that there isn't much to really do.
		 */
		if (otyp != OTYP_CHR) {
			return (ENOTSUP);
		}

		if ((flag & (FNDELAY | FNONBLOCK | FEXCL)) != 0) {
			return (EINVAL);
		}

		if ((flag & FREAD) != FREAD) {
			return (EINVAL);
		}

		return (0);
	default:
		mutex_exit(&kgpio_g_mutex);
		return (ENXIO);
	}
}

static int
kgpio_ioctl_ctrl_info(kgpio_t *kgpio, intptr_t arg, int mode)
{
	kgpio_ctrl_info_t info;

	ASSERT(MUTEX_HELD(&kgpio->kgpio_mutex));

	if ((mode & FREAD) == 0) {
		return (EBADF);
	}

	bzero(&info, sizeof (info));
	info.kci_ngroups = 0;
	info.kci_ngpios = kgpio->kgpio_ngpios;
	info.kci_ndpios = kgpio->kgpio_ndpios;
	(void) ddi_pathname(kgpio->kgpio_dip, info.kci_devpath);

	if (ddi_copyout(&info, (void *)arg, sizeof (info), mode & FKIOCTL) !=
	    0) {
		return (EFAULT);
	}

	return (0);
}

static int
kgpio_ioctl_gpio_info(kgpio_t *kgpio, intptr_t arg, int mode)
{
	int ret;
	uint_t model;
	char *pack = NULL;
	size_t pack_size = 0;
	kgpio_gpio_info_t info;
#ifdef	_MULTI_DATAMODEL
	kgpio_gpio_info32_t info32;
#endif

	ASSERT(MUTEX_HELD(&kgpio->kgpio_mutex));

	if ((mode & FREAD) == 0) {
		return (EBADF);
	}

	model = ddi_model_convert_from(mode);
	switch (model) {
#ifdef	_MULTI_DATAMODEL
	case DDI_MODEL_ILP32:
		if (ddi_copyin((void *)arg, &info32, sizeof (info32),
		    mode & FKIOCTL) != 0) {
			return (EFAULT);
		}

		info.kgi_id = info32.kgi_id;
		info.kgi_flags = info32.kgi_flags;
		info.kgi_attr = info32.kgi_attr;
		info.kgi_attr_len = info32.kgi_attr_len;
		break;
#endif	/* _MULTI_DATAMODEL */
	case DDI_MODEL_NONE:
		if (ddi_copyin((void *)arg, &info, sizeof (info),
		    mode & FKIOCTL) != 0) {
			return (EFAULT);
		}
		break;
	default:
		return (ENOTSUP);
	}

	if (info.kgi_id >= kgpio->kgpio_ngpios) {
		return (ENOENT);
	}

	nvlist_t *attr = fnvlist_alloc();
	ret = kgpio->kgpio_ops->kgo_get(kgpio->kgpio_drv, info.kgi_id, attr);
	if (ret != 0) {
		goto out;
	}

	pack = fnvlist_pack(attr, &pack_size);
	if (info.kgi_attr_len >= pack_size) {
		if (ddi_copyout(pack, (void *)info.kgi_attr, pack_size,
		    mode & FKIOCTL) != 0) {
			ret = EFAULT;
			goto out;
		}
		ret = 0;
	} else {
		ret = EOVERFLOW;
	}

	info.kgi_attr_len = pack_size;
	switch (model) {
#ifdef	_MULTI_DATAMODEL
	case DDI_MODEL_ILP32:
		if (info.kgi_attr_len > UINT32_MAX) {
			info32.kgi_attr_len = UINT32_MAX;
			ret = EOVERFLOW;
		} else {
			info32.kgi_attr_len = info.kgi_attr_len;
		}

		if (ddi_copyout(&info32, (void *)arg, sizeof (info32),
		    mode & FKIOCTL) != 0) {
			ret = EFAULT;
			goto out;
		}
		break;
#endif	/* _MULTI_DATAMODEL */
	case DDI_MODEL_NONE:
		if (ddi_copyout(&info, (void *)arg, sizeof (info),
		    mode & FKIOCTL) != 0) {
			ret = EFAULT;
			goto out;
		}
	}

out:
	if (pack != NULL) {
		ASSERT3U(pack_size, !=, 0);
		fnvlist_pack_free(pack, pack_size);
	}
	nvlist_free(attr);
	return (ret);
}

static int
kgpio_ioctl_gpio_update(kgpio_t *kgpio, intptr_t arg, int mode)
{
	int ret;
	uint_t model;
	char *user_data = NULL;
	nvlist_t *attr_nvl = NULL, *err_nvl = NULL;
	kgpio_update_t kgu;
#ifdef	_MULTI_DATAMODEL
	kgpio_update32_t kgu32;
#endif

	ASSERT(MUTEX_HELD(&kgpio->kgpio_mutex));

	if ((mode & FWRITE) == 0) {
		return (EBADF);
	}

	model = ddi_model_convert_from(mode);
	switch (model) {
#ifdef	_MULTI_DATAMODEL
	case DDI_MODEL_ILP32:
		if (ddi_copyin((void *)arg, &kgu32, sizeof (kgu32),
		    mode & FKIOCTL) != 0) {
			return (EFAULT);
		}

		kgu.kgu_id = kgu32.kgu_id;
		kgu.kgu_flags = kgu32.kgu_flags;
		kgu.kgu_attr = kgu32.kgu_attr;
		kgu.kgu_attr_len = kgu32.kgu_attr_len;
		kgu.kgu_err = kgu32.kgu_err;
		kgu.kgu_err_len = kgu32.kgu_err_len;
		break;
#endif	/* _MULTI_DATAMODEL */
	case DDI_MODEL_NONE:
		if (ddi_copyin((void *)arg, &kgu, sizeof (kgu),
		    mode & FKIOCTL) != 0) {
			return (EFAULT);
		}
		break;
	default:
		return (ENOTSUP);
	}

	/*
	 * We need to go back and verify that this GPIO doesn't correspond to a
	 * DPIO at all. This means we need the global mutex again. It's safe for
	 * us to drop and reacquire the kgpio's lock as because we're in the
	 * context of the open device, it can't go away.
	 */
	mutex_exit(&kgpio->kgpio_mutex);
	mutex_enter(&kgpio_g_mutex);
	mutex_enter(&kgpio->kgpio_mutex);

	for (dpio_t *dpio = list_head(&kgpio_g_dpios); dpio != NULL;
	    dpio = list_next(&kgpio_g_dpios, dpio)) {
		if (dpio->dpio_kgpio == kgpio &&
		    dpio->dpio_gpio_num == kgu.kgu_id) {
			mutex_exit(&kgpio_g_mutex);
			return (EROFS);
		}
	}
	mutex_exit(&kgpio_g_mutex);

	if (kgu.kgu_attr_len > kgpio_max_user_nvl) {
		return (E2BIG);
	}

	if (kgu.kgu_id >= kgpio->kgpio_ngpios) {
		return (ENOENT);
	}

	user_data = kmem_alloc(kgpio_max_user_nvl, KM_NOSLEEP_LAZY);
	if (user_data == NULL) {
		return (ENOMEM);
	}

	if (ddi_copyin((void *)kgu.kgu_attr, user_data, kgu.kgu_attr_len,
	    mode & FKIOCTL) != 0) {
		ret = EFAULT;
		goto err;
	}

	if (nvlist_unpack(user_data, kgu.kgu_attr_len, &attr_nvl, 0) != 0) {
		ret = EINVAL;
		goto err;
	}

	err_nvl = fnvlist_alloc();
	ret = kgpio->kgpio_ops->kgo_set(kgpio->kgpio_drv, kgu.kgu_id, attr_nvl,
	    err_nvl);
	/*
	 * If this failed and we had an error nvlist, then we don't return an
	 * errno and instead translate this into the structure that we copy out.
	 * We always zero out the flags and then will set what appropriate bits
	 * we need. This next if statement will zero out ret, indicating to us
	 * that we should attempt to copy out this structure. If anything in the
	 * process of trying to copy out errors fails, then we don't worry about
	 * that and return a larger error because that is indicative of failure
	 * it just means userland can't get as much info as we wished.
	 */
	kgu.kgu_flags = 0;
	if (ret != 0 && nvlist_next_nvpair(err_nvl, NULL) != NULL) {
		size_t err_len;

		kgu.kgu_flags |= KGPIO_UPDATE_ERROR;
		ret = nvlist_size(err_nvl, &err_len, NV_ENCODE_NATIVE);

		if (ret == 0 && err_len <= MIN(kgu.kgu_err_len,
		    kgpio_max_user_nvl)) {
			ret = nvlist_pack(err_nvl, &user_data, &err_len,
			    NV_ENCODE_NATIVE, 0);
			if (ret != 0) {
				goto err;
			}

			kgu.kgu_err_len = err_len;
			if (ddi_copyout(user_data, (void *)kgu.kgu_err, err_len,
			    mode & FKIOCTL) != 0) {
				ret = EFAULT;
			} else {
				kgu.kgu_flags |= KGPIO_UPDATE_ERR_NVL_VALID;
				ret = 0;
			}
		}
	}

	if (ret != 0) {
		goto err;
	}

	switch (model) {
#ifdef	_MULTI_DATAMODEL
	case DDI_MODEL_ILP32:
		/*
		 * Other values should still hold from copyin, hence we only
		 * update those that we would have changed here.
		 */
		kgu32.kgu_flags = kgu.kgu_flags;
		kgu32.kgu_err_len = kgu.kgu_err_len;

		if (ddi_copyout(&kgu32, (void *)arg, sizeof (kgu32),
		    mode & FKIOCTL) != 0) {
			ret = EFAULT;
		}
		break;
#endif	/* _MULTI_DATAMODEL */
	case DDI_MODEL_NONE:
		if (ddi_copyout(&kgu, (void *)arg, sizeof (kgu),
		    mode & FKIOCTL) != 0) {
			ret = EFAULT;
		}
		break;
	default:
		ret = ENOTSUP;
	}

err:
	if (err_nvl != NULL) {
		nvlist_free(err_nvl);
	}

	if (attr_nvl != NULL) {
		nvlist_free(attr_nvl);
	}

	if (user_data != NULL) {
		kmem_free(user_data, kgpio_max_user_nvl);
	}
	return (ret);
}

static bool
kgpio_valid_name(const char *name, size_t buflen)
{
	size_t i;

	for (i = 0; i < buflen; i++) {
		if (name[i] == '\0')
			break;

		/*
		 * Right now we constrain GPIO names to be alphanumeric and
		 * allow for separators to exist. However, for file system
		 * simplicity we constrain the first character to be
		 * alphanumeric.
		 */
		if (i == 0 && !isalnum(name[i])) {
			return (false);
		} else if (!isalnum(name[i]) && name[i] != '_' &&
		    name[i] != '.' && name[i] != '-' && name[i] != '+') {
			return (false);
		}
	}

	if (i == 0 || i == buflen) {
		return (false);
	}

	return (true);
}

static int
kgpio_ioctl_dpio_create(kgpio_t *kgpio, intptr_t arg, int mode)
{
	int ret;
	dpio_caps_t sup_caps, caps = 0;
	const kgpio_dpio_flags_t all_flags = KGPIO_DPIO_F_READ |
	    KGPIO_DPIO_F_WRITE | KGPIO_DPIO_F_KERNEL;
	kgpio_dpio_create_t create;
	char name[KGPIO_DPIO_INT_NAMELEN];
	size_t namelen;

	ASSERT(MUTEX_HELD(&kgpio->kgpio_mutex));

	if ((mode & FWRITE) == 0) {
		return (EBADF);
	}

	if (ddi_copyin((void *)arg, &create, sizeof (kgpio_dpio_create_t),
	    mode & FKIOCTL) != 0) {
		return (EFAULT);
	}

	if (create.kdc_id >= kgpio->kgpio_ngpios) {
		return (ENOENT);
	}

	if (!kgpio_valid_name(create.kdc_name, sizeof (create.kdc_name))) {
		return (EINVAL);
	}
	namelen = snprintf(name, sizeof (name), "dpio:%s", create.kdc_name);
	ASSERT3U(namelen, <, KGPIO_DPIO_INT_NAMELEN);

	/*
	 * It is perfectly fine to create a DPIO with no flags. That is then
	 * something which is constrained with its current attributes, providing
	 * the system guarantees that it should not change, though it is a
	 * little weird.
	 */
	if ((create.kdc_flags & ~all_flags) != 0) {
		return (EINVAL);
	}

	if (kgpio->kgpio_ops->kgo_cap == NULL) {
		return (ENOTSUP);
	}
	ret = kgpio->kgpio_ops->kgo_cap(kgpio->kgpio_drv, create.kdc_id,
	    &sup_caps);
	if (ret != 0) {
		return (ret);
	}

	if ((create.kdc_flags & KGPIO_DPIO_F_READ) != 0) {
		if (kgpio->kgpio_ops->kgo_input == NULL ||
		    (sup_caps & DPIO_C_READ) == 0) {
			return (ENOTSUP);
		}
		caps |= DPIO_C_READ;
	}

	if ((create.kdc_flags & KGPIO_DPIO_F_WRITE) != 0) {
		if (kgpio->kgpio_ops->kgo_output_state == NULL ||
		    kgpio->kgpio_ops->kgo_output == NULL ||
		    (sup_caps & DPIO_C_WRITE) == 0) {
			return (ENOTSUP);
		}
		caps |= DPIO_C_WRITE;
	}

	if ((caps & DPIO_C_READ) != 0 && (sup_caps & DPIO_C_POLL) != 0) {
		caps |= DPIO_C_POLL;
	}

	/*
	 * At this point, everything that we have for the DPIO is valid. The
	 * remaining things we need to try and do are:
	 *
	 *  o Ensure that there isn't a DPIO with this name already.
	 *  o Ensure that there isn't a DPIO already using this particular
	 *    GPIO.
	 *  o Create our DPIO structure, get underlying caps, and ultimately
	 *    create our minor.
	 *
	 * To do this, we need to acquire the global lock to ensure that we
	 * don't end up racing with anyone else. We've already gotten all
	 * information that we need from the kgpio controller and because we
	 * looked up and ensured the underlying controller is held, it should
	 * not disappear on us as we drop the lock.
	 */
	mutex_exit(&kgpio->kgpio_mutex);
	mutex_enter(&kgpio_g_mutex);
	mutex_enter(&kgpio->kgpio_mutex);

	for (dpio_t *dpio = list_head(&kgpio_g_dpios); dpio != NULL;
	    dpio = list_next(&kgpio_g_dpios, dpio)) {
		if (dpio->dpio_kgpio == kgpio &&
		    dpio->dpio_gpio_num == create.kdc_id) {
			mutex_exit(&kgpio_g_mutex);
			return (EBUSY);
		}

		if (strcmp(name, dpio->dpio_name) == 0) {
			mutex_exit(&kgpio_g_mutex);
			return (EEXIST);
		}
	}

	dpio_t *dpio = kmem_zalloc(sizeof (dpio_t), KM_NOSLEEP_LAZY);
	if (dpio == NULL) {
		mutex_exit(&kgpio_g_mutex);
		return (ENOMEM);
	}

	dpio->dpio_kgpio = kgpio;
	dpio->dpio_gpio_num = create.kdc_id;
	dpio->dpio_caps = caps;
	if ((create.kdc_flags & KGPIO_DPIO_F_KERNEL) != 0) {
		dpio->dpio_flags |= DPIO_F_KERNEL;
	}
	/*
	 * Note, we have a guarantee that the name length here is less than the
	 * actual buffer size. The NUL termination comes from the kmem_zalloc
	 * earlier.
	 */
	bcopy(name, dpio->dpio_name, namelen);
	mutex_init(&dpio->dpio_mutex, NULL, MUTEX_DRIVER, NULL);

	dpio->dpio_minor.kminor_id = id_alloc_nosleep(kgpio_g_ids);
	if (dpio->dpio_minor.kminor_id == -1) {
		mutex_exit(&kgpio_g_mutex);
		kgpio_dpio_cleanup(dpio);
		return (ENOSPC);
	}
	dpio->dpio_minor.kminor_type = KGPIO_MINOR_T_DPIO;
	dpio->dpio_minor.kminor_data.kminor_dpio = dpio;

	if (ddi_create_minor_node(kgpio_g_dip, dpio->dpio_name, S_IFCHR,
	    (minor_t)dpio->dpio_minor.kminor_id, DDI_NT_GPIO_DPIO, 0) !=
	    DDI_SUCCESS) {
		mutex_exit(&kgpio_g_mutex);
		kgpio_dpio_cleanup(dpio);
		return (EIO);
	}

	list_insert_tail(&kgpio_g_dpios, dpio);
	avl_add(&kgpio_g_minors, &dpio->dpio_minor);
	kgpio->kgpio_ndpios++;
	mutex_exit(&kgpio_g_mutex);

	/*
	 * This was successful, there is one last dance that we must do. We must
	 * place a hold on the kgpio's dip. And of course, no lock holding
	 * across the ndi hold.
	 */
	mutex_exit(&kgpio->kgpio_mutex);
	e_ddi_hold_devi(kgpio->kgpio_dip);
	mutex_enter(&kgpio->kgpio_mutex);

	return (0);
}

static int
kgpio_ioctl_dpio_destroy(kgpio_t *kgpio, intptr_t arg, int mode)
{
	dpio_t *dpio;
	kgpio_dpio_destroy_t destroy;

	ASSERT(MUTEX_HELD(&kgpio->kgpio_mutex));

	if ((mode & FWRITE) == 0) {
		return (EBADF);
	}

	if (ddi_copyin((void *)arg, &destroy, sizeof (kgpio_dpio_destroy_t),
	    mode & FKIOCTL) != 0) {
		return (EFAULT);
	}

	if (destroy.kdd_id >= kgpio->kgpio_ngpios) {
		return (ENOENT);
	}

	mutex_exit(&kgpio->kgpio_mutex);
	mutex_enter(&kgpio_g_mutex);
	for (dpio = list_head(&kgpio_g_dpios); dpio != NULL;
	    dpio = list_next(&kgpio_g_dpios, dpio)) {
		if (dpio->dpio_kgpio == kgpio &&
		    dpio->dpio_gpio_num == destroy.kdd_id) {
			break;
		}
	}

	if (dpio == NULL) {
		mutex_enter(&kgpio->kgpio_mutex);
		mutex_exit(&kgpio_g_mutex);
		return (ENOENT);
	}

	if ((dpio->dpio_status & DPIO_S_OPEN) != 0) {
		mutex_enter(&kgpio->kgpio_mutex);
		mutex_exit(&kgpio_g_mutex);
		return (EBUSY);
	}

	/*
	 * OK, time to tear all this down. Remove it from global visibility as
	 * it's not open. After this point, we no longer need the kgpio_g_lock.
	 */
	list_remove(&kgpio_g_dpios, dpio);
	avl_remove(&kgpio_g_minors, &dpio->dpio_minor);
	mutex_exit(&kgpio_g_mutex);

	/*
	 * At this point, it should be safe to destroy the dpio and then clean
	 * up the remaining tracking on the kgpio. Over there, we need to need
	 * to drop our corresponding hold and decrement the overall count.
	 *
	 * To ensure that devfs notices that the minor goes away, we basically
	 * have to flag the directory for rebuild. As such, we do this somewhat
	 * via a constrained max power way -- by asking it to clean up after
	 * ourselves. This will of course be busy, but it does mean that a
	 * rebuild flag will show up.
	 */
	kgpio_dpio_cleanup(dpio);
	(void) devfs_clean(ddi_get_parent(kgpio_g_dip), "kgpio@0", 0);
	ddi_release_devi(kgpio->kgpio_dip);

	mutex_enter(&kgpio->kgpio_mutex);
	VERIFY3P(kgpio->kgpio_ndpios, >, 0);
	kgpio->kgpio_ndpios--;

	return (0);
}

static int
kgpio_ioctl_dpio_info_common(const dpio_t *dpio, dpio_info_t *infop,
    intptr_t arg, int mode)
{
	if ((mode & FREAD) == 0) {
		return (EBADF);
	}

	bcopy(dpio->dpio_kgpio->kgpio_mname, infop->dpi_ctrl,
	    sizeof (dpio->dpio_kgpio->kgpio_mname));
	infop->dpi_gpio = dpio->dpio_gpio_num;
	infop->dpi_caps = dpio->dpio_caps;
	infop->dpi_flags = dpio->dpio_flags;

	if (ddi_copyout(infop, (void *)arg, sizeof (dpio_info_t),
	    mode & FKIOCTL) != 0) {
		return (EFAULT);
	}

	return (0);
}

static int
kgpio_ioctl_dpio_info_specific(dpio_t *dpio, intptr_t arg, int mode)
{
	dpio_info_t info;

	ASSERT(MUTEX_HELD(&dpio->dpio_mutex));

	bzero(&info, sizeof (info));
	bcopy(dpio->dpio_name, info.dpi_dpio, sizeof (dpio->dpio_name));
	return (kgpio_ioctl_dpio_info_common(dpio, &info, arg, mode));
}

static int
kgpio_ioctl_dpio_time(dpio_t *dpio, intptr_t arg, int mode)
{
	dpio_timing_t time;

	ASSERT(MUTEX_HELD(&dpio->dpio_mutex));

	if ((mode & FREAD) == 0) {
		return (EBADF);
	}

	bzero(&time, sizeof (time));
	time.dpt_last_input_intr = dpio->dpio_last_intr;
	time.dpt_last_write = dpio->dpio_last_write;

	if (ddi_copyout(&time, (void *)arg, sizeof (dpio_timing_t),
	    mode & FKIOCTL) != 0) {
		return (EFAULT);
	}

	return (0);
}

static int
kgpio_ioctl_dpio_curout(dpio_t *dpio, intptr_t arg, int mode)
{
	int ret;
	dpio_curout_t curout;
	kgpio_t *kgpio = dpio->dpio_kgpio;

	ASSERT(MUTEX_HELD(&dpio->dpio_mutex));

	if ((mode & FREAD) == 0) {
		return (EBADF);
	}

	bzero(&curout, sizeof (curout));
	if ((dpio->dpio_caps & DPIO_C_WRITE) == 0) {
		return (ENOTSUP);
	}

	mutex_exit(&dpio->dpio_mutex);
	mutex_enter(&kgpio->kgpio_mutex);
	ret = kgpio->kgpio_ops->kgo_output_state(kgpio->kgpio_drv,
	    dpio->dpio_gpio_num, &curout.dps_curout);
	mutex_exit(&kgpio->kgpio_mutex);
	mutex_enter(&dpio->dpio_mutex);

	if (ret != 0) {
		return (ret);

	}

	if (ddi_copyout(&curout, (void *)arg, sizeof (dpio_curout_t),
	    mode & FKIOCTL) != 0) {
		return (EFAULT);
	}

	return (0);
}

static int
kgpio_ioctl_dpio_info_search(intptr_t arg, int mode)
{
	size_t len;
	dpio_info_t info;

	ASSERT(MUTEX_HELD(&kgpio_g_mutex));

	if (ddi_copyin((void *)arg, &info, sizeof (dpio_info_t),
	    mode & FKIOCTL) != 0) {
		return (EFAULT);
	}

	len = strnlen(info.dpi_dpio, sizeof (info.dpi_dpio));
	if (len == 0 || len == sizeof (info.dpi_dpio)) {
		return (EINVAL);
	}

	for (dpio_t *dpio = list_head(&kgpio_g_dpios); dpio != NULL;
	    dpio = list_next(&kgpio_g_dpios, dpio)) {
		if (strcmp(dpio->dpio_name, info.dpi_dpio) == 0) {
			return (kgpio_ioctl_dpio_info_common(dpio, &info, arg,
			    mode));
		}
	}

	return (ENOENT);
}

static int
kgpio_ioctl_gpio_name2id(kgpio_t *kgpio, intptr_t arg, int mode)
{
	int ret;
	kgpio_ioc_name2id_t id;
	size_t len;

	ASSERT(MUTEX_HELD(&kgpio->kgpio_mutex));

	if ((mode & FREAD) == 0) {
		return (EBADF);
	}

	if (ddi_copyin((void *)arg, &id, sizeof (id), mode & FKIOCTL) != 0) {
		return (EFAULT);
	}

	len = strnlen(id.kin_name, sizeof (id.kin_name));
	if (len == 0 || len == sizeof (id.kin_name)) {
		return (EINVAL);
	}

	ret = kgpio->kgpio_ops->kgo_name2id(kgpio->kgpio_drv, id.kin_name,
	    &id.kin_id);
	if (ret != 0) {
		return (ret);
	}

	if (ddi_copyout(&id, (void *)arg, sizeof (id), mode & FKIOCTL) != 0) {
		return (EFAULT);
	}

	return (0);
}

static int
kgpio_ioctl(dev_t dev, int cmd, intptr_t arg, int mode, cred_t *credp,
    int *rvalp)
{
	int ret;
	kgpio_minor_t *minor;
	kgpio_t *kgpio;
	dpio_t *dpio;

	mutex_enter(&kgpio_g_mutex);
	minor = kgpio_minor_find((id_t)getminor(dev));
	VERIFY3P(minor, !=, NULL);
	switch (minor->kminor_type) {
	case KGPIO_MINOR_T_CTRL:
		kgpio = minor->kminor_data.kminor_ctrl;
		VERIFY3P(kgpio, !=, NULL);

		mutex_enter(&kgpio->kgpio_mutex);
		mutex_exit(&kgpio_g_mutex);
		ASSERT(kgpio->kgpio_flags & KGPIO_F_VALID);
		ASSERT(kgpio->kgpio_flags & KGPIO_F_HELD);

		switch (cmd) {
		case KGPIO_IOC_CTRL_INFO:
			ret = kgpio_ioctl_ctrl_info(kgpio, arg, mode);
			break;
		case KGPIO_IOC_GPIO_INFO:
			ret = kgpio_ioctl_gpio_info(kgpio, arg, mode);
			break;
		case KGPIO_IOC_GPIO_UPDATE:
			ret = kgpio_ioctl_gpio_update(kgpio, arg, mode);
			break;
		case KGPIO_IOC_DPIO_CREATE:
			ret = kgpio_ioctl_dpio_create(kgpio, arg, mode);
			break;
		case KGPIO_IOC_DPIO_DESTROY:
			ret = kgpio_ioctl_dpio_destroy(kgpio, arg, mode);
			break;
		case KGPIO_IOC_GPIO_NAME2ID:
			ret = kgpio_ioctl_gpio_name2id(kgpio, arg, mode);
			break;
		default:
			ret = ENOTTY;
			break;
		}

		mutex_exit(&kgpio->kgpio_mutex);
		break;
	case KGPIO_MINOR_T_DPIO:
		dpio = minor->kminor_data.kminor_dpio;
		VERIFY3P(dpio, !=, NULL);
		mutex_enter(&dpio->dpio_mutex);
		mutex_exit(&kgpio_g_mutex);

		switch (cmd) {
		case DPIO_IOC_INFO:
			ret = kgpio_ioctl_dpio_info_specific(dpio, arg, mode);
			break;
		case DPIO_IOC_TIMING:
			ret = kgpio_ioctl_dpio_time(dpio, arg, mode);
			break;
		case DPIO_IOC_CUROUT:
			ret = kgpio_ioctl_dpio_curout(dpio, arg, mode);
			break;
		default:
			ret = ENOTTY;
			break;
		}
		mutex_exit(&dpio->dpio_mutex);
		break;
	case KGPIO_MINOR_T_DPINFO:
		switch (cmd) {
		case DPIO_IOC_INFO:
			ret = kgpio_ioctl_dpio_info_search(arg, mode);
			break;
		default:
			ret = ENOTTY;
			break;
		}
		mutex_exit(&kgpio_g_mutex);
		break;
	default:
		mutex_exit(&kgpio_g_mutex);
		return (ENXIO);
	}
	return (ret);
}

static int
kgpio_read(dev_t dev, struct uio *uiop, cred_t *credp)
{
	int ret;
	kgpio_minor_t *minor;
	dpio_t *dpio;
	kgpio_t *kgpio;
	dpio_input_t input;
	offset_t off;

	mutex_enter(&kgpio_g_mutex);
	minor = kgpio_minor_find((id_t)getminor(dev));
	VERIFY3P(minor, !=, NULL);

	if (minor->kminor_type != KGPIO_MINOR_T_DPIO) {
		mutex_exit(&kgpio_g_mutex);
		return (ENXIO);
	}

	dpio = minor->kminor_data.kminor_dpio;
	VERIFY3P(dpio, !=, NULL);
	mutex_exit(&kgpio_g_mutex);

	if ((dpio->dpio_caps & DPIO_C_READ) == 0) {
		return (ENOTSUP);
	}

	if (uiop->uio_resid <= 0) {
		return (EINVAL);
	}

	if (uiop->uio_resid < sizeof (input)) {
		return (EOVERFLOW);
	}

	kgpio = dpio->dpio_kgpio;
	mutex_enter(&kgpio->kgpio_mutex);
	ret = kgpio->kgpio_ops->kgo_input(kgpio->kgpio_drv, dpio->dpio_gpio_num,
	    &input);
	mutex_exit(&kgpio->kgpio_mutex);
	if (ret != 0) {
		return (ret);
	}

	off = uiop->uio_loffset;
	ret = uiomove(&input, sizeof (input), UIO_READ, uiop);
	uiop->uio_loffset = off;

	return (ret);
}

static int
kgpio_write(dev_t dev, struct uio *uiop, cred_t *credp)
{
	int ret;
	kgpio_minor_t *minor;
	dpio_t *dpio;
	kgpio_t *kgpio;
	dpio_output_t output;
	offset_t off;

	mutex_enter(&kgpio_g_mutex);
	minor = kgpio_minor_find((id_t)getminor(dev));
	VERIFY3P(minor, !=, NULL);

	if (minor->kminor_type != KGPIO_MINOR_T_DPIO) {
		mutex_exit(&kgpio_g_mutex);
		return (ENXIO);
	}

	dpio = minor->kminor_data.kminor_dpio;
	VERIFY3P(dpio, !=, NULL);
	mutex_exit(&kgpio_g_mutex);

	if ((dpio->dpio_caps & DPIO_C_WRITE) == 0) {
		return (ENOTSUP);
	}

	if (uiop->uio_resid < sizeof (output)) {
		return (EINVAL);
	}

	off = uiop->uio_loffset;
	ret = uiomove(&output, sizeof (output), UIO_WRITE, uiop);
	uiop->uio_loffset = off;
	if (ret != 0) {
		return (ret);
	}

	switch (output) {
	case DPIO_OUTPUT_LOW:
	case DPIO_OUTPUT_HIGH:
	case DPIO_OUTPUT_DISABLE:
		break;
	default:
		return (EINVAL);
	}

	kgpio = dpio->dpio_kgpio;
	mutex_enter(&kgpio->kgpio_mutex);
	ret = kgpio->kgpio_ops->kgo_output(kgpio->kgpio_drv,
	    dpio->dpio_gpio_num, output);
	mutex_exit(&kgpio->kgpio_mutex);

	if (ret == 0) {
		mutex_enter(&dpio->dpio_mutex);
		dpio->dpio_last_write = gethrtime();
		mutex_exit(&dpio->dpio_mutex);
	}

	return (ret);
}

static int
kgpio_close(dev_t dev, int flag, int otyp, cred_t *credp)
{
	kgpio_minor_t *minor;
	kgpio_t *kgpio;
	dpio_t *dpio;

	if (otyp != OTYP_CHR) {
		return (EINVAL);
	}

	mutex_enter(&kgpio_g_mutex);
	minor = kgpio_minor_find((id_t)getminor(dev));
	VERIFY3P(minor, !=, NULL);
	switch (minor->kminor_type) {
	case KGPIO_MINOR_T_CTRL:
		kgpio = minor->kminor_data.kminor_ctrl;
		VERIFY3P(kgpio, !=, NULL);

		mutex_enter(&kgpio->kgpio_mutex);
		ASSERT(kgpio->kgpio_flags & KGPIO_F_VALID);
		ASSERT(kgpio->kgpio_flags & KGPIO_F_HELD);

		/*
		 * The system guarantees that we are mutually exclusive with
		 * open(9E).  As such, it's safe for us to go ahead and clear
		 * this out. Note, we drop all of our locks to honor the general
		 * lock ordering of no NDI activity with locks held.
		 */
		mutex_exit(&kgpio_g_mutex);
		mutex_exit(&kgpio->kgpio_mutex);

		kgpio_release(kgpio);
		return (0);
	case KGPIO_MINOR_T_DPIO:
		dpio = minor->kminor_data.kminor_dpio;
		VERIFY3P(dpio, !=, NULL);
		mutex_enter(&dpio->dpio_mutex);
		mutex_exit(&kgpio_g_mutex);

		/*
		 * Because of the last-close style behavior, the only thing that
		 * we need to do is to make sure that we clear out our state
		 * flags and indicate that we are no longer open and no longer
		 * exclusive, if we were.
		 */
		dpio->dpio_status &= ~(DPIO_S_EXCL | DPIO_S_OPEN);
		mutex_exit(&dpio->dpio_mutex);
		return (0);
	case KGPIO_MINOR_T_DPINFO:
		mutex_exit(&kgpio_g_mutex);
		/*
		 * There is nothing special to do to close the dpio information
		 * based minor device as there is no state or other logic
		 * associated with it.
		 */
		return (0);
	default:
		mutex_exit(&kgpio_g_mutex);
		return (ENXIO);
	}
}

static int
kgpio_attach(dev_info_t *dip, ddi_attach_cmd_t cmd)
{
	switch (cmd) {
	case DDI_ATTACH:
		break;
	case DDI_RESUME:
		return (DDI_SUCCESS);
	default:
		return (DDI_FAILURE);
	}

	if (ddi_get_instance(dip) != 0) {
		dev_err(dip, CE_WARN, "asked to attach non-zero instance");
		return (DDI_FAILURE);
	}

	mutex_enter(&kgpio_g_mutex);
	if (kgpio_g_dip != NULL) {
		mutex_exit(&kgpio_g_mutex);
		dev_err(dip, CE_WARN, "asked to attach a second kgpio "
		    "instance");
		return (DDI_FAILURE);
	}

	/*
	 * Set up the dpio minor, which always uses minor number 1, note this is
	 * reserved outside of the id_space, so we don't have to allocate or
	 * worry about failure.
	 */
	if (ddi_create_minor_node(dip, KGPIO_MINOR_NAME_DPINFO, S_IFCHR,
	    KGPIO_MINOR_DPINFO, DDI_PSEUDO, 0) != 0) {
		dev_err(dip, CE_WARN, "failed to create dpinfo minor");
		mutex_exit(&kgpio_g_mutex);
		return (DDI_FAILURE);
	}

	kgpio_g_dpinfo.kminor_id = KGPIO_MINOR_DPINFO;
	kgpio_g_dpinfo.kminor_type = KGPIO_MINOR_T_DPINFO;
	avl_add(&kgpio_g_minors, &kgpio_g_dpinfo);
	kgpio_g_dip = dip;

	/*
	 * At this point, we need to check for any drivers that beat us and
	 * register them.
	 */
	for (kgpio_t *k = list_head(&kgpio_g_gpios); k != NULL;
	    k = list_next(&kgpio_g_gpios, k)) {
		mutex_enter(&k->kgpio_mutex);
		ASSERT0(k->kgpio_flags & KGPIO_F_MINOR_VALID);
		kgpio_create_minor(k);
		mutex_exit(&k->kgpio_mutex);
	}
	mutex_exit(&kgpio_g_mutex);
	return (DDI_SUCCESS);
}

static int
kgpio_getinfo(dev_info_t *dip, ddi_info_cmd_t cmd, void *arg, void **resultp)
{
	switch (cmd) {
	case DDI_INFO_DEVT2DEVINFO:
		*resultp = kgpio_g_dip;
		break;
	case DDI_INFO_DEVT2INSTANCE:
		*resultp = (void *)(uintptr_t)ddi_get_instance(kgpio_g_dip);
		break;
	default:
		return (DDI_FAILURE);
	}

	return (DDI_SUCCESS);
}

static int
kgpio_detach(dev_info_t *dip, ddi_detach_cmd_t cmd)
{
	switch (cmd) {
	case DDI_DETACH:
		break;
	case DDI_SUSPEND:
		return (DDI_SUCCESS);
	default:
		return (DDI_FAILURE);
	}

	mutex_enter(&kgpio_g_mutex);
	if (dip != kgpio_g_dip) {
		mutex_exit(&kgpio_g_mutex);
		dev_err(dip, CE_WARN, "asked to detach dip that is not the "
		    "current kgpio dip");
		return (DDI_FAILURE);
	}

	if (list_is_empty(&kgpio_g_gpios) == 0) {
		mutex_exit(&kgpio_g_mutex);
		return (DDI_FAILURE);
	}

	avl_remove(&kgpio_g_minors, &kgpio_g_dpinfo);
	ddi_remove_minor_node(dip, KGPIO_MINOR_NAME_DPINFO);
	kgpio_g_dip = NULL;
	mutex_exit(&kgpio_g_mutex);
	return (DDI_SUCCESS);
}

static struct cb_ops kgpio_cb_ops = {
	.cb_open = kgpio_open,
	.cb_close = kgpio_close,
	.cb_strategy = nodev,
	.cb_print = nodev,
	.cb_dump = nodev,
	.cb_read = kgpio_read,
	.cb_write = kgpio_write,
	.cb_ioctl = kgpio_ioctl,
	.cb_devmap = nodev,
	.cb_mmap = nodev,
	.cb_segmap = nodev,
	.cb_chpoll = nochpoll,
	.cb_prop_op = ddi_prop_op,
	.cb_flag = D_MP,
	.cb_rev = CB_REV,
	.cb_aread = nodev,
	.cb_awrite = nodev
};

static struct dev_ops kgpio_dev_ops = {
	.devo_rev = DEVO_REV,
	.devo_refcnt = 0,
	.devo_getinfo = kgpio_getinfo,
	.devo_identify = nulldev,
	.devo_probe = nulldev,
	.devo_attach = kgpio_attach,
	.devo_detach = kgpio_detach,
	.devo_reset = nodev,
	.devo_quiesce = ddi_quiesce_not_needed,
	.devo_cb_ops = &kgpio_cb_ops
};

static struct modldrv kgpio_modldrv = {
	.drv_modops = &mod_driverops,
	.drv_linkinfo = "Kernel GPIO Framework",
	.drv_dev_ops = &kgpio_dev_ops
};

static struct modlinkage kgpio_modlinkage = {
	.ml_rev = MODREV_1,
	.ml_linkage = { &kgpio_modldrv, NULL }
};

static void
kgpio_init(void)
{
	mutex_init(&kgpio_g_mutex, NULL, MUTEX_DRIVER, NULL);
	list_create(&kgpio_g_gpios, sizeof (kgpio_t),
	    offsetof(kgpio_t, kgpio_link));
	list_create(&kgpio_g_dpios, sizeof (dpio_t),
	    offsetof(dpio_t, dpio_link));
	avl_create(&kgpio_g_minors, kgpio_minor_comparator,
	    sizeof (kgpio_minor_t), offsetof(kgpio_minor_t, kminor_avl));
	kgpio_g_ids = id_space_create("kgpios", KGPIO_MINOR_FIRST, L_MAXMIN32);
}

static void
kgpio_fini(void)
{
	id_space_destroy(kgpio_g_ids);
	avl_destroy(&kgpio_g_minors);
	list_destroy(&kgpio_g_dpios);
	list_destroy(&kgpio_g_gpios);
	mutex_destroy(&kgpio_g_mutex);
}

int
_init(void)
{
	int err;

	kgpio_init();
	err = mod_install(&kgpio_modlinkage);
	if (err != 0) {
		kgpio_fini();
		return (err);
	}

	return (0);
}

int
_info(struct modinfo *modinfop)
{
	return (mod_info(&kgpio_modlinkage, modinfop));
}

int
_fini(void)
{
	int err;

	mutex_enter(&kgpio_g_mutex);
	if (list_is_empty(&kgpio_g_gpios) == 0) {
		mutex_exit(&kgpio_g_mutex);
		return (EBUSY);
	}
	mutex_exit(&kgpio_g_mutex);


	err = mod_remove(&kgpio_modlinkage);
	if (err != 0) {
		return (err);
	}

	kgpio_fini();
	return (0);
}