[dragonfly.git] / sys / dev / misc / gpio / gpio_led.c

/*
 * Copyright (c) 2009 The DragonFly Project.  All rights reserved.
 *
 * This code is derived from software contributed to The DragonFly Project
 * by Alex Hornung <ahornung@gmail.com>
 *
 * 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.
 * 3. Neither the name of The DragonFly Project nor the names of its
 *    contributors may be used to endorse or promote products derived
 *    from this software without specific, prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS 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
 * COPYRIGHT HOLDERS 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.
 */

#include <sys/param.h>
#include <sys/conf.h>
#include <sys/kernel.h>
#include <sys/systm.h>
#include <sys/limits.h>
#include <sys/malloc.h>
#include <sys/ctype.h>
#include <sys/sbuf.h>
#include <sys/queue.h>
#include <dev/misc/gpio/gpio.h>
#include <sys/uio.h>
#include <sys/lock.h>
#include <sys/devfs.h>

struct ledsc {
	LIST_ENTRY(ledsc)	list;
	struct gpio *gp;
	int		pin;
	cdev_t	dev;
	int		unit;
	int		opened;
	char	*name;
	struct gpio_mapping *gp_map;
};

DEVFS_DECLARE_CLONE_BITMAP(nled);
static struct lock led_lock;
static LIST_HEAD(, ledsc) led_list = LIST_HEAD_INITIALIZER(&led_list);
static MALLOC_DEFINE(M_LED, "LED", "LED driver");


static int
led_open(struct dev_open_args *ap)
{
	struct ledsc *sc;
	cdev_t	dev;

	dev = ap->a_head.a_dev;
	sc = dev->si_drv1;

	if (sc->opened)
		return EBUSY;

	sc->opened = 1;

	return 0;
}

static int
led_close(struct dev_close_args *ap)
{
	struct ledsc *sc;
	cdev_t	dev;

	dev = ap->a_head.a_dev;
	sc = dev->si_drv1;

	if (sc->opened)
		sc->opened = 0;

	return 0;
}

static int
led_write(struct dev_write_args *ap)
{
	struct ledsc *sc;
	cdev_t	dev;
	int		error;
	int		data = 0;
	int		len;

	dev = ap->a_head.a_dev;
	sc = dev->si_drv1;

	if (ap->a_uio->uio_resid > sizeof(int))
		return EINVAL;

	len = ap->a_uio->uio_resid;

	error = uiomove((void *)&data, ap->a_uio->uio_resid, ap->a_uio);
	if (error)
		return error;

	if (len > 1)
		data = ((char *)&data)[0];

	if (data >= '0')
		data -= '0';

	gpio_pin_write(sc->gp, sc->gp_map, 0, data);

	return 0;
}

static int
led_read(struct dev_read_args *ap)
{
	struct ledsc *sc;
	cdev_t	dev;
	int		error;
	int		data = 0;

	dev = ap->a_head.a_dev;
	sc = dev->si_drv1;

	if (ap->a_uio->uio_resid < sizeof(int))
		return EINVAL;

	data = gpio_pin_read(sc->gp, sc->gp_map, 0);

	error = uiomove((void *)&data,
	    (ap->a_uio->uio_resid > sizeof(int))?(sizeof(int)):(ap->a_uio->uio_resid),
		ap->a_uio);

	return error;
}

static int
led_ioctl(struct dev_ioctl_args *ap)
{
	/* XXX: set a name */
	return 0;
}

static struct dev_ops nled_ops = {
	{ "gpio", 0, 0 },
	.d_open  =	led_open,
	.d_close =	led_close,
	.d_write = 	led_write,
	.d_read  =	led_read,
	.d_ioctl =	led_ioctl,
};


static int
led_attach(struct gpio *gp, void *arg, int pin, u_int32_t mask)
{
	struct ledsc *sc;

	if (arg == NULL)
		return 1;

	lockmgr(&led_lock, LK_EXCLUSIVE);
	sc = kmalloc(sizeof(struct ledsc), M_LED, M_WAITOK);

	/* XXX: check for name collisions */
	sc->name = kstrdup((char *)arg, M_LED);
	sc->pin = pin;
	sc->gp = gp;

	sc->gp_map = gpio_map(gp, NULL, pin, 1);
	if (sc->gp_map == NULL) {
		lockmgr(&led_lock, LK_RELEASE);
		return 2;
	}

	sc->unit = devfs_clone_bitmap_get(&DEVFS_CLONE_BITMAP(nled), 0);

	LIST_INSERT_HEAD(&led_list, sc, list);
	sc->dev = make_dev(&nled_ops, sc->unit,
	    UID_ROOT, GID_WHEEL, 0600, "led/%s", sc->name);
	sc->dev->si_drv1 = sc;
	lockmgr(&led_lock, LK_RELEASE);

	kprintf("gpio_led: Attached led '%s' to gpio %s, pin %d\n",
	    sc->name, sc->gp->driver_name, pin);

	return 0;
}

static int
led_detach(struct gpio *gp, void *arg, int pin)
{
	/* XXX: implement */
	return 0;
}

void
led_switch(const char *name, int on_off)
{
	struct ledsc *sc;

	if (name == NULL)
		return;

	lockmgr(&led_lock, LK_EXCLUSIVE);
	LIST_FOREACH(sc, &led_list, list) {
		if (strcmp(name, sc->name) != 0)
			continue;

		gpio_pin_write(sc->gp, sc->gp_map, 0, on_off);
		break;
	}

	lockmgr(&led_lock, LK_RELEASE);
}

struct gpio_consumer led_gpio_cons = {
	.consumer_name = "led",
	.consumer_attach = led_attach,
	.consumer_detach = led_detach,
};

static void
led_drvinit(void *unused)
{
	lockinit(&led_lock, "led_lock", 0, 0);
	devfs_clone_bitmap_init(&DEVFS_CLONE_BITMAP(nled));
	gpio_consumer_register(&led_gpio_cons);
}

SYSINIT(leddev, SI_SUB_DRIVERS, SI_ORDER_MIDDLE, led_drvinit, NULL);
Commit	Line	Data
a0e087c3 AH	1	/*
	2	* Copyright (c) 2009 The DragonFly Project. All rights reserved.
	3	*
	4	* This code is derived from software contributed to The DragonFly Project
	5	* by Alex Hornung <ahornung@gmail.com>
	6	*
	7	* Redistribution and use in source and binary forms, with or without
	8	* modification, are permitted provided that the following conditions
	9	* are met:
	10	*
	11	* 1. Redistributions of source code must retain the above copyright
	12	* notice, this list of conditions and the following disclaimer.
	13	* 2. Redistributions in binary form must reproduce the above copyright
	14	* notice, this list of conditions and the following disclaimer in
	15	* the documentation and/or other materials provided with the
	16	* distribution.
	17	* 3. Neither the name of The DragonFly Project nor the names of its
	18	* contributors may be used to endorse or promote products derived
	19	* from this software without specific, prior written permission.
	20	*
	21	* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
	22	* ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
	23	* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
	24	* FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
	25	* COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
	26	* INCIDENTAL, SPECIAL, EXEMPLARY OR CONSEQUENTIAL DAMAGES (INCLUDING,
	27	* BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
	28	* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
	29	* AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
	30	* OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
	31	* OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
	32	* SUCH DAMAGE.
	33	*/
	34
a0e087c3 AH	35	#include <sys/param.h>
	36	#include <sys/conf.h>
	37	#include <sys/kernel.h>
	38	#include <sys/systm.h>
	39	#include <sys/limits.h>
	40	#include <sys/malloc.h>
	41	#include <sys/ctype.h>
	42	#include <sys/sbuf.h>
	43	#include <sys/queue.h>
	44	#include <dev/misc/gpio/gpio.h>
	45	#include <sys/uio.h>
	46	#include <sys/lock.h>
	47	#include <sys/devfs.h>
	48
	49	struct ledsc {
	50	LIST_ENTRY(ledsc) list;
	51	struct gpio *gp;
	52	int pin;
	53	cdev_t dev;
	54	int unit;
	55	int opened;
	56	char *name;
	57	struct gpio_mapping *gp_map;
	58	};
	59
	60	DEVFS_DECLARE_CLONE_BITMAP(nled);
	61	static struct lock led_lock;
	62	static LIST_HEAD(, ledsc) led_list = LIST_HEAD_INITIALIZER(&led_list);
	63	static MALLOC_DEFINE(M_LED, "LED", "LED driver");
	64
	65
	66	static int
	67	led_open(struct dev_open_args *ap)
	68	{
	69	struct ledsc *sc;
	70	cdev_t dev;
	71
	72	dev = ap->a_head.a_dev;
	73	sc = dev->si_drv1;
	74
	75	if (sc->opened)
	76	return EBUSY;
	77
	78	sc->opened = 1;
	79
	80	return 0;
	81	}
	82
	83	static int
	84	led_close(struct dev_close_args *ap)
	85	{
	86	struct ledsc *sc;
	87	cdev_t dev;
	88
	89	dev = ap->a_head.a_dev;
	90	sc = dev->si_drv1;
	91
	92	if (sc->opened)
	93	sc->opened = 0;
	94
	95	return 0;
	96	}
	97
	98	static int
99	led_write(struct dev_write_args *ap)
100	{
101	struct ledsc *sc;
102	cdev_t dev;
103	int error;
104	int data = 0;
105	int len;
106
107	dev = ap->a_head.a_dev;
108	sc = dev->si_drv1;
109
110	if (ap->a_uio->uio_resid > sizeof(int))
111	return EINVAL;
112
113	len = ap->a_uio->uio_resid;
114
115	error = uiomove((void *)&data, ap->a_uio->uio_resid, ap->a_uio);
116	if (error)
117	return error;
118
119	if (len > 1)
120	data = ((char *)&data)[0];
121
122	if (data >= '0')
123	data -= '0';
124
125	gpio_pin_write(sc->gp, sc->gp_map, 0, data);
126
127	return 0;
128	}
129
130	static int
131	led_read(struct dev_read_args *ap)
132	{
133	struct ledsc *sc;
134	cdev_t dev;
135	int error;
136	int data = 0;
137
138	dev = ap->a_head.a_dev;
139	sc = dev->si_drv1;
140
141	if (ap->a_uio->uio_resid < sizeof(int))
142	return EINVAL;
143
144	data = gpio_pin_read(sc->gp, sc->gp_map, 0);
145
146	error = uiomove((void *)&data,
147	(ap->a_uio->uio_resid > sizeof(int))?(sizeof(int)):(ap->a_uio->uio_resid),
148	ap->a_uio);
149
150	return error;
151	}
152
153	static int
154	led_ioctl(struct dev_ioctl_args *ap)
155	{
156	/* XXX: set a name */
157	return 0;
158	}
159
160	static struct dev_ops nled_ops = {
161	{ "gpio", 0, 0 },
162	.d_open = led_open,
163	.d_close = led_close,
164	.d_write = led_write,
165	.d_read = led_read,
166	.d_ioctl = led_ioctl,
167	};
168
169
170	static int
171	led_attach(struct gpio gp, void arg, int pin, u_int32_t mask)
172	{
173	struct ledsc *sc;
174
175	if (arg == NULL)
176	return 1;
177
178	lockmgr(&led_lock, LK_EXCLUSIVE);
179	sc = kmalloc(sizeof(struct ledsc), M_LED, M_WAITOK);
180
181	/* XXX: check for name collisions */
182	sc->name = kstrdup((char *)arg, M_LED);
183	sc->pin = pin;
184	sc->gp = gp;
185
186	sc->gp_map = gpio_map(gp, NULL, pin, 1);
187	if (sc->gp_map == NULL) {
2d12c69a	188	lockmgr(&led_lock, LK_RELEASE);
a0e087c3 AH	189	return 2;
	190	}
	191
	192	sc->unit = devfs_clone_bitmap_get(&DEVFS_CLONE_BITMAP(nled), 0);
	193
	194	LIST_INSERT_HEAD(&led_list, sc, list);
	195	sc->dev = make_dev(&nled_ops, sc->unit,
	196	UID_ROOT, GID_WHEEL, 0600, "led/%s", sc->name);
	197	sc->dev->si_drv1 = sc;
	198	lockmgr(&led_lock, LK_RELEASE);
	199
	200	kprintf("gpio_led: Attached led '%s' to gpio %s, pin %d\n",
	201	sc->name, sc->gp->driver_name, pin);
	202
	203	return 0;
	204	}
	205
92b817bb	206	static int
a0e087c3 AH	207	led_detach(struct gpio gp, void arg, int pin)
	208	{
	209	/* XXX: implement */
92b817bb	210	return 0;
a0e087c3 AH	211	}
	212
	213	void
	214	led_switch(const char *name, int on_off)
	215	{
	216	struct ledsc *sc;
	217
	218	if (name == NULL)
	219	return;
	220
	221	lockmgr(&led_lock, LK_EXCLUSIVE);
	222	LIST_FOREACH(sc, &led_list, list) {
	223	if (strcmp(name, sc->name) != 0)
	224	continue;
	225
	226	gpio_pin_write(sc->gp, sc->gp_map, 0, on_off);
	227	break;
	228	}
	229
	230	lockmgr(&led_lock, LK_RELEASE);
	231	}
	232
	233	struct gpio_consumer led_gpio_cons = {
	234	.consumer_name = "led",
	235	.consumer_attach = led_attach,
	236	.consumer_detach = led_detach,
	237	};
	238
	239	static void
	240	led_drvinit(void *unused)
	241	{
	242	lockinit(&led_lock, "led_lock", 0, 0);
	243	devfs_clone_bitmap_init(&DEVFS_CLONE_BITMAP(nled));
	244	gpio_consumer_register(&led_gpio_cons);
	245	}
	246
	247	SYSINIT(leddev, SI_SUB_DRIVERS, SI_ORDER_MIDDLE, led_drvinit, NULL);