[linux-2.6-block.git] / drivers / gpu / drm / i2c / ch7006_drv.c

/*
 * Copyright (C) 2009 Francisco Jerez.
 * All Rights Reserved.
 *
 * Permission is hereby granted, free of charge, to any person obtaining
 * a copy of this software and associated documentation files (the
 * "Software"), to deal in the Software without restriction, including
 * without limitation the rights to use, copy, modify, merge, publish,
 * distribute, sublicense, and/or sell copies of the Software, and to
 * permit persons to whom the Software is furnished to do so, subject to
 * the following conditions:
 *
 * The above copyright notice and this permission notice (including the
 * next paragraph) shall be included in all copies or substantial
 * portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
 * IN NO EVENT SHALL THE COPYRIGHT OWNER(S) AND/OR ITS SUPPLIERS BE
 * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
 * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
 * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 *
 */

#include <linux/module.h>

#include "ch7006_priv.h"

/* DRM encoder functions */

static void ch7006_encoder_set_config(struct drm_encoder *encoder,
				      void *params)
{
	struct ch7006_priv *priv = to_ch7006_priv(encoder);

	priv->params = *(struct ch7006_encoder_params *)params;
}

static void ch7006_encoder_destroy(struct drm_encoder *encoder)
{
	struct ch7006_priv *priv = to_ch7006_priv(encoder);

	drm_property_destroy(encoder->dev, priv->scale_property);

	kfree(priv);
	to_encoder_slave(encoder)->slave_priv = NULL;

	drm_i2c_encoder_destroy(encoder);
}

static void  ch7006_encoder_dpms(struct drm_encoder *encoder, int mode)
{
	struct i2c_client *client = drm_i2c_encoder_get_client(encoder);
	struct ch7006_priv *priv = to_ch7006_priv(encoder);
	struct ch7006_state *state = &priv->state;

	ch7006_dbg(client, "\n");

	if (mode == priv->last_dpms)
		return;
	priv->last_dpms = mode;

	ch7006_setup_power_state(encoder);

	ch7006_load_reg(client, state, CH7006_POWER);
}

static void ch7006_encoder_save(struct drm_encoder *encoder)
{
	struct i2c_client *client = drm_i2c_encoder_get_client(encoder);
	struct ch7006_priv *priv = to_ch7006_priv(encoder);

	ch7006_dbg(client, "\n");

	ch7006_state_save(client, &priv->saved_state);
}

static void ch7006_encoder_restore(struct drm_encoder *encoder)
{
	struct i2c_client *client = drm_i2c_encoder_get_client(encoder);
	struct ch7006_priv *priv = to_ch7006_priv(encoder);

	ch7006_dbg(client, "\n");

	ch7006_state_load(client, &priv->saved_state);
}

static bool ch7006_encoder_mode_fixup(struct drm_encoder *encoder,
				      const struct drm_display_mode *mode,
				      struct drm_display_mode *adjusted_mode)
{
	struct ch7006_priv *priv = to_ch7006_priv(encoder);

	/* The ch7006 is painfully picky with the input timings so no
	 * custom modes for now... */

	priv->mode = ch7006_lookup_mode(encoder, mode);

	return !!priv->mode;
}

static int ch7006_encoder_mode_valid(struct drm_encoder *encoder,
				     struct drm_display_mode *mode)
{
	if (ch7006_lookup_mode(encoder, mode))
		return MODE_OK;
	else
		return MODE_BAD;
}

static void ch7006_encoder_mode_set(struct drm_encoder *encoder,
				     struct drm_display_mode *drm_mode,
				     struct drm_display_mode *adjusted_mode)
{
	struct i2c_client *client = drm_i2c_encoder_get_client(encoder);
	struct ch7006_priv *priv = to_ch7006_priv(encoder);
	struct ch7006_encoder_params *params = &priv->params;
	struct ch7006_state *state = &priv->state;
	uint8_t *regs = state->regs;
	struct ch7006_mode *mode = priv->mode;
	struct ch7006_tv_norm_info *norm = &ch7006_tv_norms[priv->norm];
	int start_active;

	ch7006_dbg(client, "\n");

	regs[CH7006_DISPMODE] = norm->dispmode | mode->dispmode;
	regs[CH7006_BWIDTH] = 0;
	regs[CH7006_INPUT_FORMAT] = bitf(CH7006_INPUT_FORMAT_FORMAT,
					 params->input_format);

	regs[CH7006_CLKMODE] = CH7006_CLKMODE_SUBC_LOCK
		| bitf(CH7006_CLKMODE_XCM, params->xcm)
		| bitf(CH7006_CLKMODE_PCM, params->pcm);
	if (params->clock_mode)
		regs[CH7006_CLKMODE] |= CH7006_CLKMODE_MASTER;
	if (params->clock_edge)
		regs[CH7006_CLKMODE] |= CH7006_CLKMODE_POS_EDGE;

	start_active = (drm_mode->htotal & ~0x7) - (drm_mode->hsync_start & ~0x7);
	regs[CH7006_POV] = bitf(CH7006_POV_START_ACTIVE_8, start_active);
	regs[CH7006_START_ACTIVE] = bitf(CH7006_START_ACTIVE_0, start_active);

	regs[CH7006_INPUT_SYNC] = 0;
	if (params->sync_direction)
		regs[CH7006_INPUT_SYNC] |= CH7006_INPUT_SYNC_OUTPUT;
	if (params->sync_encoding)
		regs[CH7006_INPUT_SYNC] |= CH7006_INPUT_SYNC_EMBEDDED;
	if (drm_mode->flags & DRM_MODE_FLAG_PVSYNC)
		regs[CH7006_INPUT_SYNC] |= CH7006_INPUT_SYNC_PVSYNC;
	if (drm_mode->flags & DRM_MODE_FLAG_PHSYNC)
		regs[CH7006_INPUT_SYNC] |= CH7006_INPUT_SYNC_PHSYNC;

	regs[CH7006_DETECT] = 0;
	regs[CH7006_BCLKOUT] = 0;

	regs[CH7006_SUBC_INC3] = 0;
	if (params->pout_level)
		regs[CH7006_SUBC_INC3] |= CH7006_SUBC_INC3_POUT_3_3V;

	regs[CH7006_SUBC_INC4] = 0;
	if (params->active_detect)
		regs[CH7006_SUBC_INC4] |= CH7006_SUBC_INC4_DS_INPUT;

	regs[CH7006_PLL_CONTROL] = priv->saved_state.regs[CH7006_PLL_CONTROL];

	ch7006_setup_levels(encoder);
	ch7006_setup_subcarrier(encoder);
	ch7006_setup_pll(encoder);
	ch7006_setup_power_state(encoder);
	ch7006_setup_properties(encoder);

	ch7006_state_load(client, state);
}

static enum drm_connector_status ch7006_encoder_detect(struct drm_encoder *encoder,
						       struct drm_connector *connector)
{
	struct i2c_client *client = drm_i2c_encoder_get_client(encoder);
	struct ch7006_priv *priv = to_ch7006_priv(encoder);
	struct ch7006_state *state = &priv->state;
	int det;

	ch7006_dbg(client, "\n");

	ch7006_save_reg(client, state, CH7006_DETECT);
	ch7006_save_reg(client, state, CH7006_POWER);
	ch7006_save_reg(client, state, CH7006_CLKMODE);

	ch7006_write(client, CH7006_POWER, CH7006_POWER_RESET |
					   bitfs(CH7006_POWER_LEVEL, NORMAL));
	ch7006_write(client, CH7006_CLKMODE, CH7006_CLKMODE_MASTER);

	ch7006_write(client, CH7006_DETECT, CH7006_DETECT_SENSE);

	ch7006_write(client, CH7006_DETECT, 0);

	det = ch7006_read(client, CH7006_DETECT);

	ch7006_load_reg(client, state, CH7006_CLKMODE);
	ch7006_load_reg(client, state, CH7006_POWER);
	ch7006_load_reg(client, state, CH7006_DETECT);

	if ((det & (CH7006_DETECT_SVIDEO_Y_TEST|
		    CH7006_DETECT_SVIDEO_C_TEST|
		    CH7006_DETECT_CVBS_TEST)) == 0)
		priv->subconnector = DRM_MODE_SUBCONNECTOR_SCART;
	else if ((det & (CH7006_DETECT_SVIDEO_Y_TEST|
			 CH7006_DETECT_SVIDEO_C_TEST)) == 0)
		priv->subconnector = DRM_MODE_SUBCONNECTOR_SVIDEO;
	else if ((det & CH7006_DETECT_CVBS_TEST) == 0)
		priv->subconnector = DRM_MODE_SUBCONNECTOR_Composite;
	else
		priv->subconnector = DRM_MODE_SUBCONNECTOR_Unknown;

	drm_object_property_set_value(&connector->base,
			encoder->dev->mode_config.tv_subconnector_property,
							priv->subconnector);

	return priv->subconnector ? connector_status_connected :
					connector_status_disconnected;
}

static int ch7006_encoder_get_modes(struct drm_encoder *encoder,
				    struct drm_connector *connector)
{
	struct ch7006_priv *priv = to_ch7006_priv(encoder);
	struct ch7006_mode *mode;
	int n = 0;

	for (mode = ch7006_modes; mode->mode.clock; mode++) {
		if (~mode->valid_scales & 1<<priv->scale ||
		    ~mode->valid_norms & 1<<priv->norm)
			continue;

		drm_mode_probed_add(connector,
				drm_mode_duplicate(encoder->dev, &mode->mode));

		n++;
	}

	return n;
}

static int ch7006_encoder_create_resources(struct drm_encoder *encoder,
					   struct drm_connector *connector)
{
	struct ch7006_priv *priv = to_ch7006_priv(encoder);
	struct drm_device *dev = encoder->dev;
	struct drm_mode_config *conf = &dev->mode_config;

	drm_mode_create_tv_properties(dev, NUM_TV_NORMS, ch7006_tv_norm_names);

	priv->scale_property = drm_property_create_range(dev, 0, "scale", 0, 2);

	drm_object_attach_property(&connector->base, conf->tv_select_subconnector_property,
				      priv->select_subconnector);
	drm_object_attach_property(&connector->base, conf->tv_subconnector_property,
				      priv->subconnector);
	drm_object_attach_property(&connector->base, conf->tv_left_margin_property,
				      priv->hmargin);
	drm_object_attach_property(&connector->base, conf->tv_bottom_margin_property,
				      priv->vmargin);
	drm_object_attach_property(&connector->base, conf->tv_mode_property,
				      priv->norm);
	drm_object_attach_property(&connector->base, conf->tv_brightness_property,
				      priv->brightness);
	drm_object_attach_property(&connector->base, conf->tv_contrast_property,
				      priv->contrast);
	drm_object_attach_property(&connector->base, conf->tv_flicker_reduction_property,
				      priv->flicker);
	drm_object_attach_property(&connector->base, priv->scale_property,
				      priv->scale);

	return 0;
}

static int ch7006_encoder_set_property(struct drm_encoder *encoder,
				       struct drm_connector *connector,
				       struct drm_property *property,
				       uint64_t val)
{
	struct i2c_client *client = drm_i2c_encoder_get_client(encoder);
	struct ch7006_priv *priv = to_ch7006_priv(encoder);
	struct ch7006_state *state = &priv->state;
	struct drm_mode_config *conf = &encoder->dev->mode_config;
	struct drm_crtc *crtc = encoder->crtc;
	bool modes_changed = false;

	ch7006_dbg(client, "\n");

	if (property == conf->tv_select_subconnector_property) {
		priv->select_subconnector = val;

		ch7006_setup_power_state(encoder);

		ch7006_load_reg(client, state, CH7006_POWER);

	} else if (property == conf->tv_left_margin_property) {
		priv->hmargin = val;

		ch7006_setup_properties(encoder);

		ch7006_load_reg(client, state, CH7006_POV);
		ch7006_load_reg(client, state, CH7006_HPOS);

	} else if (property == conf->tv_bottom_margin_property) {
		priv->vmargin = val;

		ch7006_setup_properties(encoder);

		ch7006_load_reg(client, state, CH7006_POV);
		ch7006_load_reg(client, state, CH7006_VPOS);

	} else if (property == conf->tv_mode_property) {
		if (connector->dpms != DRM_MODE_DPMS_OFF)
			return -EINVAL;

		priv->norm = val;

		modes_changed = true;

	} else if (property == conf->tv_brightness_property) {
		priv->brightness = val;

		ch7006_setup_levels(encoder);

		ch7006_load_reg(client, state, CH7006_BLACK_LEVEL);

	} else if (property == conf->tv_contrast_property) {
		priv->contrast = val;

		ch7006_setup_properties(encoder);

		ch7006_load_reg(client, state, CH7006_CONTRAST);

	} else if (property == conf->tv_flicker_reduction_property) {
		priv->flicker = val;

		ch7006_setup_properties(encoder);

		ch7006_load_reg(client, state, CH7006_FFILTER);

	} else if (property == priv->scale_property) {
		if (connector->dpms != DRM_MODE_DPMS_OFF)
			return -EINVAL;

		priv->scale = val;

		modes_changed = true;

	} else {
		return -EINVAL;
	}

	if (modes_changed) {
		drm_helper_probe_single_connector_modes(connector, 0, 0);

		/* Disable the crtc to ensure a full modeset is
		 * performed whenever it's turned on again. */
		if (crtc) {
			struct drm_mode_set modeset = {
				.crtc = crtc,
			};

			drm_mode_set_config_internal(&modeset);
		}
	}

	return 0;
}

static struct drm_encoder_slave_funcs ch7006_encoder_funcs = {
	.set_config = ch7006_encoder_set_config,
	.destroy = ch7006_encoder_destroy,
	.dpms = ch7006_encoder_dpms,
	.save = ch7006_encoder_save,
	.restore = ch7006_encoder_restore,
	.mode_fixup = ch7006_encoder_mode_fixup,
	.mode_valid = ch7006_encoder_mode_valid,
	.mode_set = ch7006_encoder_mode_set,
	.detect = ch7006_encoder_detect,
	.get_modes = ch7006_encoder_get_modes,
	.create_resources = ch7006_encoder_create_resources,
	.set_property = ch7006_encoder_set_property,
};


/* I2C driver functions */

static int ch7006_probe(struct i2c_client *client, const struct i2c_device_id *id)
{
	uint8_t addr = CH7006_VERSION_ID;
	uint8_t val;
	int ret;

	ch7006_dbg(client, "\n");

	ret = i2c_master_send(client, &addr, sizeof(addr));
	if (ret < 0)
		goto fail;

	ret = i2c_master_recv(client, &val, sizeof(val));
	if (ret < 0)
		goto fail;

	ch7006_info(client, "Detected version ID: %x\n", val);

	/* I don't know what this is for, but otherwise I get no
	 * signal.
	 */
	ch7006_write(client, 0x3d, 0x0);

	return 0;

fail:
	ch7006_err(client, "Error %d reading version ID\n", ret);

	return -ENODEV;
}

static int ch7006_remove(struct i2c_client *client)
{
	ch7006_dbg(client, "\n");

	return 0;
}

static int ch7006_resume(struct device *dev)
{
	struct i2c_client *client = to_i2c_client(dev);

	ch7006_dbg(client, "\n");

	ch7006_write(client, 0x3d, 0x0);

	return 0;
}

static int ch7006_encoder_init(struct i2c_client *client,
			       struct drm_device *dev,
			       struct drm_encoder_slave *encoder)
{
	struct ch7006_priv *priv;
	int i;

	ch7006_dbg(client, "\n");

	priv = kzalloc(sizeof(*priv), GFP_KERNEL);
	if (!priv)
		return -ENOMEM;

	encoder->slave_priv = priv;
	encoder->slave_funcs = &ch7006_encoder_funcs;

	priv->norm = TV_NORM_PAL;
	priv->select_subconnector = DRM_MODE_SUBCONNECTOR_Automatic;
	priv->subconnector = DRM_MODE_SUBCONNECTOR_Unknown;
	priv->scale = 1;
	priv->contrast = 50;
	priv->brightness = 50;
	priv->flicker = 50;
	priv->hmargin = 50;
	priv->vmargin = 50;
	priv->last_dpms = -1;
	priv->chip_version = ch7006_read(client, CH7006_VERSION_ID);

	if (ch7006_tv_norm) {
		for (i = 0; i < NUM_TV_NORMS; i++) {
			if (!strcmp(ch7006_tv_norm_names[i], ch7006_tv_norm)) {
				priv->norm = i;
				break;
			}
		}

		if (i == NUM_TV_NORMS)
			ch7006_err(client, "Invalid TV norm setting \"%s\".\n",
				   ch7006_tv_norm);
	}

	if (ch7006_scale >= 0 && ch7006_scale <= 2)
		priv->scale = ch7006_scale;
	else
		ch7006_err(client, "Invalid scale setting \"%d\".\n",
			   ch7006_scale);

	return 0;
}

static struct i2c_device_id ch7006_ids[] = {
	{ "ch7006", 0 },
	{ }
};
MODULE_DEVICE_TABLE(i2c, ch7006_ids);

static const struct dev_pm_ops ch7006_pm_ops = {
	.resume = ch7006_resume,
};

static struct drm_i2c_encoder_driver ch7006_driver = {
	.i2c_driver = {
		.probe = ch7006_probe,
		.remove = ch7006_remove,

		.driver = {
			.name = "ch7006",
			.pm = &ch7006_pm_ops,
		},

		.id_table = ch7006_ids,
	},

	.encoder_init = ch7006_encoder_init,
};


/* Module initialization */

static int __init ch7006_init(void)
{
	return drm_i2c_encoder_register(THIS_MODULE, &ch7006_driver);
}

static void __exit ch7006_exit(void)
{
	drm_i2c_encoder_unregister(&ch7006_driver);
}

int ch7006_debug;
module_param_named(debug, ch7006_debug, int, 0600);
MODULE_PARM_DESC(debug, "Enable debug output.");

char *ch7006_tv_norm;
module_param_named(tv_norm, ch7006_tv_norm, charp, 0600);
MODULE_PARM_DESC(tv_norm, "Default TV norm.\n"
		 "\t\tSupported: PAL, PAL-M, PAL-N, PAL-Nc, PAL-60, NTSC-M, NTSC-J.\n"
		 "\t\tDefault: PAL");

int ch7006_scale = 1;
module_param_named(scale, ch7006_scale, int, 0600);
MODULE_PARM_DESC(scale, "Default scale.\n"
		 "\t\tSupported: 0 -> Select video modes with a higher blanking ratio.\n"
		 "\t\t\t1 -> Select default video modes.\n"
		 "\t\t\t2 -> Select video modes with a lower blanking ratio.");

MODULE_AUTHOR("Francisco Jerez <currojerez@riseup.net>");
MODULE_DESCRIPTION("Chrontel ch7006 TV encoder driver");
MODULE_LICENSE("GPL and additional rights");

module_init(ch7006_init);
module_exit(ch7006_exit);
Commit	Line	Data
6ee73861 BS	1	/*
	2	* Copyright (C) 2009 Francisco Jerez.
	3	* All Rights Reserved.
	4	*
	5	* Permission is hereby granted, free of charge, to any person obtaining
	6	* a copy of this software and associated documentation files (the
	7	* "Software"), to deal in the Software without restriction, including
	8	* without limitation the rights to use, copy, modify, merge, publish,
	9	* distribute, sublicense, and/or sell copies of the Software, and to
	10	* permit persons to whom the Software is furnished to do so, subject to
	11	* the following conditions:
	12	*
	13	* The above copyright notice and this permission notice (including the
	14	* next paragraph) shall be included in all copies or substantial
	15	* portions of the Software.
	16	*
	17	* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
	18	* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
	19	* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
	20	* IN NO EVENT SHALL THE COPYRIGHT OWNER(S) AND/OR ITS SUPPLIERS BE
	21	* LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
	22	* OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
	23	* WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
	24	*
	25	*/
	26
e0cd3608 PG	27	#include <linux/module.h>
e0cd3608 PG	28
6ee73861 BS	29	#include "ch7006_priv.h"
	30
	31	/* DRM encoder functions */
	32
	33	static void ch7006_encoder_set_config(struct drm_encoder *encoder,
	34	void *params)
	35	{
	36	struct ch7006_priv *priv = to_ch7006_priv(encoder);
	37
6d6a413a	38	priv->params = (struct ch7006_encoder_params )params;
6ee73861 BS	39	}
	40
	41	static void ch7006_encoder_destroy(struct drm_encoder *encoder)
	42	{
	43	struct ch7006_priv *priv = to_ch7006_priv(encoder);
	44
	45	drm_property_destroy(encoder->dev, priv->scale_property);
	46
	47	kfree(priv);
	48	to_encoder_slave(encoder)->slave_priv = NULL;
	49
	50	drm_i2c_encoder_destroy(encoder);
	51	}
	52
	53	static void ch7006_encoder_dpms(struct drm_encoder *encoder, int mode)
	54	{
	55	struct i2c_client *client = drm_i2c_encoder_get_client(encoder);
	56	struct ch7006_priv *priv = to_ch7006_priv(encoder);
	57	struct ch7006_state *state = &priv->state;
	58
	59	ch7006_dbg(client, "\n");
	60
	61	if (mode == priv->last_dpms)
	62	return;
	63	priv->last_dpms = mode;
	64
	65	ch7006_setup_power_state(encoder);
	66
	67	ch7006_load_reg(client, state, CH7006_POWER);
	68	}
	69
	70	static void ch7006_encoder_save(struct drm_encoder *encoder)
	71	{
	72	struct i2c_client *client = drm_i2c_encoder_get_client(encoder);
	73	struct ch7006_priv *priv = to_ch7006_priv(encoder);
	74
	75	ch7006_dbg(client, "\n");
	76
	77	ch7006_state_save(client, &priv->saved_state);
	78	}
	79
	80	static void ch7006_encoder_restore(struct drm_encoder *encoder)
	81	{
	82	struct i2c_client *client = drm_i2c_encoder_get_client(encoder);
	83	struct ch7006_priv *priv = to_ch7006_priv(encoder);
	84
	85	ch7006_dbg(client, "\n");
	86
	87	ch7006_state_load(client, &priv->saved_state);
	88	}
	89
	90	static bool ch7006_encoder_mode_fixup(struct drm_encoder *encoder,
e811f5ae	91	const struct drm_display_mode *mode,
6ee73861 BS	92	struct drm_display_mode *adjusted_mode)
	93	{
	94	struct ch7006_priv *priv = to_ch7006_priv(encoder);
	95
	96	/* The ch7006 is painfully picky with the input timings so no
	97	* custom modes for now... */
	98
	99	priv->mode = ch7006_lookup_mode(encoder, mode);
	100
	101	return !!priv->mode;
	102	}
	103
	104	static int ch7006_encoder_mode_valid(struct drm_encoder *encoder,
	105	struct drm_display_mode *mode)
	106	{
	107	if (ch7006_lookup_mode(encoder, mode))
	108	return MODE_OK;
	109	else
	110	return MODE_BAD;
	111	}
	112
	113	static void ch7006_encoder_mode_set(struct drm_encoder *encoder,
	114	struct drm_display_mode *drm_mode,
	115	struct drm_display_mode *adjusted_mode)
	116	{
	117	struct i2c_client *client = drm_i2c_encoder_get_client(encoder);
	118	struct ch7006_priv *priv = to_ch7006_priv(encoder);
6d6a413a	119	struct ch7006_encoder_params *params = &priv->params;
6ee73861 BS	120	struct ch7006_state *state = &priv->state;
	121	uint8_t *regs = state->regs;
	122	struct ch7006_mode *mode = priv->mode;
	123	struct ch7006_tv_norm_info *norm = &ch7006_tv_norms[priv->norm];
	124	int start_active;
	125
	126	ch7006_dbg(client, "\n");
	127
	128	regs[CH7006_DISPMODE] = norm->dispmode \| mode->dispmode;
	129	regs[CH7006_BWIDTH] = 0;
	130	regs[CH7006_INPUT_FORMAT] = bitf(CH7006_INPUT_FORMAT_FORMAT,
	131	params->input_format);
	132
	133	regs[CH7006_CLKMODE] = CH7006_CLKMODE_SUBC_LOCK
	134	\| bitf(CH7006_CLKMODE_XCM, params->xcm)
	135	\| bitf(CH7006_CLKMODE_PCM, params->pcm);
	136	if (params->clock_mode)
	137	regs[CH7006_CLKMODE] \|= CH7006_CLKMODE_MASTER;
	138	if (params->clock_edge)
	139	regs[CH7006_CLKMODE] \|= CH7006_CLKMODE_POS_EDGE;
	140
	141	start_active = (drm_mode->htotal & ~0x7) - (drm_mode->hsync_start & ~0x7);
	142	regs[CH7006_POV] = bitf(CH7006_POV_START_ACTIVE_8, start_active);
	143	regs[CH7006_START_ACTIVE] = bitf(CH7006_START_ACTIVE_0, start_active);
	144
	145	regs[CH7006_INPUT_SYNC] = 0;
	146	if (params->sync_direction)
	147	regs[CH7006_INPUT_SYNC] \|= CH7006_INPUT_SYNC_OUTPUT;
	148	if (params->sync_encoding)
	149	regs[CH7006_INPUT_SYNC] \|= CH7006_INPUT_SYNC_EMBEDDED;
	150	if (drm_mode->flags & DRM_MODE_FLAG_PVSYNC)
	151	regs[CH7006_INPUT_SYNC] \|= CH7006_INPUT_SYNC_PVSYNC;
	152	if (drm_mode->flags & DRM_MODE_FLAG_PHSYNC)
	153	regs[CH7006_INPUT_SYNC] \|= CH7006_INPUT_SYNC_PHSYNC;
	154
	155	regs[CH7006_DETECT] = 0;
	156	regs[CH7006_BCLKOUT] = 0;
	157
	158	regs[CH7006_SUBC_INC3] = 0;
	159	if (params->pout_level)
	160	regs[CH7006_SUBC_INC3] \|= CH7006_SUBC_INC3_POUT_3_3V;
	161
	162	regs[CH7006_SUBC_INC4] = 0;
	163	if (params->active_detect)
	164	regs[CH7006_SUBC_INC4] \|= CH7006_SUBC_INC4_DS_INPUT;
	165
	166	regs[CH7006_PLL_CONTROL] = priv->saved_state.regs[CH7006_PLL_CONTROL];
	167
	168	ch7006_setup_levels(encoder);
	169	ch7006_setup_subcarrier(encoder);
	170	ch7006_setup_pll(encoder);
	171	ch7006_setup_power_state(encoder);
	172	ch7006_setup_properties(encoder);
	173
	174	ch7006_state_load(client, state);
	175	}
	176
	177	static enum drm_connector_status ch7006_encoder_detect(struct drm_encoder *encoder,
	178	struct drm_connector *connector)
	179	{
	180	struct i2c_client *client = drm_i2c_encoder_get_client(encoder);
	181	struct ch7006_priv *priv = to_ch7006_priv(encoder);
	182	struct ch7006_state *state = &priv->state;
	183	int det;
184
185	ch7006_dbg(client, "\n");
186
187	ch7006_save_reg(client, state, CH7006_DETECT);
188	ch7006_save_reg(client, state, CH7006_POWER);
189	ch7006_save_reg(client, state, CH7006_CLKMODE);
190
191	ch7006_write(client, CH7006_POWER, CH7006_POWER_RESET \|
192	bitfs(CH7006_POWER_LEVEL, NORMAL));
193	ch7006_write(client, CH7006_CLKMODE, CH7006_CLKMODE_MASTER);
194
195	ch7006_write(client, CH7006_DETECT, CH7006_DETECT_SENSE);
196
197	ch7006_write(client, CH7006_DETECT, 0);
198
199	det = ch7006_read(client, CH7006_DETECT);
200
201	ch7006_load_reg(client, state, CH7006_CLKMODE);
202	ch7006_load_reg(client, state, CH7006_POWER);
203	ch7006_load_reg(client, state, CH7006_DETECT);
204
205	if ((det & (CH7006_DETECT_SVIDEO_Y_TEST\|
206	CH7006_DETECT_SVIDEO_C_TEST\|
207	CH7006_DETECT_CVBS_TEST)) == 0)
208	priv->subconnector = DRM_MODE_SUBCONNECTOR_SCART;
209	else if ((det & (CH7006_DETECT_SVIDEO_Y_TEST\|
210	CH7006_DETECT_SVIDEO_C_TEST)) == 0)
211	priv->subconnector = DRM_MODE_SUBCONNECTOR_SVIDEO;
212	else if ((det & CH7006_DETECT_CVBS_TEST) == 0)
213	priv->subconnector = DRM_MODE_SUBCONNECTOR_Composite;
214	else
215	priv->subconnector = DRM_MODE_SUBCONNECTOR_Unknown;
216
ec61c71d	217	drm_object_property_set_value(&connector->base,
6ee73861 BS	218	encoder->dev->mode_config.tv_subconnector_property,
	219	priv->subconnector);
	220
	221	return priv->subconnector ? connector_status_connected :
	222	connector_status_disconnected;
	223	}
	224
	225	static int ch7006_encoder_get_modes(struct drm_encoder *encoder,
	226	struct drm_connector *connector)
	227	{
	228	struct ch7006_priv *priv = to_ch7006_priv(encoder);
	229	struct ch7006_mode *mode;
	230	int n = 0;
	231
	232	for (mode = ch7006_modes; mode->mode.clock; mode++) {
	233	if (~mode->valid_scales & 1<<priv->scale \|\|
	234	~mode->valid_norms & 1<<priv->norm)
	235	continue;
	236
	237	drm_mode_probed_add(connector,
	238	drm_mode_duplicate(encoder->dev, &mode->mode));
	239
	240	n++;
	241	}
	242
	243	return n;
	244	}
	245
	246	static int ch7006_encoder_create_resources(struct drm_encoder *encoder,
	247	struct drm_connector *connector)
	248	{
	249	struct ch7006_priv *priv = to_ch7006_priv(encoder);
	250	struct drm_device *dev = encoder->dev;
	251	struct drm_mode_config *conf = &dev->mode_config;
	252
	253	drm_mode_create_tv_properties(dev, NUM_TV_NORMS, ch7006_tv_norm_names);
	254
d9bc3c02	255	priv->scale_property = drm_property_create_range(dev, 0, "scale", 0, 2);
6ee73861	256
ec61c71d	257	drm_object_attach_property(&connector->base, conf->tv_select_subconnector_property,
6ee73861	258	priv->select_subconnector);
ec61c71d	259	drm_object_attach_property(&connector->base, conf->tv_subconnector_property,
6ee73861	260	priv->subconnector);
ec61c71d	261	drm_object_attach_property(&connector->base, conf->tv_left_margin_property,
6ee73861	262	priv->hmargin);
ec61c71d	263	drm_object_attach_property(&connector->base, conf->tv_bottom_margin_property,
6ee73861	264	priv->vmargin);
ec61c71d	265	drm_object_attach_property(&connector->base, conf->tv_mode_property,
6ee73861	266	priv->norm);
ec61c71d	267	drm_object_attach_property(&connector->base, conf->tv_brightness_property,
6ee73861	268	priv->brightness);
ec61c71d	269	drm_object_attach_property(&connector->base, conf->tv_contrast_property,
6ee73861	270	priv->contrast);
ec61c71d	271	drm_object_attach_property(&connector->base, conf->tv_flicker_reduction_property,
6ee73861	272	priv->flicker);
ec61c71d	273	drm_object_attach_property(&connector->base, priv->scale_property,
6ee73861 BS	274	priv->scale);
	275
	276	return 0;
	277	}
	278
	279	static int ch7006_encoder_set_property(struct drm_encoder *encoder,
	280	struct drm_connector *connector,
	281	struct drm_property *property,
	282	uint64_t val)
	283	{
	284	struct i2c_client *client = drm_i2c_encoder_get_client(encoder);
	285	struct ch7006_priv *priv = to_ch7006_priv(encoder);
	286	struct ch7006_state *state = &priv->state;
	287	struct drm_mode_config *conf = &encoder->dev->mode_config;
	288	struct drm_crtc *crtc = encoder->crtc;
	289	bool modes_changed = false;
	290
	291	ch7006_dbg(client, "\n");
	292
	293	if (property == conf->tv_select_subconnector_property) {
	294	priv->select_subconnector = val;
	295
	296	ch7006_setup_power_state(encoder);
	297
	298	ch7006_load_reg(client, state, CH7006_POWER);
	299
	300	} else if (property == conf->tv_left_margin_property) {
	301	priv->hmargin = val;
	302
	303	ch7006_setup_properties(encoder);
	304
	305	ch7006_load_reg(client, state, CH7006_POV);
	306	ch7006_load_reg(client, state, CH7006_HPOS);
	307
	308	} else if (property == conf->tv_bottom_margin_property) {
	309	priv->vmargin = val;
	310
	311	ch7006_setup_properties(encoder);
	312
	313	ch7006_load_reg(client, state, CH7006_POV);
	314	ch7006_load_reg(client, state, CH7006_VPOS);
	315
	316	} else if (property == conf->tv_mode_property) {
	317	if (connector->dpms != DRM_MODE_DPMS_OFF)
	318	return -EINVAL;
	319
	320	priv->norm = val;
	321
	322	modes_changed = true;
	323
	324	} else if (property == conf->tv_brightness_property) {
	325	priv->brightness = val;
	326
	327	ch7006_setup_levels(encoder);
	328
	329	ch7006_load_reg(client, state, CH7006_BLACK_LEVEL);
	330
	331	} else if (property == conf->tv_contrast_property) {
	332	priv->contrast = val;
	333
	334	ch7006_setup_properties(encoder);
	335
	336	ch7006_load_reg(client, state, CH7006_CONTRAST);
	337
338	} else if (property == conf->tv_flicker_reduction_property) {
339	priv->flicker = val;
340
341	ch7006_setup_properties(encoder);
342
343	ch7006_load_reg(client, state, CH7006_FFILTER);
344
345	} else if (property == priv->scale_property) {
346	if (connector->dpms != DRM_MODE_DPMS_OFF)
347	return -EINVAL;
348
349	priv->scale = val;
350
351	modes_changed = true;
352
353	} else {
354	return -EINVAL;
355	}
356
357	if (modes_changed) {
358	drm_helper_probe_single_connector_modes(connector, 0, 0);
359
360	/* Disable the crtc to ensure a full modeset is
361	* performed whenever it's turned on again. */
362	if (crtc) {
363	struct drm_mode_set modeset = {
364	.crtc = crtc,
365	};
366
2d13b679	367	drm_mode_set_config_internal(&modeset);
6ee73861 BS	368	}
	369	}
	370
	371	return 0;
	372	}
	373
	374	static struct drm_encoder_slave_funcs ch7006_encoder_funcs = {
	375	.set_config = ch7006_encoder_set_config,
	376	.destroy = ch7006_encoder_destroy,
	377	.dpms = ch7006_encoder_dpms,
	378	.save = ch7006_encoder_save,
	379	.restore = ch7006_encoder_restore,
	380	.mode_fixup = ch7006_encoder_mode_fixup,
	381	.mode_valid = ch7006_encoder_mode_valid,
	382	.mode_set = ch7006_encoder_mode_set,
	383	.detect = ch7006_encoder_detect,
	384	.get_modes = ch7006_encoder_get_modes,
	385	.create_resources = ch7006_encoder_create_resources,
	386	.set_property = ch7006_encoder_set_property,
	387	};
	388
	389
	390	/* I2C driver functions */
	391
	392	static int ch7006_probe(struct i2c_client client, const struct i2c_device_id id)
	393	{
	394	uint8_t addr = CH7006_VERSION_ID;
	395	uint8_t val;
	396	int ret;
	397
	398	ch7006_dbg(client, "\n");
	399
	400	ret = i2c_master_send(client, &addr, sizeof(addr));
	401	if (ret < 0)
	402	goto fail;
	403
	404	ret = i2c_master_recv(client, &val, sizeof(val));
	405	if (ret < 0)
	406	goto fail;
	407
	408	ch7006_info(client, "Detected version ID: %x\n", val);
	409
dc4a684a FJ	410	/* I don't know what this is for, but otherwise I get no
	411	* signal.
	412	*/
	413	ch7006_write(client, 0x3d, 0x0);
	414
6ee73861 BS	415	return 0;
	416
	417	fail:
	418	ch7006_err(client, "Error %d reading version ID\n", ret);
	419
	420	return -ENODEV;
	421	}
	422
	423	static int ch7006_remove(struct i2c_client *client)
	424	{
	425	ch7006_dbg(client, "\n");
	426
	427	return 0;
	428	}
	429
0227a7fd	430	static int ch7006_resume(struct device *dev)
0edeb0c0	431	{
0227a7fd	432	struct i2c_client *client = to_i2c_client(dev);
0edeb0c0	433
0edeb0c0 FJ	434	ch7006_dbg(client, "\n");
	435
	436	ch7006_write(client, 0x3d, 0x0);
	437
	438	return 0;
	439	}
	440
6ee73861 BS	441	static int ch7006_encoder_init(struct i2c_client *client,
	442	struct drm_device *dev,
	443	struct drm_encoder_slave *encoder)
	444	{
	445	struct ch7006_priv *priv;
	446	int i;
	447
	448	ch7006_dbg(client, "\n");
	449
	450	priv = kzalloc(sizeof(*priv), GFP_KERNEL);
	451	if (!priv)
	452	return -ENOMEM;
	453
	454	encoder->slave_priv = priv;
	455	encoder->slave_funcs = &ch7006_encoder_funcs;
	456
	457	priv->norm = TV_NORM_PAL;
	458	priv->select_subconnector = DRM_MODE_SUBCONNECTOR_Automatic;
	459	priv->subconnector = DRM_MODE_SUBCONNECTOR_Unknown;
	460	priv->scale = 1;
	461	priv->contrast = 50;
	462	priv->brightness = 50;
	463	priv->flicker = 50;
	464	priv->hmargin = 50;
	465	priv->vmargin = 50;
	466	priv->last_dpms = -1;
c93ebb40	467	priv->chip_version = ch7006_read(client, CH7006_VERSION_ID);
6ee73861 BS	468
	469	if (ch7006_tv_norm) {
	470	for (i = 0; i < NUM_TV_NORMS; i++) {
	471	if (!strcmp(ch7006_tv_norm_names[i], ch7006_tv_norm)) {
	472	priv->norm = i;
	473	break;
	474	}
	475	}
	476
	477	if (i == NUM_TV_NORMS)
	478	ch7006_err(client, "Invalid TV norm setting \"%s\".\n",
	479	ch7006_tv_norm);
	480	}
	481
	482	if (ch7006_scale >= 0 && ch7006_scale <= 2)
	483	priv->scale = ch7006_scale;
	484	else
	485	ch7006_err(client, "Invalid scale setting \"%d\".\n",
	486	ch7006_scale);
	487
	488	return 0;
	489	}
	490
	491	static struct i2c_device_id ch7006_ids[] = {
	492	{ "ch7006", 0 },
	493	{ }
	494	};
	495	MODULE_DEVICE_TABLE(i2c, ch7006_ids);
	496
0227a7fd MB	497	static const struct dev_pm_ops ch7006_pm_ops = {
	498	.resume = ch7006_resume,
	499	};
	500
6ee73861 BS	501	static struct drm_i2c_encoder_driver ch7006_driver = {
	502	.i2c_driver = {
	503	.probe = ch7006_probe,
	504	.remove = ch7006_remove,
	505
	506	.driver = {
	507	.name = "ch7006",
0227a7fd	508	.pm = &ch7006_pm_ops,
6ee73861 BS	509	},
	510
	511	.id_table = ch7006_ids,
	512	},
	513
	514	.encoder_init = ch7006_encoder_init,
	515	};
	516
	517
	518	/* Module initialization */
	519
	520	static int __init ch7006_init(void)
	521	{
	522	return drm_i2c_encoder_register(THIS_MODULE, &ch7006_driver);
	523	}
	524
	525	static void __exit ch7006_exit(void)
	526	{
	527	drm_i2c_encoder_unregister(&ch7006_driver);
	528	}
	529
	530	int ch7006_debug;
	531	module_param_named(debug, ch7006_debug, int, 0600);
	532	MODULE_PARM_DESC(debug, "Enable debug output.");
	533
	534	char *ch7006_tv_norm;
	535	module_param_named(tv_norm, ch7006_tv_norm, charp, 0600);
	536	MODULE_PARM_DESC(tv_norm, "Default TV norm.\n"
	537	"\t\tSupported: PAL, PAL-M, PAL-N, PAL-Nc, PAL-60, NTSC-M, NTSC-J.\n"
	538	"\t\tDefault: PAL");
	539
	540	int ch7006_scale = 1;
	541	module_param_named(scale, ch7006_scale, int, 0600);
	542	MODULE_PARM_DESC(scale, "Default scale.\n"
	543	"\t\tSupported: 0 -> Select video modes with a higher blanking ratio.\n"
	544	"\t\t\t1 -> Select default video modes.\n"
	545	"\t\t\t2 -> Select video modes with a lower blanking ratio.");
	546
	547	MODULE_AUTHOR("Francisco Jerez <currojerez@riseup.net>");
	548	MODULE_DESCRIPTION("Chrontel ch7006 TV encoder driver");
	549	MODULE_LICENSE("GPL and additional rights");
	550
	551	module_init(ch7006_init);
	552	module_exit(ch7006_exit);