[mirror_ubuntu-artful-kernel.git] / drivers / mfd / lp3943.c

/*
 * TI/National Semiconductor LP3943 MFD Core Driver
 *
 * Copyright 2013 Texas Instruments
 *
 * Author: Milo Kim <milo.kim@ti.com>
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 2 as
 * published by the Free Software Foundation.
 *
 * Driver structure:
 *   LP3943 is an integrated device capable of driving 16 output channels.
 *   It can be used for a GPIO expander and PWM generators.
 *
 *                                   LED control    General usage for a device
 *                                   ___________   ____________________________
 *
 *   LP3943 MFD ---- GPIO expander    leds-gpio        eg) HW enable pin
 *               |
 *               --- PWM generator    leds-pwm         eg) PWM input
 *
 *   Internal two PWM channels are used for LED dimming effect.
 *   And each output pin can be used as a GPIO as well.
 *   The LED functionality can work with GPIOs or PWMs.
 *   LEDs can be controlled with legacy leds-gpio(static brightness) or
 *   leds-pwm drivers(dynamic brightness control).
 *   Alternatively, it can be used for generic GPIO and PWM controller.
 *   For example, a GPIO is HW enable pin of a device.
 *   A PWM is input pin of a backlight device.
 */

#include <linux/err.h>
#include <linux/gpio.h>
#include <linux/i2c.h>
#include <linux/mfd/core.h>
#include <linux/mfd/lp3943.h>
#include <linux/module.h>
#include <linux/of.h>
#include <linux/slab.h>

#define LP3943_MAX_REGISTERS		0x09

/* Register configuration for pin MUX */
static const struct lp3943_reg_cfg lp3943_mux_cfg[] = {
	/* address, mask, shift */
	{ LP3943_REG_MUX0, 0x03, 0 },
	{ LP3943_REG_MUX0, 0x0C, 2 },
	{ LP3943_REG_MUX0, 0x30, 4 },
	{ LP3943_REG_MUX0, 0xC0, 6 },
	{ LP3943_REG_MUX1, 0x03, 0 },
	{ LP3943_REG_MUX1, 0x0C, 2 },
	{ LP3943_REG_MUX1, 0x30, 4 },
	{ LP3943_REG_MUX1, 0xC0, 6 },
	{ LP3943_REG_MUX2, 0x03, 0 },
	{ LP3943_REG_MUX2, 0x0C, 2 },
	{ LP3943_REG_MUX2, 0x30, 4 },
	{ LP3943_REG_MUX2, 0xC0, 6 },
	{ LP3943_REG_MUX3, 0x03, 0 },
	{ LP3943_REG_MUX3, 0x0C, 2 },
	{ LP3943_REG_MUX3, 0x30, 4 },
	{ LP3943_REG_MUX3, 0xC0, 6 },
};

static const struct mfd_cell lp3943_devs[] = {
	{
		.name = "lp3943-pwm",
		.of_compatible = "ti,lp3943-pwm",
	},
	{
		.name = "lp3943-gpio",
		.of_compatible = "ti,lp3943-gpio",
	},
};

int lp3943_read_byte(struct lp3943 *lp3943, u8 reg, u8 *read)
{
	int ret;
	unsigned int val;

	ret = regmap_read(lp3943->regmap, reg, &val);
	if (ret < 0)
		return ret;

	*read = (u8)val;
	return 0;
}
EXPORT_SYMBOL_GPL(lp3943_read_byte);

int lp3943_write_byte(struct lp3943 *lp3943, u8 reg, u8 data)
{
	return regmap_write(lp3943->regmap, reg, data);
}
EXPORT_SYMBOL_GPL(lp3943_write_byte);

int lp3943_update_bits(struct lp3943 *lp3943, u8 reg, u8 mask, u8 data)
{
	return regmap_update_bits(lp3943->regmap, reg, mask, data);
}
EXPORT_SYMBOL_GPL(lp3943_update_bits);

static const struct regmap_config lp3943_regmap_config = {
	.reg_bits = 8,
	.val_bits = 8,
	.max_register = LP3943_MAX_REGISTERS,
};

static int lp3943_probe(struct i2c_client *cl, const struct i2c_device_id *id)
{
	struct lp3943 *lp3943;
	struct device *dev = &cl->dev;

	lp3943 = devm_kzalloc(dev, sizeof(*lp3943), GFP_KERNEL);
	if (!lp3943)
		return -ENOMEM;

	lp3943->regmap = devm_regmap_init_i2c(cl, &lp3943_regmap_config);
	if (IS_ERR(lp3943->regmap))
		return PTR_ERR(lp3943->regmap);

	lp3943->pdata = dev_get_platdata(dev);
	lp3943->dev = dev;
	lp3943->mux_cfg = lp3943_mux_cfg;
	i2c_set_clientdata(cl, lp3943);

	return devm_mfd_add_devices(dev, -1, lp3943_devs,
				    ARRAY_SIZE(lp3943_devs),
				    NULL, 0, NULL);
}

static const struct i2c_device_id lp3943_ids[] = {
	{ "lp3943", 0 },
	{ }
};
MODULE_DEVICE_TABLE(i2c, lp3943_ids);

#ifdef CONFIG_OF
static const struct of_device_id lp3943_of_match[] = {
	{ .compatible = "ti,lp3943", },
	{ }
};
MODULE_DEVICE_TABLE(of, lp3943_of_match);
#endif

static struct i2c_driver lp3943_driver = {
	.probe = lp3943_probe,
	.driver = {
		.name = "lp3943",
		.of_match_table = of_match_ptr(lp3943_of_match),
	},
	.id_table = lp3943_ids,
};

module_i2c_driver(lp3943_driver);

MODULE_DESCRIPTION("LP3943 MFD Core Driver");
MODULE_AUTHOR("Milo Kim");
MODULE_LICENSE("GPL");
Commit	Line	Data
470eca47 MK	1	/*
	2	* TI/National Semiconductor LP3943 MFD Core Driver
	3	*
	4	* Copyright 2013 Texas Instruments
	5	*
	6	* Author: Milo Kim <milo.kim@ti.com>
	7	*
	8	* This program is free software; you can redistribute it and/or modify
	9	* it under the terms of the GNU General Public License version 2 as
	10	* published by the Free Software Foundation.
	11	*
	12	* Driver structure:
	13	* LP3943 is an integrated device capable of driving 16 output channels.
	14	* It can be used for a GPIO expander and PWM generators.
	15	*
	16	* LED control General usage for a device
	17	* ___________ ____________________________
	18	*
	19	* LP3943 MFD ---- GPIO expander leds-gpio eg) HW enable pin
	20	* \|
	21	* --- PWM generator leds-pwm eg) PWM input
	22	*
	23	* Internal two PWM channels are used for LED dimming effect.
	24	* And each output pin can be used as a GPIO as well.
	25	* The LED functionality can work with GPIOs or PWMs.
	26	* LEDs can be controlled with legacy leds-gpio(static brightness) or
	27	* leds-pwm drivers(dynamic brightness control).
	28	* Alternatively, it can be used for generic GPIO and PWM controller.
	29	* For example, a GPIO is HW enable pin of a device.
	30	* A PWM is input pin of a backlight device.
	31	*/
	32
	33	#include <linux/err.h>
	34	#include <linux/gpio.h>
	35	#include <linux/i2c.h>
	36	#include <linux/mfd/core.h>
	37	#include <linux/mfd/lp3943.h>
	38	#include <linux/module.h>
	39	#include <linux/of.h>
	40	#include <linux/slab.h>
	41
	42	#define LP3943_MAX_REGISTERS 0x09
	43
	44	/* Register configuration for pin MUX */
	45	static const struct lp3943_reg_cfg lp3943_mux_cfg[] = {
	46	/* address, mask, shift */
	47	{ LP3943_REG_MUX0, 0x03, 0 },
	48	{ LP3943_REG_MUX0, 0x0C, 2 },
	49	{ LP3943_REG_MUX0, 0x30, 4 },
	50	{ LP3943_REG_MUX0, 0xC0, 6 },
	51	{ LP3943_REG_MUX1, 0x03, 0 },
	52	{ LP3943_REG_MUX1, 0x0C, 2 },
	53	{ LP3943_REG_MUX1, 0x30, 4 },
	54	{ LP3943_REG_MUX1, 0xC0, 6 },
	55	{ LP3943_REG_MUX2, 0x03, 0 },
	56	{ LP3943_REG_MUX2, 0x0C, 2 },
	57	{ LP3943_REG_MUX2, 0x30, 4 },
	58	{ LP3943_REG_MUX2, 0xC0, 6 },
	59	{ LP3943_REG_MUX3, 0x03, 0 },
	60	{ LP3943_REG_MUX3, 0x0C, 2 },
	61	{ LP3943_REG_MUX3, 0x30, 4 },
	62	{ LP3943_REG_MUX3, 0xC0, 6 },
	63	};
	64
81cf4f2d	65	static const struct mfd_cell lp3943_devs[] = {
470eca47 MK	66	{
	67	.name = "lp3943-pwm",
	68	.of_compatible = "ti,lp3943-pwm",
	69	},
	70	{
	71	.name = "lp3943-gpio",
	72	.of_compatible = "ti,lp3943-gpio",
	73	},
	74	};
	75
	76	int lp3943_read_byte(struct lp3943 lp3943, u8 reg, u8 read)
	77	{
	78	int ret;
	79	unsigned int val;
	80
	81	ret = regmap_read(lp3943->regmap, reg, &val);
	82	if (ret < 0)
	83	return ret;
	84
	85	*read = (u8)val;
	86	return 0;
	87	}
	88	EXPORT_SYMBOL_GPL(lp3943_read_byte);
	89
	90	int lp3943_write_byte(struct lp3943 *lp3943, u8 reg, u8 data)
	91	{
	92	return regmap_write(lp3943->regmap, reg, data);
	93	}
	94	EXPORT_SYMBOL_GPL(lp3943_write_byte);
	95
	96	int lp3943_update_bits(struct lp3943 *lp3943, u8 reg, u8 mask, u8 data)
	97	{
	98	return regmap_update_bits(lp3943->regmap, reg, mask, data);
	99	}
	100	EXPORT_SYMBOL_GPL(lp3943_update_bits);
	101
	102	static const struct regmap_config lp3943_regmap_config = {
	103	.reg_bits = 8,
	104	.val_bits = 8,
	105	.max_register = LP3943_MAX_REGISTERS,
	106	};
	107
	108	static int lp3943_probe(struct i2c_client cl, const struct i2c_device_id id)
	109	{
	110	struct lp3943 *lp3943;
	111	struct device *dev = &cl->dev;
	112
	113	lp3943 = devm_kzalloc(dev, sizeof(*lp3943), GFP_KERNEL);
	114	if (!lp3943)
	115	return -ENOMEM;
	116
	117	lp3943->regmap = devm_regmap_init_i2c(cl, &lp3943_regmap_config);
	118	if (IS_ERR(lp3943->regmap))
	119	return PTR_ERR(lp3943->regmap);
	120
	121	lp3943->pdata = dev_get_platdata(dev);
	122	lp3943->dev = dev;
	123	lp3943->mux_cfg = lp3943_mux_cfg;
	124	i2c_set_clientdata(cl, lp3943);
	125
c5f24454 LD	126	return devm_mfd_add_devices(dev, -1, lp3943_devs,
	127	ARRAY_SIZE(lp3943_devs),
	128	NULL, 0, NULL);
470eca47 MK	129	}
	130
	131	static const struct i2c_device_id lp3943_ids[] = {
	132	{ "lp3943", 0 },
	133	{ }
	134	};
	135	MODULE_DEVICE_TABLE(i2c, lp3943_ids);
	136
	137	#ifdef CONFIG_OF
	138	static const struct of_device_id lp3943_of_match[] = {
	139	{ .compatible = "ti,lp3943", },
	140	{ }
	141	};
	142	MODULE_DEVICE_TABLE(of, lp3943_of_match);
	143	#endif
	144
	145	static struct i2c_driver lp3943_driver = {
	146	.probe = lp3943_probe,
470eca47 MK	147	.driver = {
470eca47 MK	148	.name = "lp3943",
470eca47 MK	149	.of_match_table = of_match_ptr(lp3943_of_match),
	150	},
	151	.id_table = lp3943_ids,
	152	};
	153
	154	module_i2c_driver(lp3943_driver);
	155
	156	MODULE_DESCRIPTION("LP3943 MFD Core Driver");
	157	MODULE_AUTHOR("Milo Kim");
	158	MODULE_LICENSE("GPL");