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