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  */
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 
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  */
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  */
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  */
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 
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 
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 
388 static struct et8ek8_reglist **et8ek8_reglist_first(
389 		struct et8ek8_meta_reglist *meta)
390 {
391 	return &meta->reglist[0].ptr;
392 }
393 
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 
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 
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 = &current_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 
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 
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  */
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 
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 
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 
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 
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 
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 
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 
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 
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 
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 
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
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 
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 
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 *
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_get_try_format(&sensor->subdev, sd_state,
999 						  pad);
1000 	case V4L2_SUBDEV_FORMAT_ACTIVE:
1001 		return &sensor->format;
1002 	default:
1003 		return NULL;
1004 	}
1005 }
1006 
1007 static int et8ek8_get_pad_format(struct v4l2_subdev *subdev,
1008 				 struct v4l2_subdev_state *sd_state,
1009 				 struct v4l2_subdev_format *fmt)
1010 {
1011 	struct et8ek8_sensor *sensor = to_et8ek8_sensor(subdev);
1012 	struct v4l2_mbus_framefmt *format;
1013 
1014 	format = __et8ek8_get_pad_format(sensor, sd_state, fmt->pad,
1015 					 fmt->which);
1016 	if (!format)
1017 		return -EINVAL;
1018 
1019 	fmt->format = *format;
1020 
1021 	return 0;
1022 }
1023 
1024 static int et8ek8_set_pad_format(struct v4l2_subdev *subdev,
1025 				 struct v4l2_subdev_state *sd_state,
1026 				 struct v4l2_subdev_format *fmt)
1027 {
1028 	struct et8ek8_sensor *sensor = to_et8ek8_sensor(subdev);
1029 	struct v4l2_mbus_framefmt *format;
1030 	struct et8ek8_reglist *reglist;
1031 
1032 	format = __et8ek8_get_pad_format(sensor, sd_state, fmt->pad,
1033 					 fmt->which);
1034 	if (!format)
1035 		return -EINVAL;
1036 
1037 	reglist = et8ek8_reglist_find_mode_fmt(&meta_reglist, &fmt->format);
1038 	et8ek8_reglist_to_mbus(reglist, &fmt->format);
1039 	*format = fmt->format;
1040 
1041 	if (fmt->which == V4L2_SUBDEV_FORMAT_ACTIVE) {
1042 		sensor->current_reglist = reglist;
1043 		et8ek8_update_controls(sensor);
1044 	}
1045 
1046 	return 0;
1047 }
1048 
1049 static int et8ek8_get_frame_interval(struct v4l2_subdev *subdev,
1050 				     struct v4l2_subdev_frame_interval *fi)
1051 {
1052 	struct et8ek8_sensor *sensor = to_et8ek8_sensor(subdev);
1053 
1054 	memset(fi, 0, sizeof(*fi));
1055 	fi->interval = sensor->current_reglist->mode.timeperframe;
1056 
1057 	return 0;
1058 }
1059 
1060 static int et8ek8_set_frame_interval(struct v4l2_subdev *subdev,
1061 				     struct v4l2_subdev_frame_interval *fi)
1062 {
1063 	struct et8ek8_sensor *sensor = to_et8ek8_sensor(subdev);
1064 	struct et8ek8_reglist *reglist;
1065 
1066 	reglist = et8ek8_reglist_find_mode_ival(&meta_reglist,
1067 						sensor->current_reglist,
1068 						&fi->interval);
1069 
1070 	if (!reglist)
1071 		return -EINVAL;
1072 
1073 	if (sensor->current_reglist->mode.ext_clock != reglist->mode.ext_clock)
1074 		return -EINVAL;
1075 
1076 	sensor->current_reglist = reglist;
1077 	et8ek8_update_controls(sensor);
1078 
1079 	return 0;
1080 }
1081 
1082 static int et8ek8_g_priv_mem(struct v4l2_subdev *subdev)
1083 {
1084 	struct et8ek8_sensor *sensor = to_et8ek8_sensor(subdev);
1085 	struct i2c_client *client = v4l2_get_subdevdata(subdev);
1086 	unsigned int length = ET8EK8_PRIV_MEM_SIZE;
1087 	unsigned int offset = 0;
1088 	u8 *ptr  = sensor->priv_mem;
1089 	int rval = 0;
1090 
1091 	/* Read the EEPROM window-by-window, each window 8 bytes */
1092 	do {
1093 		u8 buffer[PRIV_MEM_WIN_SIZE];
1094 		struct i2c_msg msg;
1095 		int bytes, i;
1096 		int ofs;
1097 
1098 		/* Set the current window */
1099 		rval = et8ek8_i2c_write_reg(client, ET8EK8_REG_8BIT, 0x0001,
1100 					    0xe0 | (offset >> 3));
1101 		if (rval < 0)
1102 			return rval;
1103 
1104 		/* Wait for status bit */
1105 		for (i = 0; i < 1000; ++i) {
1106 			u32 status;
1107 
1108 			rval = et8ek8_i2c_read_reg(client, ET8EK8_REG_8BIT,
1109 						   0x0003, &status);
1110 			if (rval < 0)
1111 				return rval;
1112 			if (!(status & 0x08))
1113 				break;
1114 			usleep_range(1000, 2000);
1115 		}
1116 
1117 		if (i == 1000)
1118 			return -EIO;
1119 
1120 		/* Read window, 8 bytes at once, and copy to user space */
1121 		ofs = offset & 0x07;	/* Offset within this window */
1122 		bytes = length + ofs > 8 ? 8-ofs : length;
1123 		msg.addr = client->addr;
1124 		msg.flags = 0;
1125 		msg.len = 2;
1126 		msg.buf = buffer;
1127 		ofs += PRIV_MEM_START_REG;
1128 		buffer[0] = (u8)(ofs >> 8);
1129 		buffer[1] = (u8)(ofs & 0xFF);
1130 
1131 		rval = i2c_transfer(client->adapter, &msg, 1);
1132 		if (rval < 0)
1133 			return rval;
1134 
1135 		mdelay(ET8EK8_I2C_DELAY);
1136 		msg.addr = client->addr;
1137 		msg.len = bytes;
1138 		msg.flags = I2C_M_RD;
1139 		msg.buf = buffer;
1140 		memset(buffer, 0, sizeof(buffer));
1141 
1142 		rval = i2c_transfer(client->adapter, &msg, 1);
1143 		if (rval < 0)
1144 			return rval;
1145 
1146 		rval = 0;
1147 		memcpy(ptr, buffer, bytes);
1148 
1149 		length -= bytes;
1150 		offset += bytes;
1151 		ptr += bytes;
1152 	} while (length > 0);
1153 
1154 	return rval;
1155 }
1156 
1157 static int et8ek8_dev_init(struct v4l2_subdev *subdev)
1158 {
1159 	struct et8ek8_sensor *sensor = to_et8ek8_sensor(subdev);
1160 	struct i2c_client *client = v4l2_get_subdevdata(subdev);
1161 	int rval, rev_l, rev_h;
1162 
1163 	rval = et8ek8_power_on(sensor);
1164 	if (rval) {
1165 		dev_err(&client->dev, "could not power on\n");
1166 		return rval;
1167 	}
1168 
1169 	rval = et8ek8_i2c_read_reg(client, ET8EK8_REG_8BIT,
1170 				   REG_REVISION_NUMBER_L, &rev_l);
1171 	if (!rval)
1172 		rval = et8ek8_i2c_read_reg(client, ET8EK8_REG_8BIT,
1173 					   REG_REVISION_NUMBER_H, &rev_h);
1174 	if (rval) {
1175 		dev_err(&client->dev, "no et8ek8 sensor detected\n");
1176 		goto out_poweroff;
1177 	}
1178 
1179 	sensor->version = (rev_h << 8) + rev_l;
1180 	if (sensor->version != ET8EK8_REV_1 && sensor->version != ET8EK8_REV_2)
1181 		dev_info(&client->dev,
1182 			 "unknown version 0x%x detected, continuing anyway\n",
1183 			 sensor->version);
1184 
1185 	rval = et8ek8_reglist_import(client, &meta_reglist);
1186 	if (rval) {
1187 		dev_err(&client->dev,
1188 			"invalid register list %s, import failed\n",
1189 			ET8EK8_NAME);
1190 		goto out_poweroff;
1191 	}
1192 
1193 	sensor->current_reglist = et8ek8_reglist_find_type(&meta_reglist,
1194 							   ET8EK8_REGLIST_MODE);
1195 	if (!sensor->current_reglist) {
1196 		dev_err(&client->dev,
1197 			"invalid register list %s, no mode found\n",
1198 			ET8EK8_NAME);
1199 		rval = -ENODEV;
1200 		goto out_poweroff;
1201 	}
1202 
1203 	et8ek8_reglist_to_mbus(sensor->current_reglist, &sensor->format);
1204 
1205 	rval = et8ek8_i2c_reglist_find_write(client, &meta_reglist,
1206 					     ET8EK8_REGLIST_POWERON);
1207 	if (rval) {
1208 		dev_err(&client->dev,
1209 			"invalid register list %s, no POWERON mode found\n",
1210 			ET8EK8_NAME);
1211 		goto out_poweroff;
1212 	}
1213 	rval = et8ek8_stream_on(sensor); /* Needed to be able to read EEPROM */
1214 	if (rval)
1215 		goto out_poweroff;
1216 	rval = et8ek8_g_priv_mem(subdev);
1217 	if (rval)
1218 		dev_warn(&client->dev,
1219 			"can not read OTP (EEPROM) memory from sensor\n");
1220 	rval = et8ek8_stream_off(sensor);
1221 	if (rval)
1222 		goto out_poweroff;
1223 
1224 	rval = et8ek8_power_off(sensor);
1225 	if (rval)
1226 		goto out_poweroff;
1227 
1228 	return 0;
1229 
1230 out_poweroff:
1231 	et8ek8_power_off(sensor);
1232 
1233 	return rval;
1234 }
1235 
1236 /* --------------------------------------------------------------------------
1237  * sysfs attributes
1238  */
1239 static ssize_t
1240 priv_mem_show(struct device *dev, struct device_attribute *attr, char *buf)
1241 {
1242 	struct v4l2_subdev *subdev = dev_get_drvdata(dev);
1243 	struct et8ek8_sensor *sensor = to_et8ek8_sensor(subdev);
1244 
1245 #if PAGE_SIZE < ET8EK8_PRIV_MEM_SIZE
1246 #error PAGE_SIZE too small!
1247 #endif
1248 
1249 	memcpy(buf, sensor->priv_mem, ET8EK8_PRIV_MEM_SIZE);
1250 
1251 	return ET8EK8_PRIV_MEM_SIZE;
1252 }
1253 static DEVICE_ATTR_RO(priv_mem);
1254 
1255 /* --------------------------------------------------------------------------
1256  * V4L2 subdev core operations
1257  */
1258 
1259 static int
1260 et8ek8_registered(struct v4l2_subdev *subdev)
1261 {
1262 	struct et8ek8_sensor *sensor = to_et8ek8_sensor(subdev);
1263 	struct i2c_client *client = v4l2_get_subdevdata(subdev);
1264 	int rval;
1265 
1266 	dev_dbg(&client->dev, "registered!");
1267 
1268 	rval = device_create_file(&client->dev, &dev_attr_priv_mem);
1269 	if (rval) {
1270 		dev_err(&client->dev, "could not register sysfs entry\n");
1271 		return rval;
1272 	}
1273 
1274 	rval = et8ek8_dev_init(subdev);
1275 	if (rval)
1276 		goto err_file;
1277 
1278 	rval = et8ek8_init_controls(sensor);
1279 	if (rval) {
1280 		dev_err(&client->dev, "controls initialization failed\n");
1281 		goto err_file;
1282 	}
1283 
1284 	__et8ek8_get_pad_format(sensor, NULL, 0, V4L2_SUBDEV_FORMAT_ACTIVE);
1285 
1286 	return 0;
1287 
1288 err_file:
1289 	device_remove_file(&client->dev, &dev_attr_priv_mem);
1290 
1291 	return rval;
1292 }
1293 
1294 static int __et8ek8_set_power(struct et8ek8_sensor *sensor, bool on)
1295 {
1296 	return on ? et8ek8_power_on(sensor) : et8ek8_power_off(sensor);
1297 }
1298 
1299 static int et8ek8_set_power(struct v4l2_subdev *subdev, int on)
1300 {
1301 	struct et8ek8_sensor *sensor = to_et8ek8_sensor(subdev);
1302 	int ret = 0;
1303 
1304 	mutex_lock(&sensor->power_lock);
1305 
1306 	/* If the power count is modified from 0 to != 0 or from != 0 to 0,
1307 	 * update the power state.
1308 	 */
1309 	if (sensor->power_count == !on) {
1310 		ret = __et8ek8_set_power(sensor, !!on);
1311 		if (ret < 0)
1312 			goto done;
1313 	}
1314 
1315 	/* Update the power count. */
1316 	sensor->power_count += on ? 1 : -1;
1317 	WARN_ON(sensor->power_count < 0);
1318 
1319 done:
1320 	mutex_unlock(&sensor->power_lock);
1321 
1322 	return ret;
1323 }
1324 
1325 static int et8ek8_open(struct v4l2_subdev *sd, struct v4l2_subdev_fh *fh)
1326 {
1327 	struct et8ek8_sensor *sensor = to_et8ek8_sensor(sd);
1328 	struct v4l2_mbus_framefmt *format;
1329 	struct et8ek8_reglist *reglist;
1330 
1331 	reglist = et8ek8_reglist_find_type(&meta_reglist, ET8EK8_REGLIST_MODE);
1332 	format = __et8ek8_get_pad_format(sensor, fh->state, 0,
1333 					 V4L2_SUBDEV_FORMAT_TRY);
1334 	et8ek8_reglist_to_mbus(reglist, format);
1335 
1336 	return et8ek8_set_power(sd, true);
1337 }
1338 
1339 static int et8ek8_close(struct v4l2_subdev *sd, struct v4l2_subdev_fh *fh)
1340 {
1341 	return et8ek8_set_power(sd, false);
1342 }
1343 
1344 static const struct v4l2_subdev_video_ops et8ek8_video_ops = {
1345 	.s_stream = et8ek8_s_stream,
1346 	.g_frame_interval = et8ek8_get_frame_interval,
1347 	.s_frame_interval = et8ek8_set_frame_interval,
1348 };
1349 
1350 static const struct v4l2_subdev_core_ops et8ek8_core_ops = {
1351 	.s_power = et8ek8_set_power,
1352 };
1353 
1354 static const struct v4l2_subdev_pad_ops et8ek8_pad_ops = {
1355 	.enum_mbus_code = et8ek8_enum_mbus_code,
1356 	.enum_frame_size = et8ek8_enum_frame_size,
1357 	.enum_frame_interval = et8ek8_enum_frame_ival,
1358 	.get_fmt = et8ek8_get_pad_format,
1359 	.set_fmt = et8ek8_set_pad_format,
1360 };
1361 
1362 static const struct v4l2_subdev_ops et8ek8_ops = {
1363 	.core = &et8ek8_core_ops,
1364 	.video = &et8ek8_video_ops,
1365 	.pad = &et8ek8_pad_ops,
1366 };
1367 
1368 static const struct v4l2_subdev_internal_ops et8ek8_internal_ops = {
1369 	.registered = et8ek8_registered,
1370 	.open = et8ek8_open,
1371 	.close = et8ek8_close,
1372 };
1373 
1374 /* --------------------------------------------------------------------------
1375  * I2C driver
1376  */
1377 static int __maybe_unused et8ek8_suspend(struct device *dev)
1378 {
1379 	struct v4l2_subdev *subdev = dev_get_drvdata(dev);
1380 	struct et8ek8_sensor *sensor = to_et8ek8_sensor(subdev);
1381 
1382 	if (!sensor->power_count)
1383 		return 0;
1384 
1385 	return __et8ek8_set_power(sensor, false);
1386 }
1387 
1388 static int __maybe_unused et8ek8_resume(struct device *dev)
1389 {
1390 	struct v4l2_subdev *subdev = dev_get_drvdata(dev);
1391 	struct et8ek8_sensor *sensor = to_et8ek8_sensor(subdev);
1392 
1393 	if (!sensor->power_count)
1394 		return 0;
1395 
1396 	return __et8ek8_set_power(sensor, true);
1397 }
1398 
1399 static int et8ek8_probe(struct i2c_client *client)
1400 {
1401 	struct et8ek8_sensor *sensor;
1402 	struct device *dev = &client->dev;
1403 	int ret;
1404 
1405 	sensor = devm_kzalloc(&client->dev, sizeof(*sensor), GFP_KERNEL);
1406 	if (!sensor)
1407 		return -ENOMEM;
1408 
1409 	sensor->reset = devm_gpiod_get(dev, "reset", GPIOD_OUT_LOW);
1410 	if (IS_ERR(sensor->reset)) {
1411 		dev_dbg(&client->dev, "could not request reset gpio\n");
1412 		return PTR_ERR(sensor->reset);
1413 	}
1414 
1415 	sensor->vana = devm_regulator_get(dev, "vana");
1416 	if (IS_ERR(sensor->vana)) {
1417 		dev_err(&client->dev, "could not get regulator for vana\n");
1418 		return PTR_ERR(sensor->vana);
1419 	}
1420 
1421 	sensor->ext_clk = devm_clk_get(dev, NULL);
1422 	if (IS_ERR(sensor->ext_clk)) {
1423 		dev_err(&client->dev, "could not get clock\n");
1424 		return PTR_ERR(sensor->ext_clk);
1425 	}
1426 
1427 	ret = of_property_read_u32(dev->of_node, "clock-frequency",
1428 				   &sensor->xclk_freq);
1429 	if (ret) {
1430 		dev_warn(dev, "can't get clock-frequency\n");
1431 		return ret;
1432 	}
1433 
1434 	mutex_init(&sensor->power_lock);
1435 
1436 	v4l2_i2c_subdev_init(&sensor->subdev, client, &et8ek8_ops);
1437 	sensor->subdev.flags |= V4L2_SUBDEV_FL_HAS_DEVNODE;
1438 	sensor->subdev.internal_ops = &et8ek8_internal_ops;
1439 
1440 	sensor->subdev.entity.function = MEDIA_ENT_F_CAM_SENSOR;
1441 	sensor->pad.flags = MEDIA_PAD_FL_SOURCE;
1442 	ret = media_entity_pads_init(&sensor->subdev.entity, 1, &sensor->pad);
1443 	if (ret < 0) {
1444 		dev_err(&client->dev, "media entity init failed!\n");
1445 		goto err_mutex;
1446 	}
1447 
1448 	ret = v4l2_async_register_subdev_sensor(&sensor->subdev);
1449 	if (ret < 0)
1450 		goto err_entity;
1451 
1452 	dev_dbg(dev, "initialized!\n");
1453 
1454 	return 0;
1455 
1456 err_entity:
1457 	media_entity_cleanup(&sensor->subdev.entity);
1458 err_mutex:
1459 	mutex_destroy(&sensor->power_lock);
1460 	return ret;
1461 }
1462 
1463 static int __exit et8ek8_remove(struct i2c_client *client)
1464 {
1465 	struct v4l2_subdev *subdev = i2c_get_clientdata(client);
1466 	struct et8ek8_sensor *sensor = to_et8ek8_sensor(subdev);
1467 
1468 	if (sensor->power_count) {
1469 		WARN_ON(1);
1470 		et8ek8_power_off(sensor);
1471 		sensor->power_count = 0;
1472 	}
1473 
1474 	v4l2_device_unregister_subdev(&sensor->subdev);
1475 	device_remove_file(&client->dev, &dev_attr_priv_mem);
1476 	v4l2_ctrl_handler_free(&sensor->ctrl_handler);
1477 	v4l2_async_unregister_subdev(&sensor->subdev);
1478 	media_entity_cleanup(&sensor->subdev.entity);
1479 	mutex_destroy(&sensor->power_lock);
1480 
1481 	return 0;
1482 }
1483 
1484 static const struct of_device_id et8ek8_of_table[] = {
1485 	{ .compatible = "toshiba,et8ek8" },
1486 	{ },
1487 };
1488 MODULE_DEVICE_TABLE(of, et8ek8_of_table);
1489 
1490 static const struct i2c_device_id et8ek8_id_table[] = {
1491 	{ ET8EK8_NAME, 0 },
1492 	{ }
1493 };
1494 MODULE_DEVICE_TABLE(i2c, et8ek8_id_table);
1495 
1496 static const struct dev_pm_ops et8ek8_pm_ops = {
1497 	SET_SYSTEM_SLEEP_PM_OPS(et8ek8_suspend, et8ek8_resume)
1498 };
1499 
1500 static struct i2c_driver et8ek8_i2c_driver = {
1501 	.driver		= {
1502 		.name	= ET8EK8_NAME,
1503 		.pm	= &et8ek8_pm_ops,
1504 		.of_match_table	= et8ek8_of_table,
1505 	},
1506 	.probe_new	= et8ek8_probe,
1507 	.remove		= __exit_p(et8ek8_remove),
1508 	.id_table	= et8ek8_id_table,
1509 };
1510 
1511 module_i2c_driver(et8ek8_i2c_driver);
1512 
1513 MODULE_AUTHOR("Sakari Ailus <sakari.ailus@iki.fi>, Pavel Machek <pavel@ucw.cz");
1514 MODULE_DESCRIPTION("Toshiba ET8EK8 camera sensor driver");
1515 MODULE_LICENSE("GPL");
1516