twx-linux/drivers/gpu/drm/bridge/rk1000.c

/*
 * Driver for rockchip rk1000 tv encoder
 *  Copyright (C) 2017 Fuzhou Rockchip Electronics Co.Ltd
 *  Author:
 *      Algea Cao <algea.cao@rock-chips.com>
 *  This program is free software; you can redistribute  it and/or modify it
 *  under  the terms of  the GNU General  Public License as published by the
 *  Free Software Foundation;  either version 2 of the  License, or (at your
 *  option) any later version.
 */
#include <linux/delay.h>
#include <linux/i2c.h>
#include <linux/module.h>
#include <linux/mutex.h>
#include <linux/regmap.h>
#include <linux/mfd/syscon.h>

#include <drm/drm_atomic_helper.h>
#include <drm/drm_crtc_helper.h>
#include <drm/drm_of.h>
#include <drm/drm_probe_helper.h>

#include "../rockchip/rockchip_drm_drv.h"

#define TVE_POWCR 0x03
#define TVE_OFF 0X07
#define TVE_ON 0x03

static const struct drm_display_mode rk1000_cvbs_mode[2] = {
	{ DRM_MODE("720x576", DRM_MODE_TYPE_DRIVER, 27000, 720, 732,
		   738, 864, 0, 576, 582, 588, 625, 0,
		   DRM_MODE_FLAG_NHSYNC | DRM_MODE_FLAG_NVSYNC),
		   0, },
	{ DRM_MODE("720x480", DRM_MODE_TYPE_DRIVER, 27000, 720, 736,
		   742, 858, 0, 480, 486, 492, 529, 0,
		   DRM_MODE_FLAG_NHSYNC | DRM_MODE_FLAG_NVSYNC),
		   0, },
};

struct rk1000_tve {
	struct device *dev;
	struct i2c_client *client;
	struct drm_connector connector;
	struct drm_bridge bridge;
	struct drm_encoder *encoder;
	int mode;
	struct regmap *ctlmap;
	struct regmap *tvemap;
	u32 preferred_mode;
	struct rockchip_drm_sub_dev sub_dev;
};

enum {
	CVBS_NTSC = 0,
	CVBS_PAL,
};

static const u8 pal_tve_regs[] = {0x06, 0x00, 0x00, 0x03, 0x00, 0x00};
static const u8 pal_ctl_regs[] = {0x41, 0x01};

static const u8 ntsc_tve_regs[] = {0x00, 0x00, 0x00, 0x03, 0x00, 0x00};
static const u8 ntsc_ctl_regs[] = {0x43, 0x01};

static const struct regmap_range rk1000_tve_volatile_ranges[] = {
	{ .range_min = 0x00, .range_max = 0x05 },
};

static const struct regmap_access_table rk1000_tve_reg_table = {
	.yes_ranges = rk1000_tve_volatile_ranges,
	.n_yes_ranges = ARRAY_SIZE(rk1000_tve_volatile_ranges),
};

static const struct regmap_config rk1000_tve_regmap_config = {
	.reg_bits = 8,
	.val_bits = 8,
	.cache_type = REGCACHE_RBTREE,
	.volatile_table = &rk1000_tve_reg_table,
};

static const struct regmap_range rk1000_ctl_volatile_ranges[] = {
	{ .range_min = 0x03, .range_max = 0x04 },
};

static const struct regmap_access_table rk1000_ctl_reg_table = {
	.yes_ranges = rk1000_ctl_volatile_ranges,
	.n_yes_ranges = ARRAY_SIZE(rk1000_ctl_volatile_ranges),
};

static const struct regmap_config rk1000_ctl_regmap_config = {
	.reg_bits = 8,
	.val_bits = 8,
	.cache_type = REGCACHE_RBTREE,
	.volatile_table = &rk1000_ctl_reg_table,
};

static struct rk1000_tve *bridge_to_rk1000(struct drm_bridge *bridge)
{
	return container_of(bridge, struct rk1000_tve, bridge);
}

static struct rk1000_tve *connector_to_rk1000(struct drm_connector *connector)
{
	return container_of(connector, struct rk1000_tve, connector);
}

static int rk1000_tv_write_block(struct rk1000_tve *rk1000,
				 u8 reg, const u8 *buf, u8 len)
{
	int i, ret = 0;

	for (i = 0; i < len; i++) {
		ret = regmap_write(rk1000->tvemap, reg + i, buf[i]);
		if (ret)
			break;
	}

	return ret;
}

static int rk1000_control_write_block(struct rk1000_tve *rk1000,
				      u8 reg, const u8 *buf, u8 len)
{
	int i, ret = 0;

	for (i = 0; i < len; i++) {
		ret = regmap_write(rk1000->ctlmap, reg + i, buf[i]);
		if (ret)
			break;
	}

	return ret;
}

static int rk1000_mode_set(struct rk1000_tve *rk1000)
{
	int ret;
	const u8 *tv_regs, *control_regs;

	switch (rk1000->mode) {
	case CVBS_PAL:
		dev_dbg(rk1000->dev, "rk1000 PAL\n");
		tv_regs = pal_tve_regs;
		control_regs = pal_ctl_regs;
		break;
	case CVBS_NTSC:
		dev_dbg(rk1000->dev, "rk1000 NTSC\n");
		tv_regs = ntsc_tve_regs;
		control_regs = ntsc_ctl_regs;
		break;
	default:
		dev_dbg(rk1000->dev, "mode select err\n");
		return -EINVAL;
	}

	ret = rk1000_tv_write_block(rk1000, 0, tv_regs, 6);
	if (ret) {
		dev_err(rk1000->dev, "rk1000_tv_write_block err!\n");
		return ret;
	}

	ret = rk1000_control_write_block(rk1000, 0x03, control_regs, 2);
	if (ret < 0) {
		dev_err(rk1000->dev, "rk1000 control write block err\n");
		return ret;
	}

	return ret;
}

static int rk1000_tve_disable(struct rk1000_tve *rk1000)
{
	int ret;
	u8 val;

	val = TVE_OFF;
	ret = rk1000_tv_write_block(rk1000, TVE_POWCR, &val, 1);

	return ret;
}

static int rk1000_tve_enable(struct rk1000_tve *rk1000)
{
	int ret;
	u8 val;

	dev_dbg(rk1000->dev, "%s\n", __func__);
	ret = rk1000_mode_set(rk1000);
	if (ret)
		return ret;

	val = TVE_ON;
	ret = rk1000_tv_write_block(rk1000, TVE_POWCR, &val, 1);
	if (ret)
		return ret;

	return 0;
}

static enum drm_mode_status
rk1000_mode_valid(struct drm_connector *connector,
		  struct drm_display_mode *mode)
{
	return MODE_OK;
}

static int
rk1000_get_modes(struct drm_connector *connector)
{
	int count;
	struct rk1000_tve *rk1000 = connector_to_rk1000(connector);

	for (count = 0; count < ARRAY_SIZE(rk1000_cvbs_mode); count++) {
		struct drm_display_mode *mode_ptr;

		mode_ptr = drm_mode_duplicate(connector->dev,
					      &rk1000_cvbs_mode[count]);
		if (!mode_ptr) {
			dev_err(rk1000->dev, "mode duplicate failed\n");
			return -ENOMEM;
		}
		if (rk1000->preferred_mode == count)
			mode_ptr->type |= DRM_MODE_TYPE_PREFERRED;
		drm_mode_probed_add(connector, mode_ptr);
	}

	return count;
}

static enum drm_connector_status
rk1000_connector_detect(struct drm_connector *connector,
			bool force)
{
	return connector_status_connected;
}

static struct drm_encoder *rk1000_best_encoder(struct drm_connector *connector)
{
	struct rk1000_tve *rk1000 = connector_to_rk1000(connector);

	return rk1000->encoder;
}

static
const struct drm_connector_helper_funcs rk1000_connector_helper_funcs = {
	.get_modes = rk1000_get_modes,
	.mode_valid = rk1000_mode_valid,
	.best_encoder = rk1000_best_encoder,
};

static const struct drm_connector_funcs rk1000_connector_funcs = {
	.fill_modes = drm_helper_probe_single_connector_modes,
	.detect = rk1000_connector_detect,
	.destroy = drm_connector_cleanup,
	.reset = drm_atomic_helper_connector_reset,
	.atomic_duplicate_state = drm_atomic_helper_connector_duplicate_state,
	.atomic_destroy_state = drm_atomic_helper_connector_destroy_state,
};

static void
rk1000_bridge_mode_set(struct drm_bridge *bridge,
		       const struct drm_display_mode *mode,
		       const struct drm_display_mode *adjusted_mode)
{
	struct rk1000_tve *rk1000;

	rk1000 = bridge_to_rk1000(bridge);
	dev_dbg(rk1000->dev, "encoder mode set:%s\n", adjusted_mode->name);

	if (adjusted_mode->vdisplay == 576)
		rk1000->mode = CVBS_PAL;
	else
		rk1000->mode = CVBS_NTSC;
}

static void rk1000_bridge_enable(struct drm_bridge *bridge)
{
	int ret;
	struct rk1000_tve *rk1000 = bridge_to_rk1000(bridge);

	dev_dbg(rk1000->dev, "%s\n",  __func__);
	ret = rk1000_tve_enable(rk1000);
	if (ret)
		dev_err(rk1000->dev, "rk1000 enable failed\n");
}

static void rk1000_bridge_disable(struct drm_bridge *bridge)
{
	struct rk1000_tve *rk1000 = bridge_to_rk1000(bridge);

	dev_dbg(rk1000->dev, "%s\n",  __func__);
	rk1000_tve_disable(rk1000);
}

static int rk1000_bridge_attach(struct drm_bridge *bridge,
				enum drm_bridge_attach_flags flags)
{
	struct rk1000_tve *rk1000 = bridge_to_rk1000(bridge);
	int ret;

	if (!bridge->encoder) {
		dev_err(rk1000->dev, "Parent encoder object not found\n");
		return -ENODEV;
	}

	rk1000->encoder = bridge->encoder;
	drm_connector_helper_add(&rk1000->connector,
				 &rk1000_connector_helper_funcs);

	ret = drm_connector_init(bridge->dev, &rk1000->connector,
				 &rk1000_connector_funcs,
				 DRM_MODE_CONNECTOR_TV);
	if (ret) {
		dev_err(rk1000->dev, "Failed to initialize connector\n");
		return ret;
	}
	ret = drm_connector_attach_encoder(&rk1000->connector,
					   bridge->encoder);
	if (ret)
		dev_err(rk1000->dev, "rk1000 attach failed ret:%d", ret);

	rk1000->sub_dev.connector = &rk1000->connector;
	rk1000->sub_dev.of_node = rk1000->dev->of_node;
	rockchip_drm_register_sub_dev(&rk1000->sub_dev);

	return ret;
}

static void rk1000_bridge_detach(struct drm_bridge *bridge)
{
	struct rk1000_tve *rk1000 = bridge_to_rk1000(bridge);

	rockchip_drm_unregister_sub_dev(&rk1000->sub_dev);
}

static struct drm_bridge_funcs rk1000_bridge_funcs = {
	.enable = rk1000_bridge_enable,
	.disable = rk1000_bridge_disable,
	.mode_set = rk1000_bridge_mode_set,
	.attach = rk1000_bridge_attach,
	.detach = rk1000_bridge_detach,
};

static int rk1000_probe(struct i2c_client *client,
			const struct i2c_device_id *id)
{
	int ret;
	struct device_node *np;
	struct device_node *ctl;
	struct rk1000_tve *rk1000;
	struct i2c_client *ctl_client;

	rk1000 = devm_kzalloc(&client->dev, sizeof(*rk1000), GFP_KERNEL);
	if (!rk1000)
		return -ENOMEM;

	np = client->dev.of_node;
	rk1000->client = client;
	rk1000->dev = &client->dev;
	rk1000->mode = CVBS_PAL;

	rk1000->tvemap = devm_regmap_init_i2c(client,
					      &rk1000_tve_regmap_config);
	if (IS_ERR(rk1000->tvemap)) {
		ret = PTR_ERR(rk1000->tvemap);
		dev_err(rk1000->dev, "Failed to initialize tve regmap: %d\n",
			ret);
		return ret;
	}

	ctl = of_parse_phandle(np, "rockchip,ctl", 0);
	if (!ctl) {
		dev_err(rk1000->dev, "rk1000 can't find control node\n");
		return -EINVAL;
	}

	ctl_client = of_find_i2c_device_by_node(ctl);
	if (!ctl_client) {
		dev_err(rk1000->dev, "rk1000 can't find control client\n");
		return -EPROBE_DEFER;
	}

	rk1000->ctlmap = devm_regmap_init_i2c(ctl_client,
					      &rk1000_ctl_regmap_config);
	if (IS_ERR(rk1000->ctlmap)) {
		ret = PTR_ERR(rk1000->ctlmap);
		dev_err(rk1000->dev, "Failed to initialize ctl regmap: %d\n",
			ret);
		return ret;
	}

	ret = of_property_read_u32(np, "rockchip,tvemode",
				   &rk1000->preferred_mode);
	if (ret < 0) {
		rk1000->preferred_mode = 0;
	} else if (rk1000->preferred_mode > 1) {
		dev_err(rk1000->dev, "rk1000 tve mode value invalid\n");
		return -EINVAL;
	}

	rk1000->bridge.funcs = &rk1000_bridge_funcs;
	rk1000->bridge.of_node = rk1000->dev->of_node;

	drm_bridge_add(&rk1000->bridge);

	i2c_set_clientdata(client, rk1000);
	dev_dbg(rk1000->dev, "rk1000 probe ok\n");

	return 0;
}

static int rk1000_remove(struct i2c_client *client)
{
	struct rk1000_tve *rk1000 = i2c_get_clientdata(client);

	drm_bridge_remove(&rk1000->bridge);

	return 0;
}

static const struct i2c_device_id rk1000_i2c_id[] = {
	{ "rk1000-tve", 0 },
	{ }
};

MODULE_DEVICE_TABLE(i2c, rk1000_i2c_id);

static const struct of_device_id rk1000_dt_ids[] = {
	{ .compatible = "rockchip,rk1000-tve" },
	{ }
};

MODULE_DEVICE_TABLE(of, rk1000_dt_ids);

static struct i2c_driver rk1000_driver = {
	.driver = {
		.name = "rk1000-tve",
		.of_match_table = of_match_ptr(rk1000_dt_ids),
	},
	.id_table = rk1000_i2c_id,
	.probe = rk1000_probe,
	.remove = rk1000_remove,
};
module_i2c_driver(rk1000_driver);

MODULE_AUTHOR("Algea Cao <Algea.cao@rock-chips.com>");
MODULE_DESCRIPTION("ROCKCHIP RK1000 Driver");
MODULE_LICENSE("GPL v2");