1 // SPDX-License-Identifier: GPL-2.0
3 * Sony IMX290 CMOS Image Sensor Driver
5 * Copyright (C) 2019 FRAMOS GmbH.
7 * Copyright (C) 2019 Linaro Ltd.
8 * Author: Manivannan Sadhasivam <manivannan.sadhasivam@linaro.org>
11 #include <linux/clk.h>
12 #include <linux/delay.h>
13 #include <linux/gpio/consumer.h>
14 #include <linux/i2c.h>
15 #include <linux/module.h>
16 #include <linux/pm_runtime.h>
17 #include <linux/regmap.h>
18 #include <linux/regulator/consumer.h>
19 #include <media/media-entity.h>
20 #include <media/v4l2-ctrls.h>
21 #include <media/v4l2-device.h>
22 #include <media/v4l2-fwnode.h>
23 #include <media/v4l2-subdev.h>
25 #define IMX290_STANDBY 0x3000
26 #define IMX290_REGHOLD 0x3001
27 #define IMX290_XMSTA 0x3002
28 #define IMX290_GAIN 0x3014
30 #define IMX290_DEFAULT_LINK_FREQ 445500000
32 static const char * const imx290_supply_name[] = {
38 #define IMX290_NUM_SUPPLIES ARRAY_SIZE(imx290_supply_name)
40 struct imx290_regval {
51 const struct imx290_regval *data;
58 struct regmap *regmap;
60 struct v4l2_subdev sd;
61 struct v4l2_fwnode_endpoint ep;
63 struct v4l2_mbus_framefmt current_format;
64 const struct imx290_mode *current_mode;
66 struct regulator_bulk_data supplies[IMX290_NUM_SUPPLIES];
67 struct gpio_desc *rst_gpio;
69 struct v4l2_ctrl_handler ctrls;
70 struct v4l2_ctrl *link_freq;
71 struct v4l2_ctrl *pixel_rate;
76 struct imx290_pixfmt {
80 static const struct imx290_pixfmt imx290_formats[] = {
81 { MEDIA_BUS_FMT_SRGGB10_1X10 },
84 static const struct regmap_config imx290_regmap_config = {
87 .cache_type = REGCACHE_RBTREE,
90 static const struct imx290_regval imx290_global_init_settings[] = {
153 static const struct imx290_regval imx290_1080p_settings[] = {
171 /* data rate settings */
194 static const struct imx290_regval imx290_720p_settings[] = {
212 /* data rate settings */
235 static const struct imx290_regval imx290_10bit_settings[] = {
247 /* supported link frequencies */
248 static const s64 imx290_link_freq[] = {
249 IMX290_DEFAULT_LINK_FREQ,
253 static const struct imx290_mode imx290_modes[] = {
257 .data = imx290_1080p_settings,
258 .data_size = ARRAY_SIZE(imx290_1080p_settings),
259 .pixel_rate = 178200000,
260 .link_freq_index = 0,
265 .data = imx290_720p_settings,
266 .data_size = ARRAY_SIZE(imx290_720p_settings),
267 .pixel_rate = 178200000,
268 .link_freq_index = 0,
272 static inline struct imx290 *to_imx290(struct v4l2_subdev *_sd)
274 return container_of(_sd, struct imx290, sd);
277 static inline int imx290_read_reg(struct imx290 *imx290, u16 addr, u8 *value)
282 ret = regmap_read(imx290->regmap, addr, ®val);
284 dev_err(imx290->dev, "I2C read failed for addr: %x\n", addr);
288 *value = regval & 0xff;
293 static int imx290_write_reg(struct imx290 *imx290, u16 addr, u8 value)
297 ret = regmap_write(imx290->regmap, addr, value);
299 dev_err(imx290->dev, "I2C write failed for addr: %x\n", addr);
306 static int imx290_set_register_array(struct imx290 *imx290,
307 const struct imx290_regval *settings,
308 unsigned int num_settings)
313 for (i = 0; i < num_settings; ++i, ++settings) {
314 ret = imx290_write_reg(imx290, settings->reg, settings->val);
318 /* Settle time is 10ms for all registers */
325 static int imx290_write_buffered_reg(struct imx290 *imx290, u16 address_low,
326 u8 nr_regs, u32 value)
331 ret = imx290_write_reg(imx290, IMX290_REGHOLD, 0x01);
333 dev_err(imx290->dev, "Error setting hold register\n");
337 for (i = 0; i < nr_regs; i++) {
338 ret = imx290_write_reg(imx290, address_low + i,
339 (u8)(value >> (i * 8)));
341 dev_err(imx290->dev, "Error writing buffered registers\n");
346 ret = imx290_write_reg(imx290, IMX290_REGHOLD, 0x00);
348 dev_err(imx290->dev, "Error setting hold register\n");
355 static int imx290_set_gain(struct imx290 *imx290, u32 value)
359 ret = imx290_write_buffered_reg(imx290, IMX290_GAIN, 1, value);
361 dev_err(imx290->dev, "Unable to write gain\n");
367 static int imx290_stop_streaming(struct imx290 *imx290)
371 ret = imx290_write_reg(imx290, IMX290_STANDBY, 0x01);
377 return imx290_write_reg(imx290, IMX290_XMSTA, 0x01);
380 static int imx290_set_ctrl(struct v4l2_ctrl *ctrl)
382 struct imx290 *imx290 = container_of(ctrl->handler,
383 struct imx290, ctrls);
386 /* V4L2 controls values will be applied only when power is already up */
387 if (!pm_runtime_get_if_in_use(imx290->dev))
392 ret = imx290_set_gain(imx290, ctrl->val);
399 pm_runtime_put(imx290->dev);
404 static const struct v4l2_ctrl_ops imx290_ctrl_ops = {
405 .s_ctrl = imx290_set_ctrl,
408 static int imx290_enum_mbus_code(struct v4l2_subdev *sd,
409 struct v4l2_subdev_pad_config *cfg,
410 struct v4l2_subdev_mbus_code_enum *code)
412 if (code->index >= ARRAY_SIZE(imx290_formats))
415 code->code = imx290_formats[code->index].code;
420 static int imx290_get_fmt(struct v4l2_subdev *sd,
421 struct v4l2_subdev_pad_config *cfg,
422 struct v4l2_subdev_format *fmt)
424 struct imx290 *imx290 = to_imx290(sd);
425 struct v4l2_mbus_framefmt *framefmt;
427 mutex_lock(&imx290->lock);
429 if (fmt->which == V4L2_SUBDEV_FORMAT_TRY)
430 framefmt = v4l2_subdev_get_try_format(&imx290->sd, cfg,
433 framefmt = &imx290->current_format;
435 fmt->format = *framefmt;
437 mutex_unlock(&imx290->lock);
442 static int imx290_set_fmt(struct v4l2_subdev *sd,
443 struct v4l2_subdev_pad_config *cfg,
444 struct v4l2_subdev_format *fmt)
446 struct imx290 *imx290 = to_imx290(sd);
447 const struct imx290_mode *mode;
448 struct v4l2_mbus_framefmt *format;
451 mutex_lock(&imx290->lock);
453 mode = v4l2_find_nearest_size(imx290_modes,
454 ARRAY_SIZE(imx290_modes),
456 fmt->format.width, fmt->format.height);
458 fmt->format.width = mode->width;
459 fmt->format.height = mode->height;
461 for (i = 0; i < ARRAY_SIZE(imx290_formats); i++)
462 if (imx290_formats[i].code == fmt->format.code)
465 if (i >= ARRAY_SIZE(imx290_formats))
468 fmt->format.code = imx290_formats[i].code;
469 fmt->format.field = V4L2_FIELD_NONE;
471 if (fmt->which == V4L2_SUBDEV_FORMAT_TRY) {
472 format = v4l2_subdev_get_try_format(sd, cfg, fmt->pad);
474 format = &imx290->current_format;
475 __v4l2_ctrl_s_ctrl(imx290->link_freq, mode->link_freq_index);
476 __v4l2_ctrl_s_ctrl_int64(imx290->pixel_rate, mode->pixel_rate);
478 imx290->current_mode = mode;
481 *format = fmt->format;
483 mutex_unlock(&imx290->lock);
488 static int imx290_entity_init_cfg(struct v4l2_subdev *subdev,
489 struct v4l2_subdev_pad_config *cfg)
491 struct v4l2_subdev_format fmt = { 0 };
493 fmt.which = cfg ? V4L2_SUBDEV_FORMAT_TRY : V4L2_SUBDEV_FORMAT_ACTIVE;
494 fmt.format.width = 1920;
495 fmt.format.height = 1080;
497 imx290_set_fmt(subdev, cfg, &fmt);
502 static int imx290_write_current_format(struct imx290 *imx290,
503 struct v4l2_mbus_framefmt *format)
507 switch (format->code) {
508 case MEDIA_BUS_FMT_SRGGB10_1X10:
509 ret = imx290_set_register_array(imx290, imx290_10bit_settings,
511 imx290_10bit_settings));
513 dev_err(imx290->dev, "Could not set format registers\n");
518 dev_err(imx290->dev, "Unknown pixel format\n");
525 /* Start streaming */
526 static int imx290_start_streaming(struct imx290 *imx290)
530 /* Set init register settings */
531 ret = imx290_set_register_array(imx290, imx290_global_init_settings,
533 imx290_global_init_settings));
535 dev_err(imx290->dev, "Could not set init registers\n");
539 /* Set current frame format */
540 ret = imx290_write_current_format(imx290, &imx290->current_format);
542 dev_err(imx290->dev, "Could not set frame format\n");
546 /* Apply default values of current mode */
547 ret = imx290_set_register_array(imx290, imx290->current_mode->data,
548 imx290->current_mode->data_size);
550 dev_err(imx290->dev, "Could not set current mode\n");
554 /* Apply customized values from user */
555 ret = v4l2_ctrl_handler_setup(imx290->sd.ctrl_handler);
557 dev_err(imx290->dev, "Could not sync v4l2 controls\n");
561 ret = imx290_write_reg(imx290, IMX290_STANDBY, 0x00);
567 /* Start streaming */
568 return imx290_write_reg(imx290, IMX290_XMSTA, 0x00);
571 static int imx290_set_stream(struct v4l2_subdev *sd, int enable)
573 struct imx290 *imx290 = to_imx290(sd);
577 ret = pm_runtime_get_sync(imx290->dev);
579 pm_runtime_put_noidle(imx290->dev);
580 goto unlock_and_return;
583 ret = imx290_start_streaming(imx290);
585 dev_err(imx290->dev, "Start stream failed\n");
586 pm_runtime_put(imx290->dev);
587 goto unlock_and_return;
590 imx290_stop_streaming(imx290);
591 pm_runtime_put(imx290->dev);
599 static int imx290_get_regulators(struct device *dev, struct imx290 *imx290)
603 for (i = 0; i < IMX290_NUM_SUPPLIES; i++)
604 imx290->supplies[i].supply = imx290_supply_name[i];
606 return devm_regulator_bulk_get(dev, IMX290_NUM_SUPPLIES,
610 static int imx290_power_on(struct device *dev)
612 struct i2c_client *client = to_i2c_client(dev);
613 struct v4l2_subdev *sd = i2c_get_clientdata(client);
614 struct imx290 *imx290 = to_imx290(sd);
617 ret = clk_prepare_enable(imx290->xclk);
619 dev_err(imx290->dev, "Failed to enable clock\n");
623 ret = regulator_bulk_enable(IMX290_NUM_SUPPLIES, imx290->supplies);
625 dev_err(imx290->dev, "Failed to enable regulators\n");
626 clk_disable_unprepare(imx290->xclk);
631 gpiod_set_value_cansleep(imx290->rst_gpio, 1);
632 usleep_range(30000, 31000);
637 static int imx290_power_off(struct device *dev)
639 struct i2c_client *client = to_i2c_client(dev);
640 struct v4l2_subdev *sd = i2c_get_clientdata(client);
641 struct imx290 *imx290 = to_imx290(sd);
643 clk_disable_unprepare(imx290->xclk);
644 gpiod_set_value_cansleep(imx290->rst_gpio, 0);
645 regulator_bulk_disable(IMX290_NUM_SUPPLIES, imx290->supplies);
650 static const struct dev_pm_ops imx290_pm_ops = {
651 SET_RUNTIME_PM_OPS(imx290_power_on, imx290_power_off, NULL)
654 static const struct v4l2_subdev_video_ops imx290_video_ops = {
655 .s_stream = imx290_set_stream,
658 static const struct v4l2_subdev_pad_ops imx290_pad_ops = {
659 .init_cfg = imx290_entity_init_cfg,
660 .enum_mbus_code = imx290_enum_mbus_code,
661 .get_fmt = imx290_get_fmt,
662 .set_fmt = imx290_set_fmt,
665 static const struct v4l2_subdev_ops imx290_subdev_ops = {
666 .video = &imx290_video_ops,
667 .pad = &imx290_pad_ops,
670 static const struct media_entity_operations imx290_subdev_entity_ops = {
671 .link_validate = v4l2_subdev_link_validate,
674 static int imx290_probe(struct i2c_client *client)
676 struct device *dev = &client->dev;
677 struct fwnode_handle *endpoint;
678 struct imx290 *imx290;
682 imx290 = devm_kzalloc(dev, sizeof(*imx290), GFP_KERNEL);
687 imx290->regmap = devm_regmap_init_i2c(client, &imx290_regmap_config);
688 if (IS_ERR(imx290->regmap)) {
689 dev_err(dev, "Unable to initialize I2C\n");
693 endpoint = fwnode_graph_get_next_endpoint(dev_fwnode(dev), NULL);
695 dev_err(dev, "Endpoint node not found\n");
699 ret = v4l2_fwnode_endpoint_alloc_parse(endpoint, &imx290->ep);
700 fwnode_handle_put(endpoint);
702 dev_err(dev, "Parsing endpoint node failed\n");
706 if (!imx290->ep.nr_of_link_frequencies) {
707 dev_err(dev, "link-frequency property not found in DT\n");
712 if (imx290->ep.link_frequencies[0] != IMX290_DEFAULT_LINK_FREQ) {
713 dev_err(dev, "Unsupported link frequency\n");
718 /* Only CSI2 is supported for now */
719 if (imx290->ep.bus_type != V4L2_MBUS_CSI2_DPHY) {
720 dev_err(dev, "Unsupported bus type, should be CSI2\n");
725 /* Set default mode to max resolution */
726 imx290->current_mode = &imx290_modes[0];
728 /* get system clock (xclk) */
729 imx290->xclk = devm_clk_get(dev, "xclk");
730 if (IS_ERR(imx290->xclk)) {
731 dev_err(dev, "Could not get xclk");
732 ret = PTR_ERR(imx290->xclk);
736 ret = fwnode_property_read_u32(dev_fwnode(dev), "clock-frequency",
739 dev_err(dev, "Could not get xclk frequency\n");
743 /* external clock must be 37.125 MHz */
744 if (xclk_freq != 37125000) {
745 dev_err(dev, "External clock frequency %u is not supported\n",
751 ret = clk_set_rate(imx290->xclk, xclk_freq);
753 dev_err(dev, "Could not set xclk frequency\n");
757 ret = imx290_get_regulators(dev, imx290);
759 dev_err(dev, "Cannot get regulators\n");
763 imx290->rst_gpio = devm_gpiod_get_optional(dev, "reset", GPIOD_ASIS);
764 if (IS_ERR(imx290->rst_gpio)) {
765 dev_err(dev, "Cannot get reset gpio\n");
766 ret = PTR_ERR(imx290->rst_gpio);
770 mutex_init(&imx290->lock);
772 v4l2_ctrl_handler_init(&imx290->ctrls, 3);
774 v4l2_ctrl_new_std(&imx290->ctrls, &imx290_ctrl_ops,
775 V4L2_CID_GAIN, 0, 72, 1, 0);
777 v4l2_ctrl_new_int_menu(&imx290->ctrls,
780 ARRAY_SIZE(imx290_link_freq) - 1,
781 0, imx290_link_freq);
782 if (imx290->link_freq)
783 imx290->link_freq->flags |= V4L2_CTRL_FLAG_READ_ONLY;
785 imx290->pixel_rate = v4l2_ctrl_new_std(&imx290->ctrls, &imx290_ctrl_ops,
786 V4L2_CID_PIXEL_RATE, 1,
788 imx290_modes[0].pixel_rate);
790 imx290->sd.ctrl_handler = &imx290->ctrls;
792 if (imx290->ctrls.error) {
793 dev_err(dev, "Control initialization error %d\n",
794 imx290->ctrls.error);
795 ret = imx290->ctrls.error;
799 v4l2_i2c_subdev_init(&imx290->sd, client, &imx290_subdev_ops);
800 imx290->sd.flags |= V4L2_SUBDEV_FL_HAS_DEVNODE;
801 imx290->sd.dev = &client->dev;
802 imx290->sd.entity.ops = &imx290_subdev_entity_ops;
803 imx290->sd.entity.function = MEDIA_ENT_F_CAM_SENSOR;
805 imx290->pad.flags = MEDIA_PAD_FL_SOURCE;
806 ret = media_entity_pads_init(&imx290->sd.entity, 1, &imx290->pad);
808 dev_err(dev, "Could not register media entity\n");
812 ret = v4l2_async_register_subdev(&imx290->sd);
814 dev_err(dev, "Could not register v4l2 device\n");
818 /* Power on the device to match runtime PM state below */
819 ret = imx290_power_on(dev);
821 dev_err(dev, "Could not power on the device\n");
825 pm_runtime_set_active(dev);
826 pm_runtime_enable(dev);
827 pm_runtime_idle(dev);
829 v4l2_fwnode_endpoint_free(&imx290->ep);
834 media_entity_cleanup(&imx290->sd.entity);
836 v4l2_ctrl_handler_free(&imx290->ctrls);
837 mutex_destroy(&imx290->lock);
839 v4l2_fwnode_endpoint_free(&imx290->ep);
844 static int imx290_remove(struct i2c_client *client)
846 struct v4l2_subdev *sd = i2c_get_clientdata(client);
847 struct imx290 *imx290 = to_imx290(sd);
849 v4l2_async_unregister_subdev(sd);
850 media_entity_cleanup(&sd->entity);
851 v4l2_ctrl_handler_free(sd->ctrl_handler);
853 mutex_destroy(&imx290->lock);
855 pm_runtime_disable(imx290->dev);
856 if (!pm_runtime_status_suspended(imx290->dev))
857 imx290_power_off(imx290->dev);
858 pm_runtime_set_suspended(imx290->dev);
863 static const struct of_device_id imx290_of_match[] = {
864 { .compatible = "sony,imx290" },
867 MODULE_DEVICE_TABLE(of, imx290_of_match);
869 static struct i2c_driver imx290_i2c_driver = {
870 .probe_new = imx290_probe,
871 .remove = imx290_remove,
874 .pm = &imx290_pm_ops,
875 .of_match_table = of_match_ptr(imx290_of_match),
879 module_i2c_driver(imx290_i2c_driver);
881 MODULE_DESCRIPTION("Sony IMX290 CMOS Image Sensor Driver");
882 MODULE_AUTHOR("FRAMOS GmbH");
883 MODULE_AUTHOR("Manivannan Sadhasivam <manivannan.sadhasivam@linaro.org>");
884 MODULE_LICENSE("GPL v2");