1 // SPDX-License-Identifier: GPL-2.0
2 // Copyright (C) 2018 Intel Corporation
4 #include <linux/acpi.h>
6 #include <linux/delay.h>
8 #include <linux/module.h>
9 #include <linux/pm_runtime.h>
10 #include <media/v4l2-ctrls.h>
11 #include <media/v4l2-device.h>
12 #include <media/v4l2-fwnode.h>
13 #include <asm/unaligned.h>
15 #define IMX258_REG_VALUE_08BIT 1
16 #define IMX258_REG_VALUE_16BIT 2
18 #define IMX258_REG_MODE_SELECT 0x0100
19 #define IMX258_MODE_STANDBY 0x00
20 #define IMX258_MODE_STREAMING 0x01
23 #define IMX258_REG_CHIP_ID 0x0016
24 #define IMX258_CHIP_ID 0x0258
26 /* V_TIMING internal */
27 #define IMX258_VTS_30FPS 0x0c50
28 #define IMX258_VTS_30FPS_2K 0x0638
29 #define IMX258_VTS_30FPS_VGA 0x034c
30 #define IMX258_VTS_MAX 0xffff
32 /* HBLANK control - read only */
33 #define IMX258_PPL_DEFAULT 5352
35 /* Exposure control */
36 #define IMX258_REG_EXPOSURE 0x0202
37 #define IMX258_EXPOSURE_MIN 4
38 #define IMX258_EXPOSURE_STEP 1
39 #define IMX258_EXPOSURE_DEFAULT 0x640
40 #define IMX258_EXPOSURE_MAX 65535
42 /* Analog gain control */
43 #define IMX258_REG_ANALOG_GAIN 0x0204
44 #define IMX258_ANA_GAIN_MIN 0
45 #define IMX258_ANA_GAIN_MAX 480
46 #define IMX258_ANA_GAIN_STEP 1
47 #define IMX258_ANA_GAIN_DEFAULT 0x0
49 /* Digital gain control */
50 #define IMX258_REG_GR_DIGITAL_GAIN 0x020e
51 #define IMX258_REG_R_DIGITAL_GAIN 0x0210
52 #define IMX258_REG_B_DIGITAL_GAIN 0x0212
53 #define IMX258_REG_GB_DIGITAL_GAIN 0x0214
54 #define IMX258_DGTL_GAIN_MIN 0
55 #define IMX258_DGTL_GAIN_MAX 4096 /* Max = 0xFFF */
56 #define IMX258_DGTL_GAIN_DEFAULT 1024
57 #define IMX258_DGTL_GAIN_STEP 1
60 #define IMX258_REG_HDR 0x0220
61 #define IMX258_HDR_ON BIT(0)
62 #define IMX258_REG_HDR_RATIO 0x0222
63 #define IMX258_HDR_RATIO_MIN 0
64 #define IMX258_HDR_RATIO_MAX 5
65 #define IMX258_HDR_RATIO_STEP 1
66 #define IMX258_HDR_RATIO_DEFAULT 0x0
68 /* Test Pattern Control */
69 #define IMX258_REG_TEST_PATTERN 0x0600
72 #define REG_MIRROR_FLIP_CONTROL 0x0101
73 #define REG_CONFIG_MIRROR_HFLIP 0x01
74 #define REG_CONFIG_MIRROR_VFLIP 0x02
75 #define REG_CONFIG_FLIP_TEST_PATTERN 0x02
77 /* Input clock frequency in Hz */
78 #define IMX258_INPUT_CLOCK_FREQ 19200000
85 struct imx258_reg_list {
87 const struct imx258_reg *regs;
90 /* Link frequency config */
91 struct imx258_link_freq_config {
94 /* PLL registers for this link frequency */
95 struct imx258_reg_list reg_list;
98 /* Mode : resolution and related config&values */
109 /* Index of Link frequency config to be used */
111 /* Default register values */
112 struct imx258_reg_list reg_list;
115 /* 4208x3120 needs 1267Mbps/lane, 4 lanes */
116 static const struct imx258_reg mipi_data_rate_1267mbps[] = {
134 static const struct imx258_reg mipi_data_rate_640mbps[] = {
152 static const struct imx258_reg mode_4208x3120_regs[] = {
269 static const struct imx258_reg mode_2104_1560_regs[] = {
386 static const struct imx258_reg mode_1048_780_regs[] = {
504 * The supported formats.
505 * This table MUST contain 4 entries per format, to cover the various flip
506 * combinations in the order
512 static const u32 codes[] = {
514 MEDIA_BUS_FMT_SRGGB10_1X10,
515 MEDIA_BUS_FMT_SGRBG10_1X10,
516 MEDIA_BUS_FMT_SGBRG10_1X10,
517 MEDIA_BUS_FMT_SBGGR10_1X10
519 static const char * const imx258_test_pattern_menu[] = {
522 "Eight Vertical Colour Bars",
523 "Colour Bars With Fade to Grey",
524 "Pseudorandom Sequence (PN9)",
527 /* Configurations for supported link frequencies */
528 #define IMX258_LINK_FREQ_634MHZ 633600000ULL
529 #define IMX258_LINK_FREQ_320MHZ 320000000ULL
532 IMX258_LINK_FREQ_1267MBPS,
533 IMX258_LINK_FREQ_640MBPS,
537 * pixel_rate = link_freq * data-rate * nr_of_lanes / bits_per_sample
538 * data rate => double data rate; number of lanes => 4; bits per pixel => 10
540 static u64 link_freq_to_pixel_rate(u64 f)
548 /* Menu items for LINK_FREQ V4L2 control */
549 static const s64 link_freq_menu_items[] = {
550 IMX258_LINK_FREQ_634MHZ,
551 IMX258_LINK_FREQ_320MHZ,
554 /* Link frequency configs */
555 static const struct imx258_link_freq_config link_freq_configs[] = {
556 [IMX258_LINK_FREQ_1267MBPS] = {
557 .pixels_per_line = IMX258_PPL_DEFAULT,
559 .num_of_regs = ARRAY_SIZE(mipi_data_rate_1267mbps),
560 .regs = mipi_data_rate_1267mbps,
563 [IMX258_LINK_FREQ_640MBPS] = {
564 .pixels_per_line = IMX258_PPL_DEFAULT,
566 .num_of_regs = ARRAY_SIZE(mipi_data_rate_640mbps),
567 .regs = mipi_data_rate_640mbps,
573 static const struct imx258_mode supported_modes[] = {
577 .vts_def = IMX258_VTS_30FPS,
578 .vts_min = IMX258_VTS_30FPS,
580 .num_of_regs = ARRAY_SIZE(mode_4208x3120_regs),
581 .regs = mode_4208x3120_regs,
583 .link_freq_index = IMX258_LINK_FREQ_1267MBPS,
588 .vts_def = IMX258_VTS_30FPS_2K,
589 .vts_min = IMX258_VTS_30FPS_2K,
591 .num_of_regs = ARRAY_SIZE(mode_2104_1560_regs),
592 .regs = mode_2104_1560_regs,
594 .link_freq_index = IMX258_LINK_FREQ_640MBPS,
599 .vts_def = IMX258_VTS_30FPS_VGA,
600 .vts_min = IMX258_VTS_30FPS_VGA,
602 .num_of_regs = ARRAY_SIZE(mode_1048_780_regs),
603 .regs = mode_1048_780_regs,
605 .link_freq_index = IMX258_LINK_FREQ_640MBPS,
610 struct v4l2_subdev sd;
611 struct media_pad pad;
613 struct v4l2_ctrl_handler ctrl_handler;
615 struct v4l2_ctrl *link_freq;
616 struct v4l2_ctrl *pixel_rate;
617 struct v4l2_ctrl *vblank;
618 struct v4l2_ctrl *hblank;
619 struct v4l2_ctrl *exposure;
620 struct v4l2_ctrl *hflip;
621 struct v4l2_ctrl *vflip;
624 const struct imx258_mode *cur_mode;
627 * Mutex for serialized access:
628 * Protect sensor module set pad format and start/stop streaming safely.
632 /* Streaming on/off */
638 static inline struct imx258 *to_imx258(struct v4l2_subdev *_sd)
640 return container_of(_sd, struct imx258, sd);
643 /* Read registers up to 2 at a time */
644 static int imx258_read_reg(struct imx258 *imx258, u16 reg, u32 len, u32 *val)
646 struct i2c_client *client = v4l2_get_subdevdata(&imx258->sd);
647 struct i2c_msg msgs[2];
648 u8 addr_buf[2] = { reg >> 8, reg & 0xff };
649 u8 data_buf[4] = { 0, };
655 /* Write register address */
656 msgs[0].addr = client->addr;
658 msgs[0].len = ARRAY_SIZE(addr_buf);
659 msgs[0].buf = addr_buf;
661 /* Read data from register */
662 msgs[1].addr = client->addr;
663 msgs[1].flags = I2C_M_RD;
665 msgs[1].buf = &data_buf[4 - len];
667 ret = i2c_transfer(client->adapter, msgs, ARRAY_SIZE(msgs));
668 if (ret != ARRAY_SIZE(msgs))
671 *val = get_unaligned_be32(data_buf);
676 /* Write registers up to 2 at a time */
677 static int imx258_write_reg(struct imx258 *imx258, u16 reg, u32 len, u32 val)
679 struct i2c_client *client = v4l2_get_subdevdata(&imx258->sd);
685 put_unaligned_be16(reg, buf);
686 put_unaligned_be32(val << (8 * (4 - len)), buf + 2);
687 if (i2c_master_send(client, buf, len + 2) != len + 2)
693 /* Write a list of registers */
694 static int imx258_write_regs(struct imx258 *imx258,
695 const struct imx258_reg *regs, u32 len)
697 struct i2c_client *client = v4l2_get_subdevdata(&imx258->sd);
701 for (i = 0; i < len; i++) {
702 ret = imx258_write_reg(imx258, regs[i].address, 1,
707 "Failed to write reg 0x%4.4x. error = %d\n",
708 regs[i].address, ret);
717 /* Get bayer order based on flip setting. */
718 static u32 imx258_get_format_code(struct imx258 *imx258)
722 lockdep_assert_held(&imx258->mutex);
724 i = (imx258->vflip->val ? 2 : 0) |
725 (imx258->hflip->val ? 1 : 0);
729 /* Open sub-device */
730 static int imx258_open(struct v4l2_subdev *sd, struct v4l2_subdev_fh *fh)
732 struct imx258 *imx258 = to_imx258(sd);
733 struct v4l2_mbus_framefmt *try_fmt =
734 v4l2_subdev_get_try_format(sd, fh->state, 0);
736 /* Initialize try_fmt */
737 try_fmt->width = supported_modes[0].width;
738 try_fmt->height = supported_modes[0].height;
739 try_fmt->code = imx258_get_format_code(imx258);
740 try_fmt->field = V4L2_FIELD_NONE;
745 static int imx258_update_digital_gain(struct imx258 *imx258, u32 len, u32 val)
749 ret = imx258_write_reg(imx258, IMX258_REG_GR_DIGITAL_GAIN,
750 IMX258_REG_VALUE_16BIT,
754 ret = imx258_write_reg(imx258, IMX258_REG_GB_DIGITAL_GAIN,
755 IMX258_REG_VALUE_16BIT,
759 ret = imx258_write_reg(imx258, IMX258_REG_R_DIGITAL_GAIN,
760 IMX258_REG_VALUE_16BIT,
764 ret = imx258_write_reg(imx258, IMX258_REG_B_DIGITAL_GAIN,
765 IMX258_REG_VALUE_16BIT,
772 static int imx258_set_ctrl(struct v4l2_ctrl *ctrl)
774 struct imx258 *imx258 =
775 container_of(ctrl->handler, struct imx258, ctrl_handler);
776 struct i2c_client *client = v4l2_get_subdevdata(&imx258->sd);
780 * Applying V4L2 control value only happens
781 * when power is up for streaming
783 if (pm_runtime_get_if_in_use(&client->dev) == 0)
787 case V4L2_CID_ANALOGUE_GAIN:
788 ret = imx258_write_reg(imx258, IMX258_REG_ANALOG_GAIN,
789 IMX258_REG_VALUE_16BIT,
792 case V4L2_CID_EXPOSURE:
793 ret = imx258_write_reg(imx258, IMX258_REG_EXPOSURE,
794 IMX258_REG_VALUE_16BIT,
797 case V4L2_CID_DIGITAL_GAIN:
798 ret = imx258_update_digital_gain(imx258, IMX258_REG_VALUE_16BIT,
801 case V4L2_CID_TEST_PATTERN:
802 ret = imx258_write_reg(imx258, IMX258_REG_TEST_PATTERN,
803 IMX258_REG_VALUE_16BIT,
806 case V4L2_CID_WIDE_DYNAMIC_RANGE:
808 ret = imx258_write_reg(imx258, IMX258_REG_HDR,
809 IMX258_REG_VALUE_08BIT,
810 IMX258_HDR_RATIO_MIN);
812 ret = imx258_write_reg(imx258, IMX258_REG_HDR,
813 IMX258_REG_VALUE_08BIT,
817 ret = imx258_write_reg(imx258, IMX258_REG_HDR_RATIO,
818 IMX258_REG_VALUE_08BIT,
819 BIT(IMX258_HDR_RATIO_MAX));
824 ret = imx258_write_reg(imx258, REG_MIRROR_FLIP_CONTROL,
825 IMX258_REG_VALUE_08BIT,
826 (imx258->hflip->val ?
827 REG_CONFIG_MIRROR_HFLIP : 0) |
828 (imx258->vflip->val ?
829 REG_CONFIG_MIRROR_VFLIP : 0));
832 dev_info(&client->dev,
833 "ctrl(id:0x%x,val:0x%x) is not handled\n",
834 ctrl->id, ctrl->val);
839 pm_runtime_put(&client->dev);
844 static const struct v4l2_ctrl_ops imx258_ctrl_ops = {
845 .s_ctrl = imx258_set_ctrl,
848 static int imx258_enum_mbus_code(struct v4l2_subdev *sd,
849 struct v4l2_subdev_state *sd_state,
850 struct v4l2_subdev_mbus_code_enum *code)
852 struct imx258 *imx258 = to_imx258(sd);
854 /* Only one bayer format (10 bit) is supported */
858 code->code = imx258_get_format_code(imx258);
863 static int imx258_enum_frame_size(struct v4l2_subdev *sd,
864 struct v4l2_subdev_state *sd_state,
865 struct v4l2_subdev_frame_size_enum *fse)
867 struct imx258 *imx258 = to_imx258(sd);
868 if (fse->index >= ARRAY_SIZE(supported_modes))
871 if (fse->code != imx258_get_format_code(imx258))
874 fse->min_width = supported_modes[fse->index].width;
875 fse->max_width = fse->min_width;
876 fse->min_height = supported_modes[fse->index].height;
877 fse->max_height = fse->min_height;
882 static void imx258_update_pad_format(struct imx258 *imx258,
883 const struct imx258_mode *mode,
884 struct v4l2_subdev_format *fmt)
886 fmt->format.width = mode->width;
887 fmt->format.height = mode->height;
888 fmt->format.code = imx258_get_format_code(imx258);
889 fmt->format.field = V4L2_FIELD_NONE;
892 static int __imx258_get_pad_format(struct imx258 *imx258,
893 struct v4l2_subdev_state *sd_state,
894 struct v4l2_subdev_format *fmt)
896 if (fmt->which == V4L2_SUBDEV_FORMAT_TRY)
897 fmt->format = *v4l2_subdev_get_try_format(&imx258->sd,
901 imx258_update_pad_format(imx258, imx258->cur_mode, fmt);
906 static int imx258_get_pad_format(struct v4l2_subdev *sd,
907 struct v4l2_subdev_state *sd_state,
908 struct v4l2_subdev_format *fmt)
910 struct imx258 *imx258 = to_imx258(sd);
913 mutex_lock(&imx258->mutex);
914 ret = __imx258_get_pad_format(imx258, sd_state, fmt);
915 mutex_unlock(&imx258->mutex);
920 static int imx258_set_pad_format(struct v4l2_subdev *sd,
921 struct v4l2_subdev_state *sd_state,
922 struct v4l2_subdev_format *fmt)
924 struct imx258 *imx258 = to_imx258(sd);
925 const struct imx258_mode *mode;
926 struct v4l2_mbus_framefmt *framefmt;
933 mutex_lock(&imx258->mutex);
935 fmt->format.code = imx258_get_format_code(imx258);
937 mode = v4l2_find_nearest_size(supported_modes,
938 ARRAY_SIZE(supported_modes), width, height,
939 fmt->format.width, fmt->format.height);
940 imx258_update_pad_format(imx258, mode, fmt);
941 if (fmt->which == V4L2_SUBDEV_FORMAT_TRY) {
942 framefmt = v4l2_subdev_get_try_format(sd, sd_state, fmt->pad);
943 *framefmt = fmt->format;
945 imx258->cur_mode = mode;
946 __v4l2_ctrl_s_ctrl(imx258->link_freq, mode->link_freq_index);
948 link_freq = link_freq_menu_items[mode->link_freq_index];
949 pixel_rate = link_freq_to_pixel_rate(link_freq);
950 __v4l2_ctrl_s_ctrl_int64(imx258->pixel_rate, pixel_rate);
951 /* Update limits and set FPS to default */
952 vblank_def = imx258->cur_mode->vts_def -
953 imx258->cur_mode->height;
954 vblank_min = imx258->cur_mode->vts_min -
955 imx258->cur_mode->height;
956 __v4l2_ctrl_modify_range(
957 imx258->vblank, vblank_min,
958 IMX258_VTS_MAX - imx258->cur_mode->height, 1,
960 __v4l2_ctrl_s_ctrl(imx258->vblank, vblank_def);
962 link_freq_configs[mode->link_freq_index].pixels_per_line
963 - imx258->cur_mode->width;
964 __v4l2_ctrl_modify_range(imx258->hblank, h_blank,
965 h_blank, 1, h_blank);
968 mutex_unlock(&imx258->mutex);
973 /* Start streaming */
974 static int imx258_start_streaming(struct imx258 *imx258)
976 struct i2c_client *client = v4l2_get_subdevdata(&imx258->sd);
977 const struct imx258_reg_list *reg_list;
978 int ret, link_freq_index;
981 link_freq_index = imx258->cur_mode->link_freq_index;
982 reg_list = &link_freq_configs[link_freq_index].reg_list;
983 ret = imx258_write_regs(imx258, reg_list->regs, reg_list->num_of_regs);
985 dev_err(&client->dev, "%s failed to set plls\n", __func__);
989 /* Apply default values of current mode */
990 reg_list = &imx258->cur_mode->reg_list;
991 ret = imx258_write_regs(imx258, reg_list->regs, reg_list->num_of_regs);
993 dev_err(&client->dev, "%s failed to set mode\n", __func__);
997 /* Apply customized values from user */
998 ret = __v4l2_ctrl_handler_setup(imx258->sd.ctrl_handler);
1002 /* set stream on register */
1003 return imx258_write_reg(imx258, IMX258_REG_MODE_SELECT,
1004 IMX258_REG_VALUE_08BIT,
1005 IMX258_MODE_STREAMING);
1008 /* Stop streaming */
1009 static int imx258_stop_streaming(struct imx258 *imx258)
1011 struct i2c_client *client = v4l2_get_subdevdata(&imx258->sd);
1014 /* set stream off register */
1015 ret = imx258_write_reg(imx258, IMX258_REG_MODE_SELECT,
1016 IMX258_REG_VALUE_08BIT, IMX258_MODE_STANDBY);
1018 dev_err(&client->dev, "%s failed to set stream\n", __func__);
1021 * Return success even if it was an error, as there is nothing the
1022 * caller can do about it.
1027 static int imx258_power_on(struct device *dev)
1029 struct v4l2_subdev *sd = dev_get_drvdata(dev);
1030 struct imx258 *imx258 = to_imx258(sd);
1033 ret = clk_prepare_enable(imx258->clk);
1035 dev_err(dev, "failed to enable clock\n");
1040 static int imx258_power_off(struct device *dev)
1042 struct v4l2_subdev *sd = dev_get_drvdata(dev);
1043 struct imx258 *imx258 = to_imx258(sd);
1045 clk_disable_unprepare(imx258->clk);
1050 static int imx258_set_stream(struct v4l2_subdev *sd, int enable)
1052 struct imx258 *imx258 = to_imx258(sd);
1053 struct i2c_client *client = v4l2_get_subdevdata(sd);
1056 mutex_lock(&imx258->mutex);
1057 if (imx258->streaming == enable) {
1058 mutex_unlock(&imx258->mutex);
1063 ret = pm_runtime_resume_and_get(&client->dev);
1068 * Apply default & customized values
1069 * and then start streaming.
1071 ret = imx258_start_streaming(imx258);
1075 imx258_stop_streaming(imx258);
1076 pm_runtime_put(&client->dev);
1079 imx258->streaming = enable;
1080 mutex_unlock(&imx258->mutex);
1085 pm_runtime_put(&client->dev);
1087 mutex_unlock(&imx258->mutex);
1092 static int __maybe_unused imx258_suspend(struct device *dev)
1094 struct v4l2_subdev *sd = dev_get_drvdata(dev);
1095 struct imx258 *imx258 = to_imx258(sd);
1097 if (imx258->streaming)
1098 imx258_stop_streaming(imx258);
1103 static int __maybe_unused imx258_resume(struct device *dev)
1105 struct v4l2_subdev *sd = dev_get_drvdata(dev);
1106 struct imx258 *imx258 = to_imx258(sd);
1109 if (imx258->streaming) {
1110 ret = imx258_start_streaming(imx258);
1118 imx258_stop_streaming(imx258);
1119 imx258->streaming = 0;
1123 /* Verify chip ID */
1124 static int imx258_identify_module(struct imx258 *imx258)
1126 struct i2c_client *client = v4l2_get_subdevdata(&imx258->sd);
1130 ret = imx258_read_reg(imx258, IMX258_REG_CHIP_ID,
1131 IMX258_REG_VALUE_16BIT, &val);
1133 dev_err(&client->dev, "failed to read chip id %x\n",
1138 if (val != IMX258_CHIP_ID) {
1139 dev_err(&client->dev, "chip id mismatch: %x!=%x\n",
1140 IMX258_CHIP_ID, val);
1147 static const struct v4l2_subdev_video_ops imx258_video_ops = {
1148 .s_stream = imx258_set_stream,
1151 static const struct v4l2_subdev_pad_ops imx258_pad_ops = {
1152 .enum_mbus_code = imx258_enum_mbus_code,
1153 .get_fmt = imx258_get_pad_format,
1154 .set_fmt = imx258_set_pad_format,
1155 .enum_frame_size = imx258_enum_frame_size,
1158 static const struct v4l2_subdev_ops imx258_subdev_ops = {
1159 .video = &imx258_video_ops,
1160 .pad = &imx258_pad_ops,
1163 static const struct v4l2_subdev_internal_ops imx258_internal_ops = {
1164 .open = imx258_open,
1167 /* Initialize control handlers */
1168 static int imx258_init_controls(struct imx258 *imx258)
1170 struct i2c_client *client = v4l2_get_subdevdata(&imx258->sd);
1171 struct v4l2_fwnode_device_properties props;
1172 struct v4l2_ctrl_handler *ctrl_hdlr;
1179 ctrl_hdlr = &imx258->ctrl_handler;
1180 ret = v4l2_ctrl_handler_init(ctrl_hdlr, 10);
1184 mutex_init(&imx258->mutex);
1185 ctrl_hdlr->lock = &imx258->mutex;
1186 imx258->link_freq = v4l2_ctrl_new_int_menu(ctrl_hdlr,
1189 ARRAY_SIZE(link_freq_menu_items) - 1,
1191 link_freq_menu_items);
1193 if (imx258->link_freq)
1194 imx258->link_freq->flags |= V4L2_CTRL_FLAG_READ_ONLY;
1196 pixel_rate_max = link_freq_to_pixel_rate(link_freq_menu_items[0]);
1197 pixel_rate_min = link_freq_to_pixel_rate(link_freq_menu_items[1]);
1198 /* By default, PIXEL_RATE is read only */
1199 imx258->pixel_rate = v4l2_ctrl_new_std(ctrl_hdlr, &imx258_ctrl_ops,
1200 V4L2_CID_PIXEL_RATE,
1201 pixel_rate_min, pixel_rate_max,
1205 vblank_def = imx258->cur_mode->vts_def - imx258->cur_mode->height;
1206 vblank_min = imx258->cur_mode->vts_min - imx258->cur_mode->height;
1207 imx258->vblank = v4l2_ctrl_new_std(
1208 ctrl_hdlr, &imx258_ctrl_ops, V4L2_CID_VBLANK,
1210 IMX258_VTS_MAX - imx258->cur_mode->height, 1,
1214 imx258->vblank->flags |= V4L2_CTRL_FLAG_READ_ONLY;
1216 imx258->hblank = v4l2_ctrl_new_std(
1217 ctrl_hdlr, &imx258_ctrl_ops, V4L2_CID_HBLANK,
1218 IMX258_PPL_DEFAULT - imx258->cur_mode->width,
1219 IMX258_PPL_DEFAULT - imx258->cur_mode->width,
1221 IMX258_PPL_DEFAULT - imx258->cur_mode->width);
1224 imx258->hblank->flags |= V4L2_CTRL_FLAG_READ_ONLY;
1226 imx258->exposure = v4l2_ctrl_new_std(
1227 ctrl_hdlr, &imx258_ctrl_ops,
1228 V4L2_CID_EXPOSURE, IMX258_EXPOSURE_MIN,
1229 IMX258_EXPOSURE_MAX, IMX258_EXPOSURE_STEP,
1230 IMX258_EXPOSURE_DEFAULT);
1232 v4l2_ctrl_new_std(ctrl_hdlr, &imx258_ctrl_ops, V4L2_CID_ANALOGUE_GAIN,
1233 IMX258_ANA_GAIN_MIN, IMX258_ANA_GAIN_MAX,
1234 IMX258_ANA_GAIN_STEP, IMX258_ANA_GAIN_DEFAULT);
1236 v4l2_ctrl_new_std(ctrl_hdlr, &imx258_ctrl_ops, V4L2_CID_DIGITAL_GAIN,
1237 IMX258_DGTL_GAIN_MIN, IMX258_DGTL_GAIN_MAX,
1238 IMX258_DGTL_GAIN_STEP,
1239 IMX258_DGTL_GAIN_DEFAULT);
1241 v4l2_ctrl_new_std(ctrl_hdlr, &imx258_ctrl_ops, V4L2_CID_WIDE_DYNAMIC_RANGE,
1242 0, 1, 1, IMX258_HDR_RATIO_DEFAULT);
1244 v4l2_ctrl_new_std_menu_items(ctrl_hdlr, &imx258_ctrl_ops,
1245 V4L2_CID_TEST_PATTERN,
1246 ARRAY_SIZE(imx258_test_pattern_menu) - 1,
1247 0, 0, imx258_test_pattern_menu);
1249 ret = v4l2_fwnode_device_parse(&client->dev, &props);
1253 imx258->hflip = v4l2_ctrl_new_std(ctrl_hdlr, &imx258_ctrl_ops,
1254 V4L2_CID_HFLIP, 0, 1, 1,
1255 props.rotation == 180 ? 1 : 0);
1257 imx258->hflip->flags |= V4L2_CTRL_FLAG_MODIFY_LAYOUT;
1259 imx258->vflip = v4l2_ctrl_new_std(ctrl_hdlr, &imx258_ctrl_ops,
1260 V4L2_CID_VFLIP, 0, 1, 1,
1261 props.rotation == 180 ? 1 : 0);
1263 imx258->vflip->flags |= V4L2_CTRL_FLAG_MODIFY_LAYOUT;
1264 if (ctrl_hdlr->error) {
1265 ret = ctrl_hdlr->error;
1266 dev_err(&client->dev, "%s control init failed (%d)\n",
1271 imx258->sd.ctrl_handler = ctrl_hdlr;
1276 v4l2_ctrl_handler_free(ctrl_hdlr);
1277 mutex_destroy(&imx258->mutex);
1282 static void imx258_free_controls(struct imx258 *imx258)
1284 v4l2_ctrl_handler_free(imx258->sd.ctrl_handler);
1285 mutex_destroy(&imx258->mutex);
1288 static int imx258_probe(struct i2c_client *client)
1290 struct imx258 *imx258;
1294 imx258 = devm_kzalloc(&client->dev, sizeof(*imx258), GFP_KERNEL);
1298 imx258->clk = devm_clk_get_optional(&client->dev, NULL);
1299 if (IS_ERR(imx258->clk))
1300 return dev_err_probe(&client->dev, PTR_ERR(imx258->clk),
1301 "error getting clock\n");
1303 dev_dbg(&client->dev,
1304 "no clock provided, using clock-frequency property\n");
1306 device_property_read_u32(&client->dev, "clock-frequency", &val);
1308 val = clk_get_rate(imx258->clk);
1310 if (val != IMX258_INPUT_CLOCK_FREQ) {
1311 dev_err(&client->dev, "input clock frequency not supported\n");
1315 /* Initialize subdev */
1316 v4l2_i2c_subdev_init(&imx258->sd, client, &imx258_subdev_ops);
1318 /* Will be powered off via pm_runtime_idle */
1319 ret = imx258_power_on(&client->dev);
1323 /* Check module identity */
1324 ret = imx258_identify_module(imx258);
1326 goto error_identify;
1328 /* Set default mode to max resolution */
1329 imx258->cur_mode = &supported_modes[0];
1331 ret = imx258_init_controls(imx258);
1333 goto error_identify;
1335 /* Initialize subdev */
1336 imx258->sd.internal_ops = &imx258_internal_ops;
1337 imx258->sd.flags |= V4L2_SUBDEV_FL_HAS_DEVNODE;
1338 imx258->sd.entity.function = MEDIA_ENT_F_CAM_SENSOR;
1340 /* Initialize source pad */
1341 imx258->pad.flags = MEDIA_PAD_FL_SOURCE;
1343 ret = media_entity_pads_init(&imx258->sd.entity, 1, &imx258->pad);
1345 goto error_handler_free;
1347 ret = v4l2_async_register_subdev_sensor(&imx258->sd);
1349 goto error_media_entity;
1351 pm_runtime_set_active(&client->dev);
1352 pm_runtime_enable(&client->dev);
1353 pm_runtime_idle(&client->dev);
1358 media_entity_cleanup(&imx258->sd.entity);
1361 imx258_free_controls(imx258);
1364 imx258_power_off(&client->dev);
1369 static int imx258_remove(struct i2c_client *client)
1371 struct v4l2_subdev *sd = i2c_get_clientdata(client);
1372 struct imx258 *imx258 = to_imx258(sd);
1374 v4l2_async_unregister_subdev(sd);
1375 media_entity_cleanup(&sd->entity);
1376 imx258_free_controls(imx258);
1378 pm_runtime_disable(&client->dev);
1379 if (!pm_runtime_status_suspended(&client->dev))
1380 imx258_power_off(&client->dev);
1381 pm_runtime_set_suspended(&client->dev);
1386 static const struct dev_pm_ops imx258_pm_ops = {
1387 SET_SYSTEM_SLEEP_PM_OPS(imx258_suspend, imx258_resume)
1388 SET_RUNTIME_PM_OPS(imx258_power_off, imx258_power_on, NULL)
1392 static const struct acpi_device_id imx258_acpi_ids[] = {
1397 MODULE_DEVICE_TABLE(acpi, imx258_acpi_ids);
1400 static const struct of_device_id imx258_dt_ids[] = {
1401 { .compatible = "sony,imx258" },
1404 MODULE_DEVICE_TABLE(of, imx258_dt_ids);
1406 static struct i2c_driver imx258_i2c_driver = {
1409 .pm = &imx258_pm_ops,
1410 .acpi_match_table = ACPI_PTR(imx258_acpi_ids),
1411 .of_match_table = imx258_dt_ids,
1413 .probe_new = imx258_probe,
1414 .remove = imx258_remove,
1417 module_i2c_driver(imx258_i2c_driver);
1419 MODULE_AUTHOR("Yeh, Andy <andy.yeh@intel.com>");
1420 MODULE_AUTHOR("Chiang, Alan");
1421 MODULE_AUTHOR("Chen, Jason");
1422 MODULE_DESCRIPTION("Sony IMX258 sensor driver");
1423 MODULE_LICENSE("GPL v2");