1 // SPDX-License-Identifier: GPL-2.0
2 /*
3 * Rockchip RK803 driver
4 *
5 * Copyright (C) 2021 Rockchip Electronics Co., Ltd.
6 *
7 */
8
9 #include <linux/fs.h>
10 #include <linux/gpio/consumer.h>
11 #include <linux/i2c.h>
12 #include <linux/kernel.h>
13 #include <linux/miscdevice.h>
14 #include <linux/module.h>
15 #include <linux/regmap.h>
16 #include <linux/regulator/consumer.h>
17 #include <uapi/linux/rk803.h>
18
19 #define RK803_CHIPID1 0x0A
20 #define RK803_CHIPID2 0x0B
21
22 #define IR_LED_DEFAULT_CURRENT LED_500MA
23 #define PRO_LED_DEFAULT_CURRENT LED_600MA
24
25 #define RK803_TIMEOUT 1000 /* usec */
26
27 enum SL_LED_CURRENT {
28 LED_100MA = 0,
29 LED_200MA,
30 LED_300MA,
31 LED_400MA,
32 LED_500MA,
33 LED_600MA,
34 LED_700MA,
35 LED_800MA,
36 LED_900MA,
37 LED_1000MA,
38 LED_1100MA,
39 LED_1200MA,
40 LED_1300MA,
41 LED_1400MA,
42 LED_1500MA,
43 LED_1600MA,
44 LED_1700MA,
45 LED_1800MA,
46 LED_1900MA,
47 LED_2000MA,
48 LED_2100MA,
49 LED_2200MA,
50 LED_2300MA,
51 LED_2400MA,
52 LED_2500MA,
53 LED_2600MA,
54 LED_2700MA,
55 LED_2800MA,
56 LED_2900MA,
57 LED_3000MA,
58 LED_3100MA,
59 LED_3200MA
60 };
61
62 static const char * const rk803_supply_names[] = {
63 "dvdd", /* Digital power */
64 };
65
66 #define RK803_NUM_SUPPLIES ARRAY_SIZE(rk803_supply_names)
67
68 struct rk803_data {
69 struct i2c_client *client;
70 struct regmap *regmap;
71 unsigned short chip_id;
72
73 unsigned char current1;
74 unsigned char current2;
75 struct gpio_desc *gpio_encc1;
76 struct gpio_desc *gpio_encc2;
77 struct miscdevice misc;
78 struct regulator_bulk_data supplies[RK803_NUM_SUPPLIES];
79 };
80
81 static const struct of_device_id rk803_of_match[] = {
82 { .compatible = "rockchip,rk803" },
83 { },
84 };
85
rk803_power_on(struct rk803_data * rk803)86 static int rk803_power_on(struct rk803_data *rk803)
87 {
88 int ret;
89 struct device *dev = &rk803->client->dev;
90
91 ret = regulator_bulk_enable(RK803_NUM_SUPPLIES, rk803->supplies);
92 if (ret < 0) {
93 dev_err(dev, "Failed to enable regulators\n");
94 return ret;
95 }
96
97 usleep_range(1000, 2000);
98
99 return 0;
100 }
101
rk803_power_off(struct rk803_data * rk803)102 static void rk803_power_off(struct rk803_data *rk803)
103 {
104 regulator_bulk_disable(RK803_NUM_SUPPLIES, rk803->supplies);
105 }
106
107 static ssize_t
rk803_i2c_write_reg(struct rk803_data * rk803,uint8_t reg,uint8_t val)108 rk803_i2c_write_reg(struct rk803_data *rk803, uint8_t reg, uint8_t val)
109 {
110 unsigned long timeout, write_time;
111 struct i2c_client *client;
112 struct regmap *regmap;
113 int ret;
114
115 regmap = rk803->regmap;
116 client = rk803->client;
117 timeout = jiffies + msecs_to_jiffies(25);
118
119 do {
120 /*
121 * The timestamp shall be taken before the actual operation
122 * to avoid a premature timeout in case of high CPU load.
123 */
124 write_time = jiffies;
125
126 ret = regmap_write(regmap, reg, val);
127 dev_dbg(&client->dev, "write %xu@%d --> %d (%ld)\n",
128 val, reg, ret, jiffies);
129 if (!ret)
130 return 1;
131
132 usleep_range(1000, 1500);
133 } while (time_before(write_time, timeout));
134
135 return -ETIMEDOUT;
136 }
137
rk803_dev_ioctl(struct file * file,unsigned int cmd,unsigned long arg)138 static long rk803_dev_ioctl(struct file *file, unsigned int cmd,
139 unsigned long arg)
140 {
141 int ret = 0;
142 struct rk803_data *rk803 =
143 container_of(file->private_data, struct rk803_data, misc);
144
145 switch (cmd) {
146 case RK803_SET_GPIO1: {
147 int val = (int)arg;
148
149 gpiod_set_value(rk803->gpio_encc1, val);
150 break;
151 }
152 case RK803_SET_GPIO2: {
153 int val = (int)arg;
154
155 gpiod_set_value(rk803->gpio_encc2, val);
156 break;
157 }
158 case RK803_SET_CURENT1: {
159 int val = (int)arg;
160
161 rk803->current1 = val;
162 rk803_i2c_write_reg(rk803, 0, rk803->current1);
163 break;
164 }
165 case RK803_SET_CURENT2: {
166 int val = (int)arg;
167
168 rk803->current2 = val;
169 rk803_i2c_write_reg(rk803, 1, rk803->current2);
170 break;
171 }
172 default:
173 ret = -EFAULT;
174 break;
175 }
176 return ret;
177 }
178
179 static const struct file_operations rk803_fops = {
180 .owner = THIS_MODULE,
181 .unlocked_ioctl = rk803_dev_ioctl,
182 #ifdef CONFIG_COMPAT
183 .compat_ioctl = rk803_dev_ioctl
184 #endif
185 };
186
rk803_configure_regulators(struct rk803_data * rk803)187 static int rk803_configure_regulators(struct rk803_data *rk803)
188 {
189 unsigned int i;
190
191 for (i = 0; i < RK803_NUM_SUPPLIES; i++)
192 rk803->supplies[i].supply = rk803_supply_names[i];
193
194 return devm_regulator_bulk_get(&rk803->client->dev,
195 RK803_NUM_SUPPLIES,
196 rk803->supplies);
197 }
198
199 static int
rk803_probe(struct i2c_client * client,const struct i2c_device_id * id)200 rk803_probe(struct i2c_client *client, const struct i2c_device_id *id)
201 {
202 //struct device_node *np = client->dev.of_node;
203 struct device *dev = &client->dev;
204 int msb, lsb;
205 unsigned short chipid;
206 struct rk803_data *rk803;
207 struct regmap *regmap;
208 struct regmap_config regmap_config = { };
209 int ret;
210 int cnt = 3;
211
212 rk803 = devm_kzalloc(dev, sizeof(*rk803), GFP_KERNEL);
213 if (!rk803)
214 return -ENOMEM;
215
216 rk803->client = client;
217
218 ret = rk803_configure_regulators(rk803);
219 if (ret) {
220 dev_err(dev, "Failed to get power regulators\n");
221 return ret;
222 }
223
224 rk803_power_on(rk803);
225
226 while (cnt--) {
227
228 if (ret)
229 usleep_range(1000, 2000);
230
231 /* check chip id */
232 msb = i2c_smbus_read_byte_data(client, RK803_CHIPID1);
233 if (msb < 0) {
234 dev_err(dev, "failed to read the chip1 id at 0x%x\n",
235 RK803_CHIPID1);
236 ret = -ENODEV;
237 continue;
238 }
239
240 lsb = i2c_smbus_read_byte_data(client, RK803_CHIPID2);
241 if (lsb < 0) {
242 dev_err(dev, "failed to read the chip2 id at 0x%x\n",
243 RK803_CHIPID2);
244 ret = -ENODEV;
245 continue;
246 }
247
248 ret = 0;
249 break;
250 }
251
252 if (ret)
253 return ret;
254
255 chipid = ((msb << 8) | lsb);
256 dev_info(dev, "chip id: 0x%x\n", (unsigned int)chipid);
257
258 regmap_config.val_bits = 8;
259 regmap_config.reg_bits = 8;
260 regmap_config.disable_locking = true;
261
262 regmap = devm_regmap_init_i2c(client, ®map_config);
263 if (IS_ERR(regmap)) {
264 ret = PTR_ERR(regmap);
265 goto error;
266 }
267
268 rk803->chip_id = chipid;
269 rk803->regmap = regmap;
270 rk803->current1 = IR_LED_DEFAULT_CURRENT;
271 rk803->current2 = PRO_LED_DEFAULT_CURRENT;
272
273 rk803->gpio_encc1 = devm_gpiod_get(dev, "gpio-encc1", GPIOD_OUT_LOW);
274 if (IS_ERR(rk803->gpio_encc1)) {
275 dev_err(dev, "can not find gpio_encc1\n");
276 ret = PTR_ERR(rk803->gpio_encc1);
277 goto error;
278 }
279 rk803->gpio_encc2 = devm_gpiod_get(dev, "gpio-encc2", GPIOD_OUT_LOW);
280 if (IS_ERR(rk803->gpio_encc2)) {
281 dev_err(dev, "can not find gpio_encc2\n");
282 ret = PTR_ERR(rk803->gpio_encc2);
283 goto error;
284 }
285
286 /* OVP */
287 rk803_i2c_write_reg(rk803, 4, 1);
288
289 /* Control time */
290 rk803_i2c_write_reg(rk803, 2, 0xe3);
291
292 /* Control CV */
293 rk803_i2c_write_reg(rk803, 3, 0xa7);
294
295 /* PRO */
296 rk803_i2c_write_reg(rk803, 0, PRO_LED_DEFAULT_CURRENT);
297
298 /* IR */
299 rk803_i2c_write_reg(rk803, 1, IR_LED_DEFAULT_CURRENT);
300
301 i2c_set_clientdata(client, rk803);
302
303 rk803->misc.minor = MISC_DYNAMIC_MINOR;
304 rk803->misc.name = "rk803";
305 rk803->misc.fops = &rk803_fops;
306
307 ret = misc_register(&rk803->misc);
308 if (ret < 0) {
309 dev_err(&client->dev, "Error: misc_register returned %d\n",
310 ret);
311 goto error;
312 }
313
314 dev_info(dev, "rk803 probe ok!\n");
315 return 0;
316
317 error:
318 rk803_power_off(rk803);
319 return ret;
320 }
321
rk803_remove(struct i2c_client * client)322 static int rk803_remove(struct i2c_client *client)
323 {
324 struct rk803_data *rk803;
325
326 rk803 = i2c_get_clientdata(client);
327 misc_deregister(&rk803->misc);
328
329 rk803_power_off(rk803);
330
331 return 0;
332 }
333
334 static struct i2c_driver rk803_driver = {
335 .driver = {
336 .name = "rk803",
337 .of_match_table = rk803_of_match,
338 },
339 .probe = rk803_probe,
340 .remove = rk803_remove,
341 };
342
rk803_init(void)343 static int __init rk803_init(void)
344 {
345 return i2c_add_driver(&rk803_driver);
346 }
347
348 subsys_initcall(rk803_init);
349
rk803_exit(void)350 static void __exit rk803_exit(void)
351 {
352 i2c_del_driver(&rk803_driver);
353 }
354
355 module_exit(rk803_exit);
356
357 MODULE_DESCRIPTION("Driver for RK803");
358 MODULE_AUTHOR("Rockchip");
359 MODULE_LICENSE("GPL");
360