1 // SPDX-License-Identifier: GPL-2.0
2 // Copyright (c) 2020 Fuzhou Rockchip Electronics Co., Ltd.
3
4 #include <linux/delay.h>
5 #include <linux/i2c.h>
6 #include <linux/module.h>
7 #include <linux/pm_runtime.h>
8 #include <linux/rk-camera-module.h>
9 #include <linux/version.h>
10 #include <media/v4l2-ctrls.h>
11 #include <media/v4l2-device.h>
12 #include <linux/rk_vcm_head.h>
13
14 #define DRIVER_VERSION KERNEL_VERSION(0, 0x01, 0x0)
15 #define GT9760S_NAME "gt9760s"
16
17 #define GT9760S_MAX_CURRENT 120U
18 #define GT9760S_MAX_REG 1023U
19
20 #define GT9760S_DEFAULT_START_CURRENT 0
21 #define GT9760S_DEFAULT_RATED_CURRENT 120
22 #define GT9760S_DEFAULT_STEP_MODE 4
23 #define GT9760S_DEFAULT_DLC_ENABLE 1
24 #define GT9760S_DEFAULT_MCLK 0x1
25 #define GT9760S_DEFAULT_T_SRC 0x1F
26
27 #define GT9760S_SEL_ON_BYTE1 0xEC
28 #define GT9760S_SEL_ON_BYTE2 0xA3
29 #define GT9760S_DVO_DLC_BYTE1 0xA1
30 #define GT9760S_DVO_DLC_BYTE2 0xD
31 #define GT9760S_T_SRC_BYTE1 0xF2
32 #define GT9760S_T_SRC_BYTE2 0xF8
33 #define GT9760S_SEL_OFF_BYTE1 0xDC
34 #define GT9760S_SEL_OFF_BYTE2 0x51
35 #define REG_NULL 0xFF
36
37 /* Time to move the motor, this is fixed in the DLC specific setting */
38 #define GT9760S_DLC_MOVE_MS 7
39
40 /* gt9760s device structure */
41 struct gt9760s_device {
42 struct v4l2_ctrl_handler ctrls_vcm;
43 struct v4l2_subdev sd;
44 struct v4l2_device vdev;
45 u16 current_val;
46
47 unsigned short current_related_pos;
48 unsigned short current_lens_pos;
49 unsigned int start_current;
50 unsigned int rated_current;
51 unsigned int step;
52 unsigned int step_mode;
53 unsigned int vcm_movefull_t;
54 unsigned int dlc_enable;
55 unsigned int t_src;
56 unsigned int mclk;
57
58 struct timeval start_move_tv;
59 struct timeval end_move_tv;
60 unsigned long move_ms;
61
62 u32 module_index;
63 const char *module_facing;
64
65 struct rk_cam_vcm_cfg vcm_cfg;
66 int max_ma;
67 };
68
69 struct TimeTabel_s {
70 unsigned int t_src;/* time of slew rate control */
71 unsigned int step00;/* S[1:0] /MCLK[1:0] step period */
72 unsigned int step01;
73 unsigned int step10;
74 unsigned int step11;
75 };
76
77 static const struct TimeTabel_s gt9760s_lsc_time_table[] = {/* 1/10us */
78 {0b10000, 1360, 2720, 5440, 10880},
79 {0b10001, 1300, 2600, 5200, 10400},
80 {0b10010, 1250, 2500, 5000, 10000},
81 {0b10011, 1200, 2400, 4800, 9600},
82 {0b10100, 1160, 2320, 4640, 9280},
83 {0b10101, 1120, 2240, 4480, 8960},
84 {0b10110, 1080, 2160, 4320, 8640},
85 {0b10111, 1040, 2080, 4160, 8320},
86 {0b11000, 1010, 2020, 4040, 8080},
87 {0b11001, 980, 1960, 3920, 7840},
88 {0b11010, 950, 1900, 3800, 7600},
89 {0b11011, 920, 1840, 3680, 7360},
90 {0b11100, 890, 1780, 3560, 7120},
91 {0b11101, 870, 1740, 3480, 6960},
92 {0b11110, 850, 1700, 3400, 6800},
93 {0b11111, 830, 1660, 3320, 6640},
94 {0b00000, 810, 1620, 3240, 6480},
95 {0b00001, 790, 1580, 3160, 6320},
96 {0b00010, 775, 1550, 3100, 6200},
97 {0b00011, 760, 1520, 3040, 6080},
98 {0b00100, 745, 1490, 2980, 5960},
99 {0b00101, 730, 1460, 2920, 5840},
100 {0b00110, 715, 1430, 2860, 5720},
101 {0b00111, 700, 1400, 2800, 5600},
102 {0b01000, 690, 1380, 2760, 5520},
103 {0b01001, 680, 1360, 2720, 5440},
104 {0b01010, 670, 1340, 2680, 5360},
105 {0b01011, 660, 1320, 2640, 5280},
106 {0b01100, 655, 1310, 2620, 5240},
107 {0b01101, 650, 1300, 2600, 5200},
108 {0b01110, 645, 1290, 2580, 5160},
109 {0b01111, 640, 1280, 2560, 5120},
110 {REG_NULL, 0, 0, 0, 0},
111 };
112
113 static const struct TimeTabel_s gt9760s_dlc_time_table[] = {/* us */
114 {0b10000, 21250, 10630, 5310, 2660},
115 {0b10001, 20310, 10160, 5080, 2540},
116 {0b10010, 19530, 9770, 4880, 2440},
117 {0b10011, 18750, 9380, 4690, 2340},
118 {0b10100, 18130, 9060, 4530, 2270},
119 {0b10101, 17500, 8750, 4380, 2190},
120 {0b10110, 16880, 8440, 4220, 2110},
121 {0b10111, 16250, 8130, 4060, 2030},
122 {0b11000, 15780, 7890, 3950, 1970},
123 {0b11001, 15310, 7660, 3830, 1910},
124 {0b11010, 14840, 7420, 3710, 1860},
125 {0b11011, 14380, 7190, 3590, 1800},
126 {0b11100, 13910, 6950, 3480, 1740},
127 {0b11101, 13590, 6800, 3400, 1700},
128 {0b11110, 13280, 6640, 3320, 1660},
129 {0b11111, 12970, 6480, 3240, 1620},
130 {0b00000, 12660, 6330, 3160, 1580},
131 {0b00001, 12340, 6170, 3090, 1540},
132 {0b00010, 12110, 6050, 3030, 1510},
133 {0b00011, 11880, 5940, 2970, 1480},
134 {0b00100, 11640, 5820, 2910, 1460},
135 {0b00101, 11410, 5700, 2850, 1430},
136 {0b00110, 11170, 5590, 2790, 1400},
137 {0b00111, 10940, 5470, 2730, 1370},
138 {0b01000, 10780, 5390, 2700, 1350},
139 {0b01001, 10630, 5310, 2660, 1330},
140 {0b01010, 10470, 5230, 2620, 1310},
141 {0b01011, 10310, 5160, 2580, 1290},
142 {0b01100, 10230, 5120, 2560, 1280},
143 {0b01101, 10160, 5080, 2540, 1270},
144 {0b01110, 10080, 5040, 2520, 1260},
145 {0b01111, 10000, 5000, 2500, 1250},
146 {REG_NULL, 0, 0, 0, 0},
147 };
148
to_vcm_dev(struct v4l2_ctrl * ctrl)149 static inline struct gt9760s_device *to_vcm_dev(struct v4l2_ctrl *ctrl)
150 {
151 return container_of(ctrl->handler, struct gt9760s_device, ctrls_vcm);
152 }
153
sd_to_vcm_dev(struct v4l2_subdev * subdev)154 static inline struct gt9760s_device *sd_to_vcm_dev(struct v4l2_subdev *subdev)
155 {
156 return container_of(subdev, struct gt9760s_device, sd);
157 }
158
gt9760s_read_msg(struct i2c_client * client,u8 * msb,u8 * lsb)159 static int gt9760s_read_msg(struct i2c_client *client, u8 *msb, u8 *lsb)
160 {
161 int ret = 0;
162 struct i2c_msg msg[1];
163 unsigned char data[2];
164 int retries;
165
166 if (!client->adapter) {
167 dev_err(&client->dev, "client->adapter NULL\n");
168 return -ENODEV;
169 }
170
171 for (retries = 0; retries < 5; retries++) {
172 msg->addr = client->addr;
173 msg->flags = 1;
174 msg->len = 2;
175 msg->buf = data;
176
177 ret = i2c_transfer(client->adapter, msg, 1);
178 if (ret == 1) {
179 dev_dbg(&client->dev,
180 "%s: vcm i2c ok, addr 0x%x, data 0x%x, 0x%x\n",
181 __func__, msg->addr, data[0], data[1]);
182
183 *msb = data[0];
184 *lsb = data[1];
185 return 0;
186 }
187
188 dev_info(&client->dev,
189 "retrying I2C... %d\n", retries);
190 retries++;
191 set_current_state(TASK_UNINTERRUPTIBLE);
192 schedule_timeout(msecs_to_jiffies(20));
193 }
194 dev_err(&client->dev,
195 "%s: i2c write to failed with error %d\n", __func__, ret);
196 return ret;
197 }
198
gt9760s_write_msg(struct i2c_client * client,u8 msb,u8 lsb)199 static int gt9760s_write_msg(struct i2c_client *client, u8 msb, u8 lsb)
200 {
201 int ret = 0;
202 struct i2c_msg msg[1];
203 unsigned char data[2];
204 int retries;
205
206 if (!client->adapter) {
207 dev_err(&client->dev, "client->adapter NULL\n");
208 return -ENODEV;
209 }
210
211 for (retries = 0; retries < 5; retries++) {
212 msg->addr = client->addr;
213 msg->flags = 0;
214 msg->len = 2;
215 msg->buf = data;
216
217 data[0] = msb;
218 data[1] = lsb;
219
220 ret = i2c_transfer(client->adapter, msg, 1);
221 usleep_range(50, 100);
222
223 if (ret == 1) {
224 dev_dbg(&client->dev,
225 "%s: vcm i2c ok, addr 0x%x, data 0x%x, 0x%x\n",
226 __func__, msg->addr, data[0], data[1]);
227 return 0;
228 }
229
230 dev_info(&client->dev,
231 "retrying I2C... %d\n", retries);
232 retries++;
233 set_current_state(TASK_UNINTERRUPTIBLE);
234 schedule_timeout(msecs_to_jiffies(20));
235 }
236 dev_err(&client->dev,
237 "i2c write to failed with error %d\n", ret);
238 return ret;
239 }
240
gt9760s_move_time(struct gt9760s_device * dev_vcm,unsigned int move_pos)241 static unsigned int gt9760s_move_time(struct gt9760s_device *dev_vcm, unsigned int move_pos)
242 {
243 struct i2c_client *client = v4l2_get_subdevdata(&dev_vcm->sd);
244 unsigned int move_time_ms = 200;
245 unsigned int step_period_lsc = 0;
246 unsigned int step_period_dlc = 0;
247 unsigned int step_period = 0;
248 unsigned int codes_per_step = 1;
249 unsigned int step_case;
250 int table_cnt = 0;
251 int i = 0;
252
253 if (dev_vcm->dlc_enable) {
254 step_case = dev_vcm->mclk & 0x3;
255 table_cnt = ARRAY_SIZE(gt9760s_dlc_time_table);
256 for (i = 0; i < table_cnt; i++) {
257 if (gt9760s_dlc_time_table[i].t_src == dev_vcm->t_src)
258 break;
259 }
260 } else {
261 step_case = dev_vcm->step_mode & 0x3;
262 table_cnt = ARRAY_SIZE(gt9760s_lsc_time_table);
263 for (i = 0; i < table_cnt; i++) {
264 if (gt9760s_lsc_time_table[i].t_src == dev_vcm->t_src)
265 break;
266 }
267 }
268
269 if (i >= table_cnt)
270 i = 0;
271
272 switch (step_case) {
273 case 0:
274 step_period_lsc = gt9760s_lsc_time_table[i].step00;
275 step_period_dlc = gt9760s_dlc_time_table[i].step00;
276 break;
277 case 1:
278 step_period_lsc = gt9760s_lsc_time_table[i].step01;
279 step_period_dlc = gt9760s_dlc_time_table[i].step01;
280 break;
281 case 2:
282 step_period_lsc = gt9760s_lsc_time_table[i].step10;
283 step_period_dlc = gt9760s_dlc_time_table[i].step10;
284 break;
285 case 3:
286 step_period_lsc = gt9760s_lsc_time_table[i].step11;
287 step_period_dlc = gt9760s_dlc_time_table[i].step11;
288 break;
289 default:
290 dev_err(&client->dev,
291 "%s: step_case is error %d\n",
292 __func__, step_case);
293 break;
294 }
295 codes_per_step = (dev_vcm->step_mode & 0x0c) >> 2;
296 if (codes_per_step > 1)
297 codes_per_step = 1 << (codes_per_step - 1);
298
299 if (dev_vcm->dlc_enable) {
300 move_time_ms = (step_period_dlc + 999) / 1000;
301 } else {
302 step_period = step_period_lsc;
303
304 if (!codes_per_step)
305 move_time_ms = (step_period * move_pos + 9999) / 10000;
306 else
307 move_time_ms = (step_period * move_pos / codes_per_step + 9999) / 10000;
308 }
309
310 return move_time_ms;
311 }
312
gt9760s_init(struct i2c_client * client)313 static int gt9760s_init(struct i2c_client *client)
314 {
315 struct v4l2_subdev *sd = i2c_get_clientdata(client);
316 struct gt9760s_device *dev_vcm = sd_to_vcm_dev(sd);
317 int ret = 0;
318 u8 val;
319
320 usleep_range(7000, 7500);
321
322 ret = gt9760s_write_msg(client, GT9760S_SEL_ON_BYTE1,
323 GT9760S_SEL_ON_BYTE2);
324 if (ret)
325 goto err;
326
327 val = dev_vcm->dlc_enable << 3 | dev_vcm->mclk | 0x04;
328 ret = gt9760s_write_msg(client, GT9760S_DVO_DLC_BYTE1, val);
329 if (ret)
330 goto err;
331
332 val = dev_vcm->t_src << 3;
333 ret = gt9760s_write_msg(client, GT9760S_T_SRC_BYTE1, val);
334 if (ret)
335 goto err;
336
337 ret = gt9760s_write_msg(client, GT9760S_SEL_OFF_BYTE1,
338 GT9760S_SEL_OFF_BYTE2);
339 if (ret)
340 goto err;
341
342 return 0;
343 err:
344 dev_err(&client->dev, "failed with error %d\n", ret);
345 return -1;
346 }
347
gt9760s_get_pos(struct gt9760s_device * dev_vcm,u32 * cur_pos)348 static int gt9760s_get_pos(struct gt9760s_device *dev_vcm, u32 *cur_pos)
349 {
350 struct i2c_client *client = v4l2_get_subdevdata(&dev_vcm->sd);
351 int ret = 0;
352 unsigned char lsb = 0;
353 unsigned char msb = 0;
354 unsigned int abs_step = 0;
355
356 ret = gt9760s_read_msg(client, &msb, &lsb);
357 if (ret != 0)
358 goto err;
359
360 abs_step = (((unsigned int)(msb & 0x3FU)) << 4U) |
361 (((unsigned int)lsb) >> 4U);
362 if (abs_step <= dev_vcm->start_current)
363 abs_step = VCMDRV_MAX_LOG;
364 else if ((abs_step > dev_vcm->start_current) &&
365 (abs_step <= dev_vcm->rated_current))
366 abs_step = (dev_vcm->rated_current - abs_step) / dev_vcm->step;
367 else
368 abs_step = 0;
369
370 *cur_pos = abs_step;
371 dev_dbg(&client->dev, "%s: get position %d\n", __func__, *cur_pos);
372 return 0;
373
374 err:
375 dev_err(&client->dev,
376 "%s: failed with error %d\n", __func__, ret);
377 return ret;
378 }
379
gt9760s_set_pos(struct gt9760s_device * dev_vcm,u32 dest_pos)380 static int gt9760s_set_pos(struct gt9760s_device *dev_vcm, u32 dest_pos)
381 {
382 int ret = 0;
383 unsigned char lsb = 0;
384 unsigned char msb = 0;
385 unsigned int position = 0;
386 struct i2c_client *client = v4l2_get_subdevdata(&dev_vcm->sd);
387
388 if (dest_pos >= VCMDRV_MAX_LOG)
389 position = dev_vcm->start_current;
390 else
391 position = dev_vcm->start_current +
392 (dev_vcm->step * (VCMDRV_MAX_LOG - dest_pos));
393
394 if (position > GT9760S_MAX_REG)
395 position = GT9760S_MAX_REG;
396
397 dev_vcm->current_lens_pos = position;
398 dev_vcm->current_related_pos = dest_pos;
399 msb = (0x00U | ((dev_vcm->current_lens_pos & 0x3F0U) >> 4U));
400 lsb = (((dev_vcm->current_lens_pos & 0x0FU) << 4U) |
401 dev_vcm->step_mode);
402 ret = gt9760s_write_msg(client, msb, lsb);
403 if (ret != 0)
404 goto err;
405
406 return ret;
407 err:
408 dev_err(&client->dev,
409 "%s: failed with error %d\n", __func__, ret);
410 return ret;
411 }
412
gt9760s_get_ctrl(struct v4l2_ctrl * ctrl)413 static int gt9760s_get_ctrl(struct v4l2_ctrl *ctrl)
414 {
415 struct gt9760s_device *dev_vcm = to_vcm_dev(ctrl);
416
417 if (ctrl->id == V4L2_CID_FOCUS_ABSOLUTE)
418 return gt9760s_get_pos(dev_vcm, &ctrl->val);
419
420 return -EINVAL;
421 }
422
gt9760s_set_ctrl(struct v4l2_ctrl * ctrl)423 static int gt9760s_set_ctrl(struct v4l2_ctrl *ctrl)
424 {
425 struct gt9760s_device *dev_vcm = to_vcm_dev(ctrl);
426 struct i2c_client *client = v4l2_get_subdevdata(&dev_vcm->sd);
427 unsigned int dest_pos = ctrl->val;
428 int move_pos;
429 long mv_us;
430 int ret = 0;
431
432 if (ctrl->id == V4L2_CID_FOCUS_ABSOLUTE) {
433 if (dest_pos > VCMDRV_MAX_LOG) {
434 dev_info(&client->dev,
435 "%s dest_pos is error. %d > %d\n",
436 __func__, dest_pos, VCMDRV_MAX_LOG);
437 return -EINVAL;
438 }
439 /* calculate move time */
440 move_pos = dev_vcm->current_related_pos - dest_pos;
441 if (move_pos < 0)
442 move_pos = -move_pos;
443
444 ret = gt9760s_set_pos(dev_vcm, dest_pos);
445
446 if (dev_vcm->dlc_enable)
447 dev_vcm->move_ms = dev_vcm->vcm_movefull_t;
448 else
449 dev_vcm->move_ms =
450 ((dev_vcm->vcm_movefull_t * (uint32_t)move_pos) / VCMDRV_MAX_LOG);
451
452 dev_dbg(&client->dev, "dest_pos %d, move_ms %ld\n",
453 dest_pos, dev_vcm->move_ms);
454
455 dev_vcm->start_move_tv = ns_to_timeval(ktime_get_ns());
456 mv_us = dev_vcm->start_move_tv.tv_usec +
457 dev_vcm->move_ms * 1000;
458 if (mv_us >= 1000000) {
459 dev_vcm->end_move_tv.tv_sec =
460 dev_vcm->start_move_tv.tv_sec + 1;
461 dev_vcm->end_move_tv.tv_usec = mv_us - 1000000;
462 } else {
463 dev_vcm->end_move_tv.tv_sec =
464 dev_vcm->start_move_tv.tv_sec;
465 dev_vcm->end_move_tv.tv_usec = mv_us;
466 }
467 }
468
469 return ret;
470 }
471
472 static const struct v4l2_ctrl_ops gt9760s_vcm_ctrl_ops = {
473 .g_volatile_ctrl = gt9760s_get_ctrl,
474 .s_ctrl = gt9760s_set_ctrl,
475 };
476
gt9760s_open(struct v4l2_subdev * sd,struct v4l2_subdev_fh * fh)477 static int gt9760s_open(struct v4l2_subdev *sd, struct v4l2_subdev_fh *fh)
478 {
479 int rval;
480
481 rval = pm_runtime_get_sync(sd->dev);
482 if (rval < 0) {
483 pm_runtime_put_noidle(sd->dev);
484 return rval;
485 }
486
487 return 0;
488 }
489
gt9760s_close(struct v4l2_subdev * sd,struct v4l2_subdev_fh * fh)490 static int gt9760s_close(struct v4l2_subdev *sd, struct v4l2_subdev_fh *fh)
491 {
492 pm_runtime_put(sd->dev);
493
494 return 0;
495 }
496
497 static const struct v4l2_subdev_internal_ops gt9760s_int_ops = {
498 .open = gt9760s_open,
499 .close = gt9760s_close,
500 };
501
gt9760s_update_vcm_cfg(struct gt9760s_device * dev_vcm)502 static void gt9760s_update_vcm_cfg(struct gt9760s_device *dev_vcm)
503 {
504 struct i2c_client *client = v4l2_get_subdevdata(&dev_vcm->sd);
505 int cur_dist;
506
507 if (dev_vcm->max_ma == 0) {
508 dev_err(&client->dev, "max current is zero");
509 return;
510 }
511
512 cur_dist = dev_vcm->vcm_cfg.rated_ma - dev_vcm->vcm_cfg.start_ma;
513 cur_dist = cur_dist * GT9760S_MAX_REG / dev_vcm->max_ma;
514 dev_vcm->step = (cur_dist + (VCMDRV_MAX_LOG - 1)) / VCMDRV_MAX_LOG;
515 dev_vcm->start_current = dev_vcm->vcm_cfg.start_ma *
516 GT9760S_MAX_REG / dev_vcm->max_ma;
517 dev_vcm->rated_current = dev_vcm->start_current +
518 VCMDRV_MAX_LOG * dev_vcm->step;
519 dev_vcm->step_mode = dev_vcm->vcm_cfg.step_mode;
520
521 dev_dbg(&client->dev,
522 "vcm_cfg: %d, %d, %d, max_ma %d\n",
523 dev_vcm->vcm_cfg.start_ma,
524 dev_vcm->vcm_cfg.rated_ma,
525 dev_vcm->vcm_cfg.step_mode,
526 dev_vcm->max_ma);
527 }
528
gt9760s_ioctl(struct v4l2_subdev * sd,unsigned int cmd,void * arg)529 static long gt9760s_ioctl(struct v4l2_subdev *sd, unsigned int cmd, void *arg)
530 {
531 struct i2c_client *client = v4l2_get_subdevdata(sd);
532 struct gt9760s_device *dev_vcm = sd_to_vcm_dev(sd);
533 struct rk_cam_vcm_cfg *vcm_cfg;
534 struct rk_cam_vcm_tim *vcm_tim;
535 int ret = 0;
536
537 if (cmd == RK_VIDIOC_VCM_TIMEINFO) {
538 vcm_tim = (struct rk_cam_vcm_tim *)arg;
539
540 vcm_tim->vcm_start_t.tv_sec = dev_vcm->start_move_tv.tv_sec;
541 vcm_tim->vcm_start_t.tv_usec = dev_vcm->start_move_tv.tv_usec;
542 vcm_tim->vcm_end_t.tv_sec = dev_vcm->end_move_tv.tv_sec;
543 vcm_tim->vcm_end_t.tv_usec = dev_vcm->end_move_tv.tv_usec;
544
545 dev_dbg(&client->dev,
546 "0x%lx, 0x%lx, 0x%lx, 0x%lx\n",
547 vcm_tim->vcm_start_t.tv_sec,
548 vcm_tim->vcm_start_t.tv_usec,
549 vcm_tim->vcm_end_t.tv_sec,
550 vcm_tim->vcm_end_t.tv_usec);
551 } else if (cmd == RK_VIDIOC_GET_VCM_CFG) {
552 vcm_cfg = (struct rk_cam_vcm_cfg *)arg;
553
554 vcm_cfg->start_ma = dev_vcm->vcm_cfg.start_ma;
555 vcm_cfg->rated_ma = dev_vcm->vcm_cfg.rated_ma;
556 vcm_cfg->step_mode = dev_vcm->vcm_cfg.step_mode;
557 } else if (cmd == RK_VIDIOC_SET_VCM_CFG) {
558 vcm_cfg = (struct rk_cam_vcm_cfg *)arg;
559
560 dev_vcm->vcm_cfg.start_ma = vcm_cfg->start_ma;
561 dev_vcm->vcm_cfg.rated_ma = vcm_cfg->rated_ma;
562 dev_vcm->vcm_cfg.step_mode = vcm_cfg->step_mode;
563 gt9760s_update_vcm_cfg(dev_vcm);
564 } else {
565 dev_err(&client->dev,
566 "cmd 0x%x not supported\n", cmd);
567 return -EINVAL;
568 }
569
570 return ret;
571 }
572
573 #ifdef CONFIG_COMPAT
gt9760s_compat_ioctl32(struct v4l2_subdev * sd,unsigned int cmd,unsigned long arg)574 static long gt9760s_compat_ioctl32(struct v4l2_subdev *sd,
575 unsigned int cmd, unsigned long arg)
576 {
577 struct rk_cam_compat_vcm_tim __user *p32 = compat_ptr(arg);
578 struct i2c_client *client = v4l2_get_subdevdata(sd);
579 struct rk_cam_compat_vcm_tim cmt;
580 struct rk_cam_vcm_tim tim;
581 long ret;
582
583 if (cmd == RK_VIDIOC_COMPAT_VCM_TIMEINFO) {
584 ret = gt9760s_ioctl(sd, RK_VIDIOC_VCM_TIMEINFO, &tim);
585 cmt.vcm_start_t.tv_sec = tim.vcm_start_t.tv_sec;
586 cmt.vcm_start_t.tv_usec = tim.vcm_start_t.tv_usec;
587 cmt.vcm_end_t.tv_sec = tim.vcm_end_t.tv_sec;
588 cmt.vcm_end_t.tv_usec = tim.vcm_end_t.tv_usec;
589
590 put_user(cmt.vcm_start_t.tv_sec, &p32->vcm_start_t.tv_sec);
591 put_user(cmt.vcm_start_t.tv_usec, &p32->vcm_start_t.tv_usec);
592 put_user(cmt.vcm_end_t.tv_sec, &p32->vcm_end_t.tv_sec);
593 put_user(cmt.vcm_end_t.tv_usec, &p32->vcm_end_t.tv_usec);
594 } else {
595 dev_err(&client->dev,
596 "cmd 0x%x not supported\n", cmd);
597 return -EINVAL;
598 }
599
600 return ret;
601 }
602 #endif
603
604 static const struct v4l2_subdev_core_ops gt9760s_core_ops = {
605 .ioctl = gt9760s_ioctl,
606 #ifdef CONFIG_COMPAT
607 .compat_ioctl32 = gt9760s_compat_ioctl32
608 #endif
609 };
610
611 static const struct v4l2_subdev_ops gt9760s_ops = {
612 .core = >9760s_core_ops,
613 };
614
gt9760s_subdev_cleanup(struct gt9760s_device * dev_vcm)615 static void gt9760s_subdev_cleanup(struct gt9760s_device *dev_vcm)
616 {
617 v4l2_device_unregister_subdev(&dev_vcm->sd);
618 v4l2_device_unregister(&dev_vcm->vdev);
619 v4l2_ctrl_handler_free(&dev_vcm->ctrls_vcm);
620 media_entity_cleanup(&dev_vcm->sd.entity);
621 }
622
gt9760s_init_controls(struct gt9760s_device * dev_vcm)623 static int gt9760s_init_controls(struct gt9760s_device *dev_vcm)
624 {
625 struct v4l2_ctrl_handler *hdl = &dev_vcm->ctrls_vcm;
626 const struct v4l2_ctrl_ops *ops = >9760s_vcm_ctrl_ops;
627
628 v4l2_ctrl_handler_init(hdl, 1);
629
630 v4l2_ctrl_new_std(hdl, ops, V4L2_CID_FOCUS_ABSOLUTE,
631 0, VCMDRV_MAX_LOG, 1, VCMDRV_MAX_LOG);
632
633 if (hdl->error)
634 dev_err(dev_vcm->sd.dev, "%s fail error: 0x%x\n",
635 __func__, hdl->error);
636 dev_vcm->sd.ctrl_handler = hdl;
637 return hdl->error;
638 }
639
gt9760s_read_dts(struct i2c_client * client,struct gt9760s_device * dev_vcm)640 static int gt9760s_read_dts(struct i2c_client *client, struct gt9760s_device *dev_vcm)
641 {
642 struct device_node *np = of_node_get(client->dev.of_node);
643 struct rk_cam_vcm_cfg *vcm_cfg = &dev_vcm->vcm_cfg;
644 int ret;
645
646 if (of_property_read_u32(np,
647 OF_CAMERA_VCMDRV_MAX_CURRENT,
648 (unsigned int *)&dev_vcm->max_ma)) {
649 dev_vcm->max_ma = GT9760S_MAX_CURRENT;
650 dev_info(&client->dev,
651 "could not get module %s from dts!\n",
652 OF_CAMERA_VCMDRV_MAX_CURRENT);
653 }
654 if (dev_vcm->max_ma == 0)
655 dev_vcm->max_ma = GT9760S_MAX_CURRENT;
656
657 if (of_property_read_u32(np,
658 OF_CAMERA_VCMDRV_START_CURRENT,
659 (unsigned int *)&vcm_cfg->start_ma)) {
660 vcm_cfg->start_ma = GT9760S_DEFAULT_START_CURRENT;
661 dev_info(&client->dev,
662 "could not get module %s from dts!\n",
663 OF_CAMERA_VCMDRV_START_CURRENT);
664 }
665 if (of_property_read_u32(np,
666 OF_CAMERA_VCMDRV_RATED_CURRENT,
667 (unsigned int *)&vcm_cfg->rated_ma)) {
668 vcm_cfg->rated_ma = GT9760S_DEFAULT_RATED_CURRENT;
669 dev_info(&client->dev,
670 "could not get module %s from dts!\n",
671 OF_CAMERA_VCMDRV_RATED_CURRENT);
672 }
673 if (of_property_read_u32(np,
674 OF_CAMERA_VCMDRV_STEP_MODE,
675 (unsigned int *)&vcm_cfg->step_mode)) {
676 vcm_cfg->step_mode = GT9760S_DEFAULT_STEP_MODE;
677 dev_info(&client->dev,
678 "could not get module %s from dts!\n",
679 OF_CAMERA_VCMDRV_STEP_MODE);
680 }
681 if (of_property_read_u32(np,
682 OF_CAMERA_VCMDRV_DLC_ENABLE,
683 (unsigned int *)&dev_vcm->dlc_enable)) {
684 dev_vcm->dlc_enable = GT9760S_DEFAULT_DLC_ENABLE;
685 dev_info(&client->dev,
686 "could not get module %s from dts!\n",
687 OF_CAMERA_VCMDRV_DLC_ENABLE);
688 }
689 if (of_property_read_u32(np,
690 OF_CAMERA_VCMDRV_MCLK,
691 (unsigned int *)&dev_vcm->mclk)) {
692 dev_vcm->mclk = GT9760S_DEFAULT_MCLK;
693 dev_info(&client->dev,
694 "could not get module %s from dts!\n",
695 OF_CAMERA_VCMDRV_MCLK);
696 }
697 if (of_property_read_u32(np,
698 OF_CAMERA_VCMDRV_T_SRC,
699 (unsigned int *)&dev_vcm->t_src)) {
700 dev_vcm->t_src = GT9760S_DEFAULT_T_SRC;
701 dev_info(&client->dev,
702 "could not get module %s from dts!\n",
703 OF_CAMERA_VCMDRV_T_SRC);
704 }
705
706 ret = of_property_read_u32(np, RKMODULE_CAMERA_MODULE_INDEX,
707 &dev_vcm->module_index);
708 ret |= of_property_read_string(np, RKMODULE_CAMERA_MODULE_FACING,
709 &dev_vcm->module_facing);
710 if (ret) {
711 dev_err(&client->dev,
712 "could not get module information!\n");
713 return -EINVAL;
714 }
715
716 return ret;
717 }
718
gt9760s_probe(struct i2c_client * client,const struct i2c_device_id * id)719 static int gt9760s_probe(struct i2c_client *client,
720 const struct i2c_device_id *id)
721 {
722 struct gt9760s_device *dev_vcm;
723 struct v4l2_subdev *sd;
724 char facing[2];
725 int ret;
726
727 dev_info(&client->dev, "probing...\n");
728 dev_info(&client->dev, "driver version: %02x.%02x.%02x",
729 DRIVER_VERSION >> 16,
730 (DRIVER_VERSION & 0xff00) >> 8,
731 DRIVER_VERSION & 0x00ff);
732
733 dev_vcm = devm_kzalloc(&client->dev, sizeof(*dev_vcm),
734 GFP_KERNEL);
735 if (!dev_vcm)
736 return -ENOMEM;
737
738 ret = gt9760s_read_dts(client, dev_vcm);
739 if (ret)
740 return ret;
741
742 v4l2_i2c_subdev_init(&dev_vcm->sd, client, >9760s_ops);
743 dev_vcm->sd.flags |= V4L2_SUBDEV_FL_HAS_DEVNODE;
744 dev_vcm->sd.internal_ops = >9760s_int_ops;
745
746 ret = gt9760s_init_controls(dev_vcm);
747 if (ret)
748 goto err_cleanup;
749
750 ret = media_entity_pads_init(&dev_vcm->sd.entity, 0, NULL);
751 if (ret < 0)
752 goto err_cleanup;
753
754 sd = &dev_vcm->sd;
755 sd->entity.function = MEDIA_ENT_F_LENS;
756
757 memset(facing, 0, sizeof(facing));
758 if (strcmp(dev_vcm->module_facing, "back") == 0)
759 facing[0] = 'b';
760 else
761 facing[0] = 'f';
762
763 snprintf(sd->name, sizeof(sd->name), "m%02d_%s_%s %s",
764 dev_vcm->module_index, facing,
765 GT9760S_NAME, dev_name(sd->dev));
766 ret = v4l2_async_register_subdev(sd);
767 if (ret)
768 dev_err(&client->dev, "v4l2 async register subdev failed\n");
769
770 gt9760s_update_vcm_cfg(dev_vcm);
771
772 dev_vcm->move_ms = 0;
773 dev_vcm->current_related_pos = VCMDRV_MAX_LOG;
774 dev_vcm->start_move_tv = ns_to_timeval(ktime_get_ns());
775 dev_vcm->end_move_tv = ns_to_timeval(ktime_get_ns());
776 dev_vcm->vcm_movefull_t = gt9760s_move_time(dev_vcm, GT9760S_MAX_REG);
777
778 pm_runtime_set_active(&client->dev);
779 pm_runtime_enable(&client->dev);
780 pm_runtime_idle(&client->dev);
781
782 dev_info(&client->dev, "probing successful\n");
783
784 return 0;
785
786 err_cleanup:
787 gt9760s_subdev_cleanup(dev_vcm);
788 dev_err(&client->dev, "Probe failed: %d\n", ret);
789 return ret;
790 }
791
gt9760s_remove(struct i2c_client * client)792 static int gt9760s_remove(struct i2c_client *client)
793 {
794 struct v4l2_subdev *sd = i2c_get_clientdata(client);
795 struct gt9760s_device *dev_vcm = sd_to_vcm_dev(sd);
796
797 pm_runtime_disable(&client->dev);
798 gt9760s_subdev_cleanup(dev_vcm);
799
800 return 0;
801 }
802
gt9760s_vcm_suspend(struct device * dev)803 static int __maybe_unused gt9760s_vcm_suspend(struct device *dev)
804 {
805 return 0;
806 }
807
gt9760s_vcm_resume(struct device * dev)808 static int __maybe_unused gt9760s_vcm_resume(struct device *dev)
809 {
810 struct i2c_client *client = to_i2c_client(dev);
811 struct v4l2_subdev *sd = i2c_get_clientdata(client);
812 struct gt9760s_device *dev_vcm = sd_to_vcm_dev(sd);
813
814 gt9760s_init(client);
815 gt9760s_set_pos(dev_vcm, dev_vcm->current_related_pos);
816 return 0;
817 }
818
819 static const struct i2c_device_id gt9760s_id_table[] = {
820 { GT9760S_NAME, 0 },
821 { { 0 } }
822 };
823 MODULE_DEVICE_TABLE(i2c, gt9760s_id_table);
824
825 static const struct of_device_id gt9760s_of_table[] = {
826 { .compatible = "giantec semi,gt9760s" },
827 { { 0 } }
828 };
829 MODULE_DEVICE_TABLE(of, gt9760s_of_table);
830
831 static const struct dev_pm_ops gt9760s_pm_ops = {
832 SET_SYSTEM_SLEEP_PM_OPS(gt9760s_vcm_suspend, gt9760s_vcm_resume)
833 SET_RUNTIME_PM_OPS(gt9760s_vcm_suspend, gt9760s_vcm_resume, NULL)
834 };
835
836 static struct i2c_driver gt9760s_i2c_driver = {
837 .driver = {
838 .name = GT9760S_NAME,
839 .pm = >9760s_pm_ops,
840 .of_match_table = gt9760s_of_table,
841 },
842 .probe = >9760s_probe,
843 .remove = >9760s_remove,
844 .id_table = gt9760s_id_table,
845 };
846
847 module_i2c_driver(gt9760s_i2c_driver);
848
849 MODULE_DESCRIPTION("GT9760S VCM driver");
850 MODULE_LICENSE("GPL v2");
851