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