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
40struct 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
64enum 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 */
77static 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 */
141static 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
180err:
181	dev_err(&client->dev, "read from offset 0x%x error %d\n", reg, r);
182
183	return r;
184}
185
186static 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 */
218static 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 */
264static 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 */
335static 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
359static 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
375static 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
388static struct et8ek8_reglist **et8ek8_reglist_first(
389		struct et8ek8_meta_reglist *meta)
390{
391	return &meta->reglist[0].ptr;
392}
393
394static 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
402static 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
456static 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
482static 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
509static 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 */
554static 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
582static 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
636static 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
665static const struct v4l2_ctrl_ops et8ek8_ctrl_ops = {
666	.s_ctrl = et8ek8_set_ctrl,
667};
668
669static 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
681static 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
721static 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
746static 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
766fail:
767	dev_err(&client->dev, "sensor configuration failed\n");
768
769	return rval;
770}
771
772static 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
779static 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
786static 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
805static 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
815static 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
873out:
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
884static int et8ek8_enum_mbus_code(struct v4l2_subdev *subdev,
885				 struct v4l2_subdev_pad_config *cfg,
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
922static int et8ek8_enum_frame_size(struct v4l2_subdev *subdev,
923				  struct v4l2_subdev_pad_config *cfg,
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
960static int et8ek8_enum_frame_ival(struct v4l2_subdev *subdev,
961				  struct v4l2_subdev_pad_config *cfg,
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
991static struct v4l2_mbus_framefmt *
992__et8ek8_get_pad_format(struct et8ek8_sensor *sensor,
993			struct v4l2_subdev_pad_config *cfg,
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, cfg, pad);
999	case V4L2_SUBDEV_FORMAT_ACTIVE:
1000		return &sensor->format;
1001	default:
1002		return NULL;
1003	}
1004}
1005
1006static int et8ek8_get_pad_format(struct v4l2_subdev *subdev,
1007				 struct v4l2_subdev_pad_config *cfg,
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, cfg, fmt->pad, fmt->which);
1014	if (!format)
1015		return -EINVAL;
1016
1017	fmt->format = *format;
1018
1019	return 0;
1020}
1021
1022static int et8ek8_set_pad_format(struct v4l2_subdev *subdev,
1023				 struct v4l2_subdev_pad_config *cfg,
1024				 struct v4l2_subdev_format *fmt)
1025{
1026	struct et8ek8_sensor *sensor = to_et8ek8_sensor(subdev);
1027	struct v4l2_mbus_framefmt *format;
1028	struct et8ek8_reglist *reglist;
1029
1030	format = __et8ek8_get_pad_format(sensor, cfg, fmt->pad, fmt->which);
1031	if (!format)
1032		return -EINVAL;
1033
1034	reglist = et8ek8_reglist_find_mode_fmt(&meta_reglist, &fmt->format);
1035	et8ek8_reglist_to_mbus(reglist, &fmt->format);
1036	*format = fmt->format;
1037
1038	if (fmt->which == V4L2_SUBDEV_FORMAT_ACTIVE) {
1039		sensor->current_reglist = reglist;
1040		et8ek8_update_controls(sensor);
1041	}
1042
1043	return 0;
1044}
1045
1046static int et8ek8_get_frame_interval(struct v4l2_subdev *subdev,
1047				     struct v4l2_subdev_frame_interval *fi)
1048{
1049	struct et8ek8_sensor *sensor = to_et8ek8_sensor(subdev);
1050
1051	memset(fi, 0, sizeof(*fi));
1052	fi->interval = sensor->current_reglist->mode.timeperframe;
1053
1054	return 0;
1055}
1056
1057static int et8ek8_set_frame_interval(struct v4l2_subdev *subdev,
1058				     struct v4l2_subdev_frame_interval *fi)
1059{
1060	struct et8ek8_sensor *sensor = to_et8ek8_sensor(subdev);
1061	struct et8ek8_reglist *reglist;
1062
1063	reglist = et8ek8_reglist_find_mode_ival(&meta_reglist,
1064						sensor->current_reglist,
1065						&fi->interval);
1066
1067	if (!reglist)
1068		return -EINVAL;
1069
1070	if (sensor->current_reglist->mode.ext_clock != reglist->mode.ext_clock)
1071		return -EINVAL;
1072
1073	sensor->current_reglist = reglist;
1074	et8ek8_update_controls(sensor);
1075
1076	return 0;
1077}
1078
1079static int et8ek8_g_priv_mem(struct v4l2_subdev *subdev)
1080{
1081	struct et8ek8_sensor *sensor = to_et8ek8_sensor(subdev);
1082	struct i2c_client *client = v4l2_get_subdevdata(subdev);
1083	unsigned int length = ET8EK8_PRIV_MEM_SIZE;
1084	unsigned int offset = 0;
1085	u8 *ptr  = sensor->priv_mem;
1086	int rval = 0;
1087
1088	/* Read the EEPROM window-by-window, each window 8 bytes */
1089	do {
1090		u8 buffer[PRIV_MEM_WIN_SIZE];
1091		struct i2c_msg msg;
1092		int bytes, i;
1093		int ofs;
1094
1095		/* Set the current window */
1096		rval = et8ek8_i2c_write_reg(client, ET8EK8_REG_8BIT, 0x0001,
1097					    0xe0 | (offset >> 3));
1098		if (rval < 0)
1099			return rval;
1100
1101		/* Wait for status bit */
1102		for (i = 0; i < 1000; ++i) {
1103			u32 status;
1104
1105			rval = et8ek8_i2c_read_reg(client, ET8EK8_REG_8BIT,
1106						   0x0003, &status);
1107			if (rval < 0)
1108				return rval;
1109			if (!(status & 0x08))
1110				break;
1111			usleep_range(1000, 2000);
1112		}
1113
1114		if (i == 1000)
1115			return -EIO;
1116
1117		/* Read window, 8 bytes at once, and copy to user space */
1118		ofs = offset & 0x07;	/* Offset within this window */
1119		bytes = length + ofs > 8 ? 8-ofs : length;
1120		msg.addr = client->addr;
1121		msg.flags = 0;
1122		msg.len = 2;
1123		msg.buf = buffer;
1124		ofs += PRIV_MEM_START_REG;
1125		buffer[0] = (u8)(ofs >> 8);
1126		buffer[1] = (u8)(ofs & 0xFF);
1127
1128		rval = i2c_transfer(client->adapter, &msg, 1);
1129		if (rval < 0)
1130			return rval;
1131
1132		mdelay(ET8EK8_I2C_DELAY);
1133		msg.addr = client->addr;
1134		msg.len = bytes;
1135		msg.flags = I2C_M_RD;
1136		msg.buf = buffer;
1137		memset(buffer, 0, sizeof(buffer));
1138
1139		rval = i2c_transfer(client->adapter, &msg, 1);
1140		if (rval < 0)
1141			return rval;
1142
1143		rval = 0;
1144		memcpy(ptr, buffer, bytes);
1145
1146		length -= bytes;
1147		offset += bytes;
1148		ptr += bytes;
1149	} while (length > 0);
1150
1151	return rval;
1152}
1153
1154static int et8ek8_dev_init(struct v4l2_subdev *subdev)
1155{
1156	struct et8ek8_sensor *sensor = to_et8ek8_sensor(subdev);
1157	struct i2c_client *client = v4l2_get_subdevdata(subdev);
1158	int rval, rev_l, rev_h;
1159
1160	rval = et8ek8_power_on(sensor);
1161	if (rval) {
1162		dev_err(&client->dev, "could not power on\n");
1163		return rval;
1164	}
1165
1166	rval = et8ek8_i2c_read_reg(client, ET8EK8_REG_8BIT,
1167				   REG_REVISION_NUMBER_L, &rev_l);
1168	if (!rval)
1169		rval = et8ek8_i2c_read_reg(client, ET8EK8_REG_8BIT,
1170					   REG_REVISION_NUMBER_H, &rev_h);
1171	if (rval) {
1172		dev_err(&client->dev, "no et8ek8 sensor detected\n");
1173		goto out_poweroff;
1174	}
1175
1176	sensor->version = (rev_h << 8) + rev_l;
1177	if (sensor->version != ET8EK8_REV_1 && sensor->version != ET8EK8_REV_2)
1178		dev_info(&client->dev,
1179			 "unknown version 0x%x detected, continuing anyway\n",
1180			 sensor->version);
1181
1182	rval = et8ek8_reglist_import(client, &meta_reglist);
1183	if (rval) {
1184		dev_err(&client->dev,
1185			"invalid register list %s, import failed\n",
1186			ET8EK8_NAME);
1187		goto out_poweroff;
1188	}
1189
1190	sensor->current_reglist = et8ek8_reglist_find_type(&meta_reglist,
1191							   ET8EK8_REGLIST_MODE);
1192	if (!sensor->current_reglist) {
1193		dev_err(&client->dev,
1194			"invalid register list %s, no mode found\n",
1195			ET8EK8_NAME);
1196		rval = -ENODEV;
1197		goto out_poweroff;
1198	}
1199
1200	et8ek8_reglist_to_mbus(sensor->current_reglist, &sensor->format);
1201
1202	rval = et8ek8_i2c_reglist_find_write(client, &meta_reglist,
1203					     ET8EK8_REGLIST_POWERON);
1204	if (rval) {
1205		dev_err(&client->dev,
1206			"invalid register list %s, no POWERON mode found\n",
1207			ET8EK8_NAME);
1208		goto out_poweroff;
1209	}
1210	rval = et8ek8_stream_on(sensor); /* Needed to be able to read EEPROM */
1211	if (rval)
1212		goto out_poweroff;
1213	rval = et8ek8_g_priv_mem(subdev);
1214	if (rval)
1215		dev_warn(&client->dev,
1216			"can not read OTP (EEPROM) memory from sensor\n");
1217	rval = et8ek8_stream_off(sensor);
1218	if (rval)
1219		goto out_poweroff;
1220
1221	rval = et8ek8_power_off(sensor);
1222	if (rval)
1223		goto out_poweroff;
1224
1225	return 0;
1226
1227out_poweroff:
1228	et8ek8_power_off(sensor);
1229
1230	return rval;
1231}
1232
1233/* --------------------------------------------------------------------------
1234 * sysfs attributes
1235 */
1236static ssize_t
1237et8ek8_priv_mem_read(struct device *dev, struct device_attribute *attr,
1238		     char *buf)
1239{
1240	struct v4l2_subdev *subdev = i2c_get_clientdata(to_i2c_client(dev));
1241	struct et8ek8_sensor *sensor = to_et8ek8_sensor(subdev);
1242
1243#if PAGE_SIZE < ET8EK8_PRIV_MEM_SIZE
1244#error PAGE_SIZE too small!
1245#endif
1246
1247	memcpy(buf, sensor->priv_mem, ET8EK8_PRIV_MEM_SIZE);
1248
1249	return ET8EK8_PRIV_MEM_SIZE;
1250}
1251static DEVICE_ATTR(priv_mem, 0444, et8ek8_priv_mem_read, NULL);
1252
1253/* --------------------------------------------------------------------------
1254 * V4L2 subdev core operations
1255 */
1256
1257static int
1258et8ek8_registered(struct v4l2_subdev *subdev)
1259{
1260	struct et8ek8_sensor *sensor = to_et8ek8_sensor(subdev);
1261	struct i2c_client *client = v4l2_get_subdevdata(subdev);
1262	int rval;
1263
1264	dev_dbg(&client->dev, "registered!");
1265
1266	rval = device_create_file(&client->dev, &dev_attr_priv_mem);
1267	if (rval) {
1268		dev_err(&client->dev, "could not register sysfs entry\n");
1269		return rval;
1270	}
1271
1272	rval = et8ek8_dev_init(subdev);
1273	if (rval)
1274		goto err_file;
1275
1276	rval = et8ek8_init_controls(sensor);
1277	if (rval) {
1278		dev_err(&client->dev, "controls initialization failed\n");
1279		goto err_file;
1280	}
1281
1282	__et8ek8_get_pad_format(sensor, NULL, 0, V4L2_SUBDEV_FORMAT_ACTIVE);
1283
1284	return 0;
1285
1286err_file:
1287	device_remove_file(&client->dev, &dev_attr_priv_mem);
1288
1289	return rval;
1290}
1291
1292static int __et8ek8_set_power(struct et8ek8_sensor *sensor, bool on)
1293{
1294	return on ? et8ek8_power_on(sensor) : et8ek8_power_off(sensor);
1295}
1296
1297static int et8ek8_set_power(struct v4l2_subdev *subdev, int on)
1298{
1299	struct et8ek8_sensor *sensor = to_et8ek8_sensor(subdev);
1300	int ret = 0;
1301
1302	mutex_lock(&sensor->power_lock);
1303
1304	/* If the power count is modified from 0 to != 0 or from != 0 to 0,
1305	 * update the power state.
1306	 */
1307	if (sensor->power_count == !on) {
1308		ret = __et8ek8_set_power(sensor, !!on);
1309		if (ret < 0)
1310			goto done;
1311	}
1312
1313	/* Update the power count. */
1314	sensor->power_count += on ? 1 : -1;
1315	WARN_ON(sensor->power_count < 0);
1316
1317done:
1318	mutex_unlock(&sensor->power_lock);
1319
1320	return ret;
1321}
1322
1323static int et8ek8_open(struct v4l2_subdev *sd, struct v4l2_subdev_fh *fh)
1324{
1325	struct et8ek8_sensor *sensor = to_et8ek8_sensor(sd);
1326	struct v4l2_mbus_framefmt *format;
1327	struct et8ek8_reglist *reglist;
1328
1329	reglist = et8ek8_reglist_find_type(&meta_reglist, ET8EK8_REGLIST_MODE);
1330	format = __et8ek8_get_pad_format(sensor, fh->pad, 0,
1331					 V4L2_SUBDEV_FORMAT_TRY);
1332	et8ek8_reglist_to_mbus(reglist, format);
1333
1334	return et8ek8_set_power(sd, true);
1335}
1336
1337static int et8ek8_close(struct v4l2_subdev *sd, struct v4l2_subdev_fh *fh)
1338{
1339	return et8ek8_set_power(sd, false);
1340}
1341
1342static const struct v4l2_subdev_video_ops et8ek8_video_ops = {
1343	.s_stream = et8ek8_s_stream,
1344	.g_frame_interval = et8ek8_get_frame_interval,
1345	.s_frame_interval = et8ek8_set_frame_interval,
1346};
1347
1348static const struct v4l2_subdev_core_ops et8ek8_core_ops = {
1349	.s_power = et8ek8_set_power,
1350};
1351
1352static const struct v4l2_subdev_pad_ops et8ek8_pad_ops = {
1353	.enum_mbus_code = et8ek8_enum_mbus_code,
1354	.enum_frame_size = et8ek8_enum_frame_size,
1355	.enum_frame_interval = et8ek8_enum_frame_ival,
1356	.get_fmt = et8ek8_get_pad_format,
1357	.set_fmt = et8ek8_set_pad_format,
1358};
1359
1360static const struct v4l2_subdev_ops et8ek8_ops = {
1361	.core = &et8ek8_core_ops,
1362	.video = &et8ek8_video_ops,
1363	.pad = &et8ek8_pad_ops,
1364};
1365
1366static const struct v4l2_subdev_internal_ops et8ek8_internal_ops = {
1367	.registered = et8ek8_registered,
1368	.open = et8ek8_open,
1369	.close = et8ek8_close,
1370};
1371
1372/* --------------------------------------------------------------------------
1373 * I2C driver
1374 */
1375static int __maybe_unused et8ek8_suspend(struct device *dev)
1376{
1377	struct i2c_client *client = to_i2c_client(dev);
1378	struct v4l2_subdev *subdev = i2c_get_clientdata(client);
1379	struct et8ek8_sensor *sensor = to_et8ek8_sensor(subdev);
1380
1381	if (!sensor->power_count)
1382		return 0;
1383
1384	return __et8ek8_set_power(sensor, false);
1385}
1386
1387static int __maybe_unused et8ek8_resume(struct device *dev)
1388{
1389	struct i2c_client *client = to_i2c_client(dev);
1390	struct v4l2_subdev *subdev = i2c_get_clientdata(client);
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
1399static 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_common(&sensor->subdev);
1449	if (ret < 0)
1450		goto err_entity;
1451
1452	dev_dbg(dev, "initialized!\n");
1453
1454	return 0;
1455
1456err_entity:
1457	media_entity_cleanup(&sensor->subdev.entity);
1458err_mutex:
1459	mutex_destroy(&sensor->power_lock);
1460	return ret;
1461}
1462
1463static 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
1484static const struct of_device_id et8ek8_of_table[] = {
1485	{ .compatible = "toshiba,et8ek8" },
1486	{ },
1487};
1488MODULE_DEVICE_TABLE(of, et8ek8_of_table);
1489
1490static const struct i2c_device_id et8ek8_id_table[] = {
1491	{ ET8EK8_NAME, 0 },
1492	{ }
1493};
1494MODULE_DEVICE_TABLE(i2c, et8ek8_id_table);
1495
1496static const struct dev_pm_ops et8ek8_pm_ops = {
1497	SET_SYSTEM_SLEEP_PM_OPS(et8ek8_suspend, et8ek8_resume)
1498};
1499
1500static 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
1511module_i2c_driver(et8ek8_i2c_driver);
1512
1513MODULE_AUTHOR("Sakari Ailus <sakari.ailus@iki.fi>, Pavel Machek <pavel@ucw.cz");
1514MODULE_DESCRIPTION("Toshiba ET8EK8 camera sensor driver");
1515MODULE_LICENSE("GPL");
1516