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