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 = ¤t_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->pad.flags = MEDIA_PAD_FL_SOURCE; 1450 ret = media_entity_pads_init(&sensor->subdev.entity, 1, &sensor->pad); 1451 if (ret < 0) { 1452 dev_err(&client->dev, "media entity init failed!\n"); 1453 goto err_mutex; 1454 } 1455 1456 ret = v4l2_async_register_subdev(&sensor->subdev); 1457 if (ret < 0) 1458 goto err_entity; 1459 1460 dev_dbg(dev, "initialized!\n"); 1461 1462 return 0; 1463 1464 err_entity: 1465 media_entity_cleanup(&sensor->subdev.entity); 1466 err_mutex: 1467 mutex_destroy(&sensor->power_lock); 1468 return ret; 1469 } 1470 1471 static int __exit et8ek8_remove(struct i2c_client *client) 1472 { 1473 struct v4l2_subdev *subdev = i2c_get_clientdata(client); 1474 struct et8ek8_sensor *sensor = to_et8ek8_sensor(subdev); 1475 1476 if (sensor->power_count) { 1477 WARN_ON(1); 1478 et8ek8_power_off(sensor); 1479 sensor->power_count = 0; 1480 } 1481 1482 v4l2_device_unregister_subdev(&sensor->subdev); 1483 device_remove_file(&client->dev, &dev_attr_priv_mem); 1484 v4l2_ctrl_handler_free(&sensor->ctrl_handler); 1485 v4l2_async_unregister_subdev(&sensor->subdev); 1486 media_entity_cleanup(&sensor->subdev.entity); 1487 mutex_destroy(&sensor->power_lock); 1488 1489 return 0; 1490 } 1491 1492 static const struct of_device_id et8ek8_of_table[] = { 1493 { .compatible = "toshiba,et8ek8" }, 1494 { }, 1495 }; 1496 MODULE_DEVICE_TABLE(of, et8ek8_of_table); 1497 1498 static const struct i2c_device_id et8ek8_id_table[] = { 1499 { ET8EK8_NAME, 0 }, 1500 { } 1501 }; 1502 MODULE_DEVICE_TABLE(i2c, et8ek8_id_table); 1503 1504 static const struct dev_pm_ops et8ek8_pm_ops = { 1505 SET_SYSTEM_SLEEP_PM_OPS(et8ek8_suspend, et8ek8_resume) 1506 }; 1507 1508 static struct i2c_driver et8ek8_i2c_driver = { 1509 .driver = { 1510 .name = ET8EK8_NAME, 1511 .pm = &et8ek8_pm_ops, 1512 .of_match_table = et8ek8_of_table, 1513 }, 1514 .probe = et8ek8_probe, 1515 .remove = __exit_p(et8ek8_remove), 1516 .id_table = et8ek8_id_table, 1517 }; 1518 1519 module_i2c_driver(et8ek8_i2c_driver); 1520 1521 MODULE_AUTHOR("Sakari Ailus <sakari.ailus@iki.fi>, Pavel Machek <pavel@ucw.cz"); 1522 MODULE_DESCRIPTION("Toshiba ET8EK8 camera sensor driver"); 1523 MODULE_LICENSE("GPL"); 1524