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