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