1 // SPDX-License-Identifier: GPL-2.0
2 /*
3 * aw8601 vcm driver
4 *
5 * Copyright (C) 2019 Fuzhou Rockchip Electronics Co., Ltd.
6 */
7 //#define DEBUG
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
19 #define DRIVER_VERSION KERNEL_VERSION(0, 0x01, 0x0)
20 #define AW8601_NAME "aw8601"
21
22 #define AW8601_MAX_CURRENT 1023U
23 #define AW8601_MAX_REG 1023U
24
25 #define AW8601_DEFAULT_START_CURRENT 553
26 #define AW8601_DEFAULT_RATED_CURRENT 853
27 #define AW8601_DEFAULT_STEP_MODE 0x0
28 #define AW8601_DEFAULT_T_SRC 0x10
29 #define AW8601_DEFAULT_T_DIV 0x1
30 #define REG_NULL 0xFF
31
32 enum mode_e {
33 ARC2_MODE,
34 ARC3_MODE,
35 ARC4_MODE,
36 ARC5_MODE,
37 DIRECT_MODE,
38 LSC_MODE,
39 };
40
41 /* aw8601 device structure */
42 struct aw8601_device {
43 struct v4l2_ctrl_handler ctrls_vcm;
44 struct v4l2_ctrl *focus;
45 struct v4l2_subdev sd;
46 struct v4l2_device vdev;
47 u16 current_val;
48
49 unsigned short current_related_pos;
50 unsigned short current_lens_pos;
51 unsigned int start_current;
52 unsigned int rated_current;
53 unsigned int step_mode;
54 unsigned int vcm_movefull_t;
55 unsigned int t_src;
56 unsigned int t_div;
57 unsigned int max_logicalpos;
58
59 struct __kernel_old_timeval start_move_tv;
60 struct __kernel_old_timeval end_move_tv;
61 unsigned long move_us;
62
63 u32 module_index;
64 const char *module_facing;
65 struct rk_cam_vcm_cfg vcm_cfg;
66 int max_ma;
67 };
68
to_aw8601_vcm(struct v4l2_ctrl * ctrl)69 static inline struct aw8601_device *to_aw8601_vcm(struct v4l2_ctrl *ctrl)
70 {
71 return container_of(ctrl->handler, struct aw8601_device, ctrls_vcm);
72 }
73
sd_to_aw8601_vcm(struct v4l2_subdev * subdev)74 static inline struct aw8601_device *sd_to_aw8601_vcm(struct v4l2_subdev *subdev)
75 {
76 return container_of(subdev, struct aw8601_device, sd);
77 }
78
aw8601_write_reg(struct i2c_client * client,u8 reg,u32 len,u32 val)79 static int aw8601_write_reg(struct i2c_client *client, u8 reg,
80 u32 len, u32 val)
81 {
82 u32 buf_i, val_i;
83 u8 buf[5];
84 u8 *val_p;
85 __be32 val_be;
86
87 if (len > 4)
88 return -EINVAL;
89
90 buf[0] = reg;
91
92 val_be = cpu_to_be32(val);
93 val_p = (u8 *)&val_be;
94 buf_i = 1;
95 val_i = 4 - len;
96
97 while (val_i < 4)
98 buf[buf_i++] = val_p[val_i++];
99
100 if (i2c_master_send(client, buf, len + 1) != len + 1) {
101 dev_err(&client->dev, "Failed to write 0x%04x,0x%x\n", reg, val);
102 return -EIO;
103 }
104 return 0;
105 }
106
aw8601_read_reg(struct i2c_client * client,u8 reg,unsigned int len,u32 * val)107 static int aw8601_read_reg(struct i2c_client *client,
108 u8 reg,
109 unsigned int len,
110 u32 *val)
111 {
112 struct i2c_msg msgs[2];
113 u8 *data_be_p;
114 __be32 data_be = 0;
115 int ret;
116
117 if (len > 4 || !len)
118 return -EINVAL;
119
120 data_be_p = (u8 *)&data_be;
121 /* Write register address */
122 msgs[0].addr = client->addr;
123 msgs[0].flags = 0;
124 msgs[0].len = 1;
125 msgs[0].buf = (u8 *)®
126
127 /* Read data from register */
128 msgs[1].addr = client->addr;
129 msgs[1].flags = I2C_M_RD;
130 msgs[1].len = len;
131 msgs[1].buf = &data_be_p[4 - len];
132
133 ret = i2c_transfer(client->adapter, msgs, ARRAY_SIZE(msgs));
134 if (ret != ARRAY_SIZE(msgs))
135 return -EIO;
136
137 *val = be32_to_cpu(data_be);
138
139 return 0;
140 }
141
aw8601_move_time_div(struct aw8601_device * dev_vcm,unsigned int move_time_us)142 static unsigned int aw8601_move_time_div(struct aw8601_device *dev_vcm,
143 unsigned int move_time_us)
144 {
145 struct i2c_client *client = v4l2_get_subdevdata(&dev_vcm->sd);
146 unsigned int move_time = 0;
147
148 switch (dev_vcm->t_div) {
149 case 0:
150 move_time = move_time_us * 2;
151 break;
152 case 1:
153 move_time = move_time_us;
154 break;
155 case 2:
156 move_time = move_time_us / 2;
157 break;
158 case 3:
159 move_time = move_time_us / 4;
160 break;
161 case 4:
162 move_time = move_time_us * 8;
163 break;
164 case 5:
165 move_time = move_time_us * 4;
166 break;
167 default:
168 dev_err(&client->dev,
169 "%s: t_div parameter err %d\n",
170 __func__, dev_vcm->t_div);
171 break;
172 }
173 return move_time;
174 }
175
aw8601_move_time(struct aw8601_device * dev_vcm,unsigned int move_pos)176 static unsigned int aw8601_move_time(struct aw8601_device *dev_vcm,
177 unsigned int move_pos)
178 {
179 struct i2c_client *client = v4l2_get_subdevdata(&dev_vcm->sd);
180 unsigned int move_time_us = 0;
181
182 switch (dev_vcm->step_mode) {
183 case LSC_MODE:
184 move_time_us = 252 + dev_vcm->t_src * 4;
185 move_time_us = move_time_us * move_pos;
186 break;
187 case ARC2_MODE:
188 case ARC3_MODE:
189 case ARC4_MODE:
190 case ARC5_MODE:
191 move_time_us = 6300 + dev_vcm->t_src * 100;
192 move_time_us = aw8601_move_time_div(dev_vcm, move_time_us);
193 break;
194 case DIRECT_MODE:
195 move_time_us = 30000;
196 break;
197 default:
198 dev_err(&client->dev,
199 "%s: step_mode is error %d\n",
200 __func__, dev_vcm->step_mode);
201 break;
202 }
203
204 return move_time_us;
205 }
206
aw8601_get_pos(struct aw8601_device * dev_vcm,unsigned int * cur_pos)207 static int aw8601_get_pos(struct aw8601_device *dev_vcm,
208 unsigned int *cur_pos)
209 {
210 struct i2c_client *client = v4l2_get_subdevdata(&dev_vcm->sd);
211 unsigned int abs_step, range;
212 int ret;
213
214 range = dev_vcm->rated_current - dev_vcm->start_current;
215 ret = aw8601_read_reg(client, 0x03, 2, &abs_step);
216 if (ret != 0)
217 goto err;
218
219 if (abs_step <= dev_vcm->start_current) {
220 abs_step = dev_vcm->max_logicalpos;
221 } else if ((abs_step > dev_vcm->start_current) &&
222 (abs_step <= dev_vcm->rated_current)) {
223 abs_step = (abs_step - dev_vcm->start_current) * dev_vcm->max_logicalpos / range;
224 abs_step = dev_vcm->max_logicalpos - abs_step;
225 } else {
226 abs_step = 0;
227 }
228
229 *cur_pos = abs_step;
230 dev_dbg(&client->dev, "%s: get position %d\n", __func__, *cur_pos);
231 return 0;
232
233 err:
234 dev_err(&client->dev,
235 "%s: failed with error %d\n", __func__, ret);
236 return ret;
237 }
238
aw8601_set_pos(struct aw8601_device * dev_vcm,unsigned int dest_pos)239 static int aw8601_set_pos(struct aw8601_device *dev_vcm,
240 unsigned int dest_pos)
241 {
242 int ret;
243 unsigned int position = 0;
244 struct i2c_client *client = v4l2_get_subdevdata(&dev_vcm->sd);
245 u32 is_busy, i;
246 u32 range;
247
248 range = dev_vcm->rated_current - dev_vcm->start_current;
249 if (dest_pos >= dev_vcm->max_logicalpos)
250 position = dev_vcm->start_current;
251 else
252 position = dev_vcm->start_current +
253 (range * (dev_vcm->max_logicalpos - dest_pos) / dev_vcm->max_logicalpos);
254
255 if (position > AW8601_MAX_REG)
256 position = AW8601_MAX_REG;
257
258 dev_vcm->current_lens_pos = position;
259 dev_vcm->current_related_pos = dest_pos;
260 for (i = 0; i < 500; i++) {
261 ret = aw8601_read_reg(client, 0x05, 1, &is_busy);
262 if (!ret && !(is_busy & 0x01))
263 break;
264 usleep_range(100, 200);
265 }
266 ret = aw8601_write_reg(client, 0x03, 2, dev_vcm->current_lens_pos);
267 if (ret != 0)
268 goto err;
269 dev_dbg(&client->dev,
270 "%s: set reg val %d\n", __func__, dev_vcm->current_lens_pos);
271 return ret;
272 err:
273 dev_err(&client->dev,
274 "%s: failed with error %d\n", __func__, ret);
275 return ret;
276 }
277
aw8601_get_ctrl(struct v4l2_ctrl * ctrl)278 static int aw8601_get_ctrl(struct v4l2_ctrl *ctrl)
279 {
280 struct aw8601_device *dev_vcm = to_aw8601_vcm(ctrl);
281
282 if (ctrl->id == V4L2_CID_FOCUS_ABSOLUTE)
283 return aw8601_get_pos(dev_vcm, &ctrl->val);
284
285 return -EINVAL;
286 }
287
aw8601_set_ctrl(struct v4l2_ctrl * ctrl)288 static int aw8601_set_ctrl(struct v4l2_ctrl *ctrl)
289 {
290 struct aw8601_device *dev_vcm = to_aw8601_vcm(ctrl);
291 struct i2c_client *client = v4l2_get_subdevdata(&dev_vcm->sd);
292 unsigned int dest_pos = ctrl->val;
293 int move_pos;
294 long mv_us;
295 int ret = 0;
296
297 if (ctrl->id == V4L2_CID_FOCUS_ABSOLUTE) {
298 if (dest_pos > dev_vcm->max_logicalpos) {
299 dev_info(&client->dev,
300 "%s dest_pos is error. %d > %d\n",
301 __func__, dest_pos, dev_vcm->max_logicalpos);
302 return -EINVAL;
303 }
304 /* calculate move time */
305 move_pos = dev_vcm->current_related_pos - dest_pos;
306 if (move_pos < 0)
307 move_pos = -move_pos;
308
309 ret = aw8601_set_pos(dev_vcm, dest_pos);
310
311 if (dev_vcm->step_mode == LSC_MODE)
312 dev_vcm->move_us = ((dev_vcm->vcm_movefull_t * (uint32_t)move_pos) /
313 dev_vcm->max_logicalpos);
314 else
315 dev_vcm->move_us = dev_vcm->vcm_movefull_t;
316
317 dev_dbg(&client->dev,
318 "dest_pos %d, move_us %ld\n",
319 dest_pos, dev_vcm->move_us);
320
321 dev_vcm->start_move_tv = ns_to_kernel_old_timeval(ktime_get_ns());
322 mv_us = dev_vcm->start_move_tv.tv_usec +
323 dev_vcm->move_us;
324 if (mv_us >= 1000000) {
325 dev_vcm->end_move_tv.tv_sec =
326 dev_vcm->start_move_tv.tv_sec + 1;
327 dev_vcm->end_move_tv.tv_usec = mv_us - 1000000;
328 } else {
329 dev_vcm->end_move_tv.tv_sec =
330 dev_vcm->start_move_tv.tv_sec;
331 dev_vcm->end_move_tv.tv_usec = mv_us;
332 }
333 }
334
335 return ret;
336 }
337
338 static const struct v4l2_ctrl_ops aw8601_vcm_ctrl_ops = {
339 .g_volatile_ctrl = aw8601_get_ctrl,
340 .s_ctrl = aw8601_set_ctrl,
341 };
342
aw8601_open(struct v4l2_subdev * sd,struct v4l2_subdev_fh * fh)343 static int aw8601_open(struct v4l2_subdev *sd, struct v4l2_subdev_fh *fh)
344 {
345 int rval;
346
347 rval = pm_runtime_get_sync(sd->dev);
348 if (rval < 0) {
349 pm_runtime_put_noidle(sd->dev);
350 return rval;
351 }
352
353 return 0;
354 }
355
aw8601_close(struct v4l2_subdev * sd,struct v4l2_subdev_fh * fh)356 static int aw8601_close(struct v4l2_subdev *sd, struct v4l2_subdev_fh *fh)
357 {
358 pm_runtime_put(sd->dev);
359
360 return 0;
361 }
362
363 static const struct v4l2_subdev_internal_ops aw8601_int_ops = {
364 .open = aw8601_open,
365 .close = aw8601_close,
366 };
367
aw8601_update_vcm_cfg(struct aw8601_device * dev_vcm)368 static void aw8601_update_vcm_cfg(struct aw8601_device *dev_vcm)
369 {
370 struct i2c_client *client = v4l2_get_subdevdata(&dev_vcm->sd);
371
372 if (dev_vcm->max_ma == 0) {
373 dev_err(&client->dev, "max current is zero");
374 return;
375 }
376
377 dev_vcm->start_current = dev_vcm->vcm_cfg.start_ma *
378 AW8601_MAX_REG / dev_vcm->max_ma;
379 dev_vcm->rated_current = dev_vcm->vcm_cfg.rated_ma *
380 AW8601_MAX_REG / dev_vcm->max_ma;
381 dev_vcm->step_mode = dev_vcm->vcm_cfg.step_mode;
382
383 dev_info(&client->dev,
384 "vcm_cfg: %d, %d, %d, max_ma %d\n",
385 dev_vcm->vcm_cfg.start_ma,
386 dev_vcm->vcm_cfg.rated_ma,
387 dev_vcm->vcm_cfg.step_mode,
388 dev_vcm->max_ma);
389 }
390
aw8601_ioctl(struct v4l2_subdev * sd,unsigned int cmd,void * arg)391 static long aw8601_ioctl(struct v4l2_subdev *sd, unsigned int cmd, void *arg)
392 {
393 struct aw8601_device *dev_vcm = sd_to_aw8601_vcm(sd);
394 struct i2c_client *client = v4l2_get_subdevdata(sd);
395 struct rk_cam_vcm_tim *vcm_tim;
396 struct rk_cam_vcm_cfg *vcm_cfg;
397 unsigned int max_logicalpos;
398 int ret = 0;
399
400 if (cmd == RK_VIDIOC_VCM_TIMEINFO) {
401 vcm_tim = (struct rk_cam_vcm_tim *)arg;
402
403 vcm_tim->vcm_start_t.tv_sec = dev_vcm->start_move_tv.tv_sec;
404 vcm_tim->vcm_start_t.tv_usec =
405 dev_vcm->start_move_tv.tv_usec;
406 vcm_tim->vcm_end_t.tv_sec = dev_vcm->end_move_tv.tv_sec;
407 vcm_tim->vcm_end_t.tv_usec = dev_vcm->end_move_tv.tv_usec;
408
409 dev_dbg(&client->dev, "aw8601_get_move_res 0x%lx, 0x%lx, 0x%lx, 0x%lx\n",
410 vcm_tim->vcm_start_t.tv_sec,
411 vcm_tim->vcm_start_t.tv_usec,
412 vcm_tim->vcm_end_t.tv_sec,
413 vcm_tim->vcm_end_t.tv_usec);
414 } else if (cmd == RK_VIDIOC_GET_VCM_CFG) {
415 vcm_cfg = (struct rk_cam_vcm_cfg *)arg;
416
417 vcm_cfg->start_ma = dev_vcm->vcm_cfg.start_ma;
418 vcm_cfg->rated_ma = dev_vcm->vcm_cfg.rated_ma;
419 vcm_cfg->step_mode = dev_vcm->vcm_cfg.step_mode;
420 } else if (cmd == RK_VIDIOC_SET_VCM_CFG) {
421 vcm_cfg = (struct rk_cam_vcm_cfg *)arg;
422
423 if (vcm_cfg->start_ma == 0 && vcm_cfg->rated_ma == 0) {
424 dev_err(&client->dev,
425 "vcm_cfg err, start_ma %d, rated_ma %d\n",
426 vcm_cfg->start_ma, vcm_cfg->rated_ma);
427 return -EINVAL;
428 }
429 dev_vcm->vcm_cfg.start_ma = vcm_cfg->start_ma;
430 dev_vcm->vcm_cfg.rated_ma = vcm_cfg->rated_ma;
431 dev_vcm->vcm_cfg.step_mode = vcm_cfg->step_mode;
432 aw8601_update_vcm_cfg(dev_vcm);
433 } else if (cmd == RK_VIDIOC_SET_VCM_MAX_LOGICALPOS) {
434 max_logicalpos = *(unsigned int *)arg;
435
436 if (max_logicalpos > 0) {
437 dev_vcm->max_logicalpos = max_logicalpos;
438 __v4l2_ctrl_modify_range(dev_vcm->focus,
439 0, dev_vcm->max_logicalpos, 1, dev_vcm->max_logicalpos);
440 }
441 dev_dbg(&client->dev,
442 "max_logicalpos %d\n", max_logicalpos);
443 } else {
444 dev_err(&client->dev,
445 "cmd 0x%x not supported\n", cmd);
446 return -EINVAL;
447 }
448
449 return ret;
450 }
451
452 #ifdef CONFIG_COMPAT
aw8601_compat_ioctl32(struct v4l2_subdev * sd,unsigned int cmd,unsigned long arg)453 static long aw8601_compat_ioctl32(struct v4l2_subdev *sd,
454 unsigned int cmd, unsigned long arg)
455 {
456 struct i2c_client *client = v4l2_get_subdevdata(sd);
457 void __user *up = compat_ptr(arg);
458 struct rk_cam_compat_vcm_tim compat_vcm_tim;
459 struct rk_cam_vcm_tim vcm_tim;
460 struct rk_cam_vcm_cfg vcm_cfg;
461 unsigned int max_logicalpos;
462 long ret;
463
464 if (cmd == RK_VIDIOC_COMPAT_VCM_TIMEINFO) {
465 struct rk_cam_compat_vcm_tim __user *p32 = up;
466
467 ret = aw8601_ioctl(sd, RK_VIDIOC_VCM_TIMEINFO, &vcm_tim);
468 compat_vcm_tim.vcm_start_t.tv_sec = vcm_tim.vcm_start_t.tv_sec;
469 compat_vcm_tim.vcm_start_t.tv_usec = vcm_tim.vcm_start_t.tv_usec;
470 compat_vcm_tim.vcm_end_t.tv_sec = vcm_tim.vcm_end_t.tv_sec;
471 compat_vcm_tim.vcm_end_t.tv_usec = vcm_tim.vcm_end_t.tv_usec;
472
473 put_user(compat_vcm_tim.vcm_start_t.tv_sec,
474 &p32->vcm_start_t.tv_sec);
475 put_user(compat_vcm_tim.vcm_start_t.tv_usec,
476 &p32->vcm_start_t.tv_usec);
477 put_user(compat_vcm_tim.vcm_end_t.tv_sec,
478 &p32->vcm_end_t.tv_sec);
479 put_user(compat_vcm_tim.vcm_end_t.tv_usec,
480 &p32->vcm_end_t.tv_usec);
481 } else if (cmd == RK_VIDIOC_GET_VCM_CFG) {
482 ret = aw8601_ioctl(sd, RK_VIDIOC_GET_VCM_CFG, &vcm_cfg);
483 if (!ret) {
484 ret = copy_to_user(up, &vcm_cfg, sizeof(vcm_cfg));
485 if (ret)
486 ret = -EFAULT;
487 }
488 } else if (cmd == RK_VIDIOC_SET_VCM_CFG) {
489 ret = copy_from_user(&vcm_cfg, up, sizeof(vcm_cfg));
490 if (!ret)
491 ret = aw8601_ioctl(sd, cmd, &vcm_cfg);
492 else
493 ret = -EFAULT;
494 } else if (cmd == RK_VIDIOC_SET_VCM_MAX_LOGICALPOS) {
495 ret = copy_from_user(&max_logicalpos, up, sizeof(max_logicalpos));
496 if (!ret)
497 ret = aw8601_ioctl(sd, cmd, &max_logicalpos);
498 else
499 ret = -EFAULT;
500 } else {
501 dev_err(&client->dev,
502 "cmd 0x%x not supported\n", cmd);
503 return -EINVAL;
504 }
505
506 return ret;
507 }
508 #endif
509
510 static const struct v4l2_subdev_core_ops aw8601_core_ops = {
511 .ioctl = aw8601_ioctl,
512 #ifdef CONFIG_COMPAT
513 .compat_ioctl32 = aw8601_compat_ioctl32
514 #endif
515 };
516
517 static const struct v4l2_subdev_ops aw8601_ops = {
518 .core = &aw8601_core_ops,
519 };
520
aw8601_subdev_cleanup(struct aw8601_device * aw8601_dev)521 static void aw8601_subdev_cleanup(struct aw8601_device *aw8601_dev)
522 {
523 v4l2_device_unregister_subdev(&aw8601_dev->sd);
524 v4l2_device_unregister(&aw8601_dev->vdev);
525 v4l2_ctrl_handler_free(&aw8601_dev->ctrls_vcm);
526 media_entity_cleanup(&aw8601_dev->sd.entity);
527 }
528
aw8601_init_controls(struct aw8601_device * dev_vcm)529 static int aw8601_init_controls(struct aw8601_device *dev_vcm)
530 {
531 struct v4l2_ctrl_handler *hdl = &dev_vcm->ctrls_vcm;
532 const struct v4l2_ctrl_ops *ops = &aw8601_vcm_ctrl_ops;
533
534 v4l2_ctrl_handler_init(hdl, 1);
535
536 dev_vcm->focus = v4l2_ctrl_new_std(hdl, ops, V4L2_CID_FOCUS_ABSOLUTE,
537 0, dev_vcm->max_logicalpos, 1, 0);
538
539 if (hdl->error)
540 dev_err(dev_vcm->sd.dev, "%s fail error: 0x%x\n",
541 __func__, hdl->error);
542 dev_vcm->sd.ctrl_handler = hdl;
543 return hdl->error;
544 }
545
aw8601_probe(struct i2c_client * client,const struct i2c_device_id * id)546 static int aw8601_probe(struct i2c_client *client,
547 const struct i2c_device_id *id)
548 {
549 struct device_node *np = of_node_get(client->dev.of_node);
550 struct aw8601_device *aw8601_dev;
551 unsigned int max_ma, start_ma, rated_ma, step_mode;
552 unsigned int t_src, t_div;
553 struct v4l2_subdev *sd;
554 char facing[2];
555 int ret;
556
557 dev_info(&client->dev, "probing...\n");
558 if (of_property_read_u32(np,
559 OF_CAMERA_VCMDRV_MAX_CURRENT,
560 (unsigned int *)&max_ma)) {
561 max_ma = AW8601_MAX_CURRENT;
562 dev_info(&client->dev,
563 "could not get module %s from dts!\n",
564 OF_CAMERA_VCMDRV_MAX_CURRENT);
565 }
566 if (max_ma == 0)
567 max_ma = AW8601_MAX_CURRENT;
568
569 if (of_property_read_u32(np,
570 OF_CAMERA_VCMDRV_START_CURRENT,
571 (unsigned int *)&start_ma)) {
572 start_ma = AW8601_DEFAULT_START_CURRENT;
573 dev_info(&client->dev,
574 "could not get module %s from dts!\n",
575 OF_CAMERA_VCMDRV_START_CURRENT);
576 }
577 if (of_property_read_u32(np,
578 OF_CAMERA_VCMDRV_RATED_CURRENT,
579 (unsigned int *)&rated_ma)) {
580 rated_ma = AW8601_DEFAULT_RATED_CURRENT;
581 dev_info(&client->dev,
582 "could not get module %s from dts!\n",
583 OF_CAMERA_VCMDRV_RATED_CURRENT);
584 }
585 if (of_property_read_u32(np,
586 OF_CAMERA_VCMDRV_STEP_MODE,
587 (unsigned int *)&step_mode)) {
588 step_mode = AW8601_DEFAULT_STEP_MODE;
589 dev_info(&client->dev,
590 "could not get module %s from dts!\n",
591 OF_CAMERA_VCMDRV_STEP_MODE);
592 }
593
594 if (of_property_read_u32(np,
595 OF_CAMERA_VCMDRV_T_SRC,
596 (unsigned int *)&t_src)) {
597 t_src = AW8601_DEFAULT_T_SRC;
598 dev_info(&client->dev,
599 "could not get module %s from dts!\n",
600 OF_CAMERA_VCMDRV_T_SRC);
601 }
602
603 if (of_property_read_u32(np,
604 OF_CAMERA_VCMDRV_T_DIV,
605 (unsigned int *)&t_div)) {
606 t_div = AW8601_DEFAULT_T_DIV;
607 dev_info(&client->dev,
608 "could not get module %s from dts!\n",
609 OF_CAMERA_VCMDRV_T_DIV);
610 }
611
612 aw8601_dev = devm_kzalloc(&client->dev, sizeof(*aw8601_dev),
613 GFP_KERNEL);
614 if (aw8601_dev == NULL)
615 return -ENOMEM;
616
617 ret = of_property_read_u32(np, RKMODULE_CAMERA_MODULE_INDEX,
618 &aw8601_dev->module_index);
619 ret |= of_property_read_string(np, RKMODULE_CAMERA_MODULE_FACING,
620 &aw8601_dev->module_facing);
621 if (ret) {
622 dev_err(&client->dev,
623 "could not get module information!\n");
624 return -EINVAL;
625 }
626
627 v4l2_i2c_subdev_init(&aw8601_dev->sd, client, &aw8601_ops);
628 aw8601_dev->sd.flags |= V4L2_SUBDEV_FL_HAS_DEVNODE;
629 aw8601_dev->sd.internal_ops = &aw8601_int_ops;
630
631 aw8601_dev->max_logicalpos = VCMDRV_MAX_LOG;
632 ret = aw8601_init_controls(aw8601_dev);
633 if (ret)
634 goto err_cleanup;
635
636 ret = media_entity_pads_init(&aw8601_dev->sd.entity, 0, NULL);
637 if (ret < 0)
638 goto err_cleanup;
639
640 sd = &aw8601_dev->sd;
641 sd->entity.function = MEDIA_ENT_F_LENS;
642
643 memset(facing, 0, sizeof(facing));
644 if (strcmp(aw8601_dev->module_facing, "back") == 0)
645 facing[0] = 'b';
646 else
647 facing[0] = 'f';
648
649 snprintf(sd->name, sizeof(sd->name), "m%02d_%s_%s %s",
650 aw8601_dev->module_index, facing,
651 AW8601_NAME, dev_name(sd->dev));
652 ret = v4l2_async_register_subdev(sd);
653 if (ret)
654 dev_err(&client->dev, "v4l2 async register subdev failed\n");
655
656 aw8601_dev->max_ma = max_ma;
657 aw8601_dev->vcm_cfg.start_ma = start_ma;
658 aw8601_dev->vcm_cfg.rated_ma = rated_ma;
659 aw8601_dev->vcm_cfg.step_mode = step_mode;
660 aw8601_update_vcm_cfg(aw8601_dev);
661 aw8601_dev->move_us = 0;
662 aw8601_dev->current_related_pos = aw8601_dev->max_logicalpos;
663 aw8601_dev->start_move_tv = ns_to_kernel_old_timeval(ktime_get_ns());
664 aw8601_dev->end_move_tv = ns_to_kernel_old_timeval(ktime_get_ns());
665
666 aw8601_dev->t_src = t_src;
667 aw8601_dev->t_div = t_div;
668
669 aw8601_dev->vcm_movefull_t =
670 aw8601_move_time(aw8601_dev, AW8601_MAX_REG);
671 pm_runtime_set_active(&client->dev);
672 pm_runtime_enable(&client->dev);
673 pm_runtime_idle(&client->dev);
674
675 dev_info(&client->dev, "probing successful\n");
676
677 return 0;
678
679 err_cleanup:
680 aw8601_subdev_cleanup(aw8601_dev);
681 dev_err(&client->dev, "Probe failed: %d\n", ret);
682 return ret;
683 }
684
aw8601_remove(struct i2c_client * client)685 static int aw8601_remove(struct i2c_client *client)
686 {
687 struct v4l2_subdev *sd = i2c_get_clientdata(client);
688 struct aw8601_device *aw8601_dev = sd_to_aw8601_vcm(sd);
689
690 pm_runtime_disable(&client->dev);
691 aw8601_subdev_cleanup(aw8601_dev);
692
693 return 0;
694 }
695
aw8601_init(struct i2c_client * client)696 static int aw8601_init(struct i2c_client *client)
697 {
698 struct v4l2_subdev *sd = i2c_get_clientdata(client);
699 struct aw8601_device *dev_vcm = sd_to_aw8601_vcm(sd);
700 int ret = 0;
701 u32 ring = 0;
702 u32 mode_val = 0;
703 u32 algo_time = 0;
704
705 usleep_range(1000, 2000);
706
707 ret = aw8601_write_reg(client, 0x02, 1, 0x01);
708 if (ret)
709 goto err;
710 usleep_range(100, 200);
711 ret = aw8601_write_reg(client, 0x02, 1, 0x00);
712 if (ret)
713 goto err;
714 usleep_range(100, 200);
715
716 if (dev_vcm->step_mode != DIRECT_MODE &&
717 dev_vcm->step_mode != LSC_MODE)
718 ring = 0x02;
719 ret = aw8601_write_reg(client, 0x02, 1, ring);
720 if (ret)
721 goto err;
722 switch (dev_vcm->step_mode) {
723 case ARC2_MODE:
724 case ARC3_MODE:
725 case ARC4_MODE:
726 case ARC5_MODE:
727 mode_val |= dev_vcm->step_mode << 6;
728 break;
729 case LSC_MODE:
730 mode_val |= 0x10 << 6;
731 break;
732 default:
733 break;
734 }
735 mode_val |= ((dev_vcm->t_div >> 2) & 0x01);
736 algo_time = dev_vcm->t_div << 6 | dev_vcm->t_src;
737 ret = aw8601_write_reg(client, 0x06, 1, mode_val);
738 if (ret)
739 goto err;
740 ret = aw8601_write_reg(client, 0x07, 1, algo_time);
741 if (ret)
742 goto err;
743 usleep_range(100, 200);
744
745 return 0;
746 err:
747 dev_err(&client->dev, "failed with error %d\n", ret);
748 return -1;
749 }
750
aw8601_vcm_suspend(struct device * dev)751 static int __maybe_unused aw8601_vcm_suspend(struct device *dev)
752 {
753 return 0;
754 }
755
aw8601_vcm_resume(struct device * dev)756 static int __maybe_unused aw8601_vcm_resume(struct device *dev)
757 {
758 struct i2c_client *client = to_i2c_client(dev);
759 struct v4l2_subdev *sd = i2c_get_clientdata(client);
760 struct aw8601_device *dev_vcm = sd_to_aw8601_vcm(sd);
761
762 aw8601_init(client);
763 aw8601_set_pos(dev_vcm, dev_vcm->current_related_pos);
764 return 0;
765 }
766
767 static const struct i2c_device_id aw8601_id_table[] = {
768 { AW8601_NAME, 0 },
769 { { 0 } }
770 };
771 MODULE_DEVICE_TABLE(i2c, aw8601_id_table);
772
773 static const struct of_device_id aw8601_of_table[] = {
774 { .compatible = "awinic,aw8601" },
775 { { 0 } }
776 };
777 MODULE_DEVICE_TABLE(of, aw8601_of_table);
778
779 static const struct dev_pm_ops aw8601_pm_ops = {
780 SET_SYSTEM_SLEEP_PM_OPS(aw8601_vcm_suspend, aw8601_vcm_resume)
781 SET_RUNTIME_PM_OPS(aw8601_vcm_suspend, aw8601_vcm_resume, NULL)
782 };
783
784 static struct i2c_driver aw8601_i2c_driver = {
785 .driver = {
786 .name = AW8601_NAME,
787 .pm = &aw8601_pm_ops,
788 .of_match_table = aw8601_of_table,
789 },
790 .probe = &aw8601_probe,
791 .remove = &aw8601_remove,
792 .id_table = aw8601_id_table,
793 };
794
795 module_i2c_driver(aw8601_i2c_driver);
796
797 MODULE_DESCRIPTION("AW8601 VCM driver");
798 MODULE_LICENSE("GPL v2");
799