1 // SPDX-License-Identifier: GPL-2.0
2 // Copyright (C) 2018 Intel Corporation
4 #include <linux/acpi.h>
5 #include <linux/delay.h>
7 #include <linux/module.h>
8 #include <linux/pm_runtime.h>
9 #include <media/v4l2-ctrls.h>
10 #include <media/v4l2-device.h>
11 #include <asm/unaligned.h>
13 #define IMX258_REG_VALUE_08BIT 1
14 #define IMX258_REG_VALUE_16BIT 2
16 #define IMX258_REG_MODE_SELECT 0x0100
17 #define IMX258_MODE_STANDBY 0x00
18 #define IMX258_MODE_STREAMING 0x01
21 #define IMX258_REG_CHIP_ID 0x0016
22 #define IMX258_CHIP_ID 0x0258
24 /* V_TIMING internal */
25 #define IMX258_VTS_30FPS 0x0c50
26 #define IMX258_VTS_30FPS_2K 0x0638
27 #define IMX258_VTS_30FPS_VGA 0x034c
28 #define IMX258_VTS_MAX 0xffff
31 #define IMX258_FLL_MIN 0x08a6
32 #define IMX258_FLL_MAX 0xffff
33 #define IMX258_FLL_STEP 1
34 #define IMX258_FLL_DEFAULT 0x0c98
36 /* HBLANK control - read only */
37 #define IMX258_PPL_DEFAULT 5352
39 /* Exposure control */
40 #define IMX258_REG_EXPOSURE 0x0202
41 #define IMX258_EXPOSURE_MIN 4
42 #define IMX258_EXPOSURE_STEP 1
43 #define IMX258_EXPOSURE_DEFAULT 0x640
44 #define IMX258_EXPOSURE_MAX 65535
46 /* Analog gain control */
47 #define IMX258_REG_ANALOG_GAIN 0x0204
48 #define IMX258_ANA_GAIN_MIN 0
49 #define IMX258_ANA_GAIN_MAX 480
50 #define IMX258_ANA_GAIN_STEP 1
51 #define IMX258_ANA_GAIN_DEFAULT 0x0
53 /* Digital gain control */
54 #define IMX258_REG_GR_DIGITAL_GAIN 0x020e
55 #define IMX258_REG_R_DIGITAL_GAIN 0x0210
56 #define IMX258_REG_B_DIGITAL_GAIN 0x0212
57 #define IMX258_REG_GB_DIGITAL_GAIN 0x0214
58 #define IMX258_DGTL_GAIN_MIN 0
59 #define IMX258_DGTL_GAIN_MAX 4096 /* Max = 0xFFF */
60 #define IMX258_DGTL_GAIN_DEFAULT 1024
61 #define IMX258_DGTL_GAIN_STEP 1
63 /* Test Pattern Control */
64 #define IMX258_REG_TEST_PATTERN 0x0600
65 #define IMX258_TEST_PATTERN_DISABLE 0
66 #define IMX258_TEST_PATTERN_SOLID_COLOR 1
67 #define IMX258_TEST_PATTERN_COLOR_BARS 2
68 #define IMX258_TEST_PATTERN_GREY_COLOR 3
69 #define IMX258_TEST_PATTERN_PN9 4
72 #define REG_MIRROR_FLIP_CONTROL 0x0101
73 #define REG_CONFIG_MIRROR_FLIP 0x03
74 #define REG_CONFIG_FLIP_TEST_PATTERN 0x02
81 struct imx258_reg_list {
83 const struct imx258_reg *regs;
86 /* Link frequency config */
87 struct imx258_link_freq_config {
90 /* PLL registers for this link frequency */
91 struct imx258_reg_list reg_list;
94 /* Mode : resolution and related config&values */
105 /* Index of Link frequency config to be used */
107 /* Default register values */
108 struct imx258_reg_list reg_list;
111 /* 4208x3118 needs 1267Mbps/lane, 4 lanes */
112 static const struct imx258_reg mipi_data_rate_1267mbps[] = {
130 static const struct imx258_reg mipi_data_rate_640mbps[] = {
148 static const struct imx258_reg mode_4208x3118_regs[] = {
267 static const struct imx258_reg mode_2104_1560_regs[] = {
386 static const struct imx258_reg mode_1048_780_regs[] = {
505 static const char * const imx258_test_pattern_menu[] = {
513 static const int imx258_test_pattern_val[] = {
514 IMX258_TEST_PATTERN_DISABLE,
515 IMX258_TEST_PATTERN_COLOR_BARS,
516 IMX258_TEST_PATTERN_SOLID_COLOR,
517 IMX258_TEST_PATTERN_GREY_COLOR,
518 IMX258_TEST_PATTERN_PN9,
521 /* Configurations for supported link frequencies */
522 #define IMX258_LINK_FREQ_634MHZ 633600000ULL
523 #define IMX258_LINK_FREQ_320MHZ 320000000ULL
526 IMX258_LINK_FREQ_1267MBPS,
527 IMX258_LINK_FREQ_640MBPS,
531 * pixel_rate = link_freq * data-rate * nr_of_lanes / bits_per_sample
532 * data rate => double data rate; number of lanes => 4; bits per pixel => 10
534 static u64 link_freq_to_pixel_rate(u64 f)
542 /* Menu items for LINK_FREQ V4L2 control */
543 static const s64 link_freq_menu_items[] = {
544 IMX258_LINK_FREQ_634MHZ,
545 IMX258_LINK_FREQ_320MHZ,
548 /* Link frequency configs */
549 static const struct imx258_link_freq_config link_freq_configs[] = {
550 [IMX258_LINK_FREQ_1267MBPS] = {
551 .pixels_per_line = IMX258_PPL_DEFAULT,
553 .num_of_regs = ARRAY_SIZE(mipi_data_rate_1267mbps),
554 .regs = mipi_data_rate_1267mbps,
557 [IMX258_LINK_FREQ_640MBPS] = {
558 .pixels_per_line = IMX258_PPL_DEFAULT,
560 .num_of_regs = ARRAY_SIZE(mipi_data_rate_640mbps),
561 .regs = mipi_data_rate_640mbps,
567 static const struct imx258_mode supported_modes[] = {
571 .vts_def = IMX258_VTS_30FPS,
572 .vts_min = IMX258_VTS_30FPS,
574 .num_of_regs = ARRAY_SIZE(mode_4208x3118_regs),
575 .regs = mode_4208x3118_regs,
577 .link_freq_index = IMX258_LINK_FREQ_1267MBPS,
582 .vts_def = IMX258_VTS_30FPS_2K,
583 .vts_min = IMX258_VTS_30FPS_2K,
585 .num_of_regs = ARRAY_SIZE(mode_2104_1560_regs),
586 .regs = mode_2104_1560_regs,
588 .link_freq_index = IMX258_LINK_FREQ_640MBPS,
593 .vts_def = IMX258_VTS_30FPS_VGA,
594 .vts_min = IMX258_VTS_30FPS_VGA,
596 .num_of_regs = ARRAY_SIZE(mode_1048_780_regs),
597 .regs = mode_1048_780_regs,
599 .link_freq_index = IMX258_LINK_FREQ_640MBPS,
604 struct v4l2_subdev sd;
605 struct media_pad pad;
607 struct v4l2_ctrl_handler ctrl_handler;
609 struct v4l2_ctrl *link_freq;
610 struct v4l2_ctrl *pixel_rate;
611 struct v4l2_ctrl *vblank;
612 struct v4l2_ctrl *hblank;
613 struct v4l2_ctrl *exposure;
616 const struct imx258_mode *cur_mode;
619 * Mutex for serialized access:
620 * Protect sensor module set pad format and start/stop streaming safely.
624 /* Streaming on/off */
628 static inline struct imx258 *to_imx258(struct v4l2_subdev *_sd)
630 return container_of(_sd, struct imx258, sd);
633 /* Read registers up to 2 at a time */
634 static int imx258_read_reg(struct imx258 *imx258, u16 reg, u32 len, u32 *val)
636 struct i2c_client *client = v4l2_get_subdevdata(&imx258->sd);
637 struct i2c_msg msgs[2];
638 u8 addr_buf[2] = { reg >> 8, reg & 0xff };
639 u8 data_buf[4] = { 0, };
645 /* Write register address */
646 msgs[0].addr = client->addr;
648 msgs[0].len = ARRAY_SIZE(addr_buf);
649 msgs[0].buf = addr_buf;
651 /* Read data from register */
652 msgs[1].addr = client->addr;
653 msgs[1].flags = I2C_M_RD;
655 msgs[1].buf = &data_buf[4 - len];
657 ret = i2c_transfer(client->adapter, msgs, ARRAY_SIZE(msgs));
658 if (ret != ARRAY_SIZE(msgs))
661 *val = get_unaligned_be32(data_buf);
666 /* Write registers up to 2 at a time */
667 static int imx258_write_reg(struct imx258 *imx258, u16 reg, u32 len, u32 val)
669 struct i2c_client *client = v4l2_get_subdevdata(&imx258->sd);
675 put_unaligned_be16(reg, buf);
676 put_unaligned_be32(val << (8 * (4 - len)), buf + 2);
677 if (i2c_master_send(client, buf, len + 2) != len + 2)
683 /* Write a list of registers */
684 static int imx258_write_regs(struct imx258 *imx258,
685 const struct imx258_reg *regs, u32 len)
687 struct i2c_client *client = v4l2_get_subdevdata(&imx258->sd);
691 for (i = 0; i < len; i++) {
692 ret = imx258_write_reg(imx258, regs[i].address, 1,
697 "Failed to write reg 0x%4.4x. error = %d\n",
698 regs[i].address, ret);
707 /* Open sub-device */
708 static int imx258_open(struct v4l2_subdev *sd, struct v4l2_subdev_fh *fh)
710 struct v4l2_mbus_framefmt *try_fmt =
711 v4l2_subdev_get_try_format(sd, fh->pad, 0);
713 /* Initialize try_fmt */
714 try_fmt->width = supported_modes[0].width;
715 try_fmt->height = supported_modes[0].height;
716 try_fmt->code = MEDIA_BUS_FMT_SGRBG10_1X10;
717 try_fmt->field = V4L2_FIELD_NONE;
722 static int imx258_update_digital_gain(struct imx258 *imx258, u32 len, u32 val)
726 ret = imx258_write_reg(imx258, IMX258_REG_GR_DIGITAL_GAIN,
727 IMX258_REG_VALUE_16BIT,
731 ret = imx258_write_reg(imx258, IMX258_REG_GB_DIGITAL_GAIN,
732 IMX258_REG_VALUE_16BIT,
736 ret = imx258_write_reg(imx258, IMX258_REG_R_DIGITAL_GAIN,
737 IMX258_REG_VALUE_16BIT,
741 ret = imx258_write_reg(imx258, IMX258_REG_B_DIGITAL_GAIN,
742 IMX258_REG_VALUE_16BIT,
749 static int imx258_set_ctrl(struct v4l2_ctrl *ctrl)
751 struct imx258 *imx258 =
752 container_of(ctrl->handler, struct imx258, ctrl_handler);
753 struct i2c_client *client = v4l2_get_subdevdata(&imx258->sd);
757 * Applying V4L2 control value only happens
758 * when power is up for streaming
760 if (pm_runtime_get_if_in_use(&client->dev) == 0)
764 case V4L2_CID_ANALOGUE_GAIN:
765 ret = imx258_write_reg(imx258, IMX258_REG_ANALOG_GAIN,
766 IMX258_REG_VALUE_16BIT,
769 case V4L2_CID_EXPOSURE:
770 ret = imx258_write_reg(imx258, IMX258_REG_EXPOSURE,
771 IMX258_REG_VALUE_16BIT,
774 case V4L2_CID_DIGITAL_GAIN:
775 ret = imx258_update_digital_gain(imx258, IMX258_REG_VALUE_16BIT,
778 case V4L2_CID_TEST_PATTERN:
779 ret = imx258_write_reg(imx258, IMX258_REG_TEST_PATTERN,
780 IMX258_REG_VALUE_16BIT,
781 imx258_test_pattern_val[ctrl->val]);
783 ret = imx258_write_reg(imx258, REG_MIRROR_FLIP_CONTROL,
784 IMX258_REG_VALUE_08BIT,
785 ctrl->val == imx258_test_pattern_val
786 [IMX258_TEST_PATTERN_DISABLE] ?
787 REG_CONFIG_MIRROR_FLIP :
788 REG_CONFIG_FLIP_TEST_PATTERN);
791 dev_info(&client->dev,
792 "ctrl(id:0x%x,val:0x%x) is not handled\n",
793 ctrl->id, ctrl->val);
798 pm_runtime_put(&client->dev);
803 static const struct v4l2_ctrl_ops imx258_ctrl_ops = {
804 .s_ctrl = imx258_set_ctrl,
807 static int imx258_enum_mbus_code(struct v4l2_subdev *sd,
808 struct v4l2_subdev_pad_config *cfg,
809 struct v4l2_subdev_mbus_code_enum *code)
811 /* Only one bayer order(GRBG) is supported */
815 code->code = MEDIA_BUS_FMT_SGRBG10_1X10;
820 static int imx258_enum_frame_size(struct v4l2_subdev *sd,
821 struct v4l2_subdev_pad_config *cfg,
822 struct v4l2_subdev_frame_size_enum *fse)
824 if (fse->index >= ARRAY_SIZE(supported_modes))
827 if (fse->code != MEDIA_BUS_FMT_SGRBG10_1X10)
830 fse->min_width = supported_modes[fse->index].width;
831 fse->max_width = fse->min_width;
832 fse->min_height = supported_modes[fse->index].height;
833 fse->max_height = fse->min_height;
838 static void imx258_update_pad_format(const struct imx258_mode *mode,
839 struct v4l2_subdev_format *fmt)
841 fmt->format.width = mode->width;
842 fmt->format.height = mode->height;
843 fmt->format.code = MEDIA_BUS_FMT_SGRBG10_1X10;
844 fmt->format.field = V4L2_FIELD_NONE;
847 static int __imx258_get_pad_format(struct imx258 *imx258,
848 struct v4l2_subdev_pad_config *cfg,
849 struct v4l2_subdev_format *fmt)
851 if (fmt->which == V4L2_SUBDEV_FORMAT_TRY)
852 fmt->format = *v4l2_subdev_get_try_format(&imx258->sd, cfg,
855 imx258_update_pad_format(imx258->cur_mode, fmt);
860 static int imx258_get_pad_format(struct v4l2_subdev *sd,
861 struct v4l2_subdev_pad_config *cfg,
862 struct v4l2_subdev_format *fmt)
864 struct imx258 *imx258 = to_imx258(sd);
867 mutex_lock(&imx258->mutex);
868 ret = __imx258_get_pad_format(imx258, cfg, fmt);
869 mutex_unlock(&imx258->mutex);
874 static int imx258_set_pad_format(struct v4l2_subdev *sd,
875 struct v4l2_subdev_pad_config *cfg,
876 struct v4l2_subdev_format *fmt)
878 struct imx258 *imx258 = to_imx258(sd);
879 const struct imx258_mode *mode;
880 struct v4l2_mbus_framefmt *framefmt;
887 mutex_lock(&imx258->mutex);
889 /* Only one raw bayer(GBRG) order is supported */
890 fmt->format.code = MEDIA_BUS_FMT_SGRBG10_1X10;
892 mode = v4l2_find_nearest_size(supported_modes,
893 ARRAY_SIZE(supported_modes), width, height,
894 fmt->format.width, fmt->format.height);
895 imx258_update_pad_format(mode, fmt);
896 if (fmt->which == V4L2_SUBDEV_FORMAT_TRY) {
897 framefmt = v4l2_subdev_get_try_format(sd, cfg, fmt->pad);
898 *framefmt = fmt->format;
900 imx258->cur_mode = mode;
901 __v4l2_ctrl_s_ctrl(imx258->link_freq, mode->link_freq_index);
903 link_freq = link_freq_menu_items[mode->link_freq_index];
904 pixel_rate = link_freq_to_pixel_rate(link_freq);
905 __v4l2_ctrl_s_ctrl_int64(imx258->pixel_rate, pixel_rate);
906 /* Update limits and set FPS to default */
907 vblank_def = imx258->cur_mode->vts_def -
908 imx258->cur_mode->height;
909 vblank_min = imx258->cur_mode->vts_min -
910 imx258->cur_mode->height;
911 __v4l2_ctrl_modify_range(
912 imx258->vblank, vblank_min,
913 IMX258_VTS_MAX - imx258->cur_mode->height, 1,
915 __v4l2_ctrl_s_ctrl(imx258->vblank, vblank_def);
917 link_freq_configs[mode->link_freq_index].pixels_per_line
918 - imx258->cur_mode->width;
919 __v4l2_ctrl_modify_range(imx258->hblank, h_blank,
920 h_blank, 1, h_blank);
923 mutex_unlock(&imx258->mutex);
928 /* Start streaming */
929 static int imx258_start_streaming(struct imx258 *imx258)
931 struct i2c_client *client = v4l2_get_subdevdata(&imx258->sd);
932 const struct imx258_reg_list *reg_list;
933 int ret, link_freq_index;
936 link_freq_index = imx258->cur_mode->link_freq_index;
937 reg_list = &link_freq_configs[link_freq_index].reg_list;
938 ret = imx258_write_regs(imx258, reg_list->regs, reg_list->num_of_regs);
940 dev_err(&client->dev, "%s failed to set plls\n", __func__);
944 /* Apply default values of current mode */
945 reg_list = &imx258->cur_mode->reg_list;
946 ret = imx258_write_regs(imx258, reg_list->regs, reg_list->num_of_regs);
948 dev_err(&client->dev, "%s failed to set mode\n", __func__);
952 /* Set Orientation be 180 degree */
953 ret = imx258_write_reg(imx258, REG_MIRROR_FLIP_CONTROL,
954 IMX258_REG_VALUE_08BIT, REG_CONFIG_MIRROR_FLIP);
956 dev_err(&client->dev, "%s failed to set orientation\n",
961 /* Apply customized values from user */
962 ret = __v4l2_ctrl_handler_setup(imx258->sd.ctrl_handler);
966 /* set stream on register */
967 return imx258_write_reg(imx258, IMX258_REG_MODE_SELECT,
968 IMX258_REG_VALUE_08BIT,
969 IMX258_MODE_STREAMING);
973 static int imx258_stop_streaming(struct imx258 *imx258)
975 struct i2c_client *client = v4l2_get_subdevdata(&imx258->sd);
978 /* set stream off register */
979 ret = imx258_write_reg(imx258, IMX258_REG_MODE_SELECT,
980 IMX258_REG_VALUE_08BIT, IMX258_MODE_STANDBY);
982 dev_err(&client->dev, "%s failed to set stream\n", __func__);
985 * Return success even if it was an error, as there is nothing the
986 * caller can do about it.
991 static int imx258_set_stream(struct v4l2_subdev *sd, int enable)
993 struct imx258 *imx258 = to_imx258(sd);
994 struct i2c_client *client = v4l2_get_subdevdata(sd);
997 mutex_lock(&imx258->mutex);
998 if (imx258->streaming == enable) {
999 mutex_unlock(&imx258->mutex);
1004 ret = pm_runtime_get_sync(&client->dev);
1006 pm_runtime_put_noidle(&client->dev);
1011 * Apply default & customized values
1012 * and then start streaming.
1014 ret = imx258_start_streaming(imx258);
1018 imx258_stop_streaming(imx258);
1019 pm_runtime_put(&client->dev);
1022 imx258->streaming = enable;
1023 mutex_unlock(&imx258->mutex);
1028 pm_runtime_put(&client->dev);
1030 mutex_unlock(&imx258->mutex);
1035 static int __maybe_unused imx258_suspend(struct device *dev)
1037 struct i2c_client *client = to_i2c_client(dev);
1038 struct v4l2_subdev *sd = i2c_get_clientdata(client);
1039 struct imx258 *imx258 = to_imx258(sd);
1041 if (imx258->streaming)
1042 imx258_stop_streaming(imx258);
1047 static int __maybe_unused imx258_resume(struct device *dev)
1049 struct i2c_client *client = to_i2c_client(dev);
1050 struct v4l2_subdev *sd = i2c_get_clientdata(client);
1051 struct imx258 *imx258 = to_imx258(sd);
1054 if (imx258->streaming) {
1055 ret = imx258_start_streaming(imx258);
1063 imx258_stop_streaming(imx258);
1064 imx258->streaming = 0;
1068 /* Verify chip ID */
1069 static int imx258_identify_module(struct imx258 *imx258)
1071 struct i2c_client *client = v4l2_get_subdevdata(&imx258->sd);
1075 ret = imx258_read_reg(imx258, IMX258_REG_CHIP_ID,
1076 IMX258_REG_VALUE_16BIT, &val);
1078 dev_err(&client->dev, "failed to read chip id %x\n",
1083 if (val != IMX258_CHIP_ID) {
1084 dev_err(&client->dev, "chip id mismatch: %x!=%x\n",
1085 IMX258_CHIP_ID, val);
1092 static const struct v4l2_subdev_video_ops imx258_video_ops = {
1093 .s_stream = imx258_set_stream,
1096 static const struct v4l2_subdev_pad_ops imx258_pad_ops = {
1097 .enum_mbus_code = imx258_enum_mbus_code,
1098 .get_fmt = imx258_get_pad_format,
1099 .set_fmt = imx258_set_pad_format,
1100 .enum_frame_size = imx258_enum_frame_size,
1103 static const struct v4l2_subdev_ops imx258_subdev_ops = {
1104 .video = &imx258_video_ops,
1105 .pad = &imx258_pad_ops,
1108 static const struct v4l2_subdev_internal_ops imx258_internal_ops = {
1109 .open = imx258_open,
1112 /* Initialize control handlers */
1113 static int imx258_init_controls(struct imx258 *imx258)
1115 struct i2c_client *client = v4l2_get_subdevdata(&imx258->sd);
1116 struct v4l2_ctrl_handler *ctrl_hdlr;
1123 ctrl_hdlr = &imx258->ctrl_handler;
1124 ret = v4l2_ctrl_handler_init(ctrl_hdlr, 8);
1128 mutex_init(&imx258->mutex);
1129 ctrl_hdlr->lock = &imx258->mutex;
1130 imx258->link_freq = v4l2_ctrl_new_int_menu(ctrl_hdlr,
1133 ARRAY_SIZE(link_freq_menu_items) - 1,
1135 link_freq_menu_items);
1137 if (imx258->link_freq)
1138 imx258->link_freq->flags |= V4L2_CTRL_FLAG_READ_ONLY;
1140 pixel_rate_max = link_freq_to_pixel_rate(link_freq_menu_items[0]);
1141 pixel_rate_min = link_freq_to_pixel_rate(link_freq_menu_items[1]);
1142 /* By default, PIXEL_RATE is read only */
1143 imx258->pixel_rate = v4l2_ctrl_new_std(ctrl_hdlr, &imx258_ctrl_ops,
1144 V4L2_CID_PIXEL_RATE,
1145 pixel_rate_min, pixel_rate_max,
1149 vblank_def = imx258->cur_mode->vts_def - imx258->cur_mode->height;
1150 vblank_min = imx258->cur_mode->vts_min - imx258->cur_mode->height;
1151 imx258->vblank = v4l2_ctrl_new_std(
1152 ctrl_hdlr, &imx258_ctrl_ops, V4L2_CID_VBLANK,
1154 IMX258_VTS_MAX - imx258->cur_mode->height, 1,
1158 imx258->vblank->flags |= V4L2_CTRL_FLAG_READ_ONLY;
1160 imx258->hblank = v4l2_ctrl_new_std(
1161 ctrl_hdlr, &imx258_ctrl_ops, V4L2_CID_HBLANK,
1162 IMX258_PPL_DEFAULT - imx258->cur_mode->width,
1163 IMX258_PPL_DEFAULT - imx258->cur_mode->width,
1165 IMX258_PPL_DEFAULT - imx258->cur_mode->width);
1168 imx258->hblank->flags |= V4L2_CTRL_FLAG_READ_ONLY;
1170 imx258->exposure = v4l2_ctrl_new_std(
1171 ctrl_hdlr, &imx258_ctrl_ops,
1172 V4L2_CID_EXPOSURE, IMX258_EXPOSURE_MIN,
1173 IMX258_EXPOSURE_MAX, IMX258_EXPOSURE_STEP,
1174 IMX258_EXPOSURE_DEFAULT);
1176 v4l2_ctrl_new_std(ctrl_hdlr, &imx258_ctrl_ops, V4L2_CID_ANALOGUE_GAIN,
1177 IMX258_ANA_GAIN_MIN, IMX258_ANA_GAIN_MAX,
1178 IMX258_ANA_GAIN_STEP, IMX258_ANA_GAIN_DEFAULT);
1180 v4l2_ctrl_new_std(ctrl_hdlr, &imx258_ctrl_ops, V4L2_CID_DIGITAL_GAIN,
1181 IMX258_DGTL_GAIN_MIN, IMX258_DGTL_GAIN_MAX,
1182 IMX258_DGTL_GAIN_STEP,
1183 IMX258_DGTL_GAIN_DEFAULT);
1185 v4l2_ctrl_new_std_menu_items(ctrl_hdlr, &imx258_ctrl_ops,
1186 V4L2_CID_TEST_PATTERN,
1187 ARRAY_SIZE(imx258_test_pattern_menu) - 1,
1188 0, 0, imx258_test_pattern_menu);
1190 if (ctrl_hdlr->error) {
1191 ret = ctrl_hdlr->error;
1192 dev_err(&client->dev, "%s control init failed (%d)\n",
1197 imx258->sd.ctrl_handler = ctrl_hdlr;
1202 v4l2_ctrl_handler_free(ctrl_hdlr);
1203 mutex_destroy(&imx258->mutex);
1208 static void imx258_free_controls(struct imx258 *imx258)
1210 v4l2_ctrl_handler_free(imx258->sd.ctrl_handler);
1211 mutex_destroy(&imx258->mutex);
1214 static int imx258_probe(struct i2c_client *client)
1216 struct imx258 *imx258;
1220 device_property_read_u32(&client->dev, "clock-frequency", &val);
1221 if (val != 19200000)
1225 * Check that the device is mounted upside down. The driver only
1226 * supports a single pixel order right now.
1228 ret = device_property_read_u32(&client->dev, "rotation", &val);
1229 if (ret || val != 180)
1232 imx258 = devm_kzalloc(&client->dev, sizeof(*imx258), GFP_KERNEL);
1236 /* Initialize subdev */
1237 v4l2_i2c_subdev_init(&imx258->sd, client, &imx258_subdev_ops);
1239 /* Check module identity */
1240 ret = imx258_identify_module(imx258);
1244 /* Set default mode to max resolution */
1245 imx258->cur_mode = &supported_modes[0];
1247 ret = imx258_init_controls(imx258);
1251 /* Initialize subdev */
1252 imx258->sd.internal_ops = &imx258_internal_ops;
1253 imx258->sd.flags |= V4L2_SUBDEV_FL_HAS_DEVNODE;
1254 imx258->sd.entity.function = MEDIA_ENT_F_CAM_SENSOR;
1256 /* Initialize source pad */
1257 imx258->pad.flags = MEDIA_PAD_FL_SOURCE;
1259 ret = media_entity_pads_init(&imx258->sd.entity, 1, &imx258->pad);
1261 goto error_handler_free;
1263 ret = v4l2_async_register_subdev_sensor_common(&imx258->sd);
1265 goto error_media_entity;
1267 pm_runtime_set_active(&client->dev);
1268 pm_runtime_enable(&client->dev);
1269 pm_runtime_idle(&client->dev);
1274 media_entity_cleanup(&imx258->sd.entity);
1277 imx258_free_controls(imx258);
1282 static int imx258_remove(struct i2c_client *client)
1284 struct v4l2_subdev *sd = i2c_get_clientdata(client);
1285 struct imx258 *imx258 = to_imx258(sd);
1287 v4l2_async_unregister_subdev(sd);
1288 media_entity_cleanup(&sd->entity);
1289 imx258_free_controls(imx258);
1291 pm_runtime_disable(&client->dev);
1292 pm_runtime_set_suspended(&client->dev);
1297 static const struct dev_pm_ops imx258_pm_ops = {
1298 SET_SYSTEM_SLEEP_PM_OPS(imx258_suspend, imx258_resume)
1302 static const struct acpi_device_id imx258_acpi_ids[] = {
1307 MODULE_DEVICE_TABLE(acpi, imx258_acpi_ids);
1310 static struct i2c_driver imx258_i2c_driver = {
1313 .pm = &imx258_pm_ops,
1314 .acpi_match_table = ACPI_PTR(imx258_acpi_ids),
1316 .probe_new = imx258_probe,
1317 .remove = imx258_remove,
1320 module_i2c_driver(imx258_i2c_driver);
1322 MODULE_AUTHOR("Yeh, Andy <andy.yeh@intel.com>");
1323 MODULE_AUTHOR("Chiang, Alan <alanx.chiang@intel.com>");
1324 MODULE_AUTHOR("Chen, Jason <jasonx.z.chen@intel.com>");
1325 MODULE_DESCRIPTION("Sony IMX258 sensor driver");
1326 MODULE_LICENSE("GPL v2");