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(adap: client->adapter, msgs: &msg, num: 1);
162	if (r < 0)
163	goto err;
164
165	msg.len = data_length;
166	msg.flags = I2C_M_RD;
167	r = i2c_transfer(adap: client->adapter, msgs: &msg, num: 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, len: data_length, reg,
237	val, msg: &msg[wcnt], buf: &data[wcnt][0]);
238
239	/* Update write count */
240	wcnt++;
241
242	if (wcnt < ET8EK8_MAX_MSG)
243	continue;
244
245	rval = i2c_transfer(adap: client->adapter, msgs: msg, num: wcnt);
246	if (rval < 0)
247	return rval;
248
249	cnt -= wcnt;
250	wcnt = 0;
251	}
252
253	rval = i2c_transfer(adap: client->adapter, msgs: msg, num: 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, wnext: 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(msecs: 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, len: data_length, reg, val, msg: &msg, buf: data);
348
349	r = i2c_transfer(adap: client->adapter, msgs: &msg, num: 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, regs: 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(reglist: *list, fmt: &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(base: &meta->reglist[0].ptr, num: nlists, size: sizeof(meta->reglist[0].ptr),
523	cmp_func: 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(sd: &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	reg: 0x124a, val: new.analog >> 8);
565	if (r)
566	return r;
567	r = et8ek8_i2c_write_reg(client, ET8EK8_REG_8BIT,
568	reg: 0x1249, val: new.analog & 0xff);
569	if (r)
570	return r;
571
572	r = et8ek8_i2c_write_reg(client, ET8EK8_REG_8BIT,
573	reg: 0x124d, val: new.digital >> 8);
574	if (r)
575	return r;
576	r = et8ek8_i2c_write_reg(client, ET8EK8_REG_8BIT,
577	reg: 0x124c, val: 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(sd: &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, reg: 0x111B,
611	val: tp_mode << 4);
612	if (rval)
613	return rval;
614
615	rval = et8ek8_i2c_write_reg(client, ET8EK8_REG_8BIT, reg: 0x1121,
616	val: cbh_mode << 7);
617	if (rval)
618	return rval;
619
620	rval = et8ek8_i2c_write_reg(client, ET8EK8_REG_8BIT, reg: 0x1124,
621	val: cbv_mode << 7);
622	if (rval)
623	return rval;
624
625	rval = et8ek8_i2c_write_reg(client, ET8EK8_REG_8BIT, reg: 0x112C, val: din_sw);
626	if (rval)
627	return rval;
628
629	return et8ek8_i2c_write_reg(client, ET8EK8_REG_8BIT, reg: 0x1420, val: 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, gain: ctrl->val);
644
645	case V4L2_CID_EXPOSURE:
646	{
647	struct i2c_client *client =
648	v4l2_get_subdevdata(sd: &sensor->subdev);
649
650	return et8ek8_i2c_write_reg(client, ET8EK8_REG_16BIT, reg: 0x1243,
651	val: ctrl->val);
652	}
653
654	case V4L2_CID_TEST_PATTERN:
655	return et8ek8_set_test_pattern(sensor, mode: 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(hdl: &sensor->ctrl_handler, ops: &et8ek8_ctrl_ops,
689	V4L2_CID_GAIN, min: 0, ARRAY_SIZE(et8ek8_gain_table) - 1,
690	step: 1, def: 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(hdl: &sensor->ctrl_handler,
698	ops: &et8ek8_ctrl_ops, V4L2_CID_EXPOSURE,
699	min, max, step: min, def: max);
700	}
701
702	/* V4L2_CID_PIXEL_RATE */
703	sensor->pixel_rate =
704	v4l2_ctrl_new_std(hdl: &sensor->ctrl_handler, ops: &et8ek8_ctrl_ops,
705	V4L2_CID_PIXEL_RATE, min: 1, INT_MAX, step: 1, def: 1);
706
707	/* V4L2_CID_TEST_PATTERN */
708	v4l2_ctrl_new_std_menu_items(hdl: &sensor->ctrl_handler,
709	ops: &et8ek8_ctrl_ops, V4L2_CID_TEST_PATTERN,
710	ARRAY_SIZE(et8ek8_test_pattern_menu) - 1,
711	mask: 0, def: 0, qmenu: 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, step: min, def: max);
743	__v4l2_ctrl_s_ctrl_int64(ctrl: sensor->pixel_rate, val: 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(sd: subdev);
750	int rval;
751
752	rval = et8ek8_i2c_write_regs(client, regs: 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(hdl: &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(sd: &sensor->subdev);
775
776	return et8ek8_i2c_write_reg(client, ET8EK8_REG_8BIT, reg: 0x1252, val: 0xb0);
777	}
778
779	static int et8ek8_stream_off(struct et8ek8_sensor *sensor)
780	{
781	struct i2c_client *client = v4l2_get_subdevdata(sd: &sensor->subdev);
782
783	return et8ek8_i2c_write_reg(client, ET8EK8_REG_8BIT, reg: 0x1252, val: 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(desc: sensor->reset, value: 0);
808	udelay(1);
809
810	clk_disable_unprepare(clk: sensor->ext_clk);
811
812	return regulator_disable(regulator: 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(sd: subdev);
819	unsigned int xclk_freq;
820	int val, rval;
821
822	rval = regulator_enable(regulator: 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(clk: sensor->ext_clk, rate: 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(clk: 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(desc: sensor->reset, value: 1);
851
852	msleep(msecs: 5000 * 1000 / xclk_freq + 1); /* Wait 5000 cycles */
853
854	rval = et8ek8_i2c_reglist_find_write(client, meta: &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, reg: 0x1263, val: &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, reg: 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: &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: &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(reglist: *list, fmt: &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: &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(reglist: *list, fmt: &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_state_get_format(sd_state, pad);
999	case V4L2_SUBDEV_FORMAT_ACTIVE:
1000	return &sensor->format;
1001	default:
1002	return NULL;
1003	}
1004	}
1005
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, pad: fmt->pad,
1014	which: fmt->which);
1015	if (!format)
1016	return -EINVAL;
1017
1018	fmt->format = *format;
1019
1020	return 0;
1021	}
1022
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, pad: fmt->pad,
1032	which: fmt->which);
1033	if (!format)
1034	return -EINVAL;
1035
1036	reglist = et8ek8_reglist_find_mode_fmt(meta: &meta_reglist, fmt: &fmt->format);
1037	et8ek8_reglist_to_mbus(reglist, fmt: &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
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
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: &meta_reglist,
1082	current_reglist: sensor->current_reglist,
1083	timeperframe: &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
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(sd: 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, reg: 0x0001,
1115	val: 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	reg: 0x0003, val: &status);
1125	if (rval < 0)
1126	return rval;
1127	if (!(status & 0x08))
1128	break;
1129	usleep_range(min: 1000, max: 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(adap: client->adapter, msgs: &msg, num: 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(adap: client->adapter, msgs: &msg, num: 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
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(sd: 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, val: &rev_l);
1186	if (!rval)
1187	rval = et8ek8_i2c_read_reg(client, ET8EK8_REG_8BIT,
1188	REG_REVISION_NUMBER_H, val: &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: &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: &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(reglist: sensor->current_reglist, fmt: &sensor->format);
1219
1220	rval = et8ek8_i2c_reglist_find_write(client, meta: &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
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
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(sd: subdev);
1279	int rval;
1280
1281	dev_dbg(&client->dev, "registered!");
1282
1283	rval = device_create_file(device: &client->dev, entry: &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, pad: 0, which: V4L2_SUBDEV_FORMAT_ACTIVE);
1300
1301	return 0;
1302
1303	err_file:
1304	device_remove_file(dev: &client->dev, attr: &dev_attr_priv_mem);
1305
1306	return rval;
1307	}
1308
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
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: !!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(lock: &sensor->power_lock);
1336
1337	return ret;
1338	}
1339
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: &meta_reglist, ET8EK8_REGLIST_MODE);
1347	format = __et8ek8_get_pad_format(sensor, sd_state: fh->state, pad: 0,
1348	which: V4L2_SUBDEV_FORMAT_TRY);
1349	et8ek8_reglist_to_mbus(reglist, fmt: format);
1350
1351	return et8ek8_set_power(subdev: sd, on: true);
1352	}
1353
1354	static int et8ek8_close(struct v4l2_subdev *sd, struct v4l2_subdev_fh *fh)
1355	{
1356	return et8ek8_set_power(subdev: sd, on: 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	*/
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, on: false);
1401	}
1402
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, on: true);
1412	}
1413
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(dev: &client->dev, size: sizeof(*sensor), GFP_KERNEL);
1421	if (!sensor)
1422	return -ENOMEM;
1423
1424	sensor->reset = devm_gpiod_get(dev, con_id: "reset", flags: GPIOD_OUT_LOW);
1425	if (IS_ERR(ptr: sensor->reset)) {
1426	dev_dbg(&client->dev, "could not request reset gpio\n");
1427	return PTR_ERR(ptr: sensor->reset);
1428	}
1429
1430	sensor->vana = devm_regulator_get(dev, id: "vana");
1431	if (IS_ERR(ptr: sensor->vana)) {
1432	dev_err(&client->dev, "could not get regulator for vana\n");
1433	return PTR_ERR(ptr: sensor->vana);
1434	}
1435
1436	sensor->ext_clk = devm_clk_get(dev, NULL);
1437	if (IS_ERR(ptr: sensor->ext_clk)) {
1438	dev_err(&client->dev, "could not get clock\n");
1439	return PTR_ERR(ptr: sensor->ext_clk);
1440	}
1441
1442	ret = of_property_read_u32(np: dev->of_node, propname: "clock-frequency",
1443	out_value: &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(sd: &sensor->subdev, client, ops: &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(entity: &sensor->subdev.entity, num_pads: 1, pads: &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(sd: &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(entity: &sensor->subdev.entity);
1473	err_mutex:
1474	mutex_destroy(lock: &sensor->power_lock);
1475	return ret;
1476	}
1477
1478	static void __exit 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(sd: &sensor->subdev);
1490	device_remove_file(dev: &client->dev, attr: &dev_attr_priv_mem);
1491	v4l2_ctrl_handler_free(hdl: &sensor->ctrl_handler);
1492	v4l2_async_unregister_subdev(sd: &sensor->subdev);
1493	media_entity_cleanup(entity: &sensor->subdev.entity);
1494	mutex_destroy(lock: &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, 0 },
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 = __exit_p(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