1 // SPDX-License-Identifier: GPL-2.0
3 * imx214.c - imx214 sensor driver
5 * Copyright 2018 Qtechnology A/S
7 * Ricardo Ribalda <ribalda@kernel.org>
10 #include <linux/delay.h>
11 #include <linux/gpio/consumer.h>
12 #include <linux/i2c.h>
13 #include <linux/module.h>
14 #include <linux/pm_runtime.h>
15 #include <linux/regmap.h>
16 #include <linux/regulator/consumer.h>
17 #include <media/media-entity.h>
18 #include <media/v4l2-ctrls.h>
19 #include <media/v4l2-fwnode.h>
20 #include <media/v4l2-subdev.h>
22 #define IMX214_DEFAULT_CLK_FREQ 24000000
23 #define IMX214_DEFAULT_LINK_FREQ 480000000
24 #define IMX214_DEFAULT_PIXEL_RATE ((IMX214_DEFAULT_LINK_FREQ * 8LL) / 10)
26 #define IMX214_MBUS_CODE MEDIA_BUS_FMT_SRGGB10_1X10
28 static const char * const imx214_supply_name[] = {
34 #define IMX214_NUM_SUPPLIES ARRAY_SIZE(imx214_supply_name)
39 struct regmap *regmap;
41 struct v4l2_subdev sd;
43 struct v4l2_mbus_framefmt fmt;
44 struct v4l2_rect crop;
46 struct v4l2_ctrl_handler ctrls;
47 struct v4l2_ctrl *pixel_rate;
48 struct v4l2_ctrl *link_freq;
49 struct v4l2_ctrl *exposure;
50 struct v4l2_ctrl *unit_size;
52 struct regulator_bulk_data supplies[IMX214_NUM_SUPPLIES];
54 struct gpio_desc *enable_gpio;
57 * Serialize control access, get/set format, get selection
58 * and start streaming.
69 IMX214_TABLE_WAIT_MS = 0,
75 /*From imx214_mode_tbls.h*/
76 static const struct reg_8 mode_4096x2304[] = {
175 {IMX214_TABLE_WAIT_MS, 10},
177 {IMX214_TABLE_END, 0x00}
180 static const struct reg_8 mode_1920x1080[] = {
279 {IMX214_TABLE_WAIT_MS, 10},
281 {IMX214_TABLE_END, 0x00}
284 static const struct reg_8 mode_table_common[] = {
287 /* software standby settings */
293 /* external clock setting */
373 /* CNR parameter setting */
376 /* Moire reduction */
379 /* image enhancement */
401 {IMX214_TABLE_END, 0x00}
405 * Declare modes in order, from biggest
406 * to smallest height.
408 static const struct imx214_mode {
411 const struct reg_8 *reg_table;
416 .reg_table = mode_4096x2304,
421 .reg_table = mode_1920x1080,
425 static inline struct imx214 *to_imx214(struct v4l2_subdev *sd)
427 return container_of(sd, struct imx214, sd);
430 static int __maybe_unused imx214_power_on(struct device *dev)
432 struct i2c_client *client = to_i2c_client(dev);
433 struct v4l2_subdev *sd = i2c_get_clientdata(client);
434 struct imx214 *imx214 = to_imx214(sd);
437 ret = regulator_bulk_enable(IMX214_NUM_SUPPLIES, imx214->supplies);
439 dev_err(imx214->dev, "failed to enable regulators: %d\n", ret);
443 usleep_range(2000, 3000);
445 ret = clk_prepare_enable(imx214->xclk);
447 regulator_bulk_disable(IMX214_NUM_SUPPLIES, imx214->supplies);
448 dev_err(imx214->dev, "clk prepare enable failed\n");
452 gpiod_set_value_cansleep(imx214->enable_gpio, 1);
453 usleep_range(12000, 15000);
458 static int __maybe_unused imx214_power_off(struct device *dev)
460 struct i2c_client *client = to_i2c_client(dev);
461 struct v4l2_subdev *sd = i2c_get_clientdata(client);
462 struct imx214 *imx214 = to_imx214(sd);
464 gpiod_set_value_cansleep(imx214->enable_gpio, 0);
466 clk_disable_unprepare(imx214->xclk);
468 regulator_bulk_disable(IMX214_NUM_SUPPLIES, imx214->supplies);
469 usleep_range(10, 20);
474 static int imx214_enum_mbus_code(struct v4l2_subdev *sd,
475 struct v4l2_subdev_state *sd_state,
476 struct v4l2_subdev_mbus_code_enum *code)
481 code->code = IMX214_MBUS_CODE;
486 static int imx214_enum_frame_size(struct v4l2_subdev *subdev,
487 struct v4l2_subdev_state *sd_state,
488 struct v4l2_subdev_frame_size_enum *fse)
490 if (fse->code != IMX214_MBUS_CODE)
493 if (fse->index >= ARRAY_SIZE(imx214_modes))
496 fse->min_width = fse->max_width = imx214_modes[fse->index].width;
497 fse->min_height = fse->max_height = imx214_modes[fse->index].height;
502 #ifdef CONFIG_VIDEO_ADV_DEBUG
503 static int imx214_s_register(struct v4l2_subdev *subdev,
504 const struct v4l2_dbg_register *reg)
506 struct imx214 *imx214 = container_of(subdev, struct imx214, sd);
508 return regmap_write(imx214->regmap, reg->reg, reg->val);
511 static int imx214_g_register(struct v4l2_subdev *subdev,
512 struct v4l2_dbg_register *reg)
514 struct imx214 *imx214 = container_of(subdev, struct imx214, sd);
519 ret = regmap_read(imx214->regmap, reg->reg, &aux);
526 static const struct v4l2_subdev_core_ops imx214_core_ops = {
527 #ifdef CONFIG_VIDEO_ADV_DEBUG
528 .g_register = imx214_g_register,
529 .s_register = imx214_s_register,
533 static struct v4l2_mbus_framefmt *
534 __imx214_get_pad_format(struct imx214 *imx214,
535 struct v4l2_subdev_state *sd_state,
537 enum v4l2_subdev_format_whence which)
540 case V4L2_SUBDEV_FORMAT_TRY:
541 return v4l2_subdev_get_try_format(&imx214->sd, sd_state, pad);
542 case V4L2_SUBDEV_FORMAT_ACTIVE:
549 static int imx214_get_format(struct v4l2_subdev *sd,
550 struct v4l2_subdev_state *sd_state,
551 struct v4l2_subdev_format *format)
553 struct imx214 *imx214 = to_imx214(sd);
555 mutex_lock(&imx214->mutex);
556 format->format = *__imx214_get_pad_format(imx214, sd_state,
559 mutex_unlock(&imx214->mutex);
564 static struct v4l2_rect *
565 __imx214_get_pad_crop(struct imx214 *imx214,
566 struct v4l2_subdev_state *sd_state,
567 unsigned int pad, enum v4l2_subdev_format_whence which)
570 case V4L2_SUBDEV_FORMAT_TRY:
571 return v4l2_subdev_get_try_crop(&imx214->sd, sd_state, pad);
572 case V4L2_SUBDEV_FORMAT_ACTIVE:
573 return &imx214->crop;
579 static int imx214_set_format(struct v4l2_subdev *sd,
580 struct v4l2_subdev_state *sd_state,
581 struct v4l2_subdev_format *format)
583 struct imx214 *imx214 = to_imx214(sd);
584 struct v4l2_mbus_framefmt *__format;
585 struct v4l2_rect *__crop;
586 const struct imx214_mode *mode;
588 mutex_lock(&imx214->mutex);
590 __crop = __imx214_get_pad_crop(imx214, sd_state, format->pad,
593 mode = v4l2_find_nearest_size(imx214_modes,
594 ARRAY_SIZE(imx214_modes), width, height,
595 format->format.width,
596 format->format.height);
598 __crop->width = mode->width;
599 __crop->height = mode->height;
601 __format = __imx214_get_pad_format(imx214, sd_state, format->pad,
603 __format->width = __crop->width;
604 __format->height = __crop->height;
605 __format->code = IMX214_MBUS_CODE;
606 __format->field = V4L2_FIELD_NONE;
607 __format->colorspace = V4L2_COLORSPACE_SRGB;
608 __format->ycbcr_enc = V4L2_MAP_YCBCR_ENC_DEFAULT(__format->colorspace);
609 __format->quantization = V4L2_MAP_QUANTIZATION_DEFAULT(true,
610 __format->colorspace, __format->ycbcr_enc);
611 __format->xfer_func = V4L2_MAP_XFER_FUNC_DEFAULT(__format->colorspace);
613 format->format = *__format;
615 mutex_unlock(&imx214->mutex);
620 static int imx214_get_selection(struct v4l2_subdev *sd,
621 struct v4l2_subdev_state *sd_state,
622 struct v4l2_subdev_selection *sel)
624 struct imx214 *imx214 = to_imx214(sd);
626 if (sel->target != V4L2_SEL_TGT_CROP)
629 mutex_lock(&imx214->mutex);
630 sel->r = *__imx214_get_pad_crop(imx214, sd_state, sel->pad,
632 mutex_unlock(&imx214->mutex);
636 static int imx214_entity_init_cfg(struct v4l2_subdev *subdev,
637 struct v4l2_subdev_state *sd_state)
639 struct v4l2_subdev_format fmt = { };
641 fmt.which = sd_state ? V4L2_SUBDEV_FORMAT_TRY : V4L2_SUBDEV_FORMAT_ACTIVE;
642 fmt.format.width = imx214_modes[0].width;
643 fmt.format.height = imx214_modes[0].height;
645 imx214_set_format(subdev, sd_state, &fmt);
650 static int imx214_set_ctrl(struct v4l2_ctrl *ctrl)
652 struct imx214 *imx214 = container_of(ctrl->handler,
653 struct imx214, ctrls);
658 * Applying V4L2 control value only happens
659 * when power is up for streaming
661 if (!pm_runtime_get_if_in_use(imx214->dev))
665 case V4L2_CID_EXPOSURE:
667 vals[0] = ctrl->val >> 8;
668 ret = regmap_bulk_write(imx214->regmap, 0x202, vals, 2);
670 dev_err(imx214->dev, "Error %d\n", ret);
678 pm_runtime_put(imx214->dev);
683 static const struct v4l2_ctrl_ops imx214_ctrl_ops = {
684 .s_ctrl = imx214_set_ctrl,
688 static int imx214_write_table(struct imx214 *imx214,
689 const struct reg_8 table[])
695 for (; table->addr != IMX214_TABLE_END ; table++) {
696 if (table->addr == IMX214_TABLE_WAIT_MS) {
697 usleep_range(table->val * 1000,
698 table->val * 1000 + 500);
702 for (i = 0; i < MAX_CMD; i++) {
703 if (table[i].addr != (table[0].addr + i))
705 vals[i] = table[i].val;
708 ret = regmap_bulk_write(imx214->regmap, table->addr, vals, i);
711 dev_err(imx214->dev, "write_table error: %d\n", ret);
721 static int imx214_start_streaming(struct imx214 *imx214)
723 const struct imx214_mode *mode;
726 mutex_lock(&imx214->mutex);
727 ret = imx214_write_table(imx214, mode_table_common);
729 dev_err(imx214->dev, "could not sent common table %d\n", ret);
733 mode = v4l2_find_nearest_size(imx214_modes,
734 ARRAY_SIZE(imx214_modes), width, height,
735 imx214->fmt.width, imx214->fmt.height);
736 ret = imx214_write_table(imx214, mode->reg_table);
738 dev_err(imx214->dev, "could not sent mode table %d\n", ret);
741 ret = __v4l2_ctrl_handler_setup(&imx214->ctrls);
743 dev_err(imx214->dev, "could not sync v4l2 controls\n");
746 ret = regmap_write(imx214->regmap, 0x100, 1);
748 dev_err(imx214->dev, "could not sent start table %d\n", ret);
752 mutex_unlock(&imx214->mutex);
756 mutex_unlock(&imx214->mutex);
760 static int imx214_stop_streaming(struct imx214 *imx214)
764 ret = regmap_write(imx214->regmap, 0x100, 0);
766 dev_err(imx214->dev, "could not sent stop table %d\n", ret);
771 static int imx214_s_stream(struct v4l2_subdev *subdev, int enable)
773 struct imx214 *imx214 = to_imx214(subdev);
777 ret = pm_runtime_resume_and_get(imx214->dev);
781 ret = imx214_start_streaming(imx214);
785 ret = imx214_stop_streaming(imx214);
788 pm_runtime_put(imx214->dev);
794 pm_runtime_put(imx214->dev);
798 static int imx214_g_frame_interval(struct v4l2_subdev *subdev,
799 struct v4l2_subdev_frame_interval *fival)
801 fival->interval.numerator = 1;
802 fival->interval.denominator = IMX214_FPS;
807 static int imx214_enum_frame_interval(struct v4l2_subdev *subdev,
808 struct v4l2_subdev_state *sd_state,
809 struct v4l2_subdev_frame_interval_enum *fie)
811 const struct imx214_mode *mode;
816 mode = v4l2_find_nearest_size(imx214_modes,
817 ARRAY_SIZE(imx214_modes), width, height,
818 fie->width, fie->height);
820 fie->code = IMX214_MBUS_CODE;
821 fie->width = mode->width;
822 fie->height = mode->height;
823 fie->interval.numerator = 1;
824 fie->interval.denominator = IMX214_FPS;
829 static const struct v4l2_subdev_video_ops imx214_video_ops = {
830 .s_stream = imx214_s_stream,
831 .g_frame_interval = imx214_g_frame_interval,
832 .s_frame_interval = imx214_g_frame_interval,
835 static const struct v4l2_subdev_pad_ops imx214_subdev_pad_ops = {
836 .enum_mbus_code = imx214_enum_mbus_code,
837 .enum_frame_size = imx214_enum_frame_size,
838 .enum_frame_interval = imx214_enum_frame_interval,
839 .get_fmt = imx214_get_format,
840 .set_fmt = imx214_set_format,
841 .get_selection = imx214_get_selection,
842 .init_cfg = imx214_entity_init_cfg,
845 static const struct v4l2_subdev_ops imx214_subdev_ops = {
846 .core = &imx214_core_ops,
847 .video = &imx214_video_ops,
848 .pad = &imx214_subdev_pad_ops,
851 static const struct regmap_config sensor_regmap_config = {
854 .cache_type = REGCACHE_RBTREE,
857 static int imx214_get_regulators(struct device *dev, struct imx214 *imx214)
861 for (i = 0; i < IMX214_NUM_SUPPLIES; i++)
862 imx214->supplies[i].supply = imx214_supply_name[i];
864 return devm_regulator_bulk_get(dev, IMX214_NUM_SUPPLIES,
868 static int imx214_parse_fwnode(struct device *dev)
870 struct fwnode_handle *endpoint;
871 struct v4l2_fwnode_endpoint bus_cfg = {
872 .bus_type = V4L2_MBUS_CSI2_DPHY,
877 endpoint = fwnode_graph_get_next_endpoint(dev_fwnode(dev), NULL);
879 dev_err(dev, "endpoint node not found\n");
883 ret = v4l2_fwnode_endpoint_alloc_parse(endpoint, &bus_cfg);
885 dev_err(dev, "parsing endpoint node failed\n");
889 for (i = 0; i < bus_cfg.nr_of_link_frequencies; i++)
890 if (bus_cfg.link_frequencies[i] == IMX214_DEFAULT_LINK_FREQ)
893 if (i == bus_cfg.nr_of_link_frequencies) {
894 dev_err(dev, "link-frequencies %d not supported, Please review your DT\n",
895 IMX214_DEFAULT_LINK_FREQ);
901 v4l2_fwnode_endpoint_free(&bus_cfg);
902 fwnode_handle_put(endpoint);
906 static int imx214_probe(struct i2c_client *client)
908 struct device *dev = &client->dev;
909 struct imx214 *imx214;
910 static const s64 link_freq[] = {
911 IMX214_DEFAULT_LINK_FREQ,
913 static const struct v4l2_area unit_size = {
919 ret = imx214_parse_fwnode(dev);
923 imx214 = devm_kzalloc(dev, sizeof(*imx214), GFP_KERNEL);
929 imx214->xclk = devm_clk_get(dev, NULL);
930 if (IS_ERR(imx214->xclk)) {
931 dev_err(dev, "could not get xclk");
932 return PTR_ERR(imx214->xclk);
935 ret = clk_set_rate(imx214->xclk, IMX214_DEFAULT_CLK_FREQ);
937 dev_err(dev, "could not set xclk frequency\n");
941 ret = imx214_get_regulators(dev, imx214);
943 dev_err(dev, "cannot get regulators\n");
947 imx214->enable_gpio = devm_gpiod_get(dev, "enable", GPIOD_OUT_LOW);
948 if (IS_ERR(imx214->enable_gpio)) {
949 dev_err(dev, "cannot get enable gpio\n");
950 return PTR_ERR(imx214->enable_gpio);
953 imx214->regmap = devm_regmap_init_i2c(client, &sensor_regmap_config);
954 if (IS_ERR(imx214->regmap)) {
955 dev_err(dev, "regmap init failed\n");
956 return PTR_ERR(imx214->regmap);
959 v4l2_i2c_subdev_init(&imx214->sd, client, &imx214_subdev_ops);
962 * Enable power initially, to avoid warnings
963 * from clk_disable on power_off
965 imx214_power_on(imx214->dev);
967 pm_runtime_set_active(imx214->dev);
968 pm_runtime_enable(imx214->dev);
969 pm_runtime_idle(imx214->dev);
971 v4l2_ctrl_handler_init(&imx214->ctrls, 3);
973 imx214->pixel_rate = v4l2_ctrl_new_std(&imx214->ctrls, NULL,
974 V4L2_CID_PIXEL_RATE, 0,
975 IMX214_DEFAULT_PIXEL_RATE, 1,
976 IMX214_DEFAULT_PIXEL_RATE);
977 imx214->link_freq = v4l2_ctrl_new_int_menu(&imx214->ctrls, NULL,
979 ARRAY_SIZE(link_freq) - 1,
981 if (imx214->link_freq)
982 imx214->link_freq->flags |= V4L2_CTRL_FLAG_READ_ONLY;
986 * Values obtained reverse engineering blobs and/or devices.
987 * Ranges and functionality might be wrong.
989 * Sony, please release some register set documentation for the
992 * Yours sincerely, Ricardo.
994 imx214->exposure = v4l2_ctrl_new_std(&imx214->ctrls, &imx214_ctrl_ops,
998 imx214->unit_size = v4l2_ctrl_new_std_compound(&imx214->ctrls,
1000 V4L2_CID_UNIT_CELL_SIZE,
1001 v4l2_ctrl_ptr_create((void *)&unit_size));
1002 ret = imx214->ctrls.error;
1004 dev_err(&client->dev, "%s control init failed (%d)\n",
1009 imx214->sd.ctrl_handler = &imx214->ctrls;
1010 mutex_init(&imx214->mutex);
1011 imx214->ctrls.lock = &imx214->mutex;
1013 imx214->sd.flags |= V4L2_SUBDEV_FL_HAS_DEVNODE;
1014 imx214->pad.flags = MEDIA_PAD_FL_SOURCE;
1015 imx214->sd.dev = &client->dev;
1016 imx214->sd.entity.function = MEDIA_ENT_F_CAM_SENSOR;
1018 ret = media_entity_pads_init(&imx214->sd.entity, 1, &imx214->pad);
1020 dev_err(dev, "could not register media entity\n");
1024 imx214_entity_init_cfg(&imx214->sd, NULL);
1026 ret = v4l2_async_register_subdev_sensor(&imx214->sd);
1028 dev_err(dev, "could not register v4l2 device\n");
1035 media_entity_cleanup(&imx214->sd.entity);
1037 mutex_destroy(&imx214->mutex);
1038 v4l2_ctrl_handler_free(&imx214->ctrls);
1039 pm_runtime_disable(imx214->dev);
1044 static void imx214_remove(struct i2c_client *client)
1046 struct v4l2_subdev *sd = i2c_get_clientdata(client);
1047 struct imx214 *imx214 = to_imx214(sd);
1049 v4l2_async_unregister_subdev(&imx214->sd);
1050 media_entity_cleanup(&imx214->sd.entity);
1051 v4l2_ctrl_handler_free(&imx214->ctrls);
1053 pm_runtime_disable(&client->dev);
1054 pm_runtime_set_suspended(&client->dev);
1056 mutex_destroy(&imx214->mutex);
1059 static const struct of_device_id imx214_of_match[] = {
1060 { .compatible = "sony,imx214" },
1063 MODULE_DEVICE_TABLE(of, imx214_of_match);
1065 static const struct dev_pm_ops imx214_pm_ops = {
1066 SET_RUNTIME_PM_OPS(imx214_power_off, imx214_power_on, NULL)
1069 static struct i2c_driver imx214_i2c_driver = {
1071 .of_match_table = imx214_of_match,
1072 .pm = &imx214_pm_ops,
1075 .probe = imx214_probe,
1076 .remove = imx214_remove,
1079 module_i2c_driver(imx214_i2c_driver);
1081 MODULE_DESCRIPTION("Sony IMX214 Camera driver");
1082 MODULE_AUTHOR("Ricardo Ribalda <ribalda@kernel.org>");
1083 MODULE_LICENSE("GPL v2");