[mirror_ubuntu-artful-kernel.git] / drivers / base / regmap / regmap-w1.c

/*
 * Register map access API - W1 (1-Wire) support
 *
 * Copyright (c) 2017 Radioavionica Corporation
 * Author: Alex A. Mihaylov <minimumlaw@rambler.ru>
 *
 * 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
 */

#include <linux/regmap.h>
#include <linux/module.h>
#include <linux/w1.h>

#include "internal.h"

#define W1_CMD_READ_DATA	0x69
#define W1_CMD_WRITE_DATA	0x6C

/*
 * 1-Wire slaves registers with addess 8 bit and data 8 bit
 */

static int w1_reg_a8_v8_read(void *context, unsigned int reg, unsigned int *val)
{
	struct device *dev = context;
	struct w1_slave *sl = container_of(dev, struct w1_slave, dev);
	int ret = 0;

	if (reg > 255)
		return -EINVAL;

	mutex_lock(&sl->master->bus_mutex);
	if (!w1_reset_select_slave(sl)) {
		w1_write_8(sl->master, W1_CMD_READ_DATA);
		w1_write_8(sl->master, reg);
		*val = w1_read_8(sl->master);
	} else {
		ret = -ENODEV;
	}
	mutex_unlock(&sl->master->bus_mutex);

	return ret;
}

static int w1_reg_a8_v8_write(void *context, unsigned int reg, unsigned int val)
{
	struct device *dev = context;
	struct w1_slave *sl = container_of(dev, struct w1_slave, dev);
	int ret = 0;

	if (reg > 255)
		return -EINVAL;

	mutex_lock(&sl->master->bus_mutex);
	if (!w1_reset_select_slave(sl)) {
		w1_write_8(sl->master, W1_CMD_WRITE_DATA);
		w1_write_8(sl->master, reg);
		w1_write_8(sl->master, val);
	} else {
		ret = -ENODEV;
	}
	mutex_unlock(&sl->master->bus_mutex);

	return ret;
}

/*
 * 1-Wire slaves registers with addess 8 bit and data 16 bit
 */

static int w1_reg_a8_v16_read(void *context, unsigned int reg,
				unsigned int *val)
{
	struct device *dev = context;
	struct w1_slave *sl = container_of(dev, struct w1_slave, dev);
	int ret = 0;

	if (reg > 255)
		return -EINVAL;

	mutex_lock(&sl->master->bus_mutex);
	if (!w1_reset_select_slave(sl)) {
		w1_write_8(sl->master, W1_CMD_READ_DATA);
		w1_write_8(sl->master, reg);
		*val = w1_read_8(sl->master);
		*val |= w1_read_8(sl->master)<<8;
	} else {
		ret = -ENODEV;
	}
	mutex_unlock(&sl->master->bus_mutex);

	return ret;
}

static int w1_reg_a8_v16_write(void *context, unsigned int reg,
				unsigned int val)
{
	struct device *dev = context;
	struct w1_slave *sl = container_of(dev, struct w1_slave, dev);
	int ret = 0;

	if (reg > 255)
		return -EINVAL;

	mutex_lock(&sl->master->bus_mutex);
	if (!w1_reset_select_slave(sl)) {
		w1_write_8(sl->master, W1_CMD_WRITE_DATA);
		w1_write_8(sl->master, reg);
		w1_write_8(sl->master, val & 0x00FF);
		w1_write_8(sl->master, val>>8 & 0x00FF);
	} else {
		ret = -ENODEV;
	}
	mutex_unlock(&sl->master->bus_mutex);

	return ret;
}

/*
 * 1-Wire slaves registers with addess 16 bit and data 16 bit
 */

static int w1_reg_a16_v16_read(void *context, unsigned int reg,
				unsigned int *val)
{
	struct device *dev = context;
	struct w1_slave *sl = container_of(dev, struct w1_slave, dev);
	int ret = 0;

	if (reg > 65535)
		return -EINVAL;

	mutex_lock(&sl->master->bus_mutex);
	if (!w1_reset_select_slave(sl)) {
		w1_write_8(sl->master, W1_CMD_READ_DATA);
		w1_write_8(sl->master, reg & 0x00FF);
		w1_write_8(sl->master, reg>>8 & 0x00FF);
		*val = w1_read_8(sl->master);
		*val |= w1_read_8(sl->master)<<8;
	} else {
		ret = -ENODEV;
	}
	mutex_unlock(&sl->master->bus_mutex);

	return ret;
}

static int w1_reg_a16_v16_write(void *context, unsigned int reg,
				unsigned int val)
{
	struct device *dev = context;
	struct w1_slave *sl = container_of(dev, struct w1_slave, dev);
	int ret = 0;

	if (reg > 65535)
		return -EINVAL;

	mutex_lock(&sl->master->bus_mutex);
	if (!w1_reset_select_slave(sl)) {
		w1_write_8(sl->master, W1_CMD_WRITE_DATA);
		w1_write_8(sl->master, reg & 0x00FF);
		w1_write_8(sl->master, reg>>8 & 0x00FF);
		w1_write_8(sl->master, val & 0x00FF);
		w1_write_8(sl->master, val>>8 & 0x00FF);
	} else {
		ret = -ENODEV;
	}
	mutex_unlock(&sl->master->bus_mutex);

	return ret;
}

/*
 * Various types of supported bus addressing
 */

static struct regmap_bus regmap_w1_bus_a8_v8 = {
	.reg_read = w1_reg_a8_v8_read,
	.reg_write = w1_reg_a8_v8_write,
};

static struct regmap_bus regmap_w1_bus_a8_v16 = {
	.reg_read = w1_reg_a8_v16_read,
	.reg_write = w1_reg_a8_v16_write,
};

static struct regmap_bus regmap_w1_bus_a16_v16 = {
	.reg_read = w1_reg_a16_v16_read,
	.reg_write = w1_reg_a16_v16_write,
};

static const struct regmap_bus *regmap_get_w1_bus(struct device *w1_dev,
					const struct regmap_config *config)
{
	if (config->reg_bits == 8 && config->val_bits == 8)
		return &regmap_w1_bus_a8_v8;

	if (config->reg_bits == 8 && config->val_bits == 16)
		return &regmap_w1_bus_a8_v16;

	if (config->reg_bits == 16 && config->val_bits == 16)
		return &regmap_w1_bus_a16_v16;

	return ERR_PTR(-ENOTSUPP);
}

struct regmap *__regmap_init_w1(struct device *w1_dev,
				 const struct regmap_config *config,
				 struct lock_class_key *lock_key,
				 const char *lock_name)
{

	const struct regmap_bus *bus = regmap_get_w1_bus(w1_dev, config);

	if (IS_ERR(bus))
		return ERR_CAST(bus);

	return __regmap_init(w1_dev, bus, w1_dev, config,
			 lock_key, lock_name);

	return NULL;
}
EXPORT_SYMBOL_GPL(__regmap_init_w1);

struct regmap *__devm_regmap_init_w1(struct device *w1_dev,
				 const struct regmap_config *config,
				 struct lock_class_key *lock_key,
				 const char *lock_name)
{

	const struct regmap_bus *bus = regmap_get_w1_bus(w1_dev, config);

	if (IS_ERR(bus))
		return ERR_CAST(bus);

	return __devm_regmap_init(w1_dev, bus, w1_dev, config,
				 lock_key, lock_name);

	return NULL;
}
EXPORT_SYMBOL_GPL(__devm_regmap_init_w1);

MODULE_LICENSE("GPL");
Commit	Line	Data
cc5d0db3 AM	1	/*
	2	* Register map access API - W1 (1-Wire) support
	3	*
5b20a436	4	* Copyright (c) 2017 Radioavionica Corporation
cc5d0db3 AM	5	* Author: Alex A. Mihaylov <minimumlaw@rambler.ru>
	6	*
	7	* This program is free software; you can redistribute it and/or modify
	8	* it under the terms of the GNU General Public License version 2 as
	9	* published by the Free Software Foundation
	10	*/
	11
	12	#include <linux/regmap.h>
	13	#include <linux/module.h>
5b20a436	14	#include <linux/w1.h>
cc5d0db3 AM	15
	16	#include "internal.h"
	17
	18	#define W1_CMD_READ_DATA 0x69
	19	#define W1_CMD_WRITE_DATA 0x6C
	20
	21	/*
	22	* 1-Wire slaves registers with addess 8 bit and data 8 bit
	23	*/
	24
	25	static int w1_reg_a8_v8_read(void context, unsigned int reg, unsigned int val)
	26	{
	27	struct device *dev = context;
	28	struct w1_slave *sl = container_of(dev, struct w1_slave, dev);
	29	int ret = 0;
	30
	31	if (reg > 255)
	32	return -EINVAL;
	33
	34	mutex_lock(&sl->master->bus_mutex);
	35	if (!w1_reset_select_slave(sl)) {
	36	w1_write_8(sl->master, W1_CMD_READ_DATA);
	37	w1_write_8(sl->master, reg);
	38	*val = w1_read_8(sl->master);
	39	} else {
	40	ret = -ENODEV;
	41	}
	42	mutex_unlock(&sl->master->bus_mutex);
	43
	44	return ret;
	45	}
	46
	47	static int w1_reg_a8_v8_write(void *context, unsigned int reg, unsigned int val)
	48	{
	49	struct device *dev = context;
	50	struct w1_slave *sl = container_of(dev, struct w1_slave, dev);
	51	int ret = 0;
	52
	53	if (reg > 255)
	54	return -EINVAL;
	55
	56	mutex_lock(&sl->master->bus_mutex);
	57	if (!w1_reset_select_slave(sl)) {
	58	w1_write_8(sl->master, W1_CMD_WRITE_DATA);
	59	w1_write_8(sl->master, reg);
	60	w1_write_8(sl->master, val);
	61	} else {
	62	ret = -ENODEV;
	63	}
	64	mutex_unlock(&sl->master->bus_mutex);
	65
	66	return ret;
	67	}
	68
	69	/*
	70	* 1-Wire slaves registers with addess 8 bit and data 16 bit
	71	*/
	72
	73	static int w1_reg_a8_v16_read(void *context, unsigned int reg,
	74	unsigned int *val)
	75	{
	76	struct device *dev = context;
	77	struct w1_slave *sl = container_of(dev, struct w1_slave, dev);
	78	int ret = 0;
79
80	if (reg > 255)
81	return -EINVAL;
82
83	mutex_lock(&sl->master->bus_mutex);
84	if (!w1_reset_select_slave(sl)) {
85	w1_write_8(sl->master, W1_CMD_READ_DATA);
86	w1_write_8(sl->master, reg);
87	*val = w1_read_8(sl->master);
88	*val \|= w1_read_8(sl->master)<<8;
89	} else {
90	ret = -ENODEV;
91	}
92	mutex_unlock(&sl->master->bus_mutex);
93
94	return ret;
95	}
96
97	static int w1_reg_a8_v16_write(void *context, unsigned int reg,
98	unsigned int val)
99	{
100	struct device *dev = context;
101	struct w1_slave *sl = container_of(dev, struct w1_slave, dev);
102	int ret = 0;
103
104	if (reg > 255)
105	return -EINVAL;
106
107	mutex_lock(&sl->master->bus_mutex);
108	if (!w1_reset_select_slave(sl)) {
109	w1_write_8(sl->master, W1_CMD_WRITE_DATA);
110	w1_write_8(sl->master, reg);
111	w1_write_8(sl->master, val & 0x00FF);
112	w1_write_8(sl->master, val>>8 & 0x00FF);
113	} else {
114	ret = -ENODEV;
115	}
116	mutex_unlock(&sl->master->bus_mutex);
117
118	return ret;
119	}
120
121	/*
122	* 1-Wire slaves registers with addess 16 bit and data 16 bit
123	*/
124
125	static int w1_reg_a16_v16_read(void *context, unsigned int reg,
126	unsigned int *val)
127	{
128	struct device *dev = context;
129	struct w1_slave *sl = container_of(dev, struct w1_slave, dev);
130	int ret = 0;
131
132	if (reg > 65535)
133	return -EINVAL;
134
135	mutex_lock(&sl->master->bus_mutex);
136	if (!w1_reset_select_slave(sl)) {
137	w1_write_8(sl->master, W1_CMD_READ_DATA);
138	w1_write_8(sl->master, reg & 0x00FF);
139	w1_write_8(sl->master, reg>>8 & 0x00FF);
140	*val = w1_read_8(sl->master);
141	*val \|= w1_read_8(sl->master)<<8;
142	} else {
143	ret = -ENODEV;
144	}
145	mutex_unlock(&sl->master->bus_mutex);
146
147	return ret;
148	}
149
150	static int w1_reg_a16_v16_write(void *context, unsigned int reg,
151	unsigned int val)
152	{
153	struct device *dev = context;
154	struct w1_slave *sl = container_of(dev, struct w1_slave, dev);
155	int ret = 0;
156
157	if (reg > 65535)
158	return -EINVAL;
159
160	mutex_lock(&sl->master->bus_mutex);
161	if (!w1_reset_select_slave(sl)) {
162	w1_write_8(sl->master, W1_CMD_WRITE_DATA);
163	w1_write_8(sl->master, reg & 0x00FF);
164	w1_write_8(sl->master, reg>>8 & 0x00FF);
165	w1_write_8(sl->master, val & 0x00FF);
166	w1_write_8(sl->master, val>>8 & 0x00FF);
167	} else {
168	ret = -ENODEV;
169	}
170	mutex_unlock(&sl->master->bus_mutex);
171
172	return ret;
173	}
174
175	/*
176	* Various types of supported bus addressing
177	*/
178
179	static struct regmap_bus regmap_w1_bus_a8_v8 = {
180	.reg_read = w1_reg_a8_v8_read,
181	.reg_write = w1_reg_a8_v8_write,
182	};
183
184	static struct regmap_bus regmap_w1_bus_a8_v16 = {
185	.reg_read = w1_reg_a8_v16_read,
186	.reg_write = w1_reg_a8_v16_write,
187	};
188
189	static struct regmap_bus regmap_w1_bus_a16_v16 = {
190	.reg_read = w1_reg_a16_v16_read,
191	.reg_write = w1_reg_a16_v16_write,
192	};
193
194	static const struct regmap_bus regmap_get_w1_bus(struct device w1_dev,
195	const struct regmap_config *config)
196	{
197	if (config->reg_bits == 8 && config->val_bits == 8)
198	return &regmap_w1_bus_a8_v8;
199
200	if (config->reg_bits == 8 && config->val_bits == 16)
201	return &regmap_w1_bus_a8_v16;
202
203	if (config->reg_bits == 16 && config->val_bits == 16)
204	return &regmap_w1_bus_a16_v16;
205
206	return ERR_PTR(-ENOTSUPP);
207	}
208
209	struct regmap __regmap_init_w1(struct device w1_dev,
210	const struct regmap_config *config,
211	struct lock_class_key *lock_key,
212	const char *lock_name)
213	{
214
215	const struct regmap_bus *bus = regmap_get_w1_bus(w1_dev, config);
216
217	if (IS_ERR(bus))
218	return ERR_CAST(bus);
219
220	return __regmap_init(w1_dev, bus, w1_dev, config,
221	lock_key, lock_name);
222
223	return NULL;
224	}
225	EXPORT_SYMBOL_GPL(__regmap_init_w1);
226
227	struct regmap __devm_regmap_init_w1(struct device w1_dev,
228	const struct regmap_config *config,
229	struct lock_class_key *lock_key,
230	const char *lock_name)
231	{
232
233	const struct regmap_bus *bus = regmap_get_w1_bus(w1_dev, config);
234
235	if (IS_ERR(bus))
236	return ERR_CAST(bus);
237
238	return __devm_regmap_init(w1_dev, bus, w1_dev, config,
239	lock_key, lock_name);
240
241	return NULL;
242	}
243	EXPORT_SYMBOL_GPL(__devm_regmap_init_w1);
244
245	MODULE_LICENSE("GPL");