1/*
2 * drivers/mfd/si476x-prop.c -- Subroutines to access
3 * properties of si476x chips
4 *
5 * Copyright (C) 2012 Innovative Converged Devices(ICD)
6 * Copyright (C) 2013 Andrey Smirnov
7 *
8 * Author: Andrey Smirnov <andrew.smirnov@gmail.com>
9 *
10 * This program is free software; you can redistribute it and/or modify
11 * it under the terms of the GNU General Public License as published by
12 * the Free Software Foundation; version 2 of the License.
13 *
14 * This program is distributed in the hope that it will be useful, but
15 * WITHOUT ANY WARRANTY; without even the implied warranty of
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
17 * General Public License for more details.
18 */
19#include <linux/module.h>
20
21#include <linux/mfd/si476x-core.h>
22
23struct si476x_property_range {
24	u16 low, high;
25};
26
27static bool si476x_core_element_is_in_array(u16 element,
28					    const u16 array[],
29					    size_t size)
30{
31	int i;
32
33	for (i = 0; i < size; i++)
34		if (element == array[i])
35			return true;
36
37	return false;
38}
39
40static bool si476x_core_element_is_in_range(u16 element,
41					    const struct si476x_property_range range[],
42					    size_t size)
43{
44	int i;
45
46	for (i = 0; i < size; i++)
47		if (element <= range[i].high && element >= range[i].low)
48			return true;
49
50	return false;
51}
52
53static bool si476x_core_is_valid_property_a10(struct si476x_core *core,
54					      u16 property)
55{
56	static const u16 valid_properties[] = {
57		0x0000,
58		0x0500, 0x0501,
59		0x0600,
60		0x0709, 0x070C, 0x070D, 0x70E, 0x710,
61		0x0718,
62		0x1207, 0x1208,
63		0x2007,
64		0x2300,
65	};
66
67	static const struct si476x_property_range valid_ranges[] = {
68		{ 0x0200, 0x0203 },
69		{ 0x0300, 0x0303 },
70		{ 0x0400, 0x0404 },
71		{ 0x0700, 0x0707 },
72		{ 0x1100, 0x1102 },
73		{ 0x1200, 0x1204 },
74		{ 0x1300, 0x1306 },
75		{ 0x2000, 0x2005 },
76		{ 0x2100, 0x2104 },
77		{ 0x2106, 0x2106 },
78		{ 0x2200, 0x220E },
79		{ 0x3100, 0x3104 },
80		{ 0x3207, 0x320F },
81		{ 0x3300, 0x3304 },
82		{ 0x3500, 0x3517 },
83		{ 0x3600, 0x3617 },
84		{ 0x3700, 0x3717 },
85		{ 0x4000, 0x4003 },
86	};
87
88	return	si476x_core_element_is_in_range(property, valid_ranges,
89						ARRAY_SIZE(valid_ranges)) ||
90		si476x_core_element_is_in_array(property, valid_properties,
91						ARRAY_SIZE(valid_properties));
92}
93
94static bool si476x_core_is_valid_property_a20(struct si476x_core *core,
95					      u16 property)
96{
97	static const u16 valid_properties[] = {
98		0x071B,
99		0x1006,
100		0x2210,
101		0x3401,
102	};
103
104	static const struct si476x_property_range valid_ranges[] = {
105		{ 0x2215, 0x2219 },
106	};
107
108	return	si476x_core_is_valid_property_a10(core, property) ||
109		si476x_core_element_is_in_range(property, valid_ranges,
110						ARRAY_SIZE(valid_ranges))  ||
111		si476x_core_element_is_in_array(property, valid_properties,
112						ARRAY_SIZE(valid_properties));
113}
114
115static bool si476x_core_is_valid_property_a30(struct si476x_core *core,
116					      u16 property)
117{
118	static const u16 valid_properties[] = {
119		0x071C, 0x071D,
120		0x1007, 0x1008,
121		0x220F, 0x2214,
122		0x2301,
123		0x3105, 0x3106,
124		0x3402,
125	};
126
127	static const struct si476x_property_range valid_ranges[] = {
128		{ 0x0405, 0x0411 },
129		{ 0x2008, 0x200B },
130		{ 0x2220, 0x2223 },
131		{ 0x3100, 0x3106 },
132	};
133
134	return	si476x_core_is_valid_property_a20(core, property) ||
135		si476x_core_element_is_in_range(property, valid_ranges,
136						ARRAY_SIZE(valid_ranges)) ||
137		si476x_core_element_is_in_array(property, valid_properties,
138						ARRAY_SIZE(valid_properties));
139}
140
141typedef bool (*valid_property_pred_t) (struct si476x_core *, u16);
142
143static bool si476x_core_is_valid_property(struct si476x_core *core,
144					  u16 property)
145{
146	static const valid_property_pred_t is_valid_property[] = {
147		[SI476X_REVISION_A10] = si476x_core_is_valid_property_a10,
148		[SI476X_REVISION_A20] = si476x_core_is_valid_property_a20,
149		[SI476X_REVISION_A30] = si476x_core_is_valid_property_a30,
150	};
151
152	BUG_ON(core->revision > SI476X_REVISION_A30 ||
153	       core->revision == -1);
154	return is_valid_property[core->revision](core, property);
155}
156
157
158static bool si476x_core_is_readonly_property(struct si476x_core *core,
159					     u16 property)
160{
161	BUG_ON(core->revision > SI476X_REVISION_A30 ||
162	       core->revision == -1);
163
164	switch (core->revision) {
165	case SI476X_REVISION_A10:
166		return (property == 0x3200);
167	case SI476X_REVISION_A20:
168		return (property == 0x1006 ||
169			property == 0x2210 ||
170			property == 0x3200);
171	case SI476X_REVISION_A30:
172		return false;
173	}
174
175	return false;
176}
177
178static bool si476x_core_regmap_readable_register(struct device *dev,
179						 unsigned int reg)
180{
181	struct i2c_client *client = to_i2c_client(dev);
182	struct si476x_core *core = i2c_get_clientdata(client);
183
184	return si476x_core_is_valid_property(core, (u16) reg);
185
186}
187
188static bool si476x_core_regmap_writable_register(struct device *dev,
189						 unsigned int reg)
190{
191	struct i2c_client *client = to_i2c_client(dev);
192	struct si476x_core *core = i2c_get_clientdata(client);
193
194	return si476x_core_is_valid_property(core, (u16) reg) &&
195		!si476x_core_is_readonly_property(core, (u16) reg);
196}
197
198
199static int si476x_core_regmap_write(void *context, unsigned int reg,
200				    unsigned int val)
201{
202	return si476x_core_cmd_set_property(context, reg, val);
203}
204
205static int si476x_core_regmap_read(void *context, unsigned int reg,
206				   unsigned *val)
207{
208	struct si476x_core *core = context;
209	int err;
210
211	err = si476x_core_cmd_get_property(core, reg);
212	if (err < 0)
213		return err;
214
215	*val = err;
216
217	return 0;
218}
219
220
221static const struct regmap_config si476x_regmap_config = {
222	.reg_bits = 16,
223	.val_bits = 16,
224
225	.max_register = 0x4003,
226
227	.writeable_reg = si476x_core_regmap_writable_register,
228	.readable_reg = si476x_core_regmap_readable_register,
229
230	.reg_read = si476x_core_regmap_read,
231	.reg_write = si476x_core_regmap_write,
232
233	.cache_type = REGCACHE_RBTREE,
234};
235
236struct regmap *devm_regmap_init_si476x(struct si476x_core *core)
237{
238	return devm_regmap_init(&core->client->dev, NULL,
239				core, &si476x_regmap_config);
240}
241EXPORT_SYMBOL_GPL(devm_regmap_init_si476x);
242