1529 lines · c
1// SPDX-License-Identifier: GPL-2.0-only2/*3 * et8ek8_driver.c4 *5 * Copyright (C) 2008 Nokia Corporation6 *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 driver14 * (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 12838#define ET8EK8_MAX_MSG 839 40struct et8ek8_sensor {41 struct v4l2_subdev subdev;42 struct media_pad pad;43 struct v4l2_mbus_framefmt format;44 struct gpio_desc *reset;45 struct regulator *vana;46 struct clk *ext_clk;47 u32 xclk_freq;48 49 u16 version;50 51 struct v4l2_ctrl_handler ctrl_handler;52 struct v4l2_ctrl *exposure;53 struct v4l2_ctrl *pixel_rate;54 struct et8ek8_reglist *current_reglist;55 56 u8 priv_mem[ET8EK8_PRIV_MEM_SIZE];57 58 struct mutex power_lock;59 int power_count;60};61 62#define to_et8ek8_sensor(sd) container_of(sd, struct et8ek8_sensor, subdev)63 64enum et8ek8_versions {65 ET8EK8_REV_1 = 0x0001,66 ET8EK8_REV_2,67};68 69/*70 * This table describes what should be written to the sensor register71 * for each gain value. The gain(index in the table) is in terms of72 * 0.1EV, i.e. 10 indexes in the table give 2 time more gain [0] in73 * the *analog gain, [1] in the digital gain74 *75 * Analog gain [dB] = 20*log10(regvalue/32); 0x20..0x10076 */77static struct et8ek8_gain {78 u16 analog;79 u16 digital;80} const et8ek8_gain_table[] = {81 { 32, 0}, /* x1 */82 { 34, 0},83 { 37, 0},84 { 39, 0},85 { 42, 0},86 { 45, 0},87 { 49, 0},88 { 52, 0},89 { 56, 0},90 { 60, 0},91 { 64, 0}, /* x2 */92 { 69, 0},93 { 74, 0},94 { 79, 0},95 { 84, 0},96 { 91, 0},97 { 97, 0},98 {104, 0},99 {111, 0},100 {119, 0},101 {128, 0}, /* x4 */102 {137, 0},103 {147, 0},104 {158, 0},105 {169, 0},106 {181, 0},107 {194, 0},108 {208, 0},109 {223, 0},110 {239, 0},111 {256, 0}, /* x8 */112 {256, 73},113 {256, 152},114 {256, 236},115 {256, 327},116 {256, 424},117 {256, 528},118 {256, 639},119 {256, 758},120 {256, 886},121 {256, 1023}, /* x16 */122};123 124/* Register definitions */125#define REG_REVISION_NUMBER_L 0x1200126#define REG_REVISION_NUMBER_H 0x1201127 128#define PRIV_MEM_START_REG 0x0008129#define PRIV_MEM_WIN_SIZE 8130 131#define ET8EK8_I2C_DELAY 3 /* msec delay b/w accesses */132 133#define USE_CRC 1134 135/*136 * Register access helpers137 *138 * Read a 8/16/32-bit i2c register. The value is returned in 'val'.139 * Returns zero if successful, or non-zero otherwise.140 */141static int et8ek8_i2c_read_reg(struct i2c_client *client, u16 data_length,142 u16 reg, u32 *val)143{144 int r;145 struct i2c_msg msg;146 unsigned char data[4];147 148 if (!client->adapter)149 return -ENODEV;150 if (data_length != ET8EK8_REG_8BIT && data_length != ET8EK8_REG_16BIT)151 return -EINVAL;152 153 msg.addr = client->addr;154 msg.flags = 0;155 msg.len = 2;156 msg.buf = data;157 158 /* high byte goes out first */159 data[0] = (u8) (reg >> 8);160 data[1] = (u8) (reg & 0xff);161 r = i2c_transfer(client->adapter, &msg, 1);162 if (r < 0)163 goto err;164 165 msg.len = data_length;166 msg.flags = I2C_M_RD;167 r = i2c_transfer(client->adapter, &msg, 1);168 if (r < 0)169 goto err;170 171 *val = 0;172 /* high byte comes first */173 if (data_length == ET8EK8_REG_8BIT)174 *val = data[0];175 else176 *val = (data[1] << 8) + data[0];177 178 return 0;179 180err:181 dev_err(&client->dev, "read from offset 0x%x error %d\n", reg, r);182 183 return r;184}185 186static void et8ek8_i2c_create_msg(struct i2c_client *client, u16 len, u16 reg,187 u32 val, struct i2c_msg *msg,188 unsigned char *buf)189{190 msg->addr = client->addr;191 msg->flags = 0; /* Write */192 msg->len = 2 + len;193 msg->buf = buf;194 195 /* high byte goes out first */196 buf[0] = (u8) (reg >> 8);197 buf[1] = (u8) (reg & 0xff);198 199 switch (len) {200 case ET8EK8_REG_8BIT:201 buf[2] = (u8) (val) & 0xff;202 break;203 case ET8EK8_REG_16BIT:204 buf[2] = (u8) (val) & 0xff;205 buf[3] = (u8) (val >> 8) & 0xff;206 break;207 default:208 WARN_ONCE(1, ET8EK8_NAME ": %s: invalid message length.\n",209 __func__);210 }211}212 213/*214 * A buffered write method that puts the wanted register write215 * commands in smaller number of message lists and passes the lists to216 * the i2c framework217 */218static int et8ek8_i2c_buffered_write_regs(struct i2c_client *client,219 const struct et8ek8_reg *wnext,220 int cnt)221{222 struct i2c_msg msg[ET8EK8_MAX_MSG];223 unsigned char data[ET8EK8_MAX_MSG][6];224 int wcnt = 0;225 u16 reg, data_length;226 u32 val;227 int rval;228 229 /* Create new write messages for all writes */230 while (wcnt < cnt) {231 data_length = wnext->type;232 reg = wnext->reg;233 val = wnext->val;234 wnext++;235 236 et8ek8_i2c_create_msg(client, data_length, reg,237 val, &msg[wcnt], &data[wcnt][0]);238 239 /* Update write count */240 wcnt++;241 242 if (wcnt < ET8EK8_MAX_MSG)243 continue;244 245 rval = i2c_transfer(client->adapter, msg, wcnt);246 if (rval < 0)247 return rval;248 249 cnt -= wcnt;250 wcnt = 0;251 }252 253 rval = i2c_transfer(client->adapter, msg, wcnt);254 255 return rval < 0 ? rval : 0;256}257 258/*259 * Write a list of registers to i2c device.260 *261 * The list of registers is terminated by ET8EK8_REG_TERM.262 * Returns zero if successful, or non-zero otherwise.263 */264static int et8ek8_i2c_write_regs(struct i2c_client *client,265 const struct et8ek8_reg *regs)266{267 int r, cnt = 0;268 const struct et8ek8_reg *next;269 270 if (!client->adapter)271 return -ENODEV;272 273 if (!regs)274 return -EINVAL;275 276 /* Initialize list pointers to the start of the list */277 next = regs;278 279 do {280 /*281 * We have to go through the list to figure out how282 * many regular writes we have in a row283 */284 while (next->type != ET8EK8_REG_TERM &&285 next->type != ET8EK8_REG_DELAY) {286 /*287 * Here we check that the actual length fields288 * are valid289 */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 and297 * read pointer298 */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 through314 * the list, this is where we snooze for the required time315 */316 if (next->type == ET8EK8_REG_DELAY) {317 msleep(next->val);318 /*319 * ZZZ ...320 * Update list pointers and cnt and start over ...321 */322 next++;323 regs = next;324 cnt = 0;325 }326 } while (next->type != ET8EK8_REG_TERM);327 328 return 0;329}330 331/*332 * Write to a 8/16-bit register.333 * Returns zero if successful, or non-zero otherwise.334 */335static int et8ek8_i2c_write_reg(struct i2c_client *client, u16 data_length,336 u16 reg, u32 val)337{338 int r;339 struct i2c_msg msg;340 unsigned char data[6];341 342 if (!client->adapter)343 return -ENODEV;344 if (data_length != ET8EK8_REG_8BIT && data_length != ET8EK8_REG_16BIT)345 return -EINVAL;346 347 et8ek8_i2c_create_msg(client, data_length, reg, val, &msg, data);348 349 r = i2c_transfer(client->adapter, &msg, 1);350 if (r < 0) {351 dev_err(&client->dev,352 "wrote 0x%x to offset 0x%x error %d\n", val, reg, r);353 return r;354 }355 356 return 0;357}358 359static struct et8ek8_reglist *et8ek8_reglist_find_type(360 struct et8ek8_meta_reglist *meta,361 u16 type)362{363 struct et8ek8_reglist **next = &meta->reglist[0].ptr;364 365 while (*next) {366 if ((*next)->type == type)367 return *next;368 369 next++;370 }371 372 return NULL;373}374 375static int et8ek8_i2c_reglist_find_write(struct i2c_client *client,376 struct et8ek8_meta_reglist *meta,377 u16 type)378{379 struct et8ek8_reglist *reglist;380 381 reglist = et8ek8_reglist_find_type(meta, type);382 if (!reglist)383 return -EINVAL;384 385 return et8ek8_i2c_write_regs(client, reglist->regs);386}387 388static struct et8ek8_reglist **et8ek8_reglist_first(389 struct et8ek8_meta_reglist *meta)390{391 return &meta->reglist[0].ptr;392}393 394static void et8ek8_reglist_to_mbus(const struct et8ek8_reglist *reglist,395 struct v4l2_mbus_framefmt *fmt)396{397 fmt->width = reglist->mode.window_width;398 fmt->height = reglist->mode.window_height;399 fmt->code = reglist->mode.bus_format;400}401 402static struct et8ek8_reglist *et8ek8_reglist_find_mode_fmt(403 struct et8ek8_meta_reglist *meta,404 struct v4l2_mbus_framefmt *fmt)405{406 struct et8ek8_reglist **list = et8ek8_reglist_first(meta);407 struct et8ek8_reglist *best_match = NULL;408 struct et8ek8_reglist *best_other = NULL;409 struct v4l2_mbus_framefmt format;410 unsigned int max_dist_match = (unsigned int)-1;411 unsigned int max_dist_other = (unsigned int)-1;412 413 /*414 * Find the mode with the closest image size. The distance between415 * image sizes is the size in pixels of the non-overlapping regions416 * between the requested size and the frame-specified size.417 *418 * Store both the closest mode that matches the requested format, and419 * the closest mode for all other formats. The best match is returned420 * if found, otherwise the best mode with a non-matching format is421 * 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.height434 + fmt->width * fmt->height - 2 * dist;435 436 437 if (fmt->code == format.code) {438 if (dist < max_dist_match || !best_match) {439 best_match = *list;440 max_dist_match = dist;441 }442 } else {443 if (dist < max_dist_other || !best_other) {444 best_other = *list;445 max_dist_other = dist;446 }447 }448 }449 450 return best_match ? best_match : best_other;451}452 453#define TIMEPERFRAME_AVG_FPS(t) \454 (((t).denominator + ((t).numerator >> 1)) / (t).numerator)455 456static struct et8ek8_reglist *et8ek8_reglist_find_mode_ival(457 struct et8ek8_meta_reglist *meta,458 struct et8ek8_reglist *current_reglist,459 struct v4l2_fract *timeperframe)460{461 int fps = TIMEPERFRAME_AVG_FPS(*timeperframe);462 struct et8ek8_reglist **list = et8ek8_reglist_first(meta);463 struct et8ek8_mode *current_mode = ¤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 482static int et8ek8_reglist_cmp(const void *a, const void *b)483{484 const struct et8ek8_reglist **list1 = (const struct et8ek8_reglist **)a,485 **list2 = (const struct et8ek8_reglist **)b;486 487 /* Put real modes in the beginning. */488 if ((*list1)->type == ET8EK8_REGLIST_MODE &&489 (*list2)->type != ET8EK8_REGLIST_MODE)490 return -1;491 if ((*list1)->type != ET8EK8_REGLIST_MODE &&492 (*list2)->type == ET8EK8_REGLIST_MODE)493 return 1;494 495 /* Descending width. */496 if ((*list1)->mode.window_width > (*list2)->mode.window_width)497 return -1;498 if ((*list1)->mode.window_width < (*list2)->mode.window_width)499 return 1;500 501 if ((*list1)->mode.window_height > (*list2)->mode.window_height)502 return -1;503 if ((*list1)->mode.window_height < (*list2)->mode.window_height)504 return 1;505 506 return 0;507}508 509static int et8ek8_reglist_import(struct i2c_client *client,510 struct et8ek8_meta_reglist *meta)511{512 int nlists = 0, i;513 514 dev_info(&client->dev, "meta_reglist version %s\n", meta->version);515 516 while (meta->reglist[nlists].ptr)517 nlists++;518 519 if (!nlists)520 return -EINVAL;521 522 sort(&meta->reglist[0].ptr, nlists, sizeof(meta->reglist[0].ptr),523 et8ek8_reglist_cmp, NULL);524 525 i = nlists;526 nlists = 0;527 528 while (i--) {529 struct et8ek8_reglist *list;530 531 list = meta->reglist[nlists].ptr;532 533 dev_dbg(&client->dev,534 "%s: type %d\tw %d\th %d\tfmt %x\tival %d/%d\tptr %p\n",535 __func__,536 list->type,537 list->mode.window_width, list->mode.window_height,538 list->mode.bus_format,539 list->mode.timeperframe.numerator,540 list->mode.timeperframe.denominator,541 (void *)meta->reglist[nlists].ptr);542 543 nlists++;544 }545 546 return 0;547}548 549/* Called to change the V4L2 gain control value. This function550 * rounds and clamps the given value and updates the V4L2 control value.551 * If power is on, also updates the sensor analog and digital gains.552 * gain is in 0.1 EV (exposure value) units.553 */554static int et8ek8_set_gain(struct et8ek8_sensor *sensor, s32 gain)555{556 struct i2c_client *client = v4l2_get_subdevdata(&sensor->subdev);557 struct et8ek8_gain new;558 int r;559 560 new = et8ek8_gain_table[gain];561 562 /* FIXME: optimise I2C writes! */563 r = et8ek8_i2c_write_reg(client, ET8EK8_REG_8BIT,564 0x124a, new.analog >> 8);565 if (r)566 return r;567 r = et8ek8_i2c_write_reg(client, ET8EK8_REG_8BIT,568 0x1249, new.analog & 0xff);569 if (r)570 return r;571 572 r = et8ek8_i2c_write_reg(client, ET8EK8_REG_8BIT,573 0x124d, new.digital >> 8);574 if (r)575 return r;576 r = et8ek8_i2c_write_reg(client, ET8EK8_REG_8BIT,577 0x124c, new.digital & 0xff);578 579 return r;580}581 582static int et8ek8_set_test_pattern(struct et8ek8_sensor *sensor, s32 mode)583{584 struct i2c_client *client = v4l2_get_subdevdata(&sensor->subdev);585 int cbh_mode, cbv_mode, tp_mode, din_sw, r1420, rval;586 587 /* Values for normal mode */588 cbh_mode = 0;589 cbv_mode = 0;590 tp_mode = 0;591 din_sw = 0x00;592 r1420 = 0xF0;593 594 if (mode) {595 /* Test pattern mode */596 if (mode < 5) {597 cbh_mode = 1;598 cbv_mode = 1;599 tp_mode = mode + 3;600 } else {601 cbh_mode = 0;602 cbv_mode = 0;603 tp_mode = mode - 4 + 3;604 }605 606 din_sw = 0x01;607 r1420 = 0xE0;608 }609 610 rval = et8ek8_i2c_write_reg(client, ET8EK8_REG_8BIT, 0x111B,611 tp_mode << 4);612 if (rval)613 return rval;614 615 rval = et8ek8_i2c_write_reg(client, ET8EK8_REG_8BIT, 0x1121,616 cbh_mode << 7);617 if (rval)618 return rval;619 620 rval = et8ek8_i2c_write_reg(client, ET8EK8_REG_8BIT, 0x1124,621 cbv_mode << 7);622 if (rval)623 return rval;624 625 rval = et8ek8_i2c_write_reg(client, ET8EK8_REG_8BIT, 0x112C, din_sw);626 if (rval)627 return rval;628 629 return et8ek8_i2c_write_reg(client, ET8EK8_REG_8BIT, 0x1420, r1420);630}631 632/* -----------------------------------------------------------------------------633 * V4L2 controls634 */635 636static int et8ek8_set_ctrl(struct v4l2_ctrl *ctrl)637{638 struct et8ek8_sensor *sensor =639 container_of(ctrl->handler, struct et8ek8_sensor, ctrl_handler);640 641 switch (ctrl->id) {642 case V4L2_CID_GAIN:643 return et8ek8_set_gain(sensor, ctrl->val);644 645 case V4L2_CID_EXPOSURE:646 {647 struct i2c_client *client =648 v4l2_get_subdevdata(&sensor->subdev);649 650 return et8ek8_i2c_write_reg(client, ET8EK8_REG_16BIT, 0x1243,651 ctrl->val);652 }653 654 case V4L2_CID_TEST_PATTERN:655 return et8ek8_set_test_pattern(sensor, ctrl->val);656 657 case V4L2_CID_PIXEL_RATE:658 return 0;659 660 default:661 return -EINVAL;662 }663}664 665static const struct v4l2_ctrl_ops et8ek8_ctrl_ops = {666 .s_ctrl = et8ek8_set_ctrl,667};668 669static const char * const et8ek8_test_pattern_menu[] = {670 "Normal",671 "Vertical colorbar",672 "Horizontal colorbar",673 "Scale",674 "Ramp",675 "Small vertical colorbar",676 "Small horizontal colorbar",677 "Small scale",678 "Small ramp",679};680 681static int et8ek8_init_controls(struct et8ek8_sensor *sensor)682{683 s32 max_rows;684 685 v4l2_ctrl_handler_init(&sensor->ctrl_handler, 4);686 687 /* V4L2_CID_GAIN */688 v4l2_ctrl_new_std(&sensor->ctrl_handler, &et8ek8_ctrl_ops,689 V4L2_CID_GAIN, 0, ARRAY_SIZE(et8ek8_gain_table) - 1,690 1, 0);691 692 max_rows = sensor->current_reglist->mode.max_exp;693 {694 u32 min = 1, max = max_rows;695 696 sensor->exposure =697 v4l2_ctrl_new_std(&sensor->ctrl_handler,698 &et8ek8_ctrl_ops, V4L2_CID_EXPOSURE,699 min, max, min, max);700 }701 702 /* V4L2_CID_PIXEL_RATE */703 sensor->pixel_rate =704 v4l2_ctrl_new_std(&sensor->ctrl_handler, &et8ek8_ctrl_ops,705 V4L2_CID_PIXEL_RATE, 1, INT_MAX, 1, 1);706 707 /* V4L2_CID_TEST_PATTERN */708 v4l2_ctrl_new_std_menu_items(&sensor->ctrl_handler,709 &et8ek8_ctrl_ops, V4L2_CID_TEST_PATTERN,710 ARRAY_SIZE(et8ek8_test_pattern_menu) - 1,711 0, 0, et8ek8_test_pattern_menu);712 713 if (sensor->ctrl_handler.error)714 return sensor->ctrl_handler.error;715 716 sensor->subdev.ctrl_handler = &sensor->ctrl_handler;717 718 return 0;719}720 721static void et8ek8_update_controls(struct et8ek8_sensor *sensor)722{723 struct v4l2_ctrl *ctrl;724 struct et8ek8_mode *mode = &sensor->current_reglist->mode;725 726 u32 min, max, pixel_rate;727 static const int S = 8;728 729 ctrl = sensor->exposure;730 731 min = 1;732 max = mode->max_exp;733 734 /*735 * Calculate average pixel clock per line. Assume buffers can spread736 * the data over horizontal blanking time. Rounding upwards.737 * Formula taken from stock Nokia N900 kernel.738 */739 pixel_rate = ((mode->pixel_clock + (1 << S) - 1) >> S) + mode->width;740 pixel_rate = mode->window_width * (pixel_rate - 1) / mode->width;741 742 __v4l2_ctrl_modify_range(ctrl, min, max, min, max);743 __v4l2_ctrl_s_ctrl_int64(sensor->pixel_rate, pixel_rate << S);744}745 746static int et8ek8_configure(struct et8ek8_sensor *sensor)747{748 struct v4l2_subdev *subdev = &sensor->subdev;749 struct i2c_client *client = v4l2_get_subdevdata(subdev);750 int rval;751 752 rval = et8ek8_i2c_write_regs(client, sensor->current_reglist->regs);753 if (rval)754 goto fail;755 756 /* Controls set while the power to the sensor is turned off are saved757 * but not applied to the hardware. Now that we're about to start758 * streaming apply all the current values to the hardware.759 */760 rval = v4l2_ctrl_handler_setup(&sensor->ctrl_handler);761 if (rval)762 goto fail;763 764 return 0;765 766fail:767 dev_err(&client->dev, "sensor configuration failed\n");768 769 return rval;770}771 772static int et8ek8_stream_on(struct et8ek8_sensor *sensor)773{774 struct i2c_client *client = v4l2_get_subdevdata(&sensor->subdev);775 776 return et8ek8_i2c_write_reg(client, ET8EK8_REG_8BIT, 0x1252, 0xb0);777}778 779static int et8ek8_stream_off(struct et8ek8_sensor *sensor)780{781 struct i2c_client *client = v4l2_get_subdevdata(&sensor->subdev);782 783 return et8ek8_i2c_write_reg(client, ET8EK8_REG_8BIT, 0x1252, 0x30);784}785 786static int et8ek8_s_stream(struct v4l2_subdev *subdev, int streaming)787{788 struct et8ek8_sensor *sensor = to_et8ek8_sensor(subdev);789 int ret;790 791 if (!streaming)792 return et8ek8_stream_off(sensor);793 794 ret = et8ek8_configure(sensor);795 if (ret < 0)796 return ret;797 798 return et8ek8_stream_on(sensor);799}800 801/* --------------------------------------------------------------------------802 * V4L2 subdev operations803 */804 805static int et8ek8_power_off(struct et8ek8_sensor *sensor)806{807 gpiod_set_value(sensor->reset, 0);808 udelay(1);809 810 clk_disable_unprepare(sensor->ext_clk);811 812 return regulator_disable(sensor->vana);813}814 815static int et8ek8_power_on(struct et8ek8_sensor *sensor)816{817 struct v4l2_subdev *subdev = &sensor->subdev;818 struct i2c_client *client = v4l2_get_subdevdata(subdev);819 unsigned int xclk_freq;820 int val, rval;821 822 rval = regulator_enable(sensor->vana);823 if (rval) {824 dev_err(&client->dev, "failed to enable vana regulator\n");825 return rval;826 }827 828 if (sensor->current_reglist)829 xclk_freq = sensor->current_reglist->mode.ext_clock;830 else831 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_CRC860 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#else866 val &= ~BIT(4);867#endif868 rval = et8ek8_i2c_write_reg(client, ET8EK8_REG_8BIT, 0x1263, val);869 if (rval)870 goto out;871#endif872 873out:874 if (rval)875 et8ek8_power_off(sensor);876 877 return rval;878}879 880/* --------------------------------------------------------------------------881 * V4L2 subdev video operations882 */883#define MAX_FMTS 4884static 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 922static 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 960static 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 991static 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 1006static 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 1023static 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 1048static 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 V4L21056 * 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 1067static 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 V4L21076 * 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 1097static 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 1172static 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 1245out_poweroff:1246 et8ek8_power_off(sensor);1247 1248 return rval;1249}1250 1251/* --------------------------------------------------------------------------1252 * sysfs attributes1253 */1254static ssize_t1255priv_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_SIZE1261#error PAGE_SIZE too small!1262#endif1263 1264 memcpy(buf, sensor->priv_mem, ET8EK8_PRIV_MEM_SIZE);1265 1266 return ET8EK8_PRIV_MEM_SIZE;1267}1268static DEVICE_ATTR_RO(priv_mem);1269 1270/* --------------------------------------------------------------------------1271 * V4L2 subdev core operations1272 */1273 1274static int1275et8ek8_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 1303err_file:1304 device_remove_file(&client->dev, &dev_attr_priv_mem);1305 1306 return rval;1307}1308 1309static int __et8ek8_set_power(struct et8ek8_sensor *sensor, bool on)1310{1311 return on ? et8ek8_power_on(sensor) : et8ek8_power_off(sensor);1312}1313 1314static 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 1334done:1335 mutex_unlock(&sensor->power_lock);1336 1337 return ret;1338}1339 1340static 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 1354static int et8ek8_close(struct v4l2_subdev *sd, struct v4l2_subdev_fh *fh)1355{1356 return et8ek8_set_power(sd, false);1357}1358 1359static const struct v4l2_subdev_video_ops et8ek8_video_ops = {1360 .s_stream = et8ek8_s_stream,1361};1362 1363static const struct v4l2_subdev_core_ops et8ek8_core_ops = {1364 .s_power = et8ek8_set_power,1365};1366 1367static 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 1377static const struct v4l2_subdev_ops et8ek8_ops = {1378 .core = &et8ek8_core_ops,1379 .video = &et8ek8_video_ops,1380 .pad = &et8ek8_pad_ops,1381};1382 1383static 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 driver1391 */1392static 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 1403static 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 1414static 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 1471err_entity:1472 media_entity_cleanup(&sensor->subdev.entity);1473err_mutex:1474 mutex_destroy(&sensor->power_lock);1475 return ret;1476}1477 1478static 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 1497static const struct of_device_id et8ek8_of_table[] = {1498 { .compatible = "toshiba,et8ek8" },1499 { },1500};1501MODULE_DEVICE_TABLE(of, et8ek8_of_table);1502 1503static const struct i2c_device_id et8ek8_id_table[] = {1504 { ET8EK8_NAME },1505 { }1506};1507MODULE_DEVICE_TABLE(i2c, et8ek8_id_table);1508 1509static const struct dev_pm_ops et8ek8_pm_ops = {1510 SET_SYSTEM_SLEEP_PM_OPS(et8ek8_suspend, et8ek8_resume)1511};1512 1513static 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 1524module_i2c_driver(et8ek8_i2c_driver);1525 1526MODULE_AUTHOR("Sakari Ailus <sakari.ailus@iki.fi>, Pavel Machek <pavel@ucw.cz");1527MODULE_DESCRIPTION("Toshiba ET8EK8 camera sensor driver");1528MODULE_LICENSE("GPL");1529