1 // SPDX-License-Identifier: GPL-2.0-only
2 /*
3 * et8ek8_driver.c
4 *
5 * Copyright (C) 2008 Nokia Corporation
6 *
7 * Contact: Sakari Ailus <sakari.ailus@iki.fi>
8 * Tuukka Toivonen <tuukkat76@gmail.com>
9 * Pavel Machek <pavel@ucw.cz>
10 *
11 * Based on code from Toni Leinonen <toni.leinonen@offcode.fi>.
12 *
13 * This driver is based on the Micron MT9T012 camera imager driver
14 * (C) Texas Instruments.
15 */
16
17 #include <linux/clk.h>
18 #include <linux/delay.h>
19 #include <linux/gpio/consumer.h>
20 #include <linux/i2c.h>
21 #include <linux/kernel.h>
22 #include <linux/module.h>
23 #include <linux/mutex.h>
24 #include <linux/regulator/consumer.h>
25 #include <linux/slab.h>
26 #include <linux/sort.h>
27 #include <linux/v4l2-mediabus.h>
28
29 #include <media/media-entity.h>
30 #include <media/v4l2-ctrls.h>
31 #include <media/v4l2-device.h>
32 #include <media/v4l2-subdev.h>
33
34 #include "et8ek8_reg.h"
35
36 #define ET8EK8_NAME "et8ek8"
37 #define ET8EK8_PRIV_MEM_SIZE 128
38 #define ET8EK8_MAX_MSG 8
39
40 struct et8ek8_sensor {
41 struct v4l2_subdev subdev;
42 struct media_pad pad;
43 struct v4l2_mbus_framefmt format;
44 struct gpio_desc *reset;
45 struct regulator *vana;
46 struct clk *ext_clk;
47 u32 xclk_freq;
48
49 u16 version;
50
51 struct v4l2_ctrl_handler ctrl_handler;
52 struct v4l2_ctrl *exposure;
53 struct v4l2_ctrl *pixel_rate;
54 struct et8ek8_reglist *current_reglist;
55
56 u8 priv_mem[ET8EK8_PRIV_MEM_SIZE];
57
58 struct mutex power_lock;
59 int power_count;
60 };
61
62 #define to_et8ek8_sensor(sd) container_of(sd, struct et8ek8_sensor, subdev)
63
64 enum et8ek8_versions {
65 ET8EK8_REV_1 = 0x0001,
66 ET8EK8_REV_2,
67 };
68
69 /*
70 * This table describes what should be written to the sensor register
71 * for each gain value. The gain(index in the table) is in terms of
72 * 0.1EV, i.e. 10 indexes in the table give 2 time more gain [0] in
73 * the *analog gain, [1] in the digital gain
74 *
75 * Analog gain [dB] = 20*log10(regvalue/32); 0x20..0x100
76 */
77 static struct et8ek8_gain {
78 u16 analog;
79 u16 digital;
80 } const et8ek8_gain_table[] = {
81 { 32, 0}, /* x1 */
82 { 34, 0},
83 { 37, 0},
84 { 39, 0},
85 { 42, 0},
86 { 45, 0},
87 { 49, 0},
88 { 52, 0},
89 { 56, 0},
90 { 60, 0},
91 { 64, 0}, /* x2 */
92 { 69, 0},
93 { 74, 0},
94 { 79, 0},
95 { 84, 0},
96 { 91, 0},
97 { 97, 0},
98 {104, 0},
99 {111, 0},
100 {119, 0},
101 {128, 0}, /* x4 */
102 {137, 0},
103 {147, 0},
104 {158, 0},
105 {169, 0},
106 {181, 0},
107 {194, 0},
108 {208, 0},
109 {223, 0},
110 {239, 0},
111 {256, 0}, /* x8 */
112 {256, 73},
113 {256, 152},
114 {256, 236},
115 {256, 327},
116 {256, 424},
117 {256, 528},
118 {256, 639},
119 {256, 758},
120 {256, 886},
121 {256, 1023}, /* x16 */
122 };
123
124 /* Register definitions */
125 #define REG_REVISION_NUMBER_L 0x1200
126 #define REG_REVISION_NUMBER_H 0x1201
127
128 #define PRIV_MEM_START_REG 0x0008
129 #define PRIV_MEM_WIN_SIZE 8
130
131 #define ET8EK8_I2C_DELAY 3 /* msec delay b/w accesses */
132
133 #define USE_CRC 1
134
135 /*
136 * Register access helpers
137 *
138 * Read a 8/16/32-bit i2c register. The value is returned in 'val'.
139 * Returns zero if successful, or non-zero otherwise.
140 */
et8ek8_i2c_read_reg(struct i2c_client * client,u16 data_length,u16 reg,u32 * val)141 static int et8ek8_i2c_read_reg(struct i2c_client *client, u16 data_length,
142 u16 reg, u32 *val)
143 {
144 int r;
145 struct i2c_msg msg;
146 unsigned char data[4];
147
148 if (!client->adapter)
149 return -ENODEV;
150 if (data_length != ET8EK8_REG_8BIT && data_length != ET8EK8_REG_16BIT)
151 return -EINVAL;
152
153 msg.addr = client->addr;
154 msg.flags = 0;
155 msg.len = 2;
156 msg.buf = data;
157
158 /* high byte goes out first */
159 data[0] = (u8) (reg >> 8);
160 data[1] = (u8) (reg & 0xff);
161 r = i2c_transfer(client->adapter, &msg, 1);
162 if (r < 0)
163 goto err;
164
165 msg.len = data_length;
166 msg.flags = I2C_M_RD;
167 r = i2c_transfer(client->adapter, &msg, 1);
168 if (r < 0)
169 goto err;
170
171 *val = 0;
172 /* high byte comes first */
173 if (data_length == ET8EK8_REG_8BIT)
174 *val = data[0];
175 else
176 *val = (data[1] << 8) + data[0];
177
178 return 0;
179
180 err:
181 dev_err(&client->dev, "read from offset 0x%x error %d\n", reg, r);
182
183 return r;
184 }
185
et8ek8_i2c_create_msg(struct i2c_client * client,u16 len,u16 reg,u32 val,struct i2c_msg * msg,unsigned char * buf)186 static void et8ek8_i2c_create_msg(struct i2c_client *client, u16 len, u16 reg,
187 u32 val, struct i2c_msg *msg,
188 unsigned char *buf)
189 {
190 msg->addr = client->addr;
191 msg->flags = 0; /* Write */
192 msg->len = 2 + len;
193 msg->buf = buf;
194
195 /* high byte goes out first */
196 buf[0] = (u8) (reg >> 8);
197 buf[1] = (u8) (reg & 0xff);
198
199 switch (len) {
200 case ET8EK8_REG_8BIT:
201 buf[2] = (u8) (val) & 0xff;
202 break;
203 case ET8EK8_REG_16BIT:
204 buf[2] = (u8) (val) & 0xff;
205 buf[3] = (u8) (val >> 8) & 0xff;
206 break;
207 default:
208 WARN_ONCE(1, ET8EK8_NAME ": %s: invalid message length.\n",
209 __func__);
210 }
211 }
212
213 /*
214 * A buffered write method that puts the wanted register write
215 * commands in smaller number of message lists and passes the lists to
216 * the i2c framework
217 */
et8ek8_i2c_buffered_write_regs(struct i2c_client * client,const struct et8ek8_reg * wnext,int cnt)218 static int et8ek8_i2c_buffered_write_regs(struct i2c_client *client,
219 const struct et8ek8_reg *wnext,
220 int cnt)
221 {
222 struct i2c_msg msg[ET8EK8_MAX_MSG];
223 unsigned char data[ET8EK8_MAX_MSG][6];
224 int wcnt = 0;
225 u16 reg, data_length;
226 u32 val;
227 int rval;
228
229 /* Create new write messages for all writes */
230 while (wcnt < cnt) {
231 data_length = wnext->type;
232 reg = wnext->reg;
233 val = wnext->val;
234 wnext++;
235
236 et8ek8_i2c_create_msg(client, data_length, reg,
237 val, &msg[wcnt], &data[wcnt][0]);
238
239 /* Update write count */
240 wcnt++;
241
242 if (wcnt < ET8EK8_MAX_MSG)
243 continue;
244
245 rval = i2c_transfer(client->adapter, msg, wcnt);
246 if (rval < 0)
247 return rval;
248
249 cnt -= wcnt;
250 wcnt = 0;
251 }
252
253 rval = i2c_transfer(client->adapter, msg, wcnt);
254
255 return rval < 0 ? rval : 0;
256 }
257
258 /*
259 * Write a list of registers to i2c device.
260 *
261 * The list of registers is terminated by ET8EK8_REG_TERM.
262 * Returns zero if successful, or non-zero otherwise.
263 */
et8ek8_i2c_write_regs(struct i2c_client * client,const struct et8ek8_reg * regs)264 static int et8ek8_i2c_write_regs(struct i2c_client *client,
265 const struct et8ek8_reg *regs)
266 {
267 int r, cnt = 0;
268 const struct et8ek8_reg *next;
269
270 if (!client->adapter)
271 return -ENODEV;
272
273 if (!regs)
274 return -EINVAL;
275
276 /* Initialize list pointers to the start of the list */
277 next = regs;
278
279 do {
280 /*
281 * We have to go through the list to figure out how
282 * many regular writes we have in a row
283 */
284 while (next->type != ET8EK8_REG_TERM &&
285 next->type != ET8EK8_REG_DELAY) {
286 /*
287 * Here we check that the actual length fields
288 * are valid
289 */
290 if (WARN(next->type != ET8EK8_REG_8BIT &&
291 next->type != ET8EK8_REG_16BIT,
292 "Invalid type = %d", next->type)) {
293 return -EINVAL;
294 }
295 /*
296 * Increment count of successive writes and
297 * read pointer
298 */
299 cnt++;
300 next++;
301 }
302
303 /* Now we start writing ... */
304 r = et8ek8_i2c_buffered_write_regs(client, regs, cnt);
305
306 /* ... and then check that everything was OK */
307 if (r < 0) {
308 dev_err(&client->dev, "i2c transfer error!\n");
309 return r;
310 }
311
312 /*
313 * If we ran into a sleep statement when going through
314 * the list, this is where we snooze for the required time
315 */
316 if (next->type == ET8EK8_REG_DELAY) {
317 msleep(next->val);
318 /*
319 * ZZZ ...
320 * Update list pointers and cnt and start over ...
321 */
322 next++;
323 regs = next;
324 cnt = 0;
325 }
326 } while (next->type != ET8EK8_REG_TERM);
327
328 return 0;
329 }
330
331 /*
332 * Write to a 8/16-bit register.
333 * Returns zero if successful, or non-zero otherwise.
334 */
et8ek8_i2c_write_reg(struct i2c_client * client,u16 data_length,u16 reg,u32 val)335 static int et8ek8_i2c_write_reg(struct i2c_client *client, u16 data_length,
336 u16 reg, u32 val)
337 {
338 int r;
339 struct i2c_msg msg;
340 unsigned char data[6];
341
342 if (!client->adapter)
343 return -ENODEV;
344 if (data_length != ET8EK8_REG_8BIT && data_length != ET8EK8_REG_16BIT)
345 return -EINVAL;
346
347 et8ek8_i2c_create_msg(client, data_length, reg, val, &msg, data);
348
349 r = i2c_transfer(client->adapter, &msg, 1);
350 if (r < 0) {
351 dev_err(&client->dev,
352 "wrote 0x%x to offset 0x%x error %d\n", val, reg, r);
353 return r;
354 }
355
356 return 0;
357 }
358
et8ek8_reglist_find_type(struct et8ek8_meta_reglist * meta,u16 type)359 static struct et8ek8_reglist *et8ek8_reglist_find_type(
360 struct et8ek8_meta_reglist *meta,
361 u16 type)
362 {
363 struct et8ek8_reglist **next = &meta->reglist[0].ptr;
364
365 while (*next) {
366 if ((*next)->type == type)
367 return *next;
368
369 next++;
370 }
371
372 return NULL;
373 }
374
et8ek8_i2c_reglist_find_write(struct i2c_client * client,struct et8ek8_meta_reglist * meta,u16 type)375 static int et8ek8_i2c_reglist_find_write(struct i2c_client *client,
376 struct et8ek8_meta_reglist *meta,
377 u16 type)
378 {
379 struct et8ek8_reglist *reglist;
380
381 reglist = et8ek8_reglist_find_type(meta, type);
382 if (!reglist)
383 return -EINVAL;
384
385 return et8ek8_i2c_write_regs(client, reglist->regs);
386 }
387
et8ek8_reglist_first(struct et8ek8_meta_reglist * meta)388 static struct et8ek8_reglist **et8ek8_reglist_first(
389 struct et8ek8_meta_reglist *meta)
390 {
391 return &meta->reglist[0].ptr;
392 }
393
et8ek8_reglist_to_mbus(const struct et8ek8_reglist * reglist,struct v4l2_mbus_framefmt * fmt)394 static void et8ek8_reglist_to_mbus(const struct et8ek8_reglist *reglist,
395 struct v4l2_mbus_framefmt *fmt)
396 {
397 fmt->width = reglist->mode.window_width;
398 fmt->height = reglist->mode.window_height;
399 fmt->code = reglist->mode.bus_format;
400 }
401
et8ek8_reglist_find_mode_fmt(struct et8ek8_meta_reglist * meta,struct v4l2_mbus_framefmt * fmt)402 static struct et8ek8_reglist *et8ek8_reglist_find_mode_fmt(
403 struct et8ek8_meta_reglist *meta,
404 struct v4l2_mbus_framefmt *fmt)
405 {
406 struct et8ek8_reglist **list = et8ek8_reglist_first(meta);
407 struct et8ek8_reglist *best_match = NULL;
408 struct et8ek8_reglist *best_other = NULL;
409 struct v4l2_mbus_framefmt format;
410 unsigned int max_dist_match = (unsigned int)-1;
411 unsigned int max_dist_other = (unsigned int)-1;
412
413 /*
414 * Find the mode with the closest image size. The distance between
415 * image sizes is the size in pixels of the non-overlapping regions
416 * between the requested size and the frame-specified size.
417 *
418 * Store both the closest mode that matches the requested format, and
419 * the closest mode for all other formats. The best match is returned
420 * if found, otherwise the best mode with a non-matching format is
421 * returned.
422 */
423 for (; *list; list++) {
424 unsigned int dist;
425
426 if ((*list)->type != ET8EK8_REGLIST_MODE)
427 continue;
428
429 et8ek8_reglist_to_mbus(*list, &format);
430
431 dist = min(fmt->width, format.width)
432 * min(fmt->height, format.height);
433 dist = format.width * format.height
434 + fmt->width * fmt->height - 2 * dist;
435
436
437 if (fmt->code == format.code) {
438 if (dist < max_dist_match || !best_match) {
439 best_match = *list;
440 max_dist_match = dist;
441 }
442 } else {
443 if (dist < max_dist_other || !best_other) {
444 best_other = *list;
445 max_dist_other = dist;
446 }
447 }
448 }
449
450 return best_match ? best_match : best_other;
451 }
452
453 #define TIMEPERFRAME_AVG_FPS(t) \
454 (((t).denominator + ((t).numerator >> 1)) / (t).numerator)
455
et8ek8_reglist_find_mode_ival(struct et8ek8_meta_reglist * meta,struct et8ek8_reglist * current_reglist,struct v4l2_fract * timeperframe)456 static struct et8ek8_reglist *et8ek8_reglist_find_mode_ival(
457 struct et8ek8_meta_reglist *meta,
458 struct et8ek8_reglist *current_reglist,
459 struct v4l2_fract *timeperframe)
460 {
461 int fps = TIMEPERFRAME_AVG_FPS(*timeperframe);
462 struct et8ek8_reglist **list = et8ek8_reglist_first(meta);
463 struct et8ek8_mode *current_mode = ¤t_reglist->mode;
464
465 for (; *list; list++) {
466 struct et8ek8_mode *mode = &(*list)->mode;
467
468 if ((*list)->type != ET8EK8_REGLIST_MODE)
469 continue;
470
471 if (mode->window_width != current_mode->window_width ||
472 mode->window_height != current_mode->window_height)
473 continue;
474
475 if (TIMEPERFRAME_AVG_FPS(mode->timeperframe) == fps)
476 return *list;
477 }
478
479 return NULL;
480 }
481
et8ek8_reglist_cmp(const void * a,const void * b)482 static int et8ek8_reglist_cmp(const void *a, const void *b)
483 {
484 const struct et8ek8_reglist **list1 = (const struct et8ek8_reglist **)a,
485 **list2 = (const struct et8ek8_reglist **)b;
486
487 /* Put real modes in the beginning. */
488 if ((*list1)->type == ET8EK8_REGLIST_MODE &&
489 (*list2)->type != ET8EK8_REGLIST_MODE)
490 return -1;
491 if ((*list1)->type != ET8EK8_REGLIST_MODE &&
492 (*list2)->type == ET8EK8_REGLIST_MODE)
493 return 1;
494
495 /* Descending width. */
496 if ((*list1)->mode.window_width > (*list2)->mode.window_width)
497 return -1;
498 if ((*list1)->mode.window_width < (*list2)->mode.window_width)
499 return 1;
500
501 if ((*list1)->mode.window_height > (*list2)->mode.window_height)
502 return -1;
503 if ((*list1)->mode.window_height < (*list2)->mode.window_height)
504 return 1;
505
506 return 0;
507 }
508
et8ek8_reglist_import(struct i2c_client * client,struct et8ek8_meta_reglist * meta)509 static int et8ek8_reglist_import(struct i2c_client *client,
510 struct et8ek8_meta_reglist *meta)
511 {
512 int nlists = 0, i;
513
514 dev_info(&client->dev, "meta_reglist version %s\n", meta->version);
515
516 while (meta->reglist[nlists].ptr)
517 nlists++;
518
519 if (!nlists)
520 return -EINVAL;
521
522 sort(&meta->reglist[0].ptr, nlists, sizeof(meta->reglist[0].ptr),
523 et8ek8_reglist_cmp, NULL);
524
525 i = nlists;
526 nlists = 0;
527
528 while (i--) {
529 struct et8ek8_reglist *list;
530
531 list = meta->reglist[nlists].ptr;
532
533 dev_dbg(&client->dev,
534 "%s: type %d\tw %d\th %d\tfmt %x\tival %d/%d\tptr %p\n",
535 __func__,
536 list->type,
537 list->mode.window_width, list->mode.window_height,
538 list->mode.bus_format,
539 list->mode.timeperframe.numerator,
540 list->mode.timeperframe.denominator,
541 (void *)meta->reglist[nlists].ptr);
542
543 nlists++;
544 }
545
546 return 0;
547 }
548
549 /* Called to change the V4L2 gain control value. This function
550 * rounds and clamps the given value and updates the V4L2 control value.
551 * If power is on, also updates the sensor analog and digital gains.
552 * gain is in 0.1 EV (exposure value) units.
553 */
et8ek8_set_gain(struct et8ek8_sensor * sensor,s32 gain)554 static int et8ek8_set_gain(struct et8ek8_sensor *sensor, s32 gain)
555 {
556 struct i2c_client *client = v4l2_get_subdevdata(&sensor->subdev);
557 struct et8ek8_gain new;
558 int r;
559
560 new = et8ek8_gain_table[gain];
561
562 /* FIXME: optimise I2C writes! */
563 r = et8ek8_i2c_write_reg(client, ET8EK8_REG_8BIT,
564 0x124a, new.analog >> 8);
565 if (r)
566 return r;
567 r = et8ek8_i2c_write_reg(client, ET8EK8_REG_8BIT,
568 0x1249, new.analog & 0xff);
569 if (r)
570 return r;
571
572 r = et8ek8_i2c_write_reg(client, ET8EK8_REG_8BIT,
573 0x124d, new.digital >> 8);
574 if (r)
575 return r;
576 r = et8ek8_i2c_write_reg(client, ET8EK8_REG_8BIT,
577 0x124c, new.digital & 0xff);
578
579 return r;
580 }
581
et8ek8_set_test_pattern(struct et8ek8_sensor * sensor,s32 mode)582 static int et8ek8_set_test_pattern(struct et8ek8_sensor *sensor, s32 mode)
583 {
584 struct i2c_client *client = v4l2_get_subdevdata(&sensor->subdev);
585 int cbh_mode, cbv_mode, tp_mode, din_sw, r1420, rval;
586
587 /* Values for normal mode */
588 cbh_mode = 0;
589 cbv_mode = 0;
590 tp_mode = 0;
591 din_sw = 0x00;
592 r1420 = 0xF0;
593
594 if (mode) {
595 /* Test pattern mode */
596 if (mode < 5) {
597 cbh_mode = 1;
598 cbv_mode = 1;
599 tp_mode = mode + 3;
600 } else {
601 cbh_mode = 0;
602 cbv_mode = 0;
603 tp_mode = mode - 4 + 3;
604 }
605
606 din_sw = 0x01;
607 r1420 = 0xE0;
608 }
609
610 rval = et8ek8_i2c_write_reg(client, ET8EK8_REG_8BIT, 0x111B,
611 tp_mode << 4);
612 if (rval)
613 return rval;
614
615 rval = et8ek8_i2c_write_reg(client, ET8EK8_REG_8BIT, 0x1121,
616 cbh_mode << 7);
617 if (rval)
618 return rval;
619
620 rval = et8ek8_i2c_write_reg(client, ET8EK8_REG_8BIT, 0x1124,
621 cbv_mode << 7);
622 if (rval)
623 return rval;
624
625 rval = et8ek8_i2c_write_reg(client, ET8EK8_REG_8BIT, 0x112C, din_sw);
626 if (rval)
627 return rval;
628
629 return et8ek8_i2c_write_reg(client, ET8EK8_REG_8BIT, 0x1420, r1420);
630 }
631
632 /* -----------------------------------------------------------------------------
633 * V4L2 controls
634 */
635
et8ek8_set_ctrl(struct v4l2_ctrl * ctrl)636 static int et8ek8_set_ctrl(struct v4l2_ctrl *ctrl)
637 {
638 struct et8ek8_sensor *sensor =
639 container_of(ctrl->handler, struct et8ek8_sensor, ctrl_handler);
640
641 switch (ctrl->id) {
642 case V4L2_CID_GAIN:
643 return et8ek8_set_gain(sensor, ctrl->val);
644
645 case V4L2_CID_EXPOSURE:
646 {
647 struct i2c_client *client =
648 v4l2_get_subdevdata(&sensor->subdev);
649
650 return et8ek8_i2c_write_reg(client, ET8EK8_REG_16BIT, 0x1243,
651 ctrl->val);
652 }
653
654 case V4L2_CID_TEST_PATTERN:
655 return et8ek8_set_test_pattern(sensor, ctrl->val);
656
657 case V4L2_CID_PIXEL_RATE:
658 return 0;
659
660 default:
661 return -EINVAL;
662 }
663 }
664
665 static const struct v4l2_ctrl_ops et8ek8_ctrl_ops = {
666 .s_ctrl = et8ek8_set_ctrl,
667 };
668
669 static const char * const et8ek8_test_pattern_menu[] = {
670 "Normal",
671 "Vertical colorbar",
672 "Horizontal colorbar",
673 "Scale",
674 "Ramp",
675 "Small vertical colorbar",
676 "Small horizontal colorbar",
677 "Small scale",
678 "Small ramp",
679 };
680
et8ek8_init_controls(struct et8ek8_sensor * sensor)681 static int et8ek8_init_controls(struct et8ek8_sensor *sensor)
682 {
683 s32 max_rows;
684
685 v4l2_ctrl_handler_init(&sensor->ctrl_handler, 4);
686
687 /* V4L2_CID_GAIN */
688 v4l2_ctrl_new_std(&sensor->ctrl_handler, &et8ek8_ctrl_ops,
689 V4L2_CID_GAIN, 0, ARRAY_SIZE(et8ek8_gain_table) - 1,
690 1, 0);
691
692 max_rows = sensor->current_reglist->mode.max_exp;
693 {
694 u32 min = 1, max = max_rows;
695
696 sensor->exposure =
697 v4l2_ctrl_new_std(&sensor->ctrl_handler,
698 &et8ek8_ctrl_ops, V4L2_CID_EXPOSURE,
699 min, max, min, max);
700 }
701
702 /* V4L2_CID_PIXEL_RATE */
703 sensor->pixel_rate =
704 v4l2_ctrl_new_std(&sensor->ctrl_handler, &et8ek8_ctrl_ops,
705 V4L2_CID_PIXEL_RATE, 1, INT_MAX, 1, 1);
706
707 /* V4L2_CID_TEST_PATTERN */
708 v4l2_ctrl_new_std_menu_items(&sensor->ctrl_handler,
709 &et8ek8_ctrl_ops, V4L2_CID_TEST_PATTERN,
710 ARRAY_SIZE(et8ek8_test_pattern_menu) - 1,
711 0, 0, et8ek8_test_pattern_menu);
712
713 if (sensor->ctrl_handler.error)
714 return sensor->ctrl_handler.error;
715
716 sensor->subdev.ctrl_handler = &sensor->ctrl_handler;
717
718 return 0;
719 }
720
et8ek8_update_controls(struct et8ek8_sensor * sensor)721 static void et8ek8_update_controls(struct et8ek8_sensor *sensor)
722 {
723 struct v4l2_ctrl *ctrl;
724 struct et8ek8_mode *mode = &sensor->current_reglist->mode;
725
726 u32 min, max, pixel_rate;
727 static const int S = 8;
728
729 ctrl = sensor->exposure;
730
731 min = 1;
732 max = mode->max_exp;
733
734 /*
735 * Calculate average pixel clock per line. Assume buffers can spread
736 * the data over horizontal blanking time. Rounding upwards.
737 * Formula taken from stock Nokia N900 kernel.
738 */
739 pixel_rate = ((mode->pixel_clock + (1 << S) - 1) >> S) + mode->width;
740 pixel_rate = mode->window_width * (pixel_rate - 1) / mode->width;
741
742 __v4l2_ctrl_modify_range(ctrl, min, max, min, max);
743 __v4l2_ctrl_s_ctrl_int64(sensor->pixel_rate, pixel_rate << S);
744 }
745
et8ek8_configure(struct et8ek8_sensor * sensor)746 static int et8ek8_configure(struct et8ek8_sensor *sensor)
747 {
748 struct v4l2_subdev *subdev = &sensor->subdev;
749 struct i2c_client *client = v4l2_get_subdevdata(subdev);
750 int rval;
751
752 rval = et8ek8_i2c_write_regs(client, sensor->current_reglist->regs);
753 if (rval)
754 goto fail;
755
756 /* Controls set while the power to the sensor is turned off are saved
757 * but not applied to the hardware. Now that we're about to start
758 * streaming apply all the current values to the hardware.
759 */
760 rval = v4l2_ctrl_handler_setup(&sensor->ctrl_handler);
761 if (rval)
762 goto fail;
763
764 return 0;
765
766 fail:
767 dev_err(&client->dev, "sensor configuration failed\n");
768
769 return rval;
770 }
771
et8ek8_stream_on(struct et8ek8_sensor * sensor)772 static int et8ek8_stream_on(struct et8ek8_sensor *sensor)
773 {
774 struct i2c_client *client = v4l2_get_subdevdata(&sensor->subdev);
775
776 return et8ek8_i2c_write_reg(client, ET8EK8_REG_8BIT, 0x1252, 0xb0);
777 }
778
et8ek8_stream_off(struct et8ek8_sensor * sensor)779 static int et8ek8_stream_off(struct et8ek8_sensor *sensor)
780 {
781 struct i2c_client *client = v4l2_get_subdevdata(&sensor->subdev);
782
783 return et8ek8_i2c_write_reg(client, ET8EK8_REG_8BIT, 0x1252, 0x30);
784 }
785
et8ek8_s_stream(struct v4l2_subdev * subdev,int streaming)786 static int et8ek8_s_stream(struct v4l2_subdev *subdev, int streaming)
787 {
788 struct et8ek8_sensor *sensor = to_et8ek8_sensor(subdev);
789 int ret;
790
791 if (!streaming)
792 return et8ek8_stream_off(sensor);
793
794 ret = et8ek8_configure(sensor);
795 if (ret < 0)
796 return ret;
797
798 return et8ek8_stream_on(sensor);
799 }
800
801 /* --------------------------------------------------------------------------
802 * V4L2 subdev operations
803 */
804
et8ek8_power_off(struct et8ek8_sensor * sensor)805 static int et8ek8_power_off(struct et8ek8_sensor *sensor)
806 {
807 gpiod_set_value(sensor->reset, 0);
808 udelay(1);
809
810 clk_disable_unprepare(sensor->ext_clk);
811
812 return regulator_disable(sensor->vana);
813 }
814
et8ek8_power_on(struct et8ek8_sensor * sensor)815 static int et8ek8_power_on(struct et8ek8_sensor *sensor)
816 {
817 struct v4l2_subdev *subdev = &sensor->subdev;
818 struct i2c_client *client = v4l2_get_subdevdata(subdev);
819 unsigned int xclk_freq;
820 int val, rval;
821
822 rval = regulator_enable(sensor->vana);
823 if (rval) {
824 dev_err(&client->dev, "failed to enable vana regulator\n");
825 return rval;
826 }
827
828 if (sensor->current_reglist)
829 xclk_freq = sensor->current_reglist->mode.ext_clock;
830 else
831 xclk_freq = sensor->xclk_freq;
832
833 rval = clk_set_rate(sensor->ext_clk, xclk_freq);
834 if (rval < 0) {
835 dev_err(&client->dev, "unable to set extclk clock freq to %u\n",
836 xclk_freq);
837 goto out;
838 }
839 rval = clk_prepare_enable(sensor->ext_clk);
840 if (rval < 0) {
841 dev_err(&client->dev, "failed to enable extclk\n");
842 goto out;
843 }
844
845 if (rval)
846 goto out;
847
848 udelay(10); /* I wish this is a good value */
849
850 gpiod_set_value(sensor->reset, 1);
851
852 msleep(5000 * 1000 / xclk_freq + 1); /* Wait 5000 cycles */
853
854 rval = et8ek8_i2c_reglist_find_write(client, &meta_reglist,
855 ET8EK8_REGLIST_POWERON);
856 if (rval)
857 goto out;
858
859 #ifdef USE_CRC
860 rval = et8ek8_i2c_read_reg(client, ET8EK8_REG_8BIT, 0x1263, &val);
861 if (rval)
862 goto out;
863 #if USE_CRC /* TODO get crc setting from DT */
864 val |= BIT(4);
865 #else
866 val &= ~BIT(4);
867 #endif
868 rval = et8ek8_i2c_write_reg(client, ET8EK8_REG_8BIT, 0x1263, val);
869 if (rval)
870 goto out;
871 #endif
872
873 out:
874 if (rval)
875 et8ek8_power_off(sensor);
876
877 return rval;
878 }
879
880 /* --------------------------------------------------------------------------
881 * V4L2 subdev video operations
882 */
883 #define MAX_FMTS 4
et8ek8_enum_mbus_code(struct v4l2_subdev * subdev,struct v4l2_subdev_state * sd_state,struct v4l2_subdev_mbus_code_enum * code)884 static int et8ek8_enum_mbus_code(struct v4l2_subdev *subdev,
885 struct v4l2_subdev_state *sd_state,
886 struct v4l2_subdev_mbus_code_enum *code)
887 {
888 struct et8ek8_reglist **list =
889 et8ek8_reglist_first(&meta_reglist);
890 u32 pixelformat[MAX_FMTS];
891 int npixelformat = 0;
892
893 if (code->index >= MAX_FMTS)
894 return -EINVAL;
895
896 for (; *list; list++) {
897 struct et8ek8_mode *mode = &(*list)->mode;
898 int i;
899
900 if ((*list)->type != ET8EK8_REGLIST_MODE)
901 continue;
902
903 for (i = 0; i < npixelformat; i++) {
904 if (pixelformat[i] == mode->bus_format)
905 break;
906 }
907 if (i != npixelformat)
908 continue;
909
910 if (code->index == npixelformat) {
911 code->code = mode->bus_format;
912 return 0;
913 }
914
915 pixelformat[npixelformat] = mode->bus_format;
916 npixelformat++;
917 }
918
919 return -EINVAL;
920 }
921
et8ek8_enum_frame_size(struct v4l2_subdev * subdev,struct v4l2_subdev_state * sd_state,struct v4l2_subdev_frame_size_enum * fse)922 static int et8ek8_enum_frame_size(struct v4l2_subdev *subdev,
923 struct v4l2_subdev_state *sd_state,
924 struct v4l2_subdev_frame_size_enum *fse)
925 {
926 struct et8ek8_reglist **list =
927 et8ek8_reglist_first(&meta_reglist);
928 struct v4l2_mbus_framefmt format;
929 int cmp_width = INT_MAX;
930 int cmp_height = INT_MAX;
931 int index = fse->index;
932
933 for (; *list; list++) {
934 if ((*list)->type != ET8EK8_REGLIST_MODE)
935 continue;
936
937 et8ek8_reglist_to_mbus(*list, &format);
938 if (fse->code != format.code)
939 continue;
940
941 /* Assume that the modes are grouped by frame size. */
942 if (format.width == cmp_width && format.height == cmp_height)
943 continue;
944
945 cmp_width = format.width;
946 cmp_height = format.height;
947
948 if (index-- == 0) {
949 fse->min_width = format.width;
950 fse->min_height = format.height;
951 fse->max_width = format.width;
952 fse->max_height = format.height;
953 return 0;
954 }
955 }
956
957 return -EINVAL;
958 }
959
et8ek8_enum_frame_ival(struct v4l2_subdev * subdev,struct v4l2_subdev_state * sd_state,struct v4l2_subdev_frame_interval_enum * fie)960 static int et8ek8_enum_frame_ival(struct v4l2_subdev *subdev,
961 struct v4l2_subdev_state *sd_state,
962 struct v4l2_subdev_frame_interval_enum *fie)
963 {
964 struct et8ek8_reglist **list =
965 et8ek8_reglist_first(&meta_reglist);
966 struct v4l2_mbus_framefmt format;
967 int index = fie->index;
968
969 for (; *list; list++) {
970 struct et8ek8_mode *mode = &(*list)->mode;
971
972 if ((*list)->type != ET8EK8_REGLIST_MODE)
973 continue;
974
975 et8ek8_reglist_to_mbus(*list, &format);
976 if (fie->code != format.code)
977 continue;
978
979 if (fie->width != format.width || fie->height != format.height)
980 continue;
981
982 if (index-- == 0) {
983 fie->interval = mode->timeperframe;
984 return 0;
985 }
986 }
987
988 return -EINVAL;
989 }
990
991 static struct v4l2_mbus_framefmt *
__et8ek8_get_pad_format(struct et8ek8_sensor * sensor,struct v4l2_subdev_state * sd_state,unsigned int pad,enum v4l2_subdev_format_whence which)992 __et8ek8_get_pad_format(struct et8ek8_sensor *sensor,
993 struct v4l2_subdev_state *sd_state,
994 unsigned int pad, enum v4l2_subdev_format_whence which)
995 {
996 switch (which) {
997 case V4L2_SUBDEV_FORMAT_TRY:
998 return v4l2_subdev_state_get_format(sd_state, pad);
999 case V4L2_SUBDEV_FORMAT_ACTIVE:
1000 return &sensor->format;
1001 default:
1002 return NULL;
1003 }
1004 }
1005
et8ek8_get_pad_format(struct v4l2_subdev * subdev,struct v4l2_subdev_state * sd_state,struct v4l2_subdev_format * fmt)1006 static int et8ek8_get_pad_format(struct v4l2_subdev *subdev,
1007 struct v4l2_subdev_state *sd_state,
1008 struct v4l2_subdev_format *fmt)
1009 {
1010 struct et8ek8_sensor *sensor = to_et8ek8_sensor(subdev);
1011 struct v4l2_mbus_framefmt *format;
1012
1013 format = __et8ek8_get_pad_format(sensor, sd_state, fmt->pad,
1014 fmt->which);
1015 if (!format)
1016 return -EINVAL;
1017
1018 fmt->format = *format;
1019
1020 return 0;
1021 }
1022
et8ek8_set_pad_format(struct v4l2_subdev * subdev,struct v4l2_subdev_state * sd_state,struct v4l2_subdev_format * fmt)1023 static int et8ek8_set_pad_format(struct v4l2_subdev *subdev,
1024 struct v4l2_subdev_state *sd_state,
1025 struct v4l2_subdev_format *fmt)
1026 {
1027 struct et8ek8_sensor *sensor = to_et8ek8_sensor(subdev);
1028 struct v4l2_mbus_framefmt *format;
1029 struct et8ek8_reglist *reglist;
1030
1031 format = __et8ek8_get_pad_format(sensor, sd_state, fmt->pad,
1032 fmt->which);
1033 if (!format)
1034 return -EINVAL;
1035
1036 reglist = et8ek8_reglist_find_mode_fmt(&meta_reglist, &fmt->format);
1037 et8ek8_reglist_to_mbus(reglist, &fmt->format);
1038 *format = fmt->format;
1039
1040 if (fmt->which == V4L2_SUBDEV_FORMAT_ACTIVE) {
1041 sensor->current_reglist = reglist;
1042 et8ek8_update_controls(sensor);
1043 }
1044
1045 return 0;
1046 }
1047
et8ek8_get_frame_interval(struct v4l2_subdev * subdev,struct v4l2_subdev_state * sd_state,struct v4l2_subdev_frame_interval * fi)1048 static int et8ek8_get_frame_interval(struct v4l2_subdev *subdev,
1049 struct v4l2_subdev_state *sd_state,
1050 struct v4l2_subdev_frame_interval *fi)
1051 {
1052 struct et8ek8_sensor *sensor = to_et8ek8_sensor(subdev);
1053
1054 /*
1055 * FIXME: Implement support for V4L2_SUBDEV_FORMAT_TRY, using the V4L2
1056 * subdev active state API.
1057 */
1058 if (fi->which != V4L2_SUBDEV_FORMAT_ACTIVE)
1059 return -EINVAL;
1060
1061 memset(fi, 0, sizeof(*fi));
1062 fi->interval = sensor->current_reglist->mode.timeperframe;
1063
1064 return 0;
1065 }
1066
et8ek8_set_frame_interval(struct v4l2_subdev * subdev,struct v4l2_subdev_state * sd_state,struct v4l2_subdev_frame_interval * fi)1067 static int et8ek8_set_frame_interval(struct v4l2_subdev *subdev,
1068 struct v4l2_subdev_state *sd_state,
1069 struct v4l2_subdev_frame_interval *fi)
1070 {
1071 struct et8ek8_sensor *sensor = to_et8ek8_sensor(subdev);
1072 struct et8ek8_reglist *reglist;
1073
1074 /*
1075 * FIXME: Implement support for V4L2_SUBDEV_FORMAT_TRY, using the V4L2
1076 * subdev active state API.
1077 */
1078 if (fi->which != V4L2_SUBDEV_FORMAT_ACTIVE)
1079 return -EINVAL;
1080
1081 reglist = et8ek8_reglist_find_mode_ival(&meta_reglist,
1082 sensor->current_reglist,
1083 &fi->interval);
1084
1085 if (!reglist)
1086 return -EINVAL;
1087
1088 if (sensor->current_reglist->mode.ext_clock != reglist->mode.ext_clock)
1089 return -EINVAL;
1090
1091 sensor->current_reglist = reglist;
1092 et8ek8_update_controls(sensor);
1093
1094 return 0;
1095 }
1096
et8ek8_g_priv_mem(struct v4l2_subdev * subdev)1097 static int et8ek8_g_priv_mem(struct v4l2_subdev *subdev)
1098 {
1099 struct et8ek8_sensor *sensor = to_et8ek8_sensor(subdev);
1100 struct i2c_client *client = v4l2_get_subdevdata(subdev);
1101 unsigned int length = ET8EK8_PRIV_MEM_SIZE;
1102 unsigned int offset = 0;
1103 u8 *ptr = sensor->priv_mem;
1104 int rval = 0;
1105
1106 /* Read the EEPROM window-by-window, each window 8 bytes */
1107 do {
1108 u8 buffer[PRIV_MEM_WIN_SIZE];
1109 struct i2c_msg msg;
1110 int bytes, i;
1111 int ofs;
1112
1113 /* Set the current window */
1114 rval = et8ek8_i2c_write_reg(client, ET8EK8_REG_8BIT, 0x0001,
1115 0xe0 | (offset >> 3));
1116 if (rval < 0)
1117 return rval;
1118
1119 /* Wait for status bit */
1120 for (i = 0; i < 1000; ++i) {
1121 u32 status;
1122
1123 rval = et8ek8_i2c_read_reg(client, ET8EK8_REG_8BIT,
1124 0x0003, &status);
1125 if (rval < 0)
1126 return rval;
1127 if (!(status & 0x08))
1128 break;
1129 usleep_range(1000, 2000);
1130 }
1131
1132 if (i == 1000)
1133 return -EIO;
1134
1135 /* Read window, 8 bytes at once, and copy to user space */
1136 ofs = offset & 0x07; /* Offset within this window */
1137 bytes = length + ofs > 8 ? 8-ofs : length;
1138 msg.addr = client->addr;
1139 msg.flags = 0;
1140 msg.len = 2;
1141 msg.buf = buffer;
1142 ofs += PRIV_MEM_START_REG;
1143 buffer[0] = (u8)(ofs >> 8);
1144 buffer[1] = (u8)(ofs & 0xFF);
1145
1146 rval = i2c_transfer(client->adapter, &msg, 1);
1147 if (rval < 0)
1148 return rval;
1149
1150 mdelay(ET8EK8_I2C_DELAY);
1151 msg.addr = client->addr;
1152 msg.len = bytes;
1153 msg.flags = I2C_M_RD;
1154 msg.buf = buffer;
1155 memset(buffer, 0, sizeof(buffer));
1156
1157 rval = i2c_transfer(client->adapter, &msg, 1);
1158 if (rval < 0)
1159 return rval;
1160
1161 rval = 0;
1162 memcpy(ptr, buffer, bytes);
1163
1164 length -= bytes;
1165 offset += bytes;
1166 ptr += bytes;
1167 } while (length > 0);
1168
1169 return rval;
1170 }
1171
et8ek8_dev_init(struct v4l2_subdev * subdev)1172 static int et8ek8_dev_init(struct v4l2_subdev *subdev)
1173 {
1174 struct et8ek8_sensor *sensor = to_et8ek8_sensor(subdev);
1175 struct i2c_client *client = v4l2_get_subdevdata(subdev);
1176 int rval, rev_l, rev_h;
1177
1178 rval = et8ek8_power_on(sensor);
1179 if (rval) {
1180 dev_err(&client->dev, "could not power on\n");
1181 return rval;
1182 }
1183
1184 rval = et8ek8_i2c_read_reg(client, ET8EK8_REG_8BIT,
1185 REG_REVISION_NUMBER_L, &rev_l);
1186 if (!rval)
1187 rval = et8ek8_i2c_read_reg(client, ET8EK8_REG_8BIT,
1188 REG_REVISION_NUMBER_H, &rev_h);
1189 if (rval) {
1190 dev_err(&client->dev, "no et8ek8 sensor detected\n");
1191 goto out_poweroff;
1192 }
1193
1194 sensor->version = (rev_h << 8) + rev_l;
1195 if (sensor->version != ET8EK8_REV_1 && sensor->version != ET8EK8_REV_2)
1196 dev_info(&client->dev,
1197 "unknown version 0x%x detected, continuing anyway\n",
1198 sensor->version);
1199
1200 rval = et8ek8_reglist_import(client, &meta_reglist);
1201 if (rval) {
1202 dev_err(&client->dev,
1203 "invalid register list %s, import failed\n",
1204 ET8EK8_NAME);
1205 goto out_poweroff;
1206 }
1207
1208 sensor->current_reglist = et8ek8_reglist_find_type(&meta_reglist,
1209 ET8EK8_REGLIST_MODE);
1210 if (!sensor->current_reglist) {
1211 dev_err(&client->dev,
1212 "invalid register list %s, no mode found\n",
1213 ET8EK8_NAME);
1214 rval = -ENODEV;
1215 goto out_poweroff;
1216 }
1217
1218 et8ek8_reglist_to_mbus(sensor->current_reglist, &sensor->format);
1219
1220 rval = et8ek8_i2c_reglist_find_write(client, &meta_reglist,
1221 ET8EK8_REGLIST_POWERON);
1222 if (rval) {
1223 dev_err(&client->dev,
1224 "invalid register list %s, no POWERON mode found\n",
1225 ET8EK8_NAME);
1226 goto out_poweroff;
1227 }
1228 rval = et8ek8_stream_on(sensor); /* Needed to be able to read EEPROM */
1229 if (rval)
1230 goto out_poweroff;
1231 rval = et8ek8_g_priv_mem(subdev);
1232 if (rval)
1233 dev_warn(&client->dev,
1234 "can not read OTP (EEPROM) memory from sensor\n");
1235 rval = et8ek8_stream_off(sensor);
1236 if (rval)
1237 goto out_poweroff;
1238
1239 rval = et8ek8_power_off(sensor);
1240 if (rval)
1241 goto out_poweroff;
1242
1243 return 0;
1244
1245 out_poweroff:
1246 et8ek8_power_off(sensor);
1247
1248 return rval;
1249 }
1250
1251 /* --------------------------------------------------------------------------
1252 * sysfs attributes
1253 */
1254 static ssize_t
priv_mem_show(struct device * dev,struct device_attribute * attr,char * buf)1255 priv_mem_show(struct device *dev, struct device_attribute *attr, char *buf)
1256 {
1257 struct v4l2_subdev *subdev = dev_get_drvdata(dev);
1258 struct et8ek8_sensor *sensor = to_et8ek8_sensor(subdev);
1259
1260 #if PAGE_SIZE < ET8EK8_PRIV_MEM_SIZE
1261 #error PAGE_SIZE too small!
1262 #endif
1263
1264 memcpy(buf, sensor->priv_mem, ET8EK8_PRIV_MEM_SIZE);
1265
1266 return ET8EK8_PRIV_MEM_SIZE;
1267 }
1268 static DEVICE_ATTR_RO(priv_mem);
1269
1270 /* --------------------------------------------------------------------------
1271 * V4L2 subdev core operations
1272 */
1273
1274 static int
et8ek8_registered(struct v4l2_subdev * subdev)1275 et8ek8_registered(struct v4l2_subdev *subdev)
1276 {
1277 struct et8ek8_sensor *sensor = to_et8ek8_sensor(subdev);
1278 struct i2c_client *client = v4l2_get_subdevdata(subdev);
1279 int rval;
1280
1281 dev_dbg(&client->dev, "registered!");
1282
1283 rval = device_create_file(&client->dev, &dev_attr_priv_mem);
1284 if (rval) {
1285 dev_err(&client->dev, "could not register sysfs entry\n");
1286 return rval;
1287 }
1288
1289 rval = et8ek8_dev_init(subdev);
1290 if (rval)
1291 goto err_file;
1292
1293 rval = et8ek8_init_controls(sensor);
1294 if (rval) {
1295 dev_err(&client->dev, "controls initialization failed\n");
1296 goto err_file;
1297 }
1298
1299 __et8ek8_get_pad_format(sensor, NULL, 0, V4L2_SUBDEV_FORMAT_ACTIVE);
1300
1301 return 0;
1302
1303 err_file:
1304 device_remove_file(&client->dev, &dev_attr_priv_mem);
1305
1306 return rval;
1307 }
1308
__et8ek8_set_power(struct et8ek8_sensor * sensor,bool on)1309 static int __et8ek8_set_power(struct et8ek8_sensor *sensor, bool on)
1310 {
1311 return on ? et8ek8_power_on(sensor) : et8ek8_power_off(sensor);
1312 }
1313
et8ek8_set_power(struct v4l2_subdev * subdev,int on)1314 static int et8ek8_set_power(struct v4l2_subdev *subdev, int on)
1315 {
1316 struct et8ek8_sensor *sensor = to_et8ek8_sensor(subdev);
1317 int ret = 0;
1318
1319 mutex_lock(&sensor->power_lock);
1320
1321 /* If the power count is modified from 0 to != 0 or from != 0 to 0,
1322 * update the power state.
1323 */
1324 if (sensor->power_count == !on) {
1325 ret = __et8ek8_set_power(sensor, !!on);
1326 if (ret < 0)
1327 goto done;
1328 }
1329
1330 /* Update the power count. */
1331 sensor->power_count += on ? 1 : -1;
1332 WARN_ON(sensor->power_count < 0);
1333
1334 done:
1335 mutex_unlock(&sensor->power_lock);
1336
1337 return ret;
1338 }
1339
et8ek8_open(struct v4l2_subdev * sd,struct v4l2_subdev_fh * fh)1340 static int et8ek8_open(struct v4l2_subdev *sd, struct v4l2_subdev_fh *fh)
1341 {
1342 struct et8ek8_sensor *sensor = to_et8ek8_sensor(sd);
1343 struct v4l2_mbus_framefmt *format;
1344 struct et8ek8_reglist *reglist;
1345
1346 reglist = et8ek8_reglist_find_type(&meta_reglist, ET8EK8_REGLIST_MODE);
1347 format = __et8ek8_get_pad_format(sensor, fh->state, 0,
1348 V4L2_SUBDEV_FORMAT_TRY);
1349 et8ek8_reglist_to_mbus(reglist, format);
1350
1351 return et8ek8_set_power(sd, true);
1352 }
1353
et8ek8_close(struct v4l2_subdev * sd,struct v4l2_subdev_fh * fh)1354 static int et8ek8_close(struct v4l2_subdev *sd, struct v4l2_subdev_fh *fh)
1355 {
1356 return et8ek8_set_power(sd, false);
1357 }
1358
1359 static const struct v4l2_subdev_video_ops et8ek8_video_ops = {
1360 .s_stream = et8ek8_s_stream,
1361 };
1362
1363 static const struct v4l2_subdev_core_ops et8ek8_core_ops = {
1364 .s_power = et8ek8_set_power,
1365 };
1366
1367 static const struct v4l2_subdev_pad_ops et8ek8_pad_ops = {
1368 .enum_mbus_code = et8ek8_enum_mbus_code,
1369 .enum_frame_size = et8ek8_enum_frame_size,
1370 .enum_frame_interval = et8ek8_enum_frame_ival,
1371 .get_fmt = et8ek8_get_pad_format,
1372 .set_fmt = et8ek8_set_pad_format,
1373 .get_frame_interval = et8ek8_get_frame_interval,
1374 .set_frame_interval = et8ek8_set_frame_interval,
1375 };
1376
1377 static const struct v4l2_subdev_ops et8ek8_ops = {
1378 .core = &et8ek8_core_ops,
1379 .video = &et8ek8_video_ops,
1380 .pad = &et8ek8_pad_ops,
1381 };
1382
1383 static const struct v4l2_subdev_internal_ops et8ek8_internal_ops = {
1384 .registered = et8ek8_registered,
1385 .open = et8ek8_open,
1386 .close = et8ek8_close,
1387 };
1388
1389 /* --------------------------------------------------------------------------
1390 * I2C driver
1391 */
et8ek8_suspend(struct device * dev)1392 static int __maybe_unused et8ek8_suspend(struct device *dev)
1393 {
1394 struct v4l2_subdev *subdev = dev_get_drvdata(dev);
1395 struct et8ek8_sensor *sensor = to_et8ek8_sensor(subdev);
1396
1397 if (!sensor->power_count)
1398 return 0;
1399
1400 return __et8ek8_set_power(sensor, false);
1401 }
1402
et8ek8_resume(struct device * dev)1403 static int __maybe_unused et8ek8_resume(struct device *dev)
1404 {
1405 struct v4l2_subdev *subdev = dev_get_drvdata(dev);
1406 struct et8ek8_sensor *sensor = to_et8ek8_sensor(subdev);
1407
1408 if (!sensor->power_count)
1409 return 0;
1410
1411 return __et8ek8_set_power(sensor, true);
1412 }
1413
et8ek8_probe(struct i2c_client * client)1414 static int et8ek8_probe(struct i2c_client *client)
1415 {
1416 struct et8ek8_sensor *sensor;
1417 struct device *dev = &client->dev;
1418 int ret;
1419
1420 sensor = devm_kzalloc(&client->dev, sizeof(*sensor), GFP_KERNEL);
1421 if (!sensor)
1422 return -ENOMEM;
1423
1424 sensor->reset = devm_gpiod_get(dev, "reset", GPIOD_OUT_LOW);
1425 if (IS_ERR(sensor->reset)) {
1426 dev_dbg(&client->dev, "could not request reset gpio\n");
1427 return PTR_ERR(sensor->reset);
1428 }
1429
1430 sensor->vana = devm_regulator_get(dev, "vana");
1431 if (IS_ERR(sensor->vana)) {
1432 dev_err(&client->dev, "could not get regulator for vana\n");
1433 return PTR_ERR(sensor->vana);
1434 }
1435
1436 sensor->ext_clk = devm_clk_get(dev, NULL);
1437 if (IS_ERR(sensor->ext_clk)) {
1438 dev_err(&client->dev, "could not get clock\n");
1439 return PTR_ERR(sensor->ext_clk);
1440 }
1441
1442 ret = of_property_read_u32(dev->of_node, "clock-frequency",
1443 &sensor->xclk_freq);
1444 if (ret) {
1445 dev_warn(dev, "can't get clock-frequency\n");
1446 return ret;
1447 }
1448
1449 mutex_init(&sensor->power_lock);
1450
1451 v4l2_i2c_subdev_init(&sensor->subdev, client, &et8ek8_ops);
1452 sensor->subdev.flags |= V4L2_SUBDEV_FL_HAS_DEVNODE;
1453 sensor->subdev.internal_ops = &et8ek8_internal_ops;
1454
1455 sensor->subdev.entity.function = MEDIA_ENT_F_CAM_SENSOR;
1456 sensor->pad.flags = MEDIA_PAD_FL_SOURCE;
1457 ret = media_entity_pads_init(&sensor->subdev.entity, 1, &sensor->pad);
1458 if (ret < 0) {
1459 dev_err(&client->dev, "media entity init failed!\n");
1460 goto err_mutex;
1461 }
1462
1463 ret = v4l2_async_register_subdev_sensor(&sensor->subdev);
1464 if (ret < 0)
1465 goto err_entity;
1466
1467 dev_dbg(dev, "initialized!\n");
1468
1469 return 0;
1470
1471 err_entity:
1472 media_entity_cleanup(&sensor->subdev.entity);
1473 err_mutex:
1474 mutex_destroy(&sensor->power_lock);
1475 return ret;
1476 }
1477
et8ek8_remove(struct i2c_client * client)1478 static void et8ek8_remove(struct i2c_client *client)
1479 {
1480 struct v4l2_subdev *subdev = i2c_get_clientdata(client);
1481 struct et8ek8_sensor *sensor = to_et8ek8_sensor(subdev);
1482
1483 if (sensor->power_count) {
1484 WARN_ON(1);
1485 et8ek8_power_off(sensor);
1486 sensor->power_count = 0;
1487 }
1488
1489 v4l2_device_unregister_subdev(&sensor->subdev);
1490 device_remove_file(&client->dev, &dev_attr_priv_mem);
1491 v4l2_ctrl_handler_free(&sensor->ctrl_handler);
1492 v4l2_async_unregister_subdev(&sensor->subdev);
1493 media_entity_cleanup(&sensor->subdev.entity);
1494 mutex_destroy(&sensor->power_lock);
1495 }
1496
1497 static const struct of_device_id et8ek8_of_table[] = {
1498 { .compatible = "toshiba,et8ek8" },
1499 { },
1500 };
1501 MODULE_DEVICE_TABLE(of, et8ek8_of_table);
1502
1503 static const struct i2c_device_id et8ek8_id_table[] = {
1504 { ET8EK8_NAME },
1505 { }
1506 };
1507 MODULE_DEVICE_TABLE(i2c, et8ek8_id_table);
1508
1509 static const struct dev_pm_ops et8ek8_pm_ops = {
1510 SET_SYSTEM_SLEEP_PM_OPS(et8ek8_suspend, et8ek8_resume)
1511 };
1512
1513 static struct i2c_driver et8ek8_i2c_driver = {
1514 .driver = {
1515 .name = ET8EK8_NAME,
1516 .pm = &et8ek8_pm_ops,
1517 .of_match_table = et8ek8_of_table,
1518 },
1519 .probe = et8ek8_probe,
1520 .remove = et8ek8_remove,
1521 .id_table = et8ek8_id_table,
1522 };
1523
1524 module_i2c_driver(et8ek8_i2c_driver);
1525
1526 MODULE_AUTHOR("Sakari Ailus <sakari.ailus@iki.fi>, Pavel Machek <pavel@ucw.cz");
1527 MODULE_DESCRIPTION("Toshiba ET8EK8 camera sensor driver");
1528 MODULE_LICENSE("GPL");
1529