1 // SPDX-License-Identifier: GPL-2.0
2 /*
3 * dw9714 vcm driver
4 *
5 * Copyright (C) 2022 Fuzhou Rockchip Electronics Co., Ltd.
6 */
7
8 #include <linux/delay.h>
9 #include <linux/i2c.h>
10 #include <linux/module.h>
11 #include <linux/pm_runtime.h>
12 #include <linux/rk-camera-module.h>
13 #include <linux/version.h>
14 #include <media/v4l2-ctrls.h>
15 #include <media/v4l2-device.h>
16 #include <linux/rk_vcm_head.h>
17 #include <linux/compat.h>
18 #include <linux/regulator/consumer.h>
19
20 #define DRIVER_VERSION KERNEL_VERSION(0, 0x01, 0x0)
21 #define DW9714_NAME "dw9714"
22
23 #define DW9714_MAX_CURRENT 120U
24 #define DW9714_MAX_REG 1023U
25 #define DW9714_GRADUAL_MOVELENS_STEPS 32
26
27 #define DW9714_DEFAULT_START_CURRENT 0
28 #define DW9714_DEFAULT_RATED_CURRENT 100
29 #define DW9714_DEFAULT_STEP_MODE 0xd
30 #define DW9714_DEFAULT_DLC_EN 0x0
31 #define DW9714_DEFAULT_MCLK 0x0
32 #define DW9714_DEFAULT_T_SRC 0x0
33 #define REG_NULL 0xFF
34
35 /* dw9714p advanced mode */
36 #define DW9714_ADVMODE_IC_INFO 0x00
37 #define DW9714_ADVMODE_IC_VER 0x01
38 #define DW9714_ADVMODE_CONTROL 0x02
39 #define DW9714_ADVMODE_VCM_MSB 0x03
40 #define DW9714_ADVMODE_VCM_LSB 0x04
41 #define DW9714_ADVMODE_STATUS 0x05
42 #define DW9714_ADVMODE_SAC_CFG 0x06
43 #define DW9714_ADVMODE_PRESC 0x07
44 #define DW9714_ADVMODE_SAC_TIME 0x08
45 #define DW9714_ADVMODE_PRESET 0x09
46 #define DW9714_ADVMODE_NRC 0x0A
47 #define DW9714_ADVMODE_RING_EN 1
48
49 #define DW9714_DEFAULT_ADVMODE 0x00
50 #define DW9714_DEFAULT_SAC_MODE 0x04
51 #define DW9714_DEFAULT_SAC_TIME 0x0A
52 #define DW9714_DEFAULT_SAC_PRESCL 0x02
53 #define DW9714_DEFAULT_NRC_EN 0x00
54 #define DW9714_DEFAULT_NRC_MODE 0x00
55 #define DW9714_DEFAULT_NRC_PRESET 0x00
56 #define DW9714_DEFAULT_NRC_INFL 0x00
57 #define DW9714_DEFAULT_NRC_TIME 0x00
58
59 /* dw9714 device structure */
60 struct dw9714_device {
61 struct v4l2_ctrl_handler ctrls_vcm;
62 struct v4l2_ctrl *focus;
63 struct v4l2_subdev sd;
64 struct v4l2_device vdev;
65 u16 current_val;
66
67 unsigned short current_related_pos;
68 unsigned short current_lens_pos;
69 unsigned int max_current;
70 unsigned int start_current;
71 unsigned int rated_current;
72 unsigned int step_mode;
73 unsigned int vcm_movefull_t;
74 unsigned int dlc_enable;
75 unsigned int t_src;
76 unsigned int mclk;
77 unsigned int max_logicalpos;
78
79 /* advanced mode*/
80 unsigned char adcanced_mode;
81 unsigned char sac_mode;
82 unsigned char sac_time;
83 unsigned char sac_prescl;
84 unsigned char nrc_en;
85 unsigned char nrc_mode;
86 unsigned char nrc_preset;
87 unsigned char nrc_infl;
88 unsigned char nrc_time;
89
90 struct __kernel_old_timeval start_move_tv;
91 struct __kernel_old_timeval end_move_tv;
92 unsigned long move_ms;
93
94 u32 module_index;
95 const char *module_facing;
96 struct rk_cam_vcm_cfg vcm_cfg;
97
98 struct gpio_desc *xsd_gpio;
99 struct regulator *supply;
100 struct i2c_client *client;
101 bool power_on;
102 };
103
104 struct TimeTabel_s {
105 unsigned int t_src;/* time of slew rate control */
106 unsigned int step00;/* S[1:0] /MCLK[1:0] step period */
107 unsigned int step01;
108 unsigned int step10;
109 unsigned int step11;
110 };
111
112 static const struct TimeTabel_s dw9714_lsc_time_table[] = {/* 1/10us */
113 {0b10000, 1360, 2720, 5440, 10880},
114 {0b10001, 1300, 2600, 5200, 10400},
115 {0b10010, 1250, 2500, 5000, 10000},
116 {0b10011, 1200, 2400, 4800, 9600},
117 {0b10100, 1160, 2320, 4640, 9280},
118 {0b10101, 1120, 2240, 4480, 8960},
119 {0b10110, 1080, 2160, 4320, 8640},
120 {0b10111, 1040, 2080, 4160, 8320},
121 {0b11000, 1010, 2020, 4040, 8080},
122 {0b11001, 980, 1960, 3920, 7840},
123 {0b11010, 950, 1900, 3800, 7600},
124 {0b11011, 920, 1840, 3680, 7360},
125 {0b11100, 890, 1780, 3560, 7120},
126 {0b11101, 870, 1740, 3480, 6960},
127 {0b11110, 850, 1700, 3400, 6800},
128 {0b11111, 830, 1660, 3320, 6640},
129 {0b00000, 810, 1620, 3240, 6480},
130 {0b00001, 790, 1580, 3160, 6320},
131 {0b00010, 775, 1550, 3100, 6200},
132 {0b00011, 760, 1520, 3040, 6080},
133 {0b00100, 745, 1490, 2980, 5960},
134 {0b00101, 730, 1460, 2920, 5840},
135 {0b00110, 715, 1430, 2860, 5720},
136 {0b00111, 700, 1400, 2800, 5600},
137 {0b01000, 690, 1380, 2760, 5520},
138 {0b01001, 680, 1360, 2720, 5440},
139 {0b01010, 670, 1340, 2680, 5360},
140 {0b01011, 660, 1320, 2640, 5280},
141 {0b01100, 655, 1310, 2620, 5240},
142 {0b01101, 650, 1300, 2600, 5200},
143 {0b01110, 645, 1290, 2580, 5160},
144 {0b01111, 640, 1280, 2560, 5120},
145 {REG_NULL, 0, 0, 0, 0},
146 };
147
148 static const struct TimeTabel_s dw9714_dlc_time_table[] = {/* us */
149 {0b10000, 21250, 10630, 5310, 2660},
150 {0b10001, 20310, 10160, 5080, 2540},
151 {0b10010, 19530, 9770, 4880, 2440},
152 {0b10011, 18750, 9380, 4690, 2340},
153 {0b10100, 18130, 9060, 4530, 2270},
154 {0b10101, 17500, 8750, 4380, 2190},
155 {0b10110, 16880, 8440, 4220, 2110},
156 {0b10111, 16250, 8130, 4060, 2030},
157 {0b11000, 15780, 7890, 3950, 1970},
158 {0b11001, 15310, 7660, 3830, 1910},
159 {0b11010, 14840, 7420, 3710, 1860},
160 {0b11011, 14380, 7190, 3590, 1800},
161 {0b11100, 13910, 6950, 3480, 1740},
162 {0b11101, 13590, 6800, 3400, 1700},
163 {0b11110, 13280, 6640, 3320, 1660},
164 {0b11111, 12970, 6480, 3240, 1620},
165 {0b00000, 12660, 6330, 3160, 1580},
166 {0b00001, 12340, 6170, 3090, 1540},
167 {0b00010, 12110, 6050, 3030, 1510},
168 {0b00011, 11880, 5940, 2970, 1480},
169 {0b00100, 11640, 5820, 2910, 1460},
170 {0b00101, 11410, 5700, 2850, 1430},
171 {0b00110, 11170, 5590, 2790, 1400},
172 {0b00111, 10940, 5470, 2730, 1370},
173 {0b01000, 10780, 5390, 2700, 1350},
174 {0b01001, 10630, 5310, 2660, 1330},
175 {0b01010, 10470, 5230, 2620, 1310},
176 {0b01011, 10310, 5160, 2580, 1290},
177 {0b01100, 10230, 5120, 2560, 1280},
178 {0b01101, 10160, 5080, 2540, 1270},
179 {0b01110, 10080, 5040, 2520, 1260},
180 {0b01111, 10000, 5000, 2500, 1250},
181 {REG_NULL, 0, 0, 0, 0},
182 };
183
to_dw9714_vcm(struct v4l2_ctrl * ctrl)184 static inline struct dw9714_device *to_dw9714_vcm(struct v4l2_ctrl *ctrl)
185 {
186 return container_of(ctrl->handler, struct dw9714_device, ctrls_vcm);
187 }
188
sd_to_dw9714_vcm(struct v4l2_subdev * subdev)189 static inline struct dw9714_device *sd_to_dw9714_vcm(struct v4l2_subdev *subdev)
190 {
191 return container_of(subdev, struct dw9714_device, sd);
192 }
193
dw9714_read_msg(struct i2c_client * client,unsigned char * msb,unsigned char * lsb)194 static int dw9714_read_msg(struct i2c_client *client,
195 unsigned char *msb, unsigned char *lsb)
196 {
197 int ret = 0;
198 struct i2c_msg msg[1];
199 unsigned char data[2];
200 int retries;
201
202 if (!client->adapter) {
203 dev_err(&client->dev, "client->adapter NULL\n");
204 return -ENODEV;
205 }
206
207 for (retries = 0; retries < 5; retries++) {
208 msg->addr = client->addr;
209 msg->flags = I2C_M_RD;
210 msg->len = 2;
211 msg->buf = data;
212
213 ret = i2c_transfer(client->adapter, msg, 1);
214 if (ret == 1) {
215 dev_dbg(&client->dev,
216 "%s: vcm i2c ok, addr 0x%x, data 0x%x, 0x%x\n",
217 __func__, msg->addr, data[0], data[1]);
218
219 *msb = data[0];
220 *lsb = data[1];
221 return 0;
222 }
223
224 dev_info(&client->dev,
225 "retrying I2C... %d\n", retries);
226 retries++;
227 msleep(20);
228 }
229 dev_err(&client->dev,
230 "%s: i2c read to failed with error %d\n", __func__, ret);
231 return ret;
232 }
233
dw9714_write_msg(struct i2c_client * client,u8 msb,u8 lsb)234 static int dw9714_write_msg(struct i2c_client *client,
235 u8 msb, u8 lsb)
236 {
237 int ret = 0;
238 struct i2c_msg msg[1];
239 unsigned char data[2];
240 int retries;
241
242 if (!client->adapter) {
243 dev_err(&client->dev, "client->adapter NULL\n");
244 return -ENODEV;
245 }
246
247 for (retries = 0; retries < 5; retries++) {
248 msg->addr = client->addr;
249 msg->flags = 0;
250 msg->len = 2;
251 msg->buf = data;
252
253 data[0] = msb;
254 data[1] = lsb;
255
256 ret = i2c_transfer(client->adapter, msg, 1);
257 usleep_range(50, 100);
258
259 if (ret == 1) {
260 dev_dbg(&client->dev,
261 "%s: vcm i2c ok, addr 0x%x, data 0x%x, 0x%x\n",
262 __func__, msg->addr, data[0], data[1]);
263 return 0;
264 }
265
266 dev_info(&client->dev,
267 "retrying I2C... %d\n", retries);
268 msleep(20);
269 }
270 dev_err(&client->dev,
271 "i2c write to failed with error %d\n", ret);
272 return ret;
273 }
274
275 /* Write registers up to 4 at a time */
dw9714_write_reg(struct i2c_client * client,u8 reg,u32 len,u32 val)276 static int dw9714_write_reg(struct i2c_client *client, u8 reg, u32 len, u32 val)
277 {
278 u32 buf_i, val_i, retries;
279 u8 buf[5];
280 u8 *val_p;
281 __be32 val_be;
282
283 if (len > 4)
284 return -EINVAL;
285
286 buf[0] = reg;
287
288 val_be = cpu_to_be32(val);
289 val_p = (u8 *)&val_be;
290 buf_i = 1;
291 val_i = 4 - len;
292
293 while (val_i < 4)
294 buf[buf_i++] = val_p[val_i++];
295
296 for (retries = 0; retries < 5; retries++) {
297 if (i2c_master_send(client, buf, len + 1) == len + 1) {
298 dev_dbg(&client->dev,
299 "%s: vcm i2c ok, reg 0x%x, val 0x%x, len 0x%x\n",
300 __func__, reg, val, len);
301 return 0;
302 }
303
304 dev_info(&client->dev,
305 "retrying I2C... %d\n", retries);
306 msleep(20);
307 }
308
309 dev_err(&client->dev, "Failed to write 0x%04x,0x%x\n", reg, val);
310 return -EIO;
311 }
312
313 /* Read registers up to 4 at a time */
dw9714_read_reg(struct i2c_client * client,u8 reg,u32 len,u32 * val)314 static int dw9714_read_reg(struct i2c_client *client, u8 reg, u32 len, u32 *val)
315 {
316 struct i2c_msg msgs[2];
317 __be32 data_be = 0;
318 u8 *data_be_p;
319 u32 retries;
320 int ret;
321
322 if (len > 4 || !len)
323 return -EINVAL;
324
325 data_be_p = (u8 *)&data_be;
326 /* Write register address */
327 msgs[0].addr = client->addr;
328 msgs[0].flags = 0;
329 msgs[0].len = 1;
330 msgs[0].buf = (u8 *)®
331
332 /* Read data from register */
333 msgs[1].addr = client->addr;
334 msgs[1].flags = I2C_M_RD;
335 msgs[1].len = len;
336 msgs[1].buf = &data_be_p[4 - len];
337
338 for (retries = 0; retries < 5; retries++) {
339 ret = i2c_transfer(client->adapter, msgs, ARRAY_SIZE(msgs));
340 if (ret == ARRAY_SIZE(msgs)) {
341 *val = be32_to_cpu(data_be);
342 dev_dbg(&client->dev,
343 "%s: vcm i2c ok, reg 0x%x, val 0x%x\n",
344 __func__, reg, *val);
345 return 0;
346 }
347 }
348
349 dev_err(&client->dev,
350 "%s: i2c read to failed with error %d\n", __func__, ret);
351 return -EIO;
352 }
353
dw9714_move_time(struct dw9714_device * dev_vcm,unsigned int move_pos)354 static unsigned int dw9714_move_time(struct dw9714_device *dev_vcm,
355 unsigned int move_pos)
356 {
357 struct i2c_client *client = v4l2_get_subdevdata(&dev_vcm->sd);
358 unsigned int move_time_ms = 200;
359 unsigned int step_period_lsc = 0;
360 unsigned int step_period_dlc = 0;
361 unsigned int codes_per_step = 1;
362 unsigned int step_case;
363 unsigned int sac_prescl;
364 int table_cnt = 0;
365 int i = 0;
366
367 if (dev_vcm->adcanced_mode) {
368 // sac setting time = tvib = (3.81ms+(SACT[6:0]*0.03ms)) * PRESC[1:0]))
369 sac_prescl = 1 << dev_vcm->sac_prescl;
370 move_time_ms = (((381 + 3 * dev_vcm->sac_time)) * sac_prescl + 99) / 100;
371 return move_time_ms;
372 } else if (dev_vcm->dlc_enable) {
373 step_case = dev_vcm->mclk & 0x3;
374 table_cnt = sizeof(dw9714_dlc_time_table) /
375 sizeof(struct TimeTabel_s);
376 for (i = 0; i < table_cnt; i++) {
377 if (dw9714_dlc_time_table[i].t_src == dev_vcm->t_src)
378 break;
379 }
380 } else {
381 step_case = dev_vcm->step_mode & 0x3;
382 table_cnt = sizeof(dw9714_lsc_time_table) /
383 sizeof(struct TimeTabel_s);
384 for (i = 0; i < table_cnt; i++) {
385 if (dw9714_lsc_time_table[i].t_src == dev_vcm->t_src)
386 break;
387 }
388 }
389
390 if (i >= table_cnt)
391 i = 0;
392
393 switch (step_case) {
394 case 0:
395 step_period_lsc = dw9714_lsc_time_table[i].step00;
396 step_period_dlc = dw9714_dlc_time_table[i].step00;
397 break;
398 case 1:
399 step_period_lsc = dw9714_lsc_time_table[i].step01;
400 step_period_dlc = dw9714_dlc_time_table[i].step01;
401 break;
402 case 2:
403 step_period_lsc = dw9714_lsc_time_table[i].step10;
404 step_period_dlc = dw9714_dlc_time_table[i].step10;
405 break;
406 case 3:
407 step_period_lsc = dw9714_lsc_time_table[i].step11;
408 step_period_dlc = dw9714_dlc_time_table[i].step11;
409 break;
410 default:
411 dev_err(&client->dev,
412 "%s: step_case is error %d\n",
413 __func__, step_case);
414 break;
415 }
416 codes_per_step = (dev_vcm->step_mode & 0x0c) >> 2;
417 if (codes_per_step > 1)
418 codes_per_step = 1 << (codes_per_step - 1);
419
420 if (!dev_vcm->dlc_enable) {
421 if (!codes_per_step)
422 move_time_ms = (step_period_lsc * move_pos + 9999) / 10000;
423 else
424 move_time_ms = (step_period_lsc * move_pos / codes_per_step + 9999) / 10000;
425 } else {
426 move_time_ms = (step_period_dlc + 999) / 1000;
427 }
428
429 return move_time_ms;
430 }
431
dw9714_get_dac(struct dw9714_device * dev_vcm,unsigned int * cur_dac)432 static int dw9714_get_dac(struct dw9714_device *dev_vcm, unsigned int *cur_dac)
433 {
434 struct i2c_client *client = v4l2_get_subdevdata(&dev_vcm->sd);
435 int ret;
436 unsigned char lsb = 0;
437 unsigned char msb = 0;
438 unsigned int abs_step;
439
440 if (dev_vcm->adcanced_mode) {
441 ret = dw9714_read_reg(client, DW9714_ADVMODE_VCM_MSB, 2, &abs_step);
442 if (ret != 0)
443 goto err;
444 } else {
445 ret = dw9714_read_msg(client, &msb, &lsb);
446 if (ret != 0)
447 goto err;
448
449 abs_step = (((unsigned int)(msb & 0x3FU)) << 4U) |
450 (((unsigned int)lsb) >> 4U);
451 }
452
453 *cur_dac = abs_step;
454 dev_dbg(&client->dev, "%s: get dac %d\n", __func__, *cur_dac);
455 return 0;
456
457 err:
458 dev_err(&client->dev,
459 "%s: failed with error %d\n", __func__, ret);
460 return ret;
461 }
462
dw9714_set_dac(struct dw9714_device * dev_vcm,unsigned int dest_dac)463 static int dw9714_set_dac(struct dw9714_device *dev_vcm,
464 unsigned int dest_dac)
465 {
466 struct i2c_client *client = v4l2_get_subdevdata(&dev_vcm->sd);
467 int ret;
468
469 if (dev_vcm->adcanced_mode) {
470 unsigned int i;
471 bool vcm_idle = false;
472
473 /* wait for I2C bus idle */
474 vcm_idle = false;
475 for (i = 0; i < 10; i++) {
476 unsigned int status = 0;
477
478 dw9714_read_reg(client, DW9714_ADVMODE_STATUS, 1, &status);
479 status &= 0x01;
480 if (status == 0) {
481 vcm_idle = true;
482 break;
483 }
484 usleep_range(1000, 1200);
485 }
486
487 if (!vcm_idle) {
488 dev_err(&client->dev,
489 "%s: watting 0x05 flag timeout!\n", __func__);
490 return -ETIMEDOUT;
491 }
492
493 /* vcm move */
494 ret = dw9714_write_reg(client, DW9714_ADVMODE_VCM_MSB,
495 2, dest_dac);
496 if (ret != 0)
497 goto err;
498 } else {
499 unsigned char msb, lsb;
500
501 msb = (0x00U | ((dest_dac & 0x3F0U) >> 4U));
502 lsb = (((dest_dac & 0x0FU) << 4U) | dev_vcm->step_mode);
503 ret = dw9714_write_msg(client, msb, lsb);
504 if (ret != 0)
505 goto err;
506 }
507
508 return ret;
509 err:
510 dev_err(&client->dev,
511 "%s: failed with error %d\n", __func__, ret);
512 return ret;
513 }
514
dw9714_get_pos(struct dw9714_device * dev_vcm,unsigned int * cur_pos)515 static int dw9714_get_pos(struct dw9714_device *dev_vcm,
516 unsigned int *cur_pos)
517 {
518 struct i2c_client *client = v4l2_get_subdevdata(&dev_vcm->sd);
519 unsigned int dac, position, range;
520 int ret;
521
522 range = dev_vcm->rated_current - dev_vcm->start_current;
523 ret = dw9714_get_dac(dev_vcm, &dac);
524 if (!ret) {
525 if (dac <= dev_vcm->start_current) {
526 position = dev_vcm->max_logicalpos;
527 } else if ((dac > dev_vcm->start_current) &&
528 (dac <= dev_vcm->rated_current)) {
529 position = (dac - dev_vcm->start_current) * dev_vcm->max_logicalpos / range;
530 position = dev_vcm->max_logicalpos - position;
531 } else {
532 position = 0;
533 }
534
535 *cur_pos = position;
536
537 dev_dbg(&client->dev, "%s: get position %d, dac %d\n", __func__, *cur_pos, dac);
538 return 0;
539 }
540
541 dev_err(&client->dev,
542 "%s: failed with error %d\n", __func__, ret);
543 return ret;
544 }
545
dw9714_set_pos(struct dw9714_device * dev_vcm,unsigned int dest_pos)546 static int dw9714_set_pos(struct dw9714_device *dev_vcm,
547 unsigned int dest_pos)
548 {
549 struct i2c_client *client = v4l2_get_subdevdata(&dev_vcm->sd);
550 unsigned int position;
551 unsigned int range;
552 int ret;
553
554 range = dev_vcm->rated_current - dev_vcm->start_current;
555 if (dest_pos >= dev_vcm->max_logicalpos)
556 position = dev_vcm->start_current;
557 else
558 position = dev_vcm->start_current +
559 (range * (dev_vcm->max_logicalpos - dest_pos) / dev_vcm->max_logicalpos);
560
561 if (position > DW9714_MAX_REG)
562 position = DW9714_MAX_REG;
563
564 dev_vcm->current_lens_pos = position;
565 dev_vcm->current_related_pos = dest_pos;
566
567 ret = dw9714_set_dac(dev_vcm, position);
568 dev_dbg(&client->dev, "%s: set position %d, dac %d\n", __func__, dest_pos, position);
569
570 return ret;
571 }
572
dw9714_get_ctrl(struct v4l2_ctrl * ctrl)573 static int dw9714_get_ctrl(struct v4l2_ctrl *ctrl)
574 {
575 struct dw9714_device *dev_vcm = to_dw9714_vcm(ctrl);
576
577 if (ctrl->id == V4L2_CID_FOCUS_ABSOLUTE)
578 return dw9714_get_pos(dev_vcm, &ctrl->val);
579
580 return -EINVAL;
581 }
582
dw9714_set_ctrl(struct v4l2_ctrl * ctrl)583 static int dw9714_set_ctrl(struct v4l2_ctrl *ctrl)
584 {
585 struct dw9714_device *dev_vcm = to_dw9714_vcm(ctrl);
586 struct i2c_client *client = v4l2_get_subdevdata(&dev_vcm->sd);
587 unsigned int dest_pos = ctrl->val;
588 int move_pos;
589 long mv_us;
590 int ret = 0;
591
592 if (ctrl->id == V4L2_CID_FOCUS_ABSOLUTE) {
593 if (dest_pos > dev_vcm->max_logicalpos) {
594 dev_err(&client->dev,
595 "%s dest_pos is error. %d > %d\n",
596 __func__, dest_pos, dev_vcm->max_logicalpos);
597 return -EINVAL;
598 }
599 /* calculate move time */
600 move_pos = dev_vcm->current_related_pos - dest_pos;
601 if (move_pos < 0)
602 move_pos = -move_pos;
603
604 ret = dw9714_set_pos(dev_vcm, dest_pos);
605 if (dev_vcm->dlc_enable || dev_vcm->adcanced_mode)
606 dev_vcm->move_ms = dev_vcm->vcm_movefull_t;
607 else
608 dev_vcm->move_ms =
609 ((dev_vcm->vcm_movefull_t * (uint32_t)move_pos) /
610 dev_vcm->max_logicalpos);
611
612 dev_dbg(&client->dev,
613 "dest_pos %d, dac %d, move_ms %ld\n",
614 dest_pos, dev_vcm->current_lens_pos, dev_vcm->move_ms);
615
616 dev_vcm->start_move_tv = ns_to_kernel_old_timeval(ktime_get_ns());
617 mv_us = dev_vcm->start_move_tv.tv_usec +
618 dev_vcm->move_ms * 1000;
619 if (mv_us >= 1000000) {
620 dev_vcm->end_move_tv.tv_sec =
621 dev_vcm->start_move_tv.tv_sec + 1;
622 dev_vcm->end_move_tv.tv_usec = mv_us - 1000000;
623 } else {
624 dev_vcm->end_move_tv.tv_sec =
625 dev_vcm->start_move_tv.tv_sec;
626 dev_vcm->end_move_tv.tv_usec = mv_us;
627 }
628 }
629
630 return ret;
631 }
632
633 static const struct v4l2_ctrl_ops dw9714_vcm_ctrl_ops = {
634 .g_volatile_ctrl = dw9714_get_ctrl,
635 .s_ctrl = dw9714_set_ctrl,
636 };
637
dw9714_init(struct i2c_client * client)638 static int dw9714_init(struct i2c_client *client)
639 {
640 struct v4l2_subdev *sd = i2c_get_clientdata(client);
641 struct dw9714_device *dw9714_dev = sd_to_dw9714_vcm(sd);
642 unsigned char data = 0x0;
643 int ret = 0;
644
645 if (dw9714_dev->adcanced_mode) {
646 // need to wait 1ms after poweron
647 usleep_range(1000, 1200);
648 // Advanced Mode
649 ret = dw9714_write_msg(client, 0xED, 0xAB);
650 if (ret)
651 goto err;
652 // Power down
653 ret = dw9714_write_msg(client, DW9714_ADVMODE_CONTROL, 0x01);
654 if (ret)
655 goto err;
656 // active
657 ret = dw9714_write_msg(client, DW9714_ADVMODE_CONTROL, 0x00);
658 if (ret)
659 goto err;
660 // delay 1ms
661 usleep_range(1000, 1200);
662 // SAC mode & nrc_time & nrc_infl
663 data = DW9714_ADVMODE_RING_EN << 7 |
664 (dw9714_dev->nrc_infl & 0x3) << 5 |
665 (dw9714_dev->nrc_time & 0x1) << 4 |
666 (dw9714_dev->sac_mode & 0xF);
667 ret = dw9714_write_msg(client, DW9714_ADVMODE_SAC_CFG, data);
668 if (ret)
669 goto err;
670 // Set Tvib (PRESC[1:0] )
671 ret = dw9714_write_msg(client, DW9714_ADVMODE_PRESC, dw9714_dev->sac_prescl);
672 if (ret)
673 goto err;
674 // Set Tvib (SACT[6:0] )
675 ret = dw9714_write_msg(client, DW9714_ADVMODE_SAC_TIME, dw9714_dev->sac_time);
676 if (ret)
677 goto err;
678 // nrc preset
679 ret = dw9714_write_msg(client, DW9714_ADVMODE_PRESET, dw9714_dev->nrc_preset);
680 if (ret)
681 goto err;
682 // nrc en & nrc mode
683 data = (dw9714_dev->nrc_en & 0x1) << 1 |
684 (dw9714_dev->nrc_mode & 0x1);
685 ret = dw9714_write_msg(client, DW9714_ADVMODE_NRC, data);
686 if (ret)
687 goto err;
688 } else {
689 // need to wait 12ms after poweron
690 usleep_range(12000, 12500);
691
692 ret = dw9714_write_msg(client, 0xEC, 0xA3);
693 if (ret)
694 goto err;
695
696 data = (dw9714_dev->mclk & 0x3) | 0x04 |
697 ((dw9714_dev->dlc_enable << 0x3) & 0x08);
698 ret = dw9714_write_msg(client, 0xA1, data);
699 if (ret)
700 goto err;
701
702 data = (dw9714_dev->t_src << 0x3) & 0xf8;
703 ret = dw9714_write_msg(client, 0xF2, data);
704 if (ret)
705 goto err;
706
707 ret = dw9714_write_msg(client, 0xDC, 0x51);
708 if (ret)
709 goto err;
710
711 /* set normal mode */
712 ret = dw9714_write_msg(client, 0xDF, 0x5B);
713 if (ret != 0)
714 dev_err(&client->dev,
715 "%s: failed with error %d\n", __func__, ret);
716 }
717
718 return 0;
719 err:
720 dev_err(&client->dev, "failed with error %d\n", ret);
721 return -1;
722 }
723
dw9714_open(struct v4l2_subdev * sd,struct v4l2_subdev_fh * fh)724 static int dw9714_open(struct v4l2_subdev *sd, struct v4l2_subdev_fh *fh)
725 {
726 struct dw9714_device *dev_vcm = sd_to_dw9714_vcm(sd);
727 struct i2c_client *client = v4l2_get_subdevdata(sd);
728 unsigned int move_time;
729 int dac = 0;
730 int rval;
731
732 rval = pm_runtime_get_sync(sd->dev);
733 if (rval < 0) {
734 pm_runtime_put_noidle(sd->dev);
735 return rval;
736 }
737
738 dw9714_init(client);
739
740 dev_dbg(&client->dev, "%s: current_lens_pos %d, current_related_pos %d\n",
741 __func__, dev_vcm->current_lens_pos, dev_vcm->current_related_pos);
742 move_time = 1000 * dw9714_move_time(dev_vcm, DW9714_GRADUAL_MOVELENS_STEPS);
743 while (dac <= dev_vcm->current_lens_pos) {
744 dw9714_set_dac(dev_vcm, dac);
745 usleep_range(move_time, move_time + 1000);
746 dac += DW9714_GRADUAL_MOVELENS_STEPS;
747 if (dac >= dev_vcm->current_lens_pos)
748 break;
749 }
750
751 if (dac > dev_vcm->current_lens_pos) {
752 dac = dev_vcm->current_lens_pos;
753 dw9714_set_dac(dev_vcm, dac);
754 }
755
756 return 0;
757 }
758
dw9714_close(struct v4l2_subdev * sd,struct v4l2_subdev_fh * fh)759 static int dw9714_close(struct v4l2_subdev *sd, struct v4l2_subdev_fh *fh)
760 {
761 struct dw9714_device *dev_vcm = sd_to_dw9714_vcm(sd);
762 struct i2c_client *client = v4l2_get_subdevdata(sd);
763 int dac = dev_vcm->current_lens_pos;
764 unsigned int move_time;
765
766 dev_dbg(&client->dev, "%s: current_lens_pos %d, current_related_pos %d\n",
767 __func__, dev_vcm->current_lens_pos, dev_vcm->current_related_pos);
768 move_time = 1000 * dw9714_move_time(dev_vcm, DW9714_GRADUAL_MOVELENS_STEPS);
769 while (dac >= 0) {
770 dw9714_set_dac(dev_vcm, dac);
771 usleep_range(move_time, move_time + 1000);
772 dac -= DW9714_GRADUAL_MOVELENS_STEPS;
773 if (dac <= 0)
774 break;
775 }
776
777 if (dac < 0) {
778 dac = 0;
779 dw9714_set_dac(dev_vcm, dac);
780 }
781
782 pm_runtime_put(sd->dev);
783
784 return 0;
785 }
786
787 static const struct v4l2_subdev_internal_ops dw9714_int_ops = {
788 .open = dw9714_open,
789 .close = dw9714_close,
790 };
791
dw9714_update_vcm_cfg(struct dw9714_device * dev_vcm)792 static void dw9714_update_vcm_cfg(struct dw9714_device *dev_vcm)
793 {
794 struct i2c_client *client = v4l2_get_subdevdata(&dev_vcm->sd);
795
796 if (dev_vcm->max_current == 0) {
797 dev_err(&client->dev, "max current is zero");
798 return;
799 }
800
801 dev_vcm->start_current = dev_vcm->vcm_cfg.start_ma *
802 DW9714_MAX_REG / dev_vcm->max_current;
803 dev_vcm->rated_current = dev_vcm->vcm_cfg.rated_ma *
804 DW9714_MAX_REG / dev_vcm->max_current;
805 dev_vcm->step_mode = dev_vcm->vcm_cfg.step_mode;
806
807 dev_dbg(&client->dev,
808 "vcm_cfg: %d, %d, %d, max_current %d\n",
809 dev_vcm->vcm_cfg.start_ma,
810 dev_vcm->vcm_cfg.rated_ma,
811 dev_vcm->vcm_cfg.step_mode,
812 dev_vcm->max_current);
813 }
814
dw9714_ioctl(struct v4l2_subdev * sd,unsigned int cmd,void * arg)815 static long dw9714_ioctl(struct v4l2_subdev *sd, unsigned int cmd, void *arg)
816 {
817 struct dw9714_device *dev_vcm = sd_to_dw9714_vcm(sd);
818 struct i2c_client *client = v4l2_get_subdevdata(sd);
819 struct rk_cam_vcm_tim *vcm_tim;
820 struct rk_cam_vcm_cfg *vcm_cfg;
821 unsigned int max_logicalpos;
822 int ret = 0;
823
824 if (cmd == RK_VIDIOC_VCM_TIMEINFO) {
825 vcm_tim = (struct rk_cam_vcm_tim *)arg;
826
827 vcm_tim->vcm_start_t.tv_sec = dev_vcm->start_move_tv.tv_sec;
828 vcm_tim->vcm_start_t.tv_usec =
829 dev_vcm->start_move_tv.tv_usec;
830 vcm_tim->vcm_end_t.tv_sec = dev_vcm->end_move_tv.tv_sec;
831 vcm_tim->vcm_end_t.tv_usec = dev_vcm->end_move_tv.tv_usec;
832
833 dev_dbg(&client->dev, "dw9714_get_move_res 0x%lx, 0x%lx, 0x%lx, 0x%lx\n",
834 vcm_tim->vcm_start_t.tv_sec,
835 vcm_tim->vcm_start_t.tv_usec,
836 vcm_tim->vcm_end_t.tv_sec,
837 vcm_tim->vcm_end_t.tv_usec);
838 } else if (cmd == RK_VIDIOC_GET_VCM_CFG) {
839 vcm_cfg = (struct rk_cam_vcm_cfg *)arg;
840
841 vcm_cfg->start_ma = dev_vcm->vcm_cfg.start_ma;
842 vcm_cfg->rated_ma = dev_vcm->vcm_cfg.rated_ma;
843 vcm_cfg->step_mode = dev_vcm->vcm_cfg.step_mode;
844 } else if (cmd == RK_VIDIOC_SET_VCM_CFG) {
845 vcm_cfg = (struct rk_cam_vcm_cfg *)arg;
846
847 dev_vcm->vcm_cfg.start_ma = vcm_cfg->start_ma;
848 dev_vcm->vcm_cfg.rated_ma = vcm_cfg->rated_ma;
849 dev_vcm->vcm_cfg.step_mode = vcm_cfg->step_mode;
850 dw9714_update_vcm_cfg(dev_vcm);
851 } else if (cmd == RK_VIDIOC_SET_VCM_MAX_LOGICALPOS) {
852 max_logicalpos = *(unsigned int *)arg;
853
854 if (max_logicalpos > 0) {
855 dev_vcm->max_logicalpos = max_logicalpos;
856 __v4l2_ctrl_modify_range(dev_vcm->focus,
857 0, dev_vcm->max_logicalpos, 1, dev_vcm->max_logicalpos);
858 }
859 dev_dbg(&client->dev,
860 "max_logicalpos %d\n", max_logicalpos);
861 } else {
862 dev_err(&client->dev,
863 "cmd 0x%x not supported\n", cmd);
864 return -EINVAL;
865 }
866
867 return ret;
868 }
869
870 #ifdef CONFIG_COMPAT
dw9714_compat_ioctl32(struct v4l2_subdev * sd,unsigned int cmd,unsigned long arg)871 static long dw9714_compat_ioctl32(struct v4l2_subdev *sd,
872 unsigned int cmd, unsigned long arg)
873 {
874 struct i2c_client *client = v4l2_get_subdevdata(sd);
875 void __user *up = compat_ptr(arg);
876 struct rk_cam_compat_vcm_tim compat_vcm_tim;
877 struct rk_cam_vcm_tim vcm_tim;
878 struct rk_cam_vcm_cfg vcm_cfg;
879 unsigned int max_logicalpos;
880 long ret;
881
882 if (cmd == RK_VIDIOC_COMPAT_VCM_TIMEINFO) {
883 struct rk_cam_compat_vcm_tim __user *p32 = up;
884
885 ret = dw9714_ioctl(sd, RK_VIDIOC_VCM_TIMEINFO, &vcm_tim);
886 compat_vcm_tim.vcm_start_t.tv_sec = vcm_tim.vcm_start_t.tv_sec;
887 compat_vcm_tim.vcm_start_t.tv_usec = vcm_tim.vcm_start_t.tv_usec;
888 compat_vcm_tim.vcm_end_t.tv_sec = vcm_tim.vcm_end_t.tv_sec;
889 compat_vcm_tim.vcm_end_t.tv_usec = vcm_tim.vcm_end_t.tv_usec;
890
891 put_user(compat_vcm_tim.vcm_start_t.tv_sec,
892 &p32->vcm_start_t.tv_sec);
893 put_user(compat_vcm_tim.vcm_start_t.tv_usec,
894 &p32->vcm_start_t.tv_usec);
895 put_user(compat_vcm_tim.vcm_end_t.tv_sec,
896 &p32->vcm_end_t.tv_sec);
897 put_user(compat_vcm_tim.vcm_end_t.tv_usec,
898 &p32->vcm_end_t.tv_usec);
899 } else if (cmd == RK_VIDIOC_GET_VCM_CFG) {
900 ret = dw9714_ioctl(sd, RK_VIDIOC_GET_VCM_CFG, &vcm_cfg);
901 if (!ret) {
902 ret = copy_to_user(up, &vcm_cfg, sizeof(vcm_cfg));
903 if (ret)
904 ret = -EFAULT;
905 }
906 } else if (cmd == RK_VIDIOC_SET_VCM_CFG) {
907 ret = copy_from_user(&vcm_cfg, up, sizeof(vcm_cfg));
908 if (!ret)
909 ret = dw9714_ioctl(sd, cmd, &vcm_cfg);
910 else
911 ret = -EFAULT;
912 } else if (cmd == RK_VIDIOC_SET_VCM_MAX_LOGICALPOS) {
913 ret = copy_from_user(&max_logicalpos, up, sizeof(max_logicalpos));
914 if (!ret)
915 ret = dw9714_ioctl(sd, cmd, &max_logicalpos);
916 else
917 ret = -EFAULT;
918 } else {
919 dev_err(&client->dev,
920 "cmd 0x%x not supported\n", cmd);
921 return -EINVAL;
922 }
923
924 return ret;
925 }
926 #endif
927
928 static const struct v4l2_subdev_core_ops dw9714_core_ops = {
929 .ioctl = dw9714_ioctl,
930 #ifdef CONFIG_COMPAT
931 .compat_ioctl32 = dw9714_compat_ioctl32
932 #endif
933 };
934
935 static const struct v4l2_subdev_ops dw9714_ops = {
936 .core = &dw9714_core_ops,
937 };
938
dw9714_subdev_cleanup(struct dw9714_device * dw9714_dev)939 static void dw9714_subdev_cleanup(struct dw9714_device *dw9714_dev)
940 {
941 v4l2_device_unregister_subdev(&dw9714_dev->sd);
942 v4l2_device_unregister(&dw9714_dev->vdev);
943 v4l2_ctrl_handler_free(&dw9714_dev->ctrls_vcm);
944 media_entity_cleanup(&dw9714_dev->sd.entity);
945 }
946
dw9714_init_controls(struct dw9714_device * dev_vcm)947 static int dw9714_init_controls(struct dw9714_device *dev_vcm)
948 {
949 struct v4l2_ctrl_handler *hdl = &dev_vcm->ctrls_vcm;
950 const struct v4l2_ctrl_ops *ops = &dw9714_vcm_ctrl_ops;
951
952 v4l2_ctrl_handler_init(hdl, 1);
953
954 dev_vcm->focus = v4l2_ctrl_new_std(hdl, ops, V4L2_CID_FOCUS_ABSOLUTE,
955 0, dev_vcm->max_logicalpos, 1, dev_vcm->max_logicalpos);
956
957 if (hdl->error)
958 dev_err(dev_vcm->sd.dev, "%s fail error: 0x%x\n",
959 __func__, hdl->error);
960 dev_vcm->sd.ctrl_handler = hdl;
961 return hdl->error;
962 }
963
964 #define USED_SYS_DEBUG
965 #ifdef USED_SYS_DEBUG
set_dacval(struct device * dev,struct device_attribute * attr,const char * buf,size_t count)966 static ssize_t set_dacval(struct device *dev,
967 struct device_attribute *attr,
968 const char *buf,
969 size_t count)
970 {
971 struct i2c_client *client = to_i2c_client(dev);
972 struct v4l2_subdev *sd = i2c_get_clientdata(client);
973 struct dw9714_device *dev_vcm = sd_to_dw9714_vcm(sd);
974 int val = 0;
975 int ret = 0;
976
977 ret = kstrtoint(buf, 0, &val);
978 if (!ret)
979 dw9714_set_dac(dev_vcm, val);
980
981 return count;
982 }
983
get_dacval(struct device * dev,struct device_attribute * attr,char * buf)984 static ssize_t get_dacval(struct device *dev,
985 struct device_attribute *attr, char *buf)
986 {
987 struct i2c_client *client = to_i2c_client(dev);
988 struct v4l2_subdev *sd = i2c_get_clientdata(client);
989 struct dw9714_device *dev_vcm = sd_to_dw9714_vcm(sd);
990 unsigned int dac = 0;
991
992 dw9714_get_dac(dev_vcm, &dac);
993 return sprintf(buf, "%u\n", dac);
994 }
995
996 static struct device_attribute attributes[] = {
997 __ATTR(dacval, 0600, get_dacval, set_dacval),
998 };
999
add_sysfs_interfaces(struct device * dev)1000 static int add_sysfs_interfaces(struct device *dev)
1001 {
1002 int i;
1003
1004 for (i = 0; i < ARRAY_SIZE(attributes); i++)
1005 if (device_create_file(dev, attributes + i))
1006 goto undo;
1007 return 0;
1008 undo:
1009 for (i--; i >= 0 ; i--)
1010 device_remove_file(dev, attributes + i);
1011 dev_err(dev, "%s: failed to create sysfs interface\n", __func__);
1012 return -ENODEV;
1013 }
1014
remove_sysfs_interfaces(struct device * dev)1015 static int remove_sysfs_interfaces(struct device *dev)
1016 {
1017 int i;
1018
1019 for (i = 0; i < ARRAY_SIZE(attributes); i++)
1020 device_remove_file(dev, attributes + i);
1021 return 0;
1022 }
1023 #else
add_sysfs_interfaces(struct device * dev)1024 static inline int add_sysfs_interfaces(struct device *dev)
1025 {
1026 return 0;
1027 }
1028
remove_sysfs_interfaces(struct device * dev)1029 static inline int remove_sysfs_interfaces(struct device *dev)
1030 {
1031 return 0;
1032 }
1033 #endif
1034
dw9714_set_power(struct dw9714_device * dw9714,bool on)1035 static int dw9714_set_power(struct dw9714_device *dw9714, bool on)
1036 {
1037 struct i2c_client *client = dw9714->client;
1038 int ret = 0;
1039
1040 dev_info(&client->dev, "%s(%d) on(%d)\n", __func__, __LINE__, on);
1041
1042 if (dw9714->power_on == !!on)
1043 goto unlock_and_return;
1044
1045 if (on) {
1046 ret = regulator_enable(dw9714->supply);
1047 if (ret < 0) {
1048 dev_err(&client->dev, "Failed to enable regulator\n");
1049 goto unlock_and_return;
1050 }
1051 dw9714->power_on = true;
1052 } else {
1053 ret = regulator_disable(dw9714->supply);
1054 if (ret < 0) {
1055 dev_err(&client->dev, "Failed to disable regulator\n");
1056 goto unlock_and_return;
1057 }
1058 dw9714->power_on = false;
1059 }
1060
1061 unlock_and_return:
1062 return ret;
1063 }
1064
dw9714_check_i2c(struct dw9714_device * dw9714,struct i2c_client * client)1065 static int dw9714_check_i2c(struct dw9714_device *dw9714,
1066 struct i2c_client *client)
1067 {
1068 struct device *dev = &client->dev;
1069 int ret;
1070
1071 if (dw9714->adcanced_mode) {
1072 // need to wait 1ms after poweron
1073 usleep_range(1000, 1200);
1074 // Advanced Mode
1075 ret = dw9714_write_msg(client, 0xED, 0xAB);
1076 } else {
1077 // need to wait 12ms after poweron
1078 usleep_range(12000, 12500);
1079 ret = dw9714_write_msg(client, 0xEC, 0xA3);
1080 }
1081 if (!ret)
1082 dev_info(dev, "check dw9714 connection OK!\n");
1083 else
1084 dev_info(dev, "dw9714 not connect!\n");
1085
1086 return ret;
1087 }
1088
dw9714_configure_regulator(struct dw9714_device * dw9714)1089 static int dw9714_configure_regulator(struct dw9714_device *dw9714)
1090 {
1091 struct i2c_client *client = dw9714->client;
1092 int ret = 0;
1093
1094 dw9714->supply = devm_regulator_get(&client->dev, "avdd");
1095 if (IS_ERR(dw9714->supply)) {
1096 ret = PTR_ERR(dw9714->supply);
1097 if (ret != -EPROBE_DEFER)
1098 dev_err(&client->dev, "could not get regulator avdd\n");
1099 return ret;
1100 }
1101 dw9714->power_on = false;
1102 return ret;
1103 }
1104
dw9714_parse_dt_property(struct i2c_client * client,struct dw9714_device * dev_vcm)1105 static int dw9714_parse_dt_property(struct i2c_client *client,
1106 struct dw9714_device *dev_vcm)
1107 {
1108 struct device_node *np = of_node_get(client->dev.of_node);
1109 int ret;
1110
1111 if (of_property_read_u32(np,
1112 OF_CAMERA_VCMDRV_MAX_CURRENT,
1113 (unsigned int *)&dev_vcm->max_current)) {
1114 dev_vcm->max_current = DW9714_MAX_CURRENT;
1115 dev_info(&client->dev,
1116 "could not get module %s from dts!\n",
1117 OF_CAMERA_VCMDRV_MAX_CURRENT);
1118 }
1119 if (dev_vcm->max_current == 0)
1120 dev_vcm->max_current = DW9714_MAX_CURRENT;
1121
1122 if (of_property_read_u32(np,
1123 OF_CAMERA_VCMDRV_START_CURRENT,
1124 (unsigned int *)&dev_vcm->vcm_cfg.start_ma)) {
1125 dev_vcm->vcm_cfg.start_ma = DW9714_DEFAULT_START_CURRENT;
1126 dev_info(&client->dev,
1127 "could not get module %s from dts!\n",
1128 OF_CAMERA_VCMDRV_START_CURRENT);
1129 }
1130 if (of_property_read_u32(np,
1131 OF_CAMERA_VCMDRV_RATED_CURRENT,
1132 (unsigned int *)&dev_vcm->vcm_cfg.rated_ma)) {
1133 dev_vcm->vcm_cfg.rated_ma = DW9714_DEFAULT_RATED_CURRENT;
1134 dev_info(&client->dev,
1135 "could not get module %s from dts!\n",
1136 OF_CAMERA_VCMDRV_RATED_CURRENT);
1137 }
1138 if (of_property_read_u32(np,
1139 OF_CAMERA_VCMDRV_STEP_MODE,
1140 (unsigned int *)&dev_vcm->vcm_cfg.step_mode)) {
1141 dev_vcm->vcm_cfg.step_mode = DW9714_DEFAULT_STEP_MODE;
1142 dev_info(&client->dev,
1143 "could not get module %s from dts!\n",
1144 OF_CAMERA_VCMDRV_STEP_MODE);
1145 }
1146 if (of_property_read_u32(np,
1147 OF_CAMERA_VCMDRV_DLC_ENABLE,
1148 (unsigned int *)&dev_vcm->dlc_enable)) {
1149 dev_vcm->dlc_enable = DW9714_DEFAULT_DLC_EN;
1150 dev_info(&client->dev,
1151 "could not get module %s from dts!\n",
1152 OF_CAMERA_VCMDRV_DLC_ENABLE);
1153 }
1154 if (of_property_read_u32(np,
1155 OF_CAMERA_VCMDRV_MCLK,
1156 (unsigned int *)&dev_vcm->mclk)) {
1157 dev_vcm->mclk = DW9714_DEFAULT_MCLK;
1158 dev_info(&client->dev,
1159 "could not get module %s from dts!\n",
1160 OF_CAMERA_VCMDRV_MCLK);
1161 }
1162 if (of_property_read_u32(np,
1163 OF_CAMERA_VCMDRV_T_SRC,
1164 (unsigned int *)&dev_vcm->t_src)) {
1165 dev_vcm->t_src = DW9714_DEFAULT_T_SRC;
1166 dev_info(&client->dev,
1167 "could not get module %s from dts!\n",
1168 OF_CAMERA_VCMDRV_T_SRC);
1169 }
1170 if (of_property_read_u32(np,
1171 OF_CAMERA_VCMDRV_ADVANCED_MODE,
1172 (unsigned int *)&dev_vcm->adcanced_mode)) {
1173 dev_vcm->adcanced_mode = DW9714_DEFAULT_ADVMODE;
1174 dev_info(&client->dev,
1175 "could not get module %s from dts!\n",
1176 OF_CAMERA_VCMDRV_ADVANCED_MODE);
1177 }
1178 if (of_property_read_u32(np,
1179 OF_CAMERA_VCMDRV_SAC_MODE,
1180 (unsigned int *)&dev_vcm->sac_mode)) {
1181 dev_vcm->sac_mode = DW9714_DEFAULT_SAC_MODE;
1182 dev_info(&client->dev,
1183 "could not get module %s from dts!\n",
1184 OF_CAMERA_VCMDRV_SAC_MODE);
1185 }
1186 if (of_property_read_u32(np,
1187 OF_CAMERA_VCMDRV_SAC_TIME,
1188 (unsigned int *)&dev_vcm->sac_time)) {
1189 dev_vcm->sac_time = DW9714_DEFAULT_SAC_TIME;
1190 dev_info(&client->dev,
1191 "could not get module %s from dts!\n",
1192 OF_CAMERA_VCMDRV_SAC_TIME);
1193 }
1194 if (of_property_read_u32(np,
1195 OF_CAMERA_VCMDRV_PRESC,
1196 (unsigned int *)&dev_vcm->sac_prescl)) {
1197 dev_vcm->sac_prescl = DW9714_DEFAULT_SAC_PRESCL;
1198 dev_info(&client->dev,
1199 "could not get module %s from dts!\n",
1200 OF_CAMERA_VCMDRV_PRESC);
1201 }
1202 if (of_property_read_u32(np,
1203 OF_CAMERA_VCMDRV_NRC_EN,
1204 (unsigned int *)&dev_vcm->nrc_en)) {
1205 dev_vcm->nrc_en = DW9714_DEFAULT_NRC_EN;
1206 dev_info(&client->dev,
1207 "could not get module %s from dts!\n",
1208 OF_CAMERA_VCMDRV_NRC_EN);
1209 }
1210 if (of_property_read_u32(np,
1211 OF_CAMERA_VCMDRV_NRC_MODE,
1212 (unsigned int *)&dev_vcm->nrc_mode)) {
1213 dev_vcm->nrc_mode = DW9714_DEFAULT_NRC_MODE;
1214 dev_info(&client->dev,
1215 "could not get module %s from dts!\n",
1216 OF_CAMERA_VCMDRV_NRC_MODE);
1217 }
1218 if (of_property_read_u32(np,
1219 OF_CAMERA_VCMDRV_NRC_PRESET,
1220 (unsigned int *)&dev_vcm->nrc_preset)) {
1221 dev_vcm->nrc_preset = DW9714_DEFAULT_NRC_PRESET;
1222 dev_info(&client->dev,
1223 "could not get module %s from dts!\n",
1224 OF_CAMERA_VCMDRV_NRC_PRESET);
1225 }
1226 if (of_property_read_u32(np,
1227 OF_CAMERA_VCMDRV_NRC_INFL,
1228 (unsigned int *)&dev_vcm->nrc_infl)) {
1229 dev_vcm->nrc_infl = DW9714_DEFAULT_NRC_INFL;
1230 dev_info(&client->dev,
1231 "could not get module %s from dts!\n",
1232 OF_CAMERA_VCMDRV_NRC_INFL);
1233 }
1234 if (of_property_read_u32(np,
1235 OF_CAMERA_VCMDRV_NRC_TIME,
1236 (unsigned int *)&dev_vcm->nrc_time)) {
1237 dev_vcm->nrc_time = DW9714_DEFAULT_NRC_TIME;
1238 dev_info(&client->dev,
1239 "could not get module %s from dts!\n",
1240 OF_CAMERA_VCMDRV_NRC_TIME);
1241 }
1242
1243 dev_vcm->xsd_gpio = devm_gpiod_get(&client->dev, "xsd", GPIOD_OUT_HIGH);
1244 if (IS_ERR(dev_vcm->xsd_gpio))
1245 dev_warn(&client->dev, "Failed to get xsd-gpios\n");
1246
1247 ret = of_property_read_u32(np, RKMODULE_CAMERA_MODULE_INDEX,
1248 &dev_vcm->module_index);
1249 ret |= of_property_read_string(np, RKMODULE_CAMERA_MODULE_FACING,
1250 &dev_vcm->module_facing);
1251 if (ret) {
1252 dev_err(&client->dev,
1253 "could not get module information!\n");
1254 return -EINVAL;
1255 }
1256
1257 dev_vcm->client = client;
1258 ret = dw9714_configure_regulator(dev_vcm);
1259 if (ret) {
1260 dev_err(&client->dev, "Failed to get power regulator!\n");
1261 return ret;
1262 }
1263
1264 dev_dbg(&client->dev, "current: %d, %d, %d, dlc_en: %d, t_src: %d, mclk: %d",
1265 dev_vcm->max_current,
1266 dev_vcm->start_current,
1267 dev_vcm->rated_current,
1268 dev_vcm->dlc_enable,
1269 dev_vcm->t_src,
1270 dev_vcm->mclk);
1271
1272 /* advanced mode*/
1273 dev_dbg(&client->dev, "adcanced: %d, sac: %d, %d, %d, nrc: %d, %d, %d, %d, %d",
1274 dev_vcm->adcanced_mode,
1275 dev_vcm->sac_mode,
1276 dev_vcm->sac_time,
1277 dev_vcm->sac_prescl,
1278 dev_vcm->nrc_en,
1279 dev_vcm->nrc_mode,
1280 dev_vcm->nrc_preset,
1281 dev_vcm->nrc_infl,
1282 dev_vcm->nrc_time);
1283
1284 return 0;
1285 }
1286
dw9714_probe(struct i2c_client * client,const struct i2c_device_id * id)1287 static int dw9714_probe(struct i2c_client *client,
1288 const struct i2c_device_id *id)
1289 {
1290 struct dw9714_device *dw9714_dev;
1291 struct v4l2_subdev *sd;
1292 char facing[2];
1293 int ret;
1294
1295 dev_info(&client->dev, "probing...\n");
1296 dw9714_dev = devm_kzalloc(&client->dev, sizeof(*dw9714_dev),
1297 GFP_KERNEL);
1298 if (dw9714_dev == NULL)
1299 return -ENOMEM;
1300
1301 ret = dw9714_parse_dt_property(client, dw9714_dev);
1302 if (ret)
1303 return ret;
1304 v4l2_i2c_subdev_init(&dw9714_dev->sd, client, &dw9714_ops);
1305 dw9714_dev->sd.flags |= V4L2_SUBDEV_FL_HAS_DEVNODE;
1306 dw9714_dev->sd.internal_ops = &dw9714_int_ops;
1307
1308 dw9714_dev->max_logicalpos = VCMDRV_MAX_LOG;
1309 ret = dw9714_init_controls(dw9714_dev);
1310 if (ret)
1311 goto err_cleanup;
1312
1313 ret = media_entity_pads_init(&dw9714_dev->sd.entity, 0, NULL);
1314 if (ret < 0)
1315 goto err_cleanup;
1316
1317 ret = dw9714_set_power(dw9714_dev, true);
1318 if (ret)
1319 goto err_cleanup;
1320
1321 ret = dw9714_check_i2c(dw9714_dev, client);
1322 if (ret)
1323 goto err_power_off;
1324
1325 sd = &dw9714_dev->sd;
1326 sd->entity.function = MEDIA_ENT_F_LENS;
1327
1328 memset(facing, 0, sizeof(facing));
1329 if (strcmp(dw9714_dev->module_facing, "back") == 0)
1330 facing[0] = 'b';
1331 else
1332 facing[0] = 'f';
1333
1334 snprintf(sd->name, sizeof(sd->name), "m%02d_%s_%s %s",
1335 dw9714_dev->module_index, facing,
1336 DW9714_NAME, dev_name(sd->dev));
1337 ret = v4l2_async_register_subdev(sd);
1338 if (ret)
1339 dev_err(&client->dev, "v4l2 async register subdev failed\n");
1340
1341 dw9714_update_vcm_cfg(dw9714_dev);
1342 dw9714_dev->move_ms = 0;
1343 dw9714_dev->current_related_pos = dw9714_dev->max_logicalpos;
1344 dw9714_dev->current_lens_pos = dw9714_dev->start_current;
1345 dw9714_dev->start_move_tv = ns_to_kernel_old_timeval(ktime_get_ns());
1346 dw9714_dev->end_move_tv = ns_to_kernel_old_timeval(ktime_get_ns());
1347 dw9714_dev->vcm_movefull_t =
1348 dw9714_move_time(dw9714_dev, DW9714_MAX_REG);
1349 pm_runtime_enable(&client->dev);
1350
1351 add_sysfs_interfaces(&client->dev);
1352 dev_info(&client->dev, "probing successful\n");
1353
1354 return 0;
1355
1356 err_power_off:
1357 dw9714_set_power(dw9714_dev, false);
1358 err_cleanup:
1359 dw9714_subdev_cleanup(dw9714_dev);
1360 dev_err(&client->dev, "Probe failed: %d\n", ret);
1361 return ret;
1362 }
1363
dw9714_remove(struct i2c_client * client)1364 static int dw9714_remove(struct i2c_client *client)
1365 {
1366 struct v4l2_subdev *sd = i2c_get_clientdata(client);
1367 struct dw9714_device *dw9714_dev = sd_to_dw9714_vcm(sd);
1368
1369 remove_sysfs_interfaces(&client->dev);
1370 pm_runtime_disable(&client->dev);
1371 dw9714_subdev_cleanup(dw9714_dev);
1372
1373 return 0;
1374 }
1375
dw9714_vcm_suspend(struct device * dev)1376 static int __maybe_unused dw9714_vcm_suspend(struct device *dev)
1377 {
1378 struct i2c_client *client = to_i2c_client(dev);
1379 struct v4l2_subdev *sd = i2c_get_clientdata(client);
1380 struct dw9714_device *dev_vcm = sd_to_dw9714_vcm(sd);
1381
1382 dw9714_set_power(dev_vcm, false);
1383 return 0;
1384 }
1385
dw9714_vcm_resume(struct device * dev)1386 static int __maybe_unused dw9714_vcm_resume(struct device *dev)
1387 {
1388 struct i2c_client *client = to_i2c_client(dev);
1389 struct v4l2_subdev *sd = i2c_get_clientdata(client);
1390 struct dw9714_device *dev_vcm = sd_to_dw9714_vcm(sd);
1391
1392 dw9714_set_power(dev_vcm, true);
1393 return 0;
1394 }
1395
1396 static const struct i2c_device_id dw9714_id_table[] = {
1397 { DW9714_NAME, 0 },
1398 { { 0 } }
1399 };
1400 MODULE_DEVICE_TABLE(i2c, dw9714_id_table);
1401
1402 static const struct of_device_id dw9714_of_table[] = {
1403 { .compatible = "dongwoon,dw9714" },
1404 { { 0 } }
1405 };
1406 MODULE_DEVICE_TABLE(of, dw9714_of_table);
1407
1408 static const struct dev_pm_ops dw9714_pm_ops = {
1409 SET_SYSTEM_SLEEP_PM_OPS(dw9714_vcm_suspend, dw9714_vcm_resume)
1410 SET_RUNTIME_PM_OPS(dw9714_vcm_suspend, dw9714_vcm_resume, NULL)
1411 };
1412
1413 static struct i2c_driver dw9714_i2c_driver = {
1414 .driver = {
1415 .name = DW9714_NAME,
1416 .pm = &dw9714_pm_ops,
1417 .of_match_table = dw9714_of_table,
1418 },
1419 .probe = &dw9714_probe,
1420 .remove = &dw9714_remove,
1421 .id_table = dw9714_id_table,
1422 };
1423
1424 module_i2c_driver(dw9714_i2c_driver);
1425
1426 MODULE_DESCRIPTION("DW9714 VCM driver");
1427 MODULE_LICENSE("GPL v2");
1428