1 // SPDX-License-Identifier: GPL-2.0
2 // Copyright (c) 2022 Intel Corporation.
4 #include <asm/unaligned.h>
5 #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>
14 #define OG01A1B_REG_VALUE_08BIT 1
15 #define OG01A1B_REG_VALUE_16BIT 2
16 #define OG01A1B_REG_VALUE_24BIT 3
18 #define OG01A1B_LINK_FREQ_500MHZ 500000000ULL
19 #define OG01A1B_SCLK 120000000LL
20 #define OG01A1B_MCLK 19200000
21 #define OG01A1B_DATA_LANES 2
22 #define OG01A1B_RGB_DEPTH 10
24 #define OG01A1B_REG_CHIP_ID 0x300a
25 #define OG01A1B_CHIP_ID 0x470141
27 #define OG01A1B_REG_MODE_SELECT 0x0100
28 #define OG01A1B_MODE_STANDBY 0x00
29 #define OG01A1B_MODE_STREAMING 0x01
31 /* vertical-timings from sensor */
32 #define OG01A1B_REG_VTS 0x380e
33 #define OG01A1B_VTS_120FPS 0x0498
34 #define OG01A1B_VTS_120FPS_MIN 0x0498
35 #define OG01A1B_VTS_MAX 0x7fff
37 /* horizontal-timings from sensor */
38 #define OG01A1B_REG_HTS 0x380c
40 /* Exposure controls from sensor */
41 #define OG01A1B_REG_EXPOSURE 0x3501
42 #define OG01A1B_EXPOSURE_MIN 1
43 #define OG01A1B_EXPOSURE_MAX_MARGIN 14
44 #define OG01A1B_EXPOSURE_STEP 1
46 /* Analog gain controls from sensor */
47 #define OG01A1B_REG_ANALOG_GAIN 0x3508
48 #define OG01A1B_ANAL_GAIN_MIN 16
49 #define OG01A1B_ANAL_GAIN_MAX 248 /* Max = 15.5x */
50 #define OG01A1B_ANAL_GAIN_STEP 1
52 /* Digital gain controls from sensor */
53 #define OG01A1B_REG_DIG_GAIN 0x350a
54 #define OG01A1B_DGTL_GAIN_MIN 1024
55 #define OG01A1B_DGTL_GAIN_MAX 16384 /* Max = 16x */
56 #define OG01A1B_DGTL_GAIN_STEP 1
57 #define OG01A1B_DGTL_GAIN_DEFAULT 1024
60 #define OG01A1B_REG_GROUP_ACCESS 0x3208
61 #define OG01A1B_GROUP_HOLD_START 0x0
62 #define OG01A1B_GROUP_HOLD_END 0x10
63 #define OG01A1B_GROUP_HOLD_LAUNCH 0xa0
65 /* Test Pattern Control */
66 #define OG01A1B_REG_TEST_PATTERN 0x5100
67 #define OG01A1B_TEST_PATTERN_ENABLE BIT(7)
68 #define OG01A1B_TEST_PATTERN_BAR_SHIFT 2
70 #define to_og01a1b(_sd) container_of(_sd, struct og01a1b, sd)
73 OG01A1B_LINK_FREQ_1000MBPS,
81 struct og01a1b_reg_list {
83 const struct og01a1b_reg *regs;
86 struct og01a1b_link_freq_config {
87 const struct og01a1b_reg_list reg_list;
91 /* Frame width in pixels */
94 /* Frame height in pixels */
97 /* Horizontal timining size */
100 /* Default vertical timining size */
103 /* Min vertical timining size */
106 /* Link frequency needed for this resolution */
109 /* Sensor register settings for this resolution */
110 const struct og01a1b_reg_list reg_list;
113 static const struct og01a1b_reg mipi_data_rate_1000mbps[] = {
123 static const struct og01a1b_reg mode_1280x1024_regs[] = {
384 static const char * const og01a1b_test_pattern_menu[] = {
386 "Standard Color Bar",
387 "Top-Bottom Darker Color Bar",
388 "Right-Left Darker Color Bar",
389 "Bottom-Top Darker Color Bar"
392 static const s64 link_freq_menu_items[] = {
393 OG01A1B_LINK_FREQ_500MHZ,
396 static const struct og01a1b_link_freq_config link_freq_configs[] = {
397 [OG01A1B_LINK_FREQ_1000MBPS] = {
399 .num_of_regs = ARRAY_SIZE(mipi_data_rate_1000mbps),
400 .regs = mipi_data_rate_1000mbps,
405 static const struct og01a1b_mode supported_modes[] = {
410 .vts_def = OG01A1B_VTS_120FPS,
411 .vts_min = OG01A1B_VTS_120FPS_MIN,
413 .num_of_regs = ARRAY_SIZE(mode_1280x1024_regs),
414 .regs = mode_1280x1024_regs,
416 .link_freq_index = OG01A1B_LINK_FREQ_1000MBPS,
421 struct v4l2_subdev sd;
422 struct media_pad pad;
423 struct v4l2_ctrl_handler ctrl_handler;
426 struct v4l2_ctrl *link_freq;
427 struct v4l2_ctrl *pixel_rate;
428 struct v4l2_ctrl *vblank;
429 struct v4l2_ctrl *hblank;
430 struct v4l2_ctrl *exposure;
433 const struct og01a1b_mode *cur_mode;
435 /* To serialize asynchronus callbacks */
439 static u64 to_pixel_rate(u32 f_index)
441 u64 pixel_rate = link_freq_menu_items[f_index] * 2 * OG01A1B_DATA_LANES;
443 do_div(pixel_rate, OG01A1B_RGB_DEPTH);
448 static u64 to_pixels_per_line(u32 hts, u32 f_index)
450 u64 ppl = hts * to_pixel_rate(f_index);
452 do_div(ppl, OG01A1B_SCLK);
457 static int og01a1b_read_reg(struct og01a1b *og01a1b, u16 reg, u16 len, u32 *val)
459 struct i2c_client *client = v4l2_get_subdevdata(&og01a1b->sd);
460 struct i2c_msg msgs[2];
462 u8 data_buf[4] = {0};
468 put_unaligned_be16(reg, addr_buf);
469 msgs[0].addr = client->addr;
471 msgs[0].len = sizeof(addr_buf);
472 msgs[0].buf = addr_buf;
473 msgs[1].addr = client->addr;
474 msgs[1].flags = I2C_M_RD;
476 msgs[1].buf = &data_buf[4 - len];
478 ret = i2c_transfer(client->adapter, msgs, ARRAY_SIZE(msgs));
479 if (ret != ARRAY_SIZE(msgs))
482 *val = get_unaligned_be32(data_buf);
487 static int og01a1b_write_reg(struct og01a1b *og01a1b, u16 reg, u16 len, u32 val)
489 struct i2c_client *client = v4l2_get_subdevdata(&og01a1b->sd);
495 put_unaligned_be16(reg, buf);
496 put_unaligned_be32(val << 8 * (4 - len), buf + 2);
497 if (i2c_master_send(client, buf, len + 2) != len + 2)
503 static int og01a1b_write_reg_list(struct og01a1b *og01a1b,
504 const struct og01a1b_reg_list *r_list)
506 struct i2c_client *client = v4l2_get_subdevdata(&og01a1b->sd);
510 for (i = 0; i < r_list->num_of_regs; i++) {
511 ret = og01a1b_write_reg(og01a1b, r_list->regs[i].address, 1,
512 r_list->regs[i].val);
514 dev_err_ratelimited(&client->dev,
515 "failed to write reg 0x%4.4x. error = %d",
516 r_list->regs[i].address, ret);
524 static int og01a1b_test_pattern(struct og01a1b *og01a1b, u32 pattern)
527 pattern = (pattern - 1) << OG01A1B_TEST_PATTERN_BAR_SHIFT |
528 OG01A1B_TEST_PATTERN_ENABLE;
530 return og01a1b_write_reg(og01a1b, OG01A1B_REG_TEST_PATTERN,
531 OG01A1B_REG_VALUE_08BIT, pattern);
534 static int og01a1b_set_ctrl(struct v4l2_ctrl *ctrl)
536 struct og01a1b *og01a1b = container_of(ctrl->handler,
537 struct og01a1b, ctrl_handler);
538 struct i2c_client *client = v4l2_get_subdevdata(&og01a1b->sd);
542 /* Propagate change of current control to all related controls */
543 if (ctrl->id == V4L2_CID_VBLANK) {
544 /* Update max exposure while meeting expected vblanking */
545 exposure_max = og01a1b->cur_mode->height + ctrl->val -
546 OG01A1B_EXPOSURE_MAX_MARGIN;
547 __v4l2_ctrl_modify_range(og01a1b->exposure,
548 og01a1b->exposure->minimum,
549 exposure_max, og01a1b->exposure->step,
553 /* V4L2 controls values will be applied only when power is already up */
554 if (!pm_runtime_get_if_in_use(&client->dev))
558 case V4L2_CID_ANALOGUE_GAIN:
559 ret = og01a1b_write_reg(og01a1b, OG01A1B_REG_ANALOG_GAIN,
560 OG01A1B_REG_VALUE_16BIT,
564 case V4L2_CID_DIGITAL_GAIN:
565 ret = og01a1b_write_reg(og01a1b, OG01A1B_REG_DIG_GAIN,
566 OG01A1B_REG_VALUE_24BIT,
570 case V4L2_CID_EXPOSURE:
571 ret = og01a1b_write_reg(og01a1b, OG01A1B_REG_EXPOSURE,
572 OG01A1B_REG_VALUE_16BIT, ctrl->val);
575 case V4L2_CID_VBLANK:
576 ret = og01a1b_write_reg(og01a1b, OG01A1B_REG_VTS,
577 OG01A1B_REG_VALUE_16BIT,
578 og01a1b->cur_mode->height + ctrl->val);
581 case V4L2_CID_TEST_PATTERN:
582 ret = og01a1b_test_pattern(og01a1b, ctrl->val);
590 pm_runtime_put(&client->dev);
595 static const struct v4l2_ctrl_ops og01a1b_ctrl_ops = {
596 .s_ctrl = og01a1b_set_ctrl,
599 static int og01a1b_init_controls(struct og01a1b *og01a1b)
601 struct v4l2_ctrl_handler *ctrl_hdlr;
602 s64 exposure_max, h_blank;
605 ctrl_hdlr = &og01a1b->ctrl_handler;
606 ret = v4l2_ctrl_handler_init(ctrl_hdlr, 8);
610 ctrl_hdlr->lock = &og01a1b->mutex;
611 og01a1b->link_freq = v4l2_ctrl_new_int_menu(ctrl_hdlr,
615 (link_freq_menu_items) - 1,
616 0, link_freq_menu_items);
617 if (og01a1b->link_freq)
618 og01a1b->link_freq->flags |= V4L2_CTRL_FLAG_READ_ONLY;
620 og01a1b->pixel_rate = v4l2_ctrl_new_std(ctrl_hdlr, &og01a1b_ctrl_ops,
621 V4L2_CID_PIXEL_RATE, 0,
623 (OG01A1B_LINK_FREQ_1000MBPS),
626 (OG01A1B_LINK_FREQ_1000MBPS));
627 og01a1b->vblank = v4l2_ctrl_new_std(ctrl_hdlr, &og01a1b_ctrl_ops,
629 og01a1b->cur_mode->vts_min -
630 og01a1b->cur_mode->height,
632 og01a1b->cur_mode->height, 1,
633 og01a1b->cur_mode->vts_def -
634 og01a1b->cur_mode->height);
635 h_blank = to_pixels_per_line(og01a1b->cur_mode->hts,
636 og01a1b->cur_mode->link_freq_index) -
637 og01a1b->cur_mode->width;
638 og01a1b->hblank = v4l2_ctrl_new_std(ctrl_hdlr, &og01a1b_ctrl_ops,
639 V4L2_CID_HBLANK, h_blank, h_blank,
642 og01a1b->hblank->flags |= V4L2_CTRL_FLAG_READ_ONLY;
644 v4l2_ctrl_new_std(ctrl_hdlr, &og01a1b_ctrl_ops, V4L2_CID_ANALOGUE_GAIN,
645 OG01A1B_ANAL_GAIN_MIN, OG01A1B_ANAL_GAIN_MAX,
646 OG01A1B_ANAL_GAIN_STEP, OG01A1B_ANAL_GAIN_MIN);
647 v4l2_ctrl_new_std(ctrl_hdlr, &og01a1b_ctrl_ops, V4L2_CID_DIGITAL_GAIN,
648 OG01A1B_DGTL_GAIN_MIN, OG01A1B_DGTL_GAIN_MAX,
649 OG01A1B_DGTL_GAIN_STEP, OG01A1B_DGTL_GAIN_DEFAULT);
650 exposure_max = (og01a1b->cur_mode->vts_def -
651 OG01A1B_EXPOSURE_MAX_MARGIN);
652 og01a1b->exposure = v4l2_ctrl_new_std(ctrl_hdlr, &og01a1b_ctrl_ops,
654 OG01A1B_EXPOSURE_MIN,
656 OG01A1B_EXPOSURE_STEP,
658 v4l2_ctrl_new_std_menu_items(ctrl_hdlr, &og01a1b_ctrl_ops,
659 V4L2_CID_TEST_PATTERN,
660 ARRAY_SIZE(og01a1b_test_pattern_menu) - 1,
661 0, 0, og01a1b_test_pattern_menu);
663 if (ctrl_hdlr->error)
664 return ctrl_hdlr->error;
666 og01a1b->sd.ctrl_handler = ctrl_hdlr;
671 static void og01a1b_update_pad_format(const struct og01a1b_mode *mode,
672 struct v4l2_mbus_framefmt *fmt)
674 fmt->width = mode->width;
675 fmt->height = mode->height;
676 fmt->code = MEDIA_BUS_FMT_SGRBG10_1X10;
677 fmt->field = V4L2_FIELD_NONE;
680 static int og01a1b_start_streaming(struct og01a1b *og01a1b)
682 struct i2c_client *client = v4l2_get_subdevdata(&og01a1b->sd);
683 const struct og01a1b_reg_list *reg_list;
684 int link_freq_index, ret;
686 link_freq_index = og01a1b->cur_mode->link_freq_index;
687 reg_list = &link_freq_configs[link_freq_index].reg_list;
689 ret = og01a1b_write_reg_list(og01a1b, reg_list);
691 dev_err(&client->dev, "failed to set plls");
695 reg_list = &og01a1b->cur_mode->reg_list;
696 ret = og01a1b_write_reg_list(og01a1b, reg_list);
698 dev_err(&client->dev, "failed to set mode");
702 ret = __v4l2_ctrl_handler_setup(og01a1b->sd.ctrl_handler);
706 ret = og01a1b_write_reg(og01a1b, OG01A1B_REG_MODE_SELECT,
707 OG01A1B_REG_VALUE_08BIT,
708 OG01A1B_MODE_STREAMING);
710 dev_err(&client->dev, "failed to set stream");
717 static void og01a1b_stop_streaming(struct og01a1b *og01a1b)
719 struct i2c_client *client = v4l2_get_subdevdata(&og01a1b->sd);
721 if (og01a1b_write_reg(og01a1b, OG01A1B_REG_MODE_SELECT,
722 OG01A1B_REG_VALUE_08BIT, OG01A1B_MODE_STANDBY))
723 dev_err(&client->dev, "failed to set stream");
726 static int og01a1b_set_stream(struct v4l2_subdev *sd, int enable)
728 struct og01a1b *og01a1b = to_og01a1b(sd);
729 struct i2c_client *client = v4l2_get_subdevdata(sd);
732 mutex_lock(&og01a1b->mutex);
734 ret = pm_runtime_resume_and_get(&client->dev);
736 mutex_unlock(&og01a1b->mutex);
740 ret = og01a1b_start_streaming(og01a1b);
743 og01a1b_stop_streaming(og01a1b);
744 pm_runtime_put(&client->dev);
747 og01a1b_stop_streaming(og01a1b);
748 pm_runtime_put(&client->dev);
751 mutex_unlock(&og01a1b->mutex);
756 static int og01a1b_set_format(struct v4l2_subdev *sd,
757 struct v4l2_subdev_state *sd_state,
758 struct v4l2_subdev_format *fmt)
760 struct og01a1b *og01a1b = to_og01a1b(sd);
761 const struct og01a1b_mode *mode;
762 s32 vblank_def, h_blank;
764 mode = v4l2_find_nearest_size(supported_modes,
765 ARRAY_SIZE(supported_modes), width,
766 height, fmt->format.width,
769 mutex_lock(&og01a1b->mutex);
770 og01a1b_update_pad_format(mode, &fmt->format);
771 if (fmt->which == V4L2_SUBDEV_FORMAT_TRY) {
772 *v4l2_subdev_state_get_format(sd_state, fmt->pad) = fmt->format;
774 og01a1b->cur_mode = mode;
775 __v4l2_ctrl_s_ctrl(og01a1b->link_freq, mode->link_freq_index);
776 __v4l2_ctrl_s_ctrl_int64(og01a1b->pixel_rate,
777 to_pixel_rate(mode->link_freq_index));
779 /* Update limits and set FPS to default */
780 vblank_def = mode->vts_def - mode->height;
781 __v4l2_ctrl_modify_range(og01a1b->vblank,
782 mode->vts_min - mode->height,
783 OG01A1B_VTS_MAX - mode->height, 1,
785 __v4l2_ctrl_s_ctrl(og01a1b->vblank, vblank_def);
786 h_blank = to_pixels_per_line(mode->hts, mode->link_freq_index) -
788 __v4l2_ctrl_modify_range(og01a1b->hblank, h_blank, h_blank, 1,
792 mutex_unlock(&og01a1b->mutex);
797 static int og01a1b_get_format(struct v4l2_subdev *sd,
798 struct v4l2_subdev_state *sd_state,
799 struct v4l2_subdev_format *fmt)
801 struct og01a1b *og01a1b = to_og01a1b(sd);
803 mutex_lock(&og01a1b->mutex);
804 if (fmt->which == V4L2_SUBDEV_FORMAT_TRY)
805 fmt->format = *v4l2_subdev_state_get_format(sd_state,
808 og01a1b_update_pad_format(og01a1b->cur_mode, &fmt->format);
810 mutex_unlock(&og01a1b->mutex);
815 static int og01a1b_enum_mbus_code(struct v4l2_subdev *sd,
816 struct v4l2_subdev_state *sd_state,
817 struct v4l2_subdev_mbus_code_enum *code)
822 code->code = MEDIA_BUS_FMT_SGRBG10_1X10;
827 static int og01a1b_enum_frame_size(struct v4l2_subdev *sd,
828 struct v4l2_subdev_state *sd_state,
829 struct v4l2_subdev_frame_size_enum *fse)
831 if (fse->index >= ARRAY_SIZE(supported_modes))
834 if (fse->code != MEDIA_BUS_FMT_SGRBG10_1X10)
837 fse->min_width = supported_modes[fse->index].width;
838 fse->max_width = fse->min_width;
839 fse->min_height = supported_modes[fse->index].height;
840 fse->max_height = fse->min_height;
845 static int og01a1b_open(struct v4l2_subdev *sd, struct v4l2_subdev_fh *fh)
847 struct og01a1b *og01a1b = to_og01a1b(sd);
849 mutex_lock(&og01a1b->mutex);
850 og01a1b_update_pad_format(&supported_modes[0],
851 v4l2_subdev_state_get_format(fh->state, 0));
852 mutex_unlock(&og01a1b->mutex);
857 static const struct v4l2_subdev_video_ops og01a1b_video_ops = {
858 .s_stream = og01a1b_set_stream,
861 static const struct v4l2_subdev_pad_ops og01a1b_pad_ops = {
862 .set_fmt = og01a1b_set_format,
863 .get_fmt = og01a1b_get_format,
864 .enum_mbus_code = og01a1b_enum_mbus_code,
865 .enum_frame_size = og01a1b_enum_frame_size,
868 static const struct v4l2_subdev_ops og01a1b_subdev_ops = {
869 .video = &og01a1b_video_ops,
870 .pad = &og01a1b_pad_ops,
873 static const struct media_entity_operations og01a1b_subdev_entity_ops = {
874 .link_validate = v4l2_subdev_link_validate,
877 static const struct v4l2_subdev_internal_ops og01a1b_internal_ops = {
878 .open = og01a1b_open,
881 static int og01a1b_identify_module(struct og01a1b *og01a1b)
883 struct i2c_client *client = v4l2_get_subdevdata(&og01a1b->sd);
887 ret = og01a1b_read_reg(og01a1b, OG01A1B_REG_CHIP_ID,
888 OG01A1B_REG_VALUE_24BIT, &val);
892 if (val != OG01A1B_CHIP_ID) {
893 dev_err(&client->dev, "chip id mismatch: %x!=%x",
894 OG01A1B_CHIP_ID, val);
901 static int og01a1b_check_hwcfg(struct device *dev)
903 struct fwnode_handle *ep;
904 struct fwnode_handle *fwnode = dev_fwnode(dev);
905 struct v4l2_fwnode_endpoint bus_cfg = {
906 .bus_type = V4L2_MBUS_CSI2_DPHY
915 ret = fwnode_property_read_u32(fwnode, "clock-frequency", &mclk);
918 dev_err(dev, "can't get clock frequency");
922 if (mclk != OG01A1B_MCLK) {
923 dev_err(dev, "external clock %d is not supported", mclk);
927 ep = fwnode_graph_get_next_endpoint(fwnode, NULL);
931 ret = v4l2_fwnode_endpoint_alloc_parse(ep, &bus_cfg);
932 fwnode_handle_put(ep);
936 if (bus_cfg.bus.mipi_csi2.num_data_lanes != OG01A1B_DATA_LANES) {
937 dev_err(dev, "number of CSI2 data lanes %d is not supported",
938 bus_cfg.bus.mipi_csi2.num_data_lanes);
940 goto check_hwcfg_error;
943 if (!bus_cfg.nr_of_link_frequencies) {
944 dev_err(dev, "no link frequencies defined");
946 goto check_hwcfg_error;
949 for (i = 0; i < ARRAY_SIZE(link_freq_menu_items); i++) {
950 for (j = 0; j < bus_cfg.nr_of_link_frequencies; j++) {
951 if (link_freq_menu_items[i] ==
952 bus_cfg.link_frequencies[j])
956 if (j == bus_cfg.nr_of_link_frequencies) {
957 dev_err(dev, "no link frequency %lld supported",
958 link_freq_menu_items[i]);
960 goto check_hwcfg_error;
965 v4l2_fwnode_endpoint_free(&bus_cfg);
970 static void og01a1b_remove(struct i2c_client *client)
972 struct v4l2_subdev *sd = i2c_get_clientdata(client);
973 struct og01a1b *og01a1b = to_og01a1b(sd);
975 v4l2_async_unregister_subdev(sd);
976 media_entity_cleanup(&sd->entity);
977 v4l2_ctrl_handler_free(sd->ctrl_handler);
978 pm_runtime_disable(&client->dev);
979 mutex_destroy(&og01a1b->mutex);
982 static int og01a1b_probe(struct i2c_client *client)
984 struct og01a1b *og01a1b;
987 ret = og01a1b_check_hwcfg(&client->dev);
989 dev_err(&client->dev, "failed to check HW configuration: %d",
994 og01a1b = devm_kzalloc(&client->dev, sizeof(*og01a1b), GFP_KERNEL);
998 v4l2_i2c_subdev_init(&og01a1b->sd, client, &og01a1b_subdev_ops);
999 ret = og01a1b_identify_module(og01a1b);
1001 dev_err(&client->dev, "failed to find sensor: %d", ret);
1005 mutex_init(&og01a1b->mutex);
1006 og01a1b->cur_mode = &supported_modes[0];
1007 ret = og01a1b_init_controls(og01a1b);
1009 dev_err(&client->dev, "failed to init controls: %d", ret);
1010 goto probe_error_v4l2_ctrl_handler_free;
1013 og01a1b->sd.internal_ops = &og01a1b_internal_ops;
1014 og01a1b->sd.flags |= V4L2_SUBDEV_FL_HAS_DEVNODE;
1015 og01a1b->sd.entity.ops = &og01a1b_subdev_entity_ops;
1016 og01a1b->sd.entity.function = MEDIA_ENT_F_CAM_SENSOR;
1017 og01a1b->pad.flags = MEDIA_PAD_FL_SOURCE;
1018 ret = media_entity_pads_init(&og01a1b->sd.entity, 1, &og01a1b->pad);
1020 dev_err(&client->dev, "failed to init entity pads: %d", ret);
1021 goto probe_error_v4l2_ctrl_handler_free;
1024 ret = v4l2_async_register_subdev_sensor(&og01a1b->sd);
1026 dev_err(&client->dev, "failed to register V4L2 subdev: %d",
1028 goto probe_error_media_entity_cleanup;
1032 * Device is already turned on by i2c-core with ACPI domain PM.
1033 * Enable runtime PM and turn off the device.
1035 pm_runtime_set_active(&client->dev);
1036 pm_runtime_enable(&client->dev);
1037 pm_runtime_idle(&client->dev);
1041 probe_error_media_entity_cleanup:
1042 media_entity_cleanup(&og01a1b->sd.entity);
1044 probe_error_v4l2_ctrl_handler_free:
1045 v4l2_ctrl_handler_free(og01a1b->sd.ctrl_handler);
1046 mutex_destroy(&og01a1b->mutex);
1052 static const struct acpi_device_id og01a1b_acpi_ids[] = {
1057 MODULE_DEVICE_TABLE(acpi, og01a1b_acpi_ids);
1060 static struct i2c_driver og01a1b_i2c_driver = {
1063 .acpi_match_table = ACPI_PTR(og01a1b_acpi_ids),
1065 .probe = og01a1b_probe,
1066 .remove = og01a1b_remove,
1069 module_i2c_driver(og01a1b_i2c_driver);
1071 MODULE_AUTHOR("Shawn Tu");
1072 MODULE_DESCRIPTION("OmniVision OG01A1B sensor driver");
1073 MODULE_LICENSE("GPL v2");