tvnv04.c 7.3 KB
Newer Older
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26
/*
 * 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.
 *
 */

27
#include <drm/drmP.h>
28 29
#include "nouveau_drm.h"
#include "nouveau_reg.h"
30 31 32
#include "nouveau_encoder.h"
#include "nouveau_connector.h"
#include "nouveau_crtc.h"
33
#include "hw.h"
34
#include <drm/drm_crtc_helper.h>
35

36
#include <drm/i2c/ch7006.h>
37

38
static struct nouveau_i2c_board_info nv04_tv_encoder_info[] = {
39
	{
40 41 42 43 44 45 46 47 48 49
		{
			I2C_BOARD_INFO("ch7006", 0x75),
			.platform_data = &(struct ch7006_encoder_params) {
				CH7006_FORMAT_RGB24m12I, CH7006_CLOCK_MASTER,
				0, 0, 0,
				CH7006_SYNC_SLAVE, CH7006_SYNC_SEPARATED,
				CH7006_POUT_3_3V, CH7006_ACTIVE_HSYNC
			}
		},
		0
50
	},
51
	{ }
52 53 54 55
};

int nv04_tv_identify(struct drm_device *dev, int i2c_index)
{
56
	struct nouveau_drm *drm = nouveau_drm(dev);
57
	struct nouveau_i2c *i2c = nvkm_i2c(&drm->device);
58 59

	return i2c->identify(i2c, i2c_index, "TV encoder",
60
			     nv04_tv_encoder_info, NULL, NULL);
61 62
}

63

64 65 66 67 68 69 70 71 72 73
#define PLLSEL_TV_CRTC1_MASK				\
	(NV_PRAMDAC_PLL_COEFF_SELECT_TV_VSCLK1		\
	 | NV_PRAMDAC_PLL_COEFF_SELECT_TV_PCLK1)
#define PLLSEL_TV_CRTC2_MASK				\
	(NV_PRAMDAC_PLL_COEFF_SELECT_TV_VSCLK2		\
	 | NV_PRAMDAC_PLL_COEFF_SELECT_TV_PCLK2)

static void nv04_tv_dpms(struct drm_encoder *encoder, int mode)
{
	struct drm_device *dev = encoder->dev;
74
	struct nouveau_drm *drm = nouveau_drm(dev);
75
	struct nouveau_encoder *nv_encoder = nouveau_encoder(encoder);
76
	struct nv04_mode_state *state = &nv04_display(dev)->mode_reg;
77 78
	uint8_t crtc1A;

79 80
	NV_DEBUG(drm, "Setting dpms mode %d on TV encoder (output %d)\n",
		 mode, nv_encoder->dcb->index);
81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98

	state->pllsel &= ~(PLLSEL_TV_CRTC1_MASK | PLLSEL_TV_CRTC2_MASK);

	if (mode == DRM_MODE_DPMS_ON) {
		int head = nouveau_crtc(encoder->crtc)->index;
		crtc1A = NVReadVgaCrtc(dev, head, NV_CIO_CRE_RPC1_INDEX);

		state->pllsel |= head ? PLLSEL_TV_CRTC2_MASK :
					PLLSEL_TV_CRTC1_MASK;

		/* Inhibit hsync */
		crtc1A |= 0x80;

		NVWriteVgaCrtc(dev, head, NV_CIO_CRE_RPC1_INDEX, crtc1A);
	}

	NVWriteRAMDAC(dev, 0, NV_PRAMDAC_PLL_COEFF_SELECT, state->pllsel);

99
	get_slave_funcs(encoder)->dpms(encoder, mode);
100 101 102 103
}

static void nv04_tv_bind(struct drm_device *dev, int head, bool bind)
{
104
	struct nv04_crtc_reg *state = &nv04_display(dev)->mode_reg.crtc_reg[head];
105 106 107

	state->tv_setup = 0;

108
	if (bind)
109
		state->CRTC[NV_CIO_CRE_49] |= 0x10;
110
	else
111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142
		state->CRTC[NV_CIO_CRE_49] &= ~0x10;

	NVWriteVgaCrtc(dev, head, NV_CIO_CRE_LCD__INDEX,
		       state->CRTC[NV_CIO_CRE_LCD__INDEX]);
	NVWriteVgaCrtc(dev, head, NV_CIO_CRE_49,
		       state->CRTC[NV_CIO_CRE_49]);
	NVWriteRAMDAC(dev, head, NV_PRAMDAC_TV_SETUP,
		      state->tv_setup);
}

static void nv04_tv_prepare(struct drm_encoder *encoder)
{
	struct drm_device *dev = encoder->dev;
	int head = nouveau_crtc(encoder->crtc)->index;
	struct drm_encoder_helper_funcs *helper = encoder->helper_private;

	helper->dpms(encoder, DRM_MODE_DPMS_OFF);

	nv04_dfp_disable(dev, head);

	if (nv_two_heads(dev))
		nv04_tv_bind(dev, head ^ 1, false);

	nv04_tv_bind(dev, head, true);
}

static void nv04_tv_mode_set(struct drm_encoder *encoder,
			     struct drm_display_mode *mode,
			     struct drm_display_mode *adjusted_mode)
{
	struct drm_device *dev = encoder->dev;
	struct nouveau_crtc *nv_crtc = nouveau_crtc(encoder->crtc);
143
	struct nv04_crtc_reg *regp = &nv04_display(dev)->mode_reg.crtc_reg[nv_crtc->index];
144 145 146 147 148 149 150 151 152 153 154 155 156 157

	regp->tv_htotal = adjusted_mode->htotal;
	regp->tv_vtotal = adjusted_mode->vtotal;

	/* These delay the TV signals with respect to the VGA port,
	 * they might be useful if we ever allow a CRTC to drive
	 * multiple outputs.
	 */
	regp->tv_hskew = 1;
	regp->tv_hsync_delay = 1;
	regp->tv_hsync_delay2 = 64;
	regp->tv_vskew = 1;
	regp->tv_vsync_delay = 1;

158
	get_slave_funcs(encoder)->mode_set(encoder, mode, adjusted_mode);
159 160 161 162 163 164
}

static void nv04_tv_commit(struct drm_encoder *encoder)
{
	struct nouveau_encoder *nv_encoder = nouveau_encoder(encoder);
	struct drm_device *dev = encoder->dev;
165
	struct nouveau_drm *drm = nouveau_drm(dev);
166 167 168 169 170
	struct nouveau_crtc *nv_crtc = nouveau_crtc(encoder->crtc);
	struct drm_encoder_helper_funcs *helper = encoder->helper_private;

	helper->dpms(encoder, DRM_MODE_DPMS_ON);

171
	NV_DEBUG(drm, "Output %s is running on CRTC %d using output %c\n",
172 173
		 nouveau_encoder_connector_get(nv_encoder)->base.name,
		 nv_crtc->index, '@' + ffs(nv_encoder->dcb->or));
174 175 176 177
}

static void nv04_tv_destroy(struct drm_encoder *encoder)
{
178
	get_slave_funcs(encoder)->destroy(encoder);
179 180
	drm_encoder_cleanup(encoder);

181 182
	kfree(encoder->helper_private);
	kfree(nouveau_encoder(encoder));
183 184
}

185 186 187 188
static const struct drm_encoder_funcs nv04_tv_funcs = {
	.destroy = nv04_tv_destroy,
};

189 190 191 192 193 194 195 196 197 198 199
static const struct drm_encoder_helper_funcs nv04_tv_helper_funcs = {
	.dpms = nv04_tv_dpms,
	.save = drm_i2c_encoder_save,
	.restore = drm_i2c_encoder_restore,
	.mode_fixup = drm_i2c_encoder_mode_fixup,
	.prepare = nv04_tv_prepare,
	.commit = nv04_tv_commit,
	.mode_set = nv04_tv_mode_set,
	.detect = drm_i2c_encoder_detect,
};

200
int
201
nv04_tv_create(struct drm_connector *connector, struct dcb_output *entry)
202 203 204
{
	struct nouveau_encoder *nv_encoder;
	struct drm_encoder *encoder;
205
	struct drm_device *dev = connector->dev;
206
	struct nouveau_drm *drm = nouveau_drm(dev);
207
	struct nouveau_i2c *i2c = nvkm_i2c(&drm->device);
208
	struct nouveau_i2c_port *port = i2c->find(i2c, entry->i2c_index);
209 210 211
	int type, ret;

	/* Ensure that we can talk to this encoder */
212
	type = nv04_tv_identify(dev, entry->i2c_index);
213 214 215 216 217 218 219 220 221 222 223
	if (type < 0)
		return type;

	/* Allocate the necessary memory */
	nv_encoder = kzalloc(sizeof(*nv_encoder), GFP_KERNEL);
	if (!nv_encoder)
		return -ENOMEM;

	/* Initialize the common members */
	encoder = to_drm_encoder(nv_encoder);

224
	drm_encoder_init(dev, encoder, &nv04_tv_funcs, DRM_MODE_ENCODER_TVDAC);
225
	drm_encoder_helper_add(encoder, &nv04_tv_helper_funcs);
226 227 228 229 230 231 232

	encoder->possible_crtcs = entry->heads;
	encoder->possible_clones = 0;
	nv_encoder->dcb = entry;
	nv_encoder->or = ffs(entry->or) - 1;

	/* Run the slave-specific initialization */
233
	ret = drm_i2c_encoder_init(dev, to_encoder_slave(encoder),
234 235
				   &port->adapter,
				   &nv04_tv_encoder_info[type].dev);
236
	if (ret < 0)
237
		goto fail_cleanup;
238

239
	/* Attach it to the specified connector. */
240
	get_slave_funcs(encoder)->create_resources(encoder, connector);
241
	drm_mode_connector_attach_encoder(connector, encoder);
242

243 244
	return 0;

245
fail_cleanup:
246 247 248 249
	drm_encoder_cleanup(encoder);
	kfree(nv_encoder);
	return ret;
}