[linux.git] / drivers / gpio / gpio-viperboard.c

/*
 *  Nano River Technologies viperboard GPIO lib driver
 *
 *  (C) 2012 by Lemonage GmbH
 *  Author: Lars Poeschel <[email protected]>
 *  All rights reserved.
 *
 *  This program is free software; you can redistribute  it and/or modify it
 *  under  the terms of  the GNU General  Public License as published by the
 *  Free Software Foundation;  either version 2 of the	License, or (at your
 *  option) any later version.
 *
 */

#include <linux/kernel.h>
#include <linux/errno.h>
#include <linux/module.h>
#include <linux/slab.h>
#include <linux/types.h>
#include <linux/mutex.h>
#include <linux/platform_device.h>

#include <linux/usb.h>
#include <linux/gpio.h>

#include <linux/mfd/viperboard.h>

#define VPRBRD_GPIOA_CLK_1MHZ		0
#define VPRBRD_GPIOA_CLK_100KHZ		1
#define VPRBRD_GPIOA_CLK_10KHZ		2
#define VPRBRD_GPIOA_CLK_1KHZ		3
#define VPRBRD_GPIOA_CLK_100HZ		4
#define VPRBRD_GPIOA_CLK_10HZ		5

#define VPRBRD_GPIOA_FREQ_DEFAULT	1000

#define VPRBRD_GPIOA_CMD_CONT		0x00
#define VPRBRD_GPIOA_CMD_PULSE		0x01
#define VPRBRD_GPIOA_CMD_PWM		0x02
#define VPRBRD_GPIOA_CMD_SETOUT		0x03
#define VPRBRD_GPIOA_CMD_SETIN		0x04
#define VPRBRD_GPIOA_CMD_SETINT		0x05
#define VPRBRD_GPIOA_CMD_GETIN		0x06

#define VPRBRD_GPIOB_CMD_SETDIR		0x00
#define VPRBRD_GPIOB_CMD_SETVAL		0x01

struct vprbrd_gpioa_msg {
	u8 cmd;
	u8 clk;
	u8 offset;
	u8 t1;
	u8 t2;
	u8 invert;
	u8 pwmlevel;
	u8 outval;
	u8 risefall;
	u8 answer;
	u8 __fill;
} __packed;

struct vprbrd_gpiob_msg {
	u8 cmd;
	u16 val;
	u16 mask;
} __packed;

struct vprbrd_gpio {
	struct gpio_chip gpioa; /* gpio a related things */
	u32 gpioa_out;
	u32 gpioa_val;
	struct gpio_chip gpiob; /* gpio b related things */
	u32 gpiob_out;
	u32 gpiob_val;
	struct vprbrd *vb;
};

/* gpioa sampling clock module parameter */
static unsigned char gpioa_clk;
static unsigned int gpioa_freq = VPRBRD_GPIOA_FREQ_DEFAULT;
module_param(gpioa_freq, uint, 0);
MODULE_PARM_DESC(gpioa_freq,
	"gpio-a sampling freq in Hz (default is 1000Hz) valid values: 10, 100, 1000, 10000, 100000, 1000000");

/* ----- begin of gipo a chip -------------------------------------------- */

static int vprbrd_gpioa_get(struct gpio_chip *chip,
		unsigned offset)
{
	int ret, answer, error = 0;
	struct vprbrd_gpio *gpio = gpiochip_get_data(chip);
	struct vprbrd *vb = gpio->vb;
	struct vprbrd_gpioa_msg *gamsg = (struct vprbrd_gpioa_msg *)vb->buf;

	/* if io is set to output, just return the saved value */
	if (gpio->gpioa_out & (1 << offset))
		return !!(gpio->gpioa_val & (1 << offset));

	mutex_lock(&vb->lock);

	gamsg->cmd = VPRBRD_GPIOA_CMD_GETIN;
	gamsg->clk = 0x00;
	gamsg->offset = offset;
	gamsg->t1 = 0x00;
	gamsg->t2 = 0x00;
	gamsg->invert = 0x00;
	gamsg->pwmlevel = 0x00;
	gamsg->outval = 0x00;
	gamsg->risefall = 0x00;
	gamsg->answer = 0x00;
	gamsg->__fill = 0x00;

	ret = usb_control_msg(vb->usb_dev, usb_sndctrlpipe(vb->usb_dev, 0),
		VPRBRD_USB_REQUEST_GPIOA, VPRBRD_USB_TYPE_OUT, 0x0000,
		0x0000, gamsg, sizeof(struct vprbrd_gpioa_msg),
		VPRBRD_USB_TIMEOUT_MS);
	if (ret != sizeof(struct vprbrd_gpioa_msg))
		error = -EREMOTEIO;

	ret = usb_control_msg(vb->usb_dev, usb_rcvctrlpipe(vb->usb_dev, 0),
		VPRBRD_USB_REQUEST_GPIOA, VPRBRD_USB_TYPE_IN, 0x0000,
		0x0000, gamsg, sizeof(struct vprbrd_gpioa_msg),
		VPRBRD_USB_TIMEOUT_MS);
	answer = gamsg->answer & 0x01;

	mutex_unlock(&vb->lock);

	if (ret != sizeof(struct vprbrd_gpioa_msg))
		error = -EREMOTEIO;

	if (error)
		return error;

	return answer;
}

static void vprbrd_gpioa_set(struct gpio_chip *chip,
		unsigned offset, int value)
{
	int ret;
	struct vprbrd_gpio *gpio = gpiochip_get_data(chip);
	struct vprbrd *vb = gpio->vb;
	struct vprbrd_gpioa_msg *gamsg = (struct vprbrd_gpioa_msg *)vb->buf;

	if (gpio->gpioa_out & (1 << offset)) {
		if (value)
			gpio->gpioa_val |= (1 << offset);
		else
			gpio->gpioa_val &= ~(1 << offset);

		mutex_lock(&vb->lock);

		gamsg->cmd = VPRBRD_GPIOA_CMD_SETOUT;
		gamsg->clk = 0x00;
		gamsg->offset = offset;
		gamsg->t1 = 0x00;
		gamsg->t2 = 0x00;
		gamsg->invert = 0x00;
		gamsg->pwmlevel = 0x00;
		gamsg->outval = value;
		gamsg->risefall = 0x00;
		gamsg->answer = 0x00;
		gamsg->__fill = 0x00;

		ret = usb_control_msg(vb->usb_dev,
			usb_sndctrlpipe(vb->usb_dev, 0),
			VPRBRD_USB_REQUEST_GPIOA, VPRBRD_USB_TYPE_OUT,
			0x0000,	0x0000, gamsg,
			sizeof(struct vprbrd_gpioa_msg), VPRBRD_USB_TIMEOUT_MS);

		mutex_unlock(&vb->lock);

		if (ret != sizeof(struct vprbrd_gpioa_msg))
			dev_err(chip->parent, "usb error setting pin value\n");
	}
}

static int vprbrd_gpioa_direction_input(struct gpio_chip *chip,
			unsigned offset)
{
	int ret;
	struct vprbrd_gpio *gpio = gpiochip_get_data(chip);
	struct vprbrd *vb = gpio->vb;
	struct vprbrd_gpioa_msg *gamsg = (struct vprbrd_gpioa_msg *)vb->buf;

	gpio->gpioa_out &= ~(1 << offset);

	mutex_lock(&vb->lock);

	gamsg->cmd = VPRBRD_GPIOA_CMD_SETIN;
	gamsg->clk = gpioa_clk;
	gamsg->offset = offset;
	gamsg->t1 = 0x00;
	gamsg->t2 = 0x00;
	gamsg->invert = 0x00;
	gamsg->pwmlevel = 0x00;
	gamsg->outval = 0x00;
	gamsg->risefall = 0x00;
	gamsg->answer = 0x00;
	gamsg->__fill = 0x00;

	ret = usb_control_msg(vb->usb_dev, usb_sndctrlpipe(vb->usb_dev, 0),
		VPRBRD_USB_REQUEST_GPIOA, VPRBRD_USB_TYPE_OUT, 0x0000,
		0x0000, gamsg, sizeof(struct vprbrd_gpioa_msg),
		VPRBRD_USB_TIMEOUT_MS);

	mutex_unlock(&vb->lock);

	if (ret != sizeof(struct vprbrd_gpioa_msg))
		return -EREMOTEIO;

	return 0;
}

static int vprbrd_gpioa_direction_output(struct gpio_chip *chip,
			unsigned offset, int value)
{
	int ret;
	struct vprbrd_gpio *gpio = gpiochip_get_data(chip);
	struct vprbrd *vb = gpio->vb;
	struct vprbrd_gpioa_msg *gamsg = (struct vprbrd_gpioa_msg *)vb->buf;

	gpio->gpioa_out |= (1 << offset);
	if (value)
		gpio->gpioa_val |= (1 << offset);
	else
		gpio->gpioa_val &= ~(1 << offset);

	mutex_lock(&vb->lock);

	gamsg->cmd = VPRBRD_GPIOA_CMD_SETOUT;
	gamsg->clk = 0x00;
	gamsg->offset = offset;
	gamsg->t1 = 0x00;
	gamsg->t2 = 0x00;
	gamsg->invert = 0x00;
	gamsg->pwmlevel = 0x00;
	gamsg->outval = value;
	gamsg->risefall = 0x00;
	gamsg->answer = 0x00;
	gamsg->__fill = 0x00;

	ret = usb_control_msg(vb->usb_dev, usb_sndctrlpipe(vb->usb_dev, 0),
		VPRBRD_USB_REQUEST_GPIOA, VPRBRD_USB_TYPE_OUT, 0x0000,
		0x0000, gamsg, sizeof(struct vprbrd_gpioa_msg),
		VPRBRD_USB_TIMEOUT_MS);

	mutex_unlock(&vb->lock);

	if (ret != sizeof(struct vprbrd_gpioa_msg))
		return -EREMOTEIO;

	return 0;
}

/* ----- end of gpio a chip ---------------------------------------------- */

/* ----- begin of gipo b chip -------------------------------------------- */

static int vprbrd_gpiob_setdir(struct vprbrd *vb, unsigned offset,
	unsigned dir)
{
	struct vprbrd_gpiob_msg *gbmsg = (struct vprbrd_gpiob_msg *)vb->buf;
	int ret;

	gbmsg->cmd = VPRBRD_GPIOB_CMD_SETDIR;
	gbmsg->val = cpu_to_be16(dir << offset);
	gbmsg->mask = cpu_to_be16(0x0001 << offset);

	ret = usb_control_msg(vb->usb_dev, usb_sndctrlpipe(vb->usb_dev, 0),
		VPRBRD_USB_REQUEST_GPIOB, VPRBRD_USB_TYPE_OUT, 0x0000,
		0x0000, gbmsg, sizeof(struct vprbrd_gpiob_msg),
		VPRBRD_USB_TIMEOUT_MS);

	if (ret != sizeof(struct vprbrd_gpiob_msg))
		return -EREMOTEIO;

	return 0;
}

static int vprbrd_gpiob_get(struct gpio_chip *chip,
		unsigned offset)
{
	int ret;
	u16 val;
	struct vprbrd_gpio *gpio = gpiochip_get_data(chip);
	struct vprbrd *vb = gpio->vb;
	struct vprbrd_gpiob_msg *gbmsg = (struct vprbrd_gpiob_msg *)vb->buf;

	/* if io is set to output, just return the saved value */
	if (gpio->gpiob_out & (1 << offset))
		return gpio->gpiob_val & (1 << offset);

	mutex_lock(&vb->lock);

	ret = usb_control_msg(vb->usb_dev, usb_rcvctrlpipe(vb->usb_dev, 0),
		VPRBRD_USB_REQUEST_GPIOB, VPRBRD_USB_TYPE_IN, 0x0000,
		0x0000, gbmsg,	sizeof(struct vprbrd_gpiob_msg),
		VPRBRD_USB_TIMEOUT_MS);
	val = gbmsg->val;

	mutex_unlock(&vb->lock);

	if (ret != sizeof(struct vprbrd_gpiob_msg))
		return ret;

	/* cache the read values */
	gpio->gpiob_val = be16_to_cpu(val);

	return (gpio->gpiob_val >> offset) & 0x1;
}

static void vprbrd_gpiob_set(struct gpio_chip *chip,
		unsigned offset, int value)
{
	int ret;
	struct vprbrd_gpio *gpio = gpiochip_get_data(chip);
	struct vprbrd *vb = gpio->vb;
	struct vprbrd_gpiob_msg *gbmsg = (struct vprbrd_gpiob_msg *)vb->buf;

	if (gpio->gpiob_out & (1 << offset)) {
		if (value)
			gpio->gpiob_val |= (1 << offset);
		else
			gpio->gpiob_val &= ~(1 << offset);

		mutex_lock(&vb->lock);

		gbmsg->cmd = VPRBRD_GPIOB_CMD_SETVAL;
		gbmsg->val = cpu_to_be16(value << offset);
		gbmsg->mask = cpu_to_be16(0x0001 << offset);

		ret = usb_control_msg(vb->usb_dev,
			usb_sndctrlpipe(vb->usb_dev, 0),
			VPRBRD_USB_REQUEST_GPIOB, VPRBRD_USB_TYPE_OUT,
			0x0000,	0x0000, gbmsg,
			sizeof(struct vprbrd_gpiob_msg), VPRBRD_USB_TIMEOUT_MS);

		mutex_unlock(&vb->lock);

		if (ret != sizeof(struct vprbrd_gpiob_msg))
			dev_err(chip->parent, "usb error setting pin value\n");
	}
}

static int vprbrd_gpiob_direction_input(struct gpio_chip *chip,
			unsigned offset)
{
	int ret;
	struct vprbrd_gpio *gpio = gpiochip_get_data(chip);
	struct vprbrd *vb = gpio->vb;

	gpio->gpiob_out &= ~(1 << offset);

	mutex_lock(&vb->lock);

	ret = vprbrd_gpiob_setdir(vb, offset, 0);

	mutex_unlock(&vb->lock);

	if (ret)
		dev_err(chip->parent, "usb error setting pin to input\n");

	return ret;
}

static int vprbrd_gpiob_direction_output(struct gpio_chip *chip,
			unsigned offset, int value)
{
	int ret;
	struct vprbrd_gpio *gpio = gpiochip_get_data(chip);
	struct vprbrd *vb = gpio->vb;

	gpio->gpiob_out |= (1 << offset);

	mutex_lock(&vb->lock);

	ret = vprbrd_gpiob_setdir(vb, offset, 1);
	if (ret)
		dev_err(chip->parent, "usb error setting pin to output\n");

	mutex_unlock(&vb->lock);

	vprbrd_gpiob_set(chip, offset, value);

	return ret;
}

/* ----- end of gpio b chip ---------------------------------------------- */

static int vprbrd_gpio_probe(struct platform_device *pdev)
{
	struct vprbrd *vb = dev_get_drvdata(pdev->dev.parent);
	struct vprbrd_gpio *vb_gpio;
	int ret;

	vb_gpio = devm_kzalloc(&pdev->dev, sizeof(*vb_gpio), GFP_KERNEL);
	if (vb_gpio == NULL)
		return -ENOMEM;

	vb_gpio->vb = vb;
	/* registering gpio a */
	vb_gpio->gpioa.label = "viperboard gpio a";
	vb_gpio->gpioa.parent = &pdev->dev;
	vb_gpio->gpioa.owner = THIS_MODULE;
	vb_gpio->gpioa.base = -1;
	vb_gpio->gpioa.ngpio = 16;
	vb_gpio->gpioa.can_sleep = true;
	vb_gpio->gpioa.set = vprbrd_gpioa_set;
	vb_gpio->gpioa.get = vprbrd_gpioa_get;
	vb_gpio->gpioa.direction_input = vprbrd_gpioa_direction_input;
	vb_gpio->gpioa.direction_output = vprbrd_gpioa_direction_output;
	ret = devm_gpiochip_add_data(&pdev->dev, &vb_gpio->gpioa, vb_gpio);
	if (ret < 0) {
		dev_err(vb_gpio->gpioa.parent, "could not add gpio a");
		return ret;
	}

	/* registering gpio b */
	vb_gpio->gpiob.label = "viperboard gpio b";
	vb_gpio->gpiob.parent = &pdev->dev;
	vb_gpio->gpiob.owner = THIS_MODULE;
	vb_gpio->gpiob.base = -1;
	vb_gpio->gpiob.ngpio = 16;
	vb_gpio->gpiob.can_sleep = true;
	vb_gpio->gpiob.set = vprbrd_gpiob_set;
	vb_gpio->gpiob.get = vprbrd_gpiob_get;
	vb_gpio->gpiob.direction_input = vprbrd_gpiob_direction_input;
	vb_gpio->gpiob.direction_output = vprbrd_gpiob_direction_output;
	ret = devm_gpiochip_add_data(&pdev->dev, &vb_gpio->gpiob, vb_gpio);
	if (ret < 0) {
		dev_err(vb_gpio->gpiob.parent, "could not add gpio b");
		return ret;
	}

	platform_set_drvdata(pdev, vb_gpio);

	return ret;
}

static struct platform_driver vprbrd_gpio_driver = {
	.driver.name	= "viperboard-gpio",
	.probe		= vprbrd_gpio_probe,
};

static int __init vprbrd_gpio_init(void)
{
	switch (gpioa_freq) {
	case 1000000:
		gpioa_clk = VPRBRD_GPIOA_CLK_1MHZ;
		break;
	case 100000:
		gpioa_clk = VPRBRD_GPIOA_CLK_100KHZ;
		break;
	case 10000:
		gpioa_clk = VPRBRD_GPIOA_CLK_10KHZ;
		break;
	case 1000:
		gpioa_clk = VPRBRD_GPIOA_CLK_1KHZ;
		break;
	case 100:
		gpioa_clk = VPRBRD_GPIOA_CLK_100HZ;
		break;
	case 10:
		gpioa_clk = VPRBRD_GPIOA_CLK_10HZ;
		break;
	default:
		pr_warn("invalid gpioa_freq (%d)\n", gpioa_freq);
		gpioa_clk = VPRBRD_GPIOA_CLK_1KHZ;
	}

	return platform_driver_register(&vprbrd_gpio_driver);
}
subsys_initcall(vprbrd_gpio_init);

static void __exit vprbrd_gpio_exit(void)
{
	platform_driver_unregister(&vprbrd_gpio_driver);
}
module_exit(vprbrd_gpio_exit);

MODULE_AUTHOR("Lars Poeschel <[email protected]>");
MODULE_DESCRIPTION("GPIO driver for Nano River Techs Viperboard");
MODULE_LICENSE("GPL");
MODULE_ALIAS("platform:viperboard-gpio");
Commit	Line	Data
9d5b72de LP	1	/*
	2	* Nano River Technologies viperboard GPIO lib driver
	3	*
	4	* (C) 2012 by Lemonage GmbH
	5	* Author: Lars Poeschel <[email protected]>
	6	* All rights reserved.
	7	*
	8	* This program is free software; you can redistribute it and/or modify it
	9	* under the terms of the GNU General Public License as published by the
	10	* Free Software Foundation; either version 2 of the License, or (at your
	11	* option) any later version.
	12	*
	13	*/
	14
	15	#include <linux/kernel.h>
	16	#include <linux/errno.h>
	17	#include <linux/module.h>
	18	#include <linux/slab.h>
	19	#include <linux/types.h>
	20	#include <linux/mutex.h>
	21	#include <linux/platform_device.h>
	22
	23	#include <linux/usb.h>
	24	#include <linux/gpio.h>
	25
	26	#include <linux/mfd/viperboard.h>
	27
	28	#define VPRBRD_GPIOA_CLK_1MHZ 0
	29	#define VPRBRD_GPIOA_CLK_100KHZ 1
	30	#define VPRBRD_GPIOA_CLK_10KHZ 2
	31	#define VPRBRD_GPIOA_CLK_1KHZ 3
	32	#define VPRBRD_GPIOA_CLK_100HZ 4
	33	#define VPRBRD_GPIOA_CLK_10HZ 5
	34
	35	#define VPRBRD_GPIOA_FREQ_DEFAULT 1000
	36
	37	#define VPRBRD_GPIOA_CMD_CONT 0x00
	38	#define VPRBRD_GPIOA_CMD_PULSE 0x01
	39	#define VPRBRD_GPIOA_CMD_PWM 0x02
	40	#define VPRBRD_GPIOA_CMD_SETOUT 0x03
	41	#define VPRBRD_GPIOA_CMD_SETIN 0x04
	42	#define VPRBRD_GPIOA_CMD_SETINT 0x05
	43	#define VPRBRD_GPIOA_CMD_GETIN 0x06
	44
	45	#define VPRBRD_GPIOB_CMD_SETDIR 0x00
	46	#define VPRBRD_GPIOB_CMD_SETVAL 0x01
	47
	48	struct vprbrd_gpioa_msg {
	49	u8 cmd;
	50	u8 clk;
	51	u8 offset;
	52	u8 t1;
	53	u8 t2;
	54	u8 invert;
	55	u8 pwmlevel;
	56	u8 outval;
	57	u8 risefall;
	58	u8 answer;
	59	u8 __fill;
	60	} __packed;
	61
	62	struct vprbrd_gpiob_msg {
	63	u8 cmd;
	64	u16 val;
65	u16 mask;
66	} __packed;
67
68	struct vprbrd_gpio {
69	struct gpio_chip gpioa; /* gpio a related things */
70	u32 gpioa_out;
71	u32 gpioa_val;
72	struct gpio_chip gpiob; /* gpio b related things */
73	u32 gpiob_out;
74	u32 gpiob_val;
75	struct vprbrd *vb;
76	};
77
78	/* gpioa sampling clock module parameter */
79	static unsigned char gpioa_clk;
80	static unsigned int gpioa_freq = VPRBRD_GPIOA_FREQ_DEFAULT;
81	module_param(gpioa_freq, uint, 0);
82	MODULE_PARM_DESC(gpioa_freq,
83	"gpio-a sampling freq in Hz (default is 1000Hz) valid values: 10, 100, 1000, 10000, 100000, 1000000");
84
85	/* ----- begin of gipo a chip -------------------------------------------- */
86
87	static int vprbrd_gpioa_get(struct gpio_chip *chip,
88	unsigned offset)
89	{
90	int ret, answer, error = 0;
2a873c8d	91	struct vprbrd_gpio *gpio = gpiochip_get_data(chip);
9d5b72de LP	92	struct vprbrd *vb = gpio->vb;
	93	struct vprbrd_gpioa_msg gamsg = (struct vprbrd_gpioa_msg )vb->buf;
	94
	95	/* if io is set to output, just return the saved value */
	96	if (gpio->gpioa_out & (1 << offset))
80776df4	97	return !!(gpio->gpioa_val & (1 << offset));
9d5b72de LP	98
	99	mutex_lock(&vb->lock);
	100
	101	gamsg->cmd = VPRBRD_GPIOA_CMD_GETIN;
	102	gamsg->clk = 0x00;
	103	gamsg->offset = offset;
	104	gamsg->t1 = 0x00;
	105	gamsg->t2 = 0x00;
	106	gamsg->invert = 0x00;
	107	gamsg->pwmlevel = 0x00;
	108	gamsg->outval = 0x00;
	109	gamsg->risefall = 0x00;
	110	gamsg->answer = 0x00;
	111	gamsg->__fill = 0x00;
	112
	113	ret = usb_control_msg(vb->usb_dev, usb_sndctrlpipe(vb->usb_dev, 0),
	114	VPRBRD_USB_REQUEST_GPIOA, VPRBRD_USB_TYPE_OUT, 0x0000,
	115	0x0000, gamsg, sizeof(struct vprbrd_gpioa_msg),
	116	VPRBRD_USB_TIMEOUT_MS);
	117	if (ret != sizeof(struct vprbrd_gpioa_msg))
	118	error = -EREMOTEIO;
	119
	120	ret = usb_control_msg(vb->usb_dev, usb_rcvctrlpipe(vb->usb_dev, 0),
	121	VPRBRD_USB_REQUEST_GPIOA, VPRBRD_USB_TYPE_IN, 0x0000,
	122	0x0000, gamsg, sizeof(struct vprbrd_gpioa_msg),
	123	VPRBRD_USB_TIMEOUT_MS);
	124	answer = gamsg->answer & 0x01;
	125
	126	mutex_unlock(&vb->lock);
	127
	128	if (ret != sizeof(struct vprbrd_gpioa_msg))
	129	error = -EREMOTEIO;
	130
	131	if (error)
	132	return error;
	133
	134	return answer;
	135	}
	136
	137	static void vprbrd_gpioa_set(struct gpio_chip *chip,
	138	unsigned offset, int value)
	139	{
	140	int ret;
2a873c8d	141	struct vprbrd_gpio *gpio = gpiochip_get_data(chip);
9d5b72de LP	142	struct vprbrd *vb = gpio->vb;
	143	struct vprbrd_gpioa_msg gamsg = (struct vprbrd_gpioa_msg )vb->buf;
	144
	145	if (gpio->gpioa_out & (1 << offset)) {
	146	if (value)
	147	gpio->gpioa_val \|= (1 << offset);
	148	else
	149	gpio->gpioa_val &= ~(1 << offset);
	150
	151	mutex_lock(&vb->lock);
	152
	153	gamsg->cmd = VPRBRD_GPIOA_CMD_SETOUT;
	154	gamsg->clk = 0x00;
	155	gamsg->offset = offset;
	156	gamsg->t1 = 0x00;
	157	gamsg->t2 = 0x00;
	158	gamsg->invert = 0x00;
	159	gamsg->pwmlevel = 0x00;
	160	gamsg->outval = value;
	161	gamsg->risefall = 0x00;
	162	gamsg->answer = 0x00;
	163	gamsg->__fill = 0x00;
	164
	165	ret = usb_control_msg(vb->usb_dev,
	166	usb_sndctrlpipe(vb->usb_dev, 0),
	167	VPRBRD_USB_REQUEST_GPIOA, VPRBRD_USB_TYPE_OUT,
	168	0x0000, 0x0000, gamsg,
	169	sizeof(struct vprbrd_gpioa_msg), VPRBRD_USB_TIMEOUT_MS);
	170
	171	mutex_unlock(&vb->lock);
	172
	173	if (ret != sizeof(struct vprbrd_gpioa_msg))
58383c78	174	dev_err(chip->parent, "usb error setting pin value\n");
9d5b72de LP	175	}
	176	}
	177
	178	static int vprbrd_gpioa_direction_input(struct gpio_chip *chip,
	179	unsigned offset)
	180	{
	181	int ret;
2a873c8d	182	struct vprbrd_gpio *gpio = gpiochip_get_data(chip);
9d5b72de LP	183	struct vprbrd *vb = gpio->vb;
	184	struct vprbrd_gpioa_msg gamsg = (struct vprbrd_gpioa_msg )vb->buf;
	185
	186	gpio->gpioa_out &= ~(1 << offset);
	187
	188	mutex_lock(&vb->lock);
	189
	190	gamsg->cmd = VPRBRD_GPIOA_CMD_SETIN;
	191	gamsg->clk = gpioa_clk;
	192	gamsg->offset = offset;
	193	gamsg->t1 = 0x00;
	194	gamsg->t2 = 0x00;
	195	gamsg->invert = 0x00;
	196	gamsg->pwmlevel = 0x00;
	197	gamsg->outval = 0x00;
	198	gamsg->risefall = 0x00;
	199	gamsg->answer = 0x00;
	200	gamsg->__fill = 0x00;
	201
	202	ret = usb_control_msg(vb->usb_dev, usb_sndctrlpipe(vb->usb_dev, 0),
	203	VPRBRD_USB_REQUEST_GPIOA, VPRBRD_USB_TYPE_OUT, 0x0000,
	204	0x0000, gamsg, sizeof(struct vprbrd_gpioa_msg),
	205	VPRBRD_USB_TIMEOUT_MS);
	206
	207	mutex_unlock(&vb->lock);
	208
	209	if (ret != sizeof(struct vprbrd_gpioa_msg))
	210	return -EREMOTEIO;
	211
	212	return 0;
	213	}
	214
	215	static int vprbrd_gpioa_direction_output(struct gpio_chip *chip,
	216	unsigned offset, int value)
	217	{
	218	int ret;
2a873c8d	219	struct vprbrd_gpio *gpio = gpiochip_get_data(chip);
9d5b72de LP	220	struct vprbrd *vb = gpio->vb;
	221	struct vprbrd_gpioa_msg gamsg = (struct vprbrd_gpioa_msg )vb->buf;
	222
	223	gpio->gpioa_out \|= (1 << offset);
	224	if (value)
	225	gpio->gpioa_val \|= (1 << offset);
	226	else
	227	gpio->gpioa_val &= ~(1 << offset);
	228
	229	mutex_lock(&vb->lock);
	230
	231	gamsg->cmd = VPRBRD_GPIOA_CMD_SETOUT;
	232	gamsg->clk = 0x00;
	233	gamsg->offset = offset;
	234	gamsg->t1 = 0x00;
	235	gamsg->t2 = 0x00;
	236	gamsg->invert = 0x00;
	237	gamsg->pwmlevel = 0x00;
	238	gamsg->outval = value;
	239	gamsg->risefall = 0x00;
	240	gamsg->answer = 0x00;
	241	gamsg->__fill = 0x00;
	242
	243	ret = usb_control_msg(vb->usb_dev, usb_sndctrlpipe(vb->usb_dev, 0),
	244	VPRBRD_USB_REQUEST_GPIOA, VPRBRD_USB_TYPE_OUT, 0x0000,
	245	0x0000, gamsg, sizeof(struct vprbrd_gpioa_msg),
	246	VPRBRD_USB_TIMEOUT_MS);
	247
	248	mutex_unlock(&vb->lock);
	249
	250	if (ret != sizeof(struct vprbrd_gpioa_msg))
	251	return -EREMOTEIO;
	252
	253	return 0;
	254	}
	255
	256	/* ----- end of gpio a chip ---------------------------------------------- */
	257
	258	/* ----- begin of gipo b chip -------------------------------------------- */
	259
	260	static int vprbrd_gpiob_setdir(struct vprbrd *vb, unsigned offset,
	261	unsigned dir)
	262	{
	263	struct vprbrd_gpiob_msg gbmsg = (struct vprbrd_gpiob_msg )vb->buf;
	264	int ret;
	265
	266	gbmsg->cmd = VPRBRD_GPIOB_CMD_SETDIR;
	267	gbmsg->val = cpu_to_be16(dir << offset);
	268	gbmsg->mask = cpu_to_be16(0x0001 << offset);
	269
	270	ret = usb_control_msg(vb->usb_dev, usb_sndctrlpipe(vb->usb_dev, 0),
	271	VPRBRD_USB_REQUEST_GPIOB, VPRBRD_USB_TYPE_OUT, 0x0000,
	272	0x0000, gbmsg, sizeof(struct vprbrd_gpiob_msg),
	273	VPRBRD_USB_TIMEOUT_MS);
	274
	275	if (ret != sizeof(struct vprbrd_gpiob_msg))
	276	return -EREMOTEIO;
	277
	278	return 0;
	279	}
	280
	281	static int vprbrd_gpiob_get(struct gpio_chip *chip,
	282	unsigned offset)
	283	{
284	int ret;
285	u16 val;
2a873c8d	286	struct vprbrd_gpio *gpio = gpiochip_get_data(chip);
9d5b72de LP	287	struct vprbrd *vb = gpio->vb;
	288	struct vprbrd_gpiob_msg gbmsg = (struct vprbrd_gpiob_msg )vb->buf;
	289
	290	/* if io is set to output, just return the saved value */
	291	if (gpio->gpiob_out & (1 << offset))
	292	return gpio->gpiob_val & (1 << offset);
	293
	294	mutex_lock(&vb->lock);
	295
	296	ret = usb_control_msg(vb->usb_dev, usb_rcvctrlpipe(vb->usb_dev, 0),
	297	VPRBRD_USB_REQUEST_GPIOB, VPRBRD_USB_TYPE_IN, 0x0000,
	298	0x0000, gbmsg, sizeof(struct vprbrd_gpiob_msg),
	299	VPRBRD_USB_TIMEOUT_MS);
	300	val = gbmsg->val;
	301
	302	mutex_unlock(&vb->lock);
	303
	304	if (ret != sizeof(struct vprbrd_gpiob_msg))
	305	return ret;
	306
	307	/* cache the read values */
	308	gpio->gpiob_val = be16_to_cpu(val);
	309
	310	return (gpio->gpiob_val >> offset) & 0x1;
	311	}
	312
	313	static void vprbrd_gpiob_set(struct gpio_chip *chip,
	314	unsigned offset, int value)
	315	{
	316	int ret;
2a873c8d	317	struct vprbrd_gpio *gpio = gpiochip_get_data(chip);
9d5b72de LP	318	struct vprbrd *vb = gpio->vb;
	319	struct vprbrd_gpiob_msg gbmsg = (struct vprbrd_gpiob_msg )vb->buf;
	320
	321	if (gpio->gpiob_out & (1 << offset)) {
	322	if (value)
	323	gpio->gpiob_val \|= (1 << offset);
	324	else
	325	gpio->gpiob_val &= ~(1 << offset);
	326
	327	mutex_lock(&vb->lock);
	328
	329	gbmsg->cmd = VPRBRD_GPIOB_CMD_SETVAL;
	330	gbmsg->val = cpu_to_be16(value << offset);
	331	gbmsg->mask = cpu_to_be16(0x0001 << offset);
	332
	333	ret = usb_control_msg(vb->usb_dev,
	334	usb_sndctrlpipe(vb->usb_dev, 0),
	335	VPRBRD_USB_REQUEST_GPIOB, VPRBRD_USB_TYPE_OUT,
	336	0x0000, 0x0000, gbmsg,
	337	sizeof(struct vprbrd_gpiob_msg), VPRBRD_USB_TIMEOUT_MS);
	338
	339	mutex_unlock(&vb->lock);
	340
	341	if (ret != sizeof(struct vprbrd_gpiob_msg))
58383c78	342	dev_err(chip->parent, "usb error setting pin value\n");
9d5b72de LP	343	}
	344	}
	345
	346	static int vprbrd_gpiob_direction_input(struct gpio_chip *chip,
	347	unsigned offset)
	348	{
	349	int ret;
2a873c8d	350	struct vprbrd_gpio *gpio = gpiochip_get_data(chip);
9d5b72de LP	351	struct vprbrd *vb = gpio->vb;
	352
	353	gpio->gpiob_out &= ~(1 << offset);
	354
	355	mutex_lock(&vb->lock);
	356
	357	ret = vprbrd_gpiob_setdir(vb, offset, 0);
	358
	359	mutex_unlock(&vb->lock);
	360
	361	if (ret)
58383c78	362	dev_err(chip->parent, "usb error setting pin to input\n");
9d5b72de LP	363
	364	return ret;
	365	}
	366
	367	static int vprbrd_gpiob_direction_output(struct gpio_chip *chip,
	368	unsigned offset, int value)
	369	{
	370	int ret;
2a873c8d	371	struct vprbrd_gpio *gpio = gpiochip_get_data(chip);
9d5b72de LP	372	struct vprbrd *vb = gpio->vb;
	373
	374	gpio->gpiob_out \|= (1 << offset);
9d5b72de LP	375
	376	mutex_lock(&vb->lock);
	377
	378	ret = vprbrd_gpiob_setdir(vb, offset, 1);
	379	if (ret)
58383c78	380	dev_err(chip->parent, "usb error setting pin to output\n");
9d5b72de LP	381
	382	mutex_unlock(&vb->lock);
	383
	384	vprbrd_gpiob_set(chip, offset, value);
	385
	386	return ret;
	387	}
	388
	389	/* ----- end of gpio b chip ---------------------------------------------- */
	390
0fe763c5	391	static int vprbrd_gpio_probe(struct platform_device *pdev)
9d5b72de LP	392	{
	393	struct vprbrd *vb = dev_get_drvdata(pdev->dev.parent);
	394	struct vprbrd_gpio *vb_gpio;
	395	int ret;
	396
	397	vb_gpio = devm_kzalloc(&pdev->dev, sizeof(*vb_gpio), GFP_KERNEL);
	398	if (vb_gpio == NULL)
	399	return -ENOMEM;
	400
	401	vb_gpio->vb = vb;
	402	/* registering gpio a */
	403	vb_gpio->gpioa.label = "viperboard gpio a";
58383c78	404	vb_gpio->gpioa.parent = &pdev->dev;
9d5b72de LP	405	vb_gpio->gpioa.owner = THIS_MODULE;
	406	vb_gpio->gpioa.base = -1;
	407	vb_gpio->gpioa.ngpio = 16;
9fb1f39e	408	vb_gpio->gpioa.can_sleep = true;
9d5b72de LP	409	vb_gpio->gpioa.set = vprbrd_gpioa_set;
	410	vb_gpio->gpioa.get = vprbrd_gpioa_get;
	411	vb_gpio->gpioa.direction_input = vprbrd_gpioa_direction_input;
	412	vb_gpio->gpioa.direction_output = vprbrd_gpioa_direction_output;
45338c3a	413	ret = devm_gpiochip_add_data(&pdev->dev, &vb_gpio->gpioa, vb_gpio);
9d5b72de	414	if (ret < 0) {
58383c78	415	dev_err(vb_gpio->gpioa.parent, "could not add gpio a");
45338c3a	416	return ret;
9d5b72de LP	417	}
	418
	419	/* registering gpio b */
	420	vb_gpio->gpiob.label = "viperboard gpio b";
58383c78	421	vb_gpio->gpiob.parent = &pdev->dev;
9d5b72de LP	422	vb_gpio->gpiob.owner = THIS_MODULE;
	423	vb_gpio->gpiob.base = -1;
	424	vb_gpio->gpiob.ngpio = 16;
9fb1f39e	425	vb_gpio->gpiob.can_sleep = true;
9d5b72de LP	426	vb_gpio->gpiob.set = vprbrd_gpiob_set;
	427	vb_gpio->gpiob.get = vprbrd_gpiob_get;
	428	vb_gpio->gpiob.direction_input = vprbrd_gpiob_direction_input;
	429	vb_gpio->gpiob.direction_output = vprbrd_gpiob_direction_output;
45338c3a	430	ret = devm_gpiochip_add_data(&pdev->dev, &vb_gpio->gpiob, vb_gpio);
9d5b72de	431	if (ret < 0) {
58383c78	432	dev_err(vb_gpio->gpiob.parent, "could not add gpio b");
45338c3a	433	return ret;
9d5b72de LP	434	}
	435
	436	platform_set_drvdata(pdev, vb_gpio);
	437
	438	return ret;
9d5b72de LP	439	}
	440
	441	static struct platform_driver vprbrd_gpio_driver = {
	442	.driver.name = "viperboard-gpio",
9d5b72de	443	.probe = vprbrd_gpio_probe,
9d5b72de LP	444	};
	445
	446	static int __init vprbrd_gpio_init(void)
	447	{
	448	switch (gpioa_freq) {
	449	case 1000000:
	450	gpioa_clk = VPRBRD_GPIOA_CLK_1MHZ;
	451	break;
	452	case 100000:
	453	gpioa_clk = VPRBRD_GPIOA_CLK_100KHZ;
	454	break;
	455	case 10000:
	456	gpioa_clk = VPRBRD_GPIOA_CLK_10KHZ;
	457	break;
	458	case 1000:
	459	gpioa_clk = VPRBRD_GPIOA_CLK_1KHZ;
	460	break;
	461	case 100:
	462	gpioa_clk = VPRBRD_GPIOA_CLK_100HZ;
	463	break;
	464	case 10:
	465	gpioa_clk = VPRBRD_GPIOA_CLK_10HZ;
	466	break;
	467	default:
	468	pr_warn("invalid gpioa_freq (%d)\n", gpioa_freq);
	469	gpioa_clk = VPRBRD_GPIOA_CLK_1KHZ;
	470	}
	471
	472	return platform_driver_register(&vprbrd_gpio_driver);
	473	}
	474	subsys_initcall(vprbrd_gpio_init);
	475
	476	static void __exit vprbrd_gpio_exit(void)
	477	{
	478	platform_driver_unregister(&vprbrd_gpio_driver);
	479	}
	480	module_exit(vprbrd_gpio_exit);
	481
	482	MODULE_AUTHOR("Lars Poeschel <[email protected]>");
	483	MODULE_DESCRIPTION("GPIO driver for Nano River Techs Viperboard");
	484	MODULE_LICENSE("GPL");
	485	MODULE_ALIAS("platform:viperboard-gpio");