| Author | Tokens | Token Proportion | Commits | Commit Proportion |
|---|---|---|---|---|
| Mehdi Djait | 3263 | 100.00% | 1 | 100.00% |
| Total | 3263 | 1 |
// SPDX-License-Identifier: GPL-2.0 /* * Driver for the Techwell TW9900 multi-standard video decoder. * * Copyright (C) 2018 Fuzhou Rockchip Electronics Co., Ltd. * Copyright (C) 2020 Maxime Chevallier <maxime.chevallier@bootlin.com> * Copyright (C) 2023 Mehdi Djait <mehdi.djait@bootlin.com> */ #include <linux/bitfield.h> #include <linux/clk.h> #include <linux/delay.h> #include <linux/device.h> #include <linux/gpio/consumer.h> #include <linux/i2c.h> #include <linux/module.h> #include <linux/pm_runtime.h> #include <linux/regulator/consumer.h> #include <media/media-entity.h> #include <media/v4l2-async.h> #include <media/v4l2-ctrls.h> #include <media/v4l2-event.h> #include <media/v4l2-subdev.h> #define TW9900_REG_CHIP_ID 0x00 #define TW9900_REG_CHIP_STATUS 0x01 #define TW9900_REG_CHIP_STATUS_VDLOSS BIT(7) #define TW9900_REG_CHIP_STATUS_HLOCK BIT(6) #define TW9900_REG_OUT_FMT_CTL 0x03 #define TW9900_REG_OUT_FMT_CTL_STANDBY 0xA7 #define TW9900_REG_OUT_FMT_CTL_STREAMING 0xA0 #define TW9900_REG_CKHY_HSDLY 0x04 #define TW9900_REG_OUT_CTRL_I 0x05 #define TW9900_REG_ANALOG_CTL 0x06 #define TW9900_REG_CROP_HI 0x07 #define TW9900_REG_VDELAY_LO 0x08 #define TW9900_REG_VACTIVE_LO 0x09 #define TW9900_REG_HACTIVE_LO 0x0B #define TW9900_REG_CNTRL1 0x0C #define TW9900_REG_BRIGHT_CTL 0x10 #define TW9900_REG_CONTRAST_CTL 0x11 #define TW9900_REG_VBI_CNTL 0x19 #define TW9900_REG_ANAL_CTL_II 0x1A #define TW9900_REG_OUT_CTRL_II 0x1B #define TW9900_REG_STD 0x1C #define TW9900_REG_STD_AUTO_PROGRESS BIT(7) #define TW9900_STDNOW_MASK GENMASK(6, 4) #define TW9900_REG_STDR 0x1D #define TW9900_REG_MISSCNT 0x26 #define TW9900_REG_MISC_CTL_II 0x2F #define TW9900_REG_VVBI 0x55 #define TW9900_CHIP_ID 0x00 #define TW9900_STD_NTSC_M 0 #define TW9900_STD_PAL_BDGHI 1 #define TW9900_STD_AUTO 7 #define TW9900_VIDEO_POLL_TRIES 20 struct regval { u8 addr; u8 val; }; struct tw9900_mode { u32 width; u32 height; u32 std; const struct regval *reg_list; int n_regs; }; struct tw9900 { struct i2c_client *client; struct gpio_desc *reset_gpio; struct regulator *regulator; struct v4l2_subdev subdev; struct v4l2_ctrl_handler hdl; struct media_pad pad; /* Serialize access to hardware and global state. */ struct mutex mutex; bool streaming; const struct tw9900_mode *cur_mode; }; #define to_tw9900(sd) container_of(sd, struct tw9900, subdev) static const struct regval tw9900_init_regs[] = { { TW9900_REG_MISC_CTL_II, 0xE6 }, { TW9900_REG_MISSCNT, 0x24 }, { TW9900_REG_OUT_FMT_CTL, 0xA7 }, { TW9900_REG_ANAL_CTL_II, 0x0A }, { TW9900_REG_VDELAY_LO, 0x19 }, { TW9900_REG_STD, 0x00 }, { TW9900_REG_VACTIVE_LO, 0xF0 }, { TW9900_REG_STD, 0x07 }, { TW9900_REG_CKHY_HSDLY, 0x00 }, { TW9900_REG_ANALOG_CTL, 0x80 }, { TW9900_REG_CNTRL1, 0xDC }, { TW9900_REG_OUT_CTRL_I, 0x98 }, }; static const struct regval tw9900_pal_regs[] = { { TW9900_REG_STD, 0x01 }, }; static const struct regval tw9900_ntsc_regs[] = { { TW9900_REG_OUT_FMT_CTL, 0xA4 }, { TW9900_REG_VDELAY_LO, 0x12 }, { TW9900_REG_VACTIVE_LO, 0xF0 }, { TW9900_REG_CROP_HI, 0x02 }, { TW9900_REG_HACTIVE_LO, 0xD0 }, { TW9900_REG_VBI_CNTL, 0x01 }, { TW9900_REG_STD, 0x00 }, }; static const struct tw9900_mode supported_modes[] = { { .width = 720, .height = 480, .std = V4L2_STD_NTSC, .reg_list = tw9900_ntsc_regs, .n_regs = ARRAY_SIZE(tw9900_ntsc_regs), }, { .width = 720, .height = 576, .std = V4L2_STD_PAL, .reg_list = tw9900_pal_regs, .n_regs = ARRAY_SIZE(tw9900_pal_regs), }, }; static int tw9900_write_reg(struct i2c_client *client, u8 reg, u8 val) { int ret; ret = i2c_smbus_write_byte_data(client, reg, val); if (ret < 0) dev_err(&client->dev, "write reg error: %d\n", ret); return ret; } static int tw9900_write_array(struct i2c_client *client, const struct regval *regs, int n_regs) { int i, ret = 0; for (i = 0; i < n_regs; i++) { ret = tw9900_write_reg(client, regs[i].addr, regs[i].val); if (ret) return ret; } return 0; } static int tw9900_read_reg(struct i2c_client *client, u8 reg) { int ret; ret = i2c_smbus_read_byte_data(client, reg); if (ret < 0) dev_err(&client->dev, "read reg error: %d\n", ret); return ret; } static void tw9900_fill_fmt(const struct tw9900_mode *mode, struct v4l2_mbus_framefmt *fmt) { fmt->code = MEDIA_BUS_FMT_UYVY8_2X8; fmt->width = mode->width; fmt->height = mode->height; fmt->field = V4L2_FIELD_NONE; fmt->quantization = V4L2_QUANTIZATION_DEFAULT; fmt->colorspace = V4L2_COLORSPACE_SMPTE170M; fmt->xfer_func = V4L2_MAP_XFER_FUNC_DEFAULT(V4L2_COLORSPACE_SMPTE170M); fmt->ycbcr_enc = V4L2_MAP_YCBCR_ENC_DEFAULT(V4L2_COLORSPACE_SMPTE170M); } static int tw9900_get_fmt(struct v4l2_subdev *sd, struct v4l2_subdev_state *sd_state, struct v4l2_subdev_format *fmt) { struct tw9900 *tw9900 = to_tw9900(sd); struct v4l2_mbus_framefmt *mbus_fmt = &fmt->format; mutex_lock(&tw9900->mutex); tw9900_fill_fmt(tw9900->cur_mode, mbus_fmt); mutex_unlock(&tw9900->mutex); return 0; } static int tw9900_set_fmt(struct v4l2_subdev *sd, struct v4l2_subdev_state *sd_state, struct v4l2_subdev_format *fmt) { struct tw9900 *tw9900 = to_tw9900(sd); struct v4l2_mbus_framefmt *mbus_fmt = &fmt->format; mutex_lock(&tw9900->mutex); if (tw9900->streaming) { mutex_unlock(&tw9900->mutex); return -EBUSY; } tw9900_fill_fmt(tw9900->cur_mode, mbus_fmt); mutex_unlock(&tw9900->mutex); return 0; } static int tw9900_enum_mbus_code(struct v4l2_subdev *sd, struct v4l2_subdev_state *sd_state, struct v4l2_subdev_mbus_code_enum *code) { if (code->index > 0) return -EINVAL; code->code = MEDIA_BUS_FMT_UYVY8_2X8; return 0; } static int tw9900_s_ctrl(struct v4l2_ctrl *ctrl) { struct tw9900 *tw9900 = container_of(ctrl->handler, struct tw9900, hdl); int ret; if (pm_runtime_suspended(&tw9900->client->dev)) return 0; /* v4l2_ctrl_lock() locks tw9900->mutex. */ switch (ctrl->id) { case V4L2_CID_BRIGHTNESS: ret = tw9900_write_reg(tw9900->client, TW9900_REG_BRIGHT_CTL, (u8)ctrl->val); break; case V4L2_CID_CONTRAST: ret = tw9900_write_reg(tw9900->client, TW9900_REG_CONTRAST_CTL, (u8)ctrl->val); break; default: ret = -EINVAL; break; } return ret; } static int tw9900_s_stream(struct v4l2_subdev *sd, int on) { struct tw9900 *tw9900 = to_tw9900(sd); struct i2c_client *client = tw9900->client; int ret; mutex_lock(&tw9900->mutex); if (tw9900->streaming == on) { mutex_unlock(&tw9900->mutex); return 0; } mutex_unlock(&tw9900->mutex); if (on) { ret = pm_runtime_resume_and_get(&client->dev); if (ret < 0) return ret; mutex_lock(&tw9900->mutex); ret = __v4l2_ctrl_handler_setup(sd->ctrl_handler); if (ret) goto err_unlock; ret = tw9900_write_array(tw9900->client, tw9900->cur_mode->reg_list, tw9900->cur_mode->n_regs); if (ret) goto err_unlock; ret = tw9900_write_reg(client, TW9900_REG_OUT_FMT_CTL, TW9900_REG_OUT_FMT_CTL_STREAMING); if (ret) goto err_unlock; tw9900->streaming = on; mutex_unlock(&tw9900->mutex); } else { mutex_lock(&tw9900->mutex); ret = tw9900_write_reg(client, TW9900_REG_OUT_FMT_CTL, TW9900_REG_OUT_FMT_CTL_STANDBY); if (ret) goto err_unlock; tw9900->streaming = on; mutex_unlock(&tw9900->mutex); pm_runtime_put(&client->dev); } return 0; err_unlock: mutex_unlock(&tw9900->mutex); pm_runtime_put(&client->dev); return ret; } static int tw9900_subscribe_event(struct v4l2_subdev *sd, struct v4l2_fh *fh, struct v4l2_event_subscription *sub) { switch (sub->type) { case V4L2_EVENT_SOURCE_CHANGE: return v4l2_src_change_event_subdev_subscribe(sd, fh, sub); case V4L2_EVENT_CTRL: return v4l2_ctrl_subdev_subscribe_event(sd, fh, sub); default: return -EINVAL; } } static int tw9900_s_std(struct v4l2_subdev *sd, v4l2_std_id std) { struct tw9900 *tw9900 = to_tw9900(sd); const struct tw9900_mode *mode = NULL; int i; if (!(std & (V4L2_STD_NTSC | V4L2_STD_PAL))) return -EINVAL; for (i = 0; i < ARRAY_SIZE(supported_modes); i++) if (supported_modes[i].std & std) mode = &supported_modes[i]; if (!mode) return -EINVAL; mutex_lock(&tw9900->mutex); tw9900->cur_mode = mode; mutex_unlock(&tw9900->mutex); return 0; } static int tw9900_get_stream_std(struct tw9900 *tw9900, v4l2_std_id *std) { int cur_std, ret; lockdep_assert_held(&tw9900->mutex); ret = tw9900_read_reg(tw9900->client, TW9900_REG_STD); if (ret < 0) { *std = V4L2_STD_UNKNOWN; return ret; } cur_std = FIELD_GET(TW9900_STDNOW_MASK, ret); switch (cur_std) { case TW9900_STD_NTSC_M: *std = V4L2_STD_NTSC; break; case TW9900_STD_PAL_BDGHI: *std = V4L2_STD_PAL; break; case TW9900_STD_AUTO: *std = V4L2_STD_UNKNOWN; break; default: *std = V4L2_STD_UNKNOWN; break; } return 0; } static int tw9900_g_std(struct v4l2_subdev *sd, v4l2_std_id *std) { struct tw9900 *tw9900 = to_tw9900(sd); mutex_lock(&tw9900->mutex); *std = tw9900->cur_mode->std; mutex_unlock(&tw9900->mutex); return 0; } static int tw9900_start_autodetect(struct tw9900 *tw9900) { int ret; lockdep_assert_held(&tw9900->mutex); ret = tw9900_write_reg(tw9900->client, TW9900_REG_STDR, BIT(TW9900_STD_NTSC_M) | BIT(TW9900_STD_PAL_BDGHI)); if (ret) return ret; ret = tw9900_write_reg(tw9900->client, TW9900_REG_STD, TW9900_STD_AUTO); if (ret) return ret; ret = tw9900_write_reg(tw9900->client, TW9900_REG_STDR, BIT(TW9900_STD_NTSC_M) | BIT(TW9900_STD_PAL_BDGHI) | BIT(TW9900_STD_AUTO)); if (ret) return ret; /* * Autodetect takes a while to start, and during the starting sequence * the autodetection status is reported as done. */ msleep(30); return 0; } static int tw9900_detect_done(struct tw9900 *tw9900, bool *done) { int ret; lockdep_assert_held(&tw9900->mutex); ret = tw9900_read_reg(tw9900->client, TW9900_REG_STD); if (ret < 0) return ret; *done = !(ret & TW9900_REG_STD_AUTO_PROGRESS); return 0; } static int tw9900_querystd(struct v4l2_subdev *sd, v4l2_std_id *std) { struct tw9900 *tw9900 = to_tw9900(sd); bool done = false; int i, ret; mutex_lock(&tw9900->mutex); if (tw9900->streaming) { mutex_unlock(&tw9900->mutex); return -EBUSY; } mutex_unlock(&tw9900->mutex); ret = pm_runtime_resume_and_get(&tw9900->client->dev); if (ret < 0) return ret; mutex_lock(&tw9900->mutex); ret = tw9900_start_autodetect(tw9900); if (ret) goto out_unlock; for (i = 0; i < TW9900_VIDEO_POLL_TRIES; i++) { ret = tw9900_detect_done(tw9900, &done); if (ret) goto out_unlock; if (done) break; msleep(20); } if (!done) { ret = -ETIMEDOUT; goto out_unlock; } ret = tw9900_get_stream_std(tw9900, std); out_unlock: mutex_unlock(&tw9900->mutex); pm_runtime_put(&tw9900->client->dev); return ret; } static int tw9900_g_tvnorms(struct v4l2_subdev *sd, v4l2_std_id *std) { *std = V4L2_STD_NTSC | V4L2_STD_PAL; return 0; } static int tw9900_g_input_status(struct v4l2_subdev *sd, u32 *status) { struct tw9900 *tw9900 = to_tw9900(sd); int ret; mutex_lock(&tw9900->mutex); if (tw9900->streaming) { mutex_unlock(&tw9900->mutex); return -EBUSY; } mutex_unlock(&tw9900->mutex); *status = V4L2_IN_ST_NO_SIGNAL; ret = pm_runtime_resume_and_get(&tw9900->client->dev); if (ret < 0) return ret; mutex_lock(&tw9900->mutex); ret = tw9900_read_reg(tw9900->client, TW9900_REG_CHIP_STATUS); mutex_unlock(&tw9900->mutex); pm_runtime_put(&tw9900->client->dev); if (ret < 0) return ret; *status = ret & TW9900_REG_CHIP_STATUS_HLOCK ? 0 : V4L2_IN_ST_NO_SIGNAL; return 0; } static const struct v4l2_subdev_core_ops tw9900_core_ops = { .subscribe_event = tw9900_subscribe_event, .unsubscribe_event = v4l2_event_subdev_unsubscribe, }; static const struct v4l2_subdev_video_ops tw9900_video_ops = { .s_std = tw9900_s_std, .g_std = tw9900_g_std, .querystd = tw9900_querystd, .g_tvnorms = tw9900_g_tvnorms, .g_input_status = tw9900_g_input_status, .s_stream = tw9900_s_stream, }; static const struct v4l2_subdev_pad_ops tw9900_pad_ops = { .enum_mbus_code = tw9900_enum_mbus_code, .get_fmt = tw9900_get_fmt, .set_fmt = tw9900_set_fmt, }; static const struct v4l2_subdev_ops tw9900_subdev_ops = { .core = &tw9900_core_ops, .video = &tw9900_video_ops, .pad = &tw9900_pad_ops, }; static const struct v4l2_ctrl_ops tw9900_ctrl_ops = { .s_ctrl = tw9900_s_ctrl, }; static int tw9900_check_id(struct tw9900 *tw9900, struct i2c_client *client) { struct device *dev = &tw9900->client->dev; int ret; ret = pm_runtime_resume_and_get(&tw9900->client->dev); if (ret < 0) return ret; mutex_lock(&tw9900->mutex); ret = tw9900_read_reg(client, TW9900_CHIP_ID); mutex_unlock(&tw9900->mutex); pm_runtime_put(&tw9900->client->dev); if (ret < 0) return ret; if (ret != TW9900_CHIP_ID) { dev_err(dev, "Unexpected decoder id %#x\n", ret); return -ENODEV; } return 0; } static int tw9900_runtime_resume(struct device *dev) { struct i2c_client *client = to_i2c_client(dev); struct v4l2_subdev *sd = i2c_get_clientdata(client); struct tw9900 *tw9900 = to_tw9900(sd); int ret; mutex_lock(&tw9900->mutex); if (tw9900->reset_gpio) gpiod_set_value_cansleep(tw9900->reset_gpio, 1); ret = regulator_enable(tw9900->regulator); if (ret < 0) { mutex_unlock(&tw9900->mutex); return ret; } usleep_range(50000, 52000); if (tw9900->reset_gpio) gpiod_set_value_cansleep(tw9900->reset_gpio, 0); usleep_range(1000, 2000); ret = tw9900_write_array(tw9900->client, tw9900_init_regs, ARRAY_SIZE(tw9900_init_regs)); mutex_unlock(&tw9900->mutex); /* This sleep is needed for the Horizontal Sync PLL to lock. */ msleep(300); return ret; } static int tw9900_runtime_suspend(struct device *dev) { struct i2c_client *client = to_i2c_client(dev); struct v4l2_subdev *sd = i2c_get_clientdata(client); struct tw9900 *tw9900 = to_tw9900(sd); mutex_lock(&tw9900->mutex); if (tw9900->reset_gpio) gpiod_set_value_cansleep(tw9900->reset_gpio, 1); regulator_disable(tw9900->regulator); mutex_unlock(&tw9900->mutex); return 0; } static int tw9900_probe(struct i2c_client *client) { struct device *dev = &client->dev; struct v4l2_ctrl_handler *hdl; struct tw9900 *tw9900; int ret = 0; tw9900 = devm_kzalloc(dev, sizeof(*tw9900), GFP_KERNEL); if (!tw9900) return -ENOMEM; tw9900->client = client; tw9900->cur_mode = &supported_modes[0]; tw9900->reset_gpio = devm_gpiod_get_optional(dev, "reset", GPIOD_OUT_LOW); if (IS_ERR(tw9900->reset_gpio)) return dev_err_probe(dev, PTR_ERR(tw9900->reset_gpio), "Failed to get reset gpio\n"); tw9900->regulator = devm_regulator_get(&tw9900->client->dev, "vdd"); if (IS_ERR(tw9900->regulator)) return dev_err_probe(dev, PTR_ERR(tw9900->regulator), "Failed to get power regulator\n"); v4l2_i2c_subdev_init(&tw9900->subdev, client, &tw9900_subdev_ops); tw9900->subdev.flags |= V4L2_SUBDEV_FL_HAS_DEVNODE | V4L2_SUBDEV_FL_HAS_EVENTS; mutex_init(&tw9900->mutex); hdl = &tw9900->hdl; ret = v4l2_ctrl_handler_init(hdl, 2); if (ret) goto err_destory_mutex; hdl->lock = &tw9900->mutex; v4l2_ctrl_new_std(hdl, &tw9900_ctrl_ops, V4L2_CID_BRIGHTNESS, -128, 127, 1, 0); v4l2_ctrl_new_std(hdl, &tw9900_ctrl_ops, V4L2_CID_CONTRAST, 0, 255, 1, 0x60); tw9900->subdev.ctrl_handler = hdl; if (hdl->error) { ret = hdl->error; goto err_free_handler; } tw9900->pad.flags = MEDIA_PAD_FL_SOURCE; tw9900->subdev.entity.function = MEDIA_ENT_F_DV_DECODER; ret = media_entity_pads_init(&tw9900->subdev.entity, 1, &tw9900->pad); if (ret < 0) goto err_free_handler; pm_runtime_set_suspended(dev); pm_runtime_enable(dev); ret = tw9900_check_id(tw9900, client); if (ret) goto err_disable_pm; ret = v4l2_async_register_subdev(&tw9900->subdev); if (ret) { dev_err(dev, "v4l2 async register subdev failed\n"); goto err_disable_pm; } return 0; err_disable_pm: pm_runtime_disable(dev); media_entity_cleanup(&tw9900->subdev.entity); err_free_handler: v4l2_ctrl_handler_free(hdl); err_destory_mutex: mutex_destroy(&tw9900->mutex); return ret; } static void tw9900_remove(struct i2c_client *client) { struct v4l2_subdev *sd = i2c_get_clientdata(client); struct tw9900 *tw9900 = to_tw9900(sd); v4l2_async_unregister_subdev(sd); media_entity_cleanup(&sd->entity); v4l2_ctrl_handler_free(sd->ctrl_handler); pm_runtime_disable(&client->dev); mutex_destroy(&tw9900->mutex); } static const struct dev_pm_ops tw9900_pm_ops = { .runtime_suspend = tw9900_runtime_suspend, .runtime_resume = tw9900_runtime_resume, }; static const struct i2c_device_id tw9900_id[] = { { "tw9900", 0 }, { } }; MODULE_DEVICE_TABLE(i2c, tw9900_id); static const struct of_device_id tw9900_of_match[] = { { .compatible = "techwell,tw9900" }, {}, }; MODULE_DEVICE_TABLE(of, tw9900_of_match); static struct i2c_driver tw9900_i2c_driver = { .driver = { .name = "tw9900", .pm = &tw9900_pm_ops, .of_match_table = tw9900_of_match, }, .probe = tw9900_probe, .remove = tw9900_remove, .id_table = tw9900_id, }; module_i2c_driver(tw9900_i2c_driver); MODULE_DESCRIPTION("tw9900 decoder driver"); MODULE_LICENSE("GPL");
Information contained on this website is for historical information purposes only and does not indicate or represent copyright ownership.
Created with Cregit http://github.com/cregit/cregit
Version 2.0-RC1