intel_audio.c 24.4 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
/*
 * Copyright © 2014 Intel Corporation
 *
 * 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 AUTHORS OR COPYRIGHT HOLDERS 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/kernel.h>
I
Imre Deak 已提交
25 26 27
#include <linux/component.h>
#include <drm/i915_component.h>
#include "intel_drv.h"
28 29 30 31 32

#include <drm/drmP.h>
#include <drm/drm_edid.h>
#include "i915_drv.h"

33 34 35 36 37 38 39 40 41 42 43
/**
 * DOC: High Definition Audio over HDMI and Display Port
 *
 * The graphics and audio drivers together support High Definition Audio over
 * HDMI and Display Port. The audio programming sequences are divided into audio
 * codec and controller enable and disable sequences. The graphics driver
 * handles the audio codec sequences, while the audio driver handles the audio
 * controller sequences.
 *
 * The disable sequences must be performed before disabling the transcoder or
 * port. The enable sequences may only be performed after enabling the
44 45
 * transcoder and port, and after completed link training. Therefore the audio
 * enable/disable sequences are part of the modeset sequence.
46 47 48 49 50 51 52
 *
 * The codec and controller sequences could be done either parallel or serial,
 * but generally the ELDV/PD change in the codec sequence indicates to the audio
 * driver that the controller sequence should start. Indeed, most of the
 * co-operation between the graphics and audio drivers is handled via audio
 * related registers. (The notable exception is the power management, not
 * covered here.)
53 54 55 56 57
 *
 * The struct i915_audio_component is used to interact between the graphics
 * and audio drivers. The struct i915_audio_component_ops *ops in it is
 * defined in graphics driver and called in audio driver. The
 * struct i915_audio_component_audio_ops *audio_ops is called from i915 driver.
58 59
 */

60
static const struct {
61 62 63 64 65 66 67 68 69 70 71 72 73 74 75
	int clock;
	u32 config;
} hdmi_audio_clock[] = {
	{ DIV_ROUND_UP(25200 * 1000, 1001), AUD_CONFIG_PIXEL_CLOCK_HDMI_25175 },
	{ 25200, AUD_CONFIG_PIXEL_CLOCK_HDMI_25200 }, /* default per bspec */
	{ 27000, AUD_CONFIG_PIXEL_CLOCK_HDMI_27000 },
	{ 27000 * 1001 / 1000, AUD_CONFIG_PIXEL_CLOCK_HDMI_27027 },
	{ 54000, AUD_CONFIG_PIXEL_CLOCK_HDMI_54000 },
	{ 54000 * 1001 / 1000, AUD_CONFIG_PIXEL_CLOCK_HDMI_54054 },
	{ DIV_ROUND_UP(74250 * 1000, 1001), AUD_CONFIG_PIXEL_CLOCK_HDMI_74176 },
	{ 74250, AUD_CONFIG_PIXEL_CLOCK_HDMI_74250 },
	{ DIV_ROUND_UP(148500 * 1000, 1001), AUD_CONFIG_PIXEL_CLOCK_HDMI_148352 },
	{ 148500, AUD_CONFIG_PIXEL_CLOCK_HDMI_148500 },
};

76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100
/* HDMI N/CTS table */
#define TMDS_297M 297000
#define TMDS_296M DIV_ROUND_UP(297000 * 1000, 1001)
static const struct {
	int sample_rate;
	int clock;
	int n;
	int cts;
} aud_ncts[] = {
	{ 44100, TMDS_296M, 4459, 234375 },
	{ 44100, TMDS_297M, 4704, 247500 },
	{ 48000, TMDS_296M, 5824, 281250 },
	{ 48000, TMDS_297M, 5120, 247500 },
	{ 32000, TMDS_296M, 5824, 421875 },
	{ 32000, TMDS_297M, 3072, 222750 },
	{ 88200, TMDS_296M, 8918, 234375 },
	{ 88200, TMDS_297M, 9408, 247500 },
	{ 96000, TMDS_296M, 11648, 281250 },
	{ 96000, TMDS_297M, 10240, 247500 },
	{ 176400, TMDS_296M, 17836, 234375 },
	{ 176400, TMDS_297M, 18816, 247500 },
	{ 192000, TMDS_296M, 23296, 281250 },
	{ 192000, TMDS_297M, 20480, 247500 },
};

101
/* get AUD_CONFIG_PIXEL_CLOCK_HDMI_* value for mode */
102
static u32 audio_config_hdmi_pixel_clock(const struct drm_display_mode *adjusted_mode)
103 104 105 106
{
	int i;

	for (i = 0; i < ARRAY_SIZE(hdmi_audio_clock); i++) {
107
		if (adjusted_mode->crtc_clock == hdmi_audio_clock[i].clock)
108 109 110 111
			break;
	}

	if (i == ARRAY_SIZE(hdmi_audio_clock)) {
112
		DRM_DEBUG_KMS("HDMI audio pixel clock setting for %d not found, falling back to defaults\n",
113
			      adjusted_mode->crtc_clock);
114 115 116 117 118 119 120 121 122 123
		i = 1;
	}

	DRM_DEBUG_KMS("Configuring HDMI audio for pixel clock %d (0x%08x)\n",
		      hdmi_audio_clock[i].clock,
		      hdmi_audio_clock[i].config);

	return hdmi_audio_clock[i].config;
}

124 125 126 127 128 129 130 131 132 133 134 135 136
static int audio_config_get_n(const struct drm_display_mode *mode, int rate)
{
	int i;

	for (i = 0; i < ARRAY_SIZE(aud_ncts); i++) {
		if ((rate == aud_ncts[i].sample_rate) &&
			(mode->clock == aud_ncts[i].clock)) {
			return aud_ncts[i].n;
		}
	}
	return 0;
}

137 138 139 140 141 142 143 144 145 146 147 148 149 150
static uint32_t audio_config_setup_n_reg(int n, uint32_t val)
{
	int n_low, n_up;
	uint32_t tmp = val;

	n_low = n & 0xfff;
	n_up = (n >> 12) & 0xff;
	tmp &= ~(AUD_CONFIG_UPPER_N_MASK | AUD_CONFIG_LOWER_N_MASK);
	tmp |= ((n_up << AUD_CONFIG_UPPER_N_SHIFT) |
			(n_low << AUD_CONFIG_LOWER_N_SHIFT) |
			AUD_CONFIG_N_PROG_ENABLE);
	return tmp;
}

151 152
/* check whether N/CTS/M need be set manually */
static bool audio_rate_need_prog(struct intel_crtc *crtc,
153
				 const struct drm_display_mode *mode)
154 155 156 157 158 159 160 161 162
{
	if (((mode->clock == TMDS_297M) ||
		 (mode->clock == TMDS_296M)) &&
		intel_pipe_has_type(crtc, INTEL_OUTPUT_HDMI))
		return true;
	else
		return false;
}

163 164 165 166 167 168 169
static bool intel_eld_uptodate(struct drm_connector *connector,
			       int reg_eldv, uint32_t bits_eldv,
			       int reg_elda, uint32_t bits_elda,
			       int reg_edid)
{
	struct drm_i915_private *dev_priv = connector->dev->dev_private;
	uint8_t *eld = connector->eld;
170 171
	uint32_t tmp;
	int i;
172

173 174
	tmp = I915_READ(reg_eldv);
	tmp &= bits_eldv;
175

176
	if (!tmp)
177 178
		return false;

179 180 181
	tmp = I915_READ(reg_elda);
	tmp &= ~bits_elda;
	I915_WRITE(reg_elda, tmp);
182

183
	for (i = 0; i < drm_eld_size(eld) / 4; i++)
184 185 186 187 188 189
		if (I915_READ(reg_edid) != *((uint32_t *)eld + i))
			return false;

	return true;
}

190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208
static void g4x_audio_codec_disable(struct intel_encoder *encoder)
{
	struct drm_i915_private *dev_priv = encoder->base.dev->dev_private;
	uint32_t eldv, tmp;

	DRM_DEBUG_KMS("Disable audio codec\n");

	tmp = I915_READ(G4X_AUD_VID_DID);
	if (tmp == INTEL_AUDIO_DEVBLC || tmp == INTEL_AUDIO_DEVCL)
		eldv = G4X_ELDV_DEVCL_DEVBLC;
	else
		eldv = G4X_ELDV_DEVCTG;

	/* Invalidate ELD */
	tmp = I915_READ(G4X_AUD_CNTL_ST);
	tmp &= ~eldv;
	I915_WRITE(G4X_AUD_CNTL_ST, tmp);
}

209 210
static void g4x_audio_codec_enable(struct drm_connector *connector,
				   struct intel_encoder *encoder,
211
				   const struct drm_display_mode *adjusted_mode)
212 213 214 215
{
	struct drm_i915_private *dev_priv = connector->dev->dev_private;
	uint8_t *eld = connector->eld;
	uint32_t eldv;
216 217
	uint32_t tmp;
	int len, i;
218

219 220
	DRM_DEBUG_KMS("Enable audio codec, %u bytes ELD\n", eld[2]);

221 222
	tmp = I915_READ(G4X_AUD_VID_DID);
	if (tmp == INTEL_AUDIO_DEVBLC || tmp == INTEL_AUDIO_DEVCL)
223 224 225 226 227 228
		eldv = G4X_ELDV_DEVCL_DEVBLC;
	else
		eldv = G4X_ELDV_DEVCTG;

	if (intel_eld_uptodate(connector,
			       G4X_AUD_CNTL_ST, eldv,
229
			       G4X_AUD_CNTL_ST, G4X_ELD_ADDR_MASK,
230 231 232
			       G4X_HDMIW_HDMIEDID))
		return;

233
	tmp = I915_READ(G4X_AUD_CNTL_ST);
234
	tmp &= ~(eldv | G4X_ELD_ADDR_MASK);
235 236
	len = (tmp >> 9) & 0x1f;		/* ELD buffer size */
	I915_WRITE(G4X_AUD_CNTL_ST, tmp);
237

238
	len = min(drm_eld_size(eld) / 4, len);
239 240 241 242
	DRM_DEBUG_DRIVER("ELD size %d\n", len);
	for (i = 0; i < len; i++)
		I915_WRITE(G4X_HDMIW_HDMIEDID, *((uint32_t *)eld + i));

243 244 245
	tmp = I915_READ(G4X_AUD_CNTL_ST);
	tmp |= eldv;
	I915_WRITE(G4X_AUD_CNTL_ST, tmp);
246 247
}

248 249
static void hsw_audio_codec_disable(struct intel_encoder *encoder)
{
250 251 252
	struct drm_i915_private *dev_priv = encoder->base.dev->dev_private;
	struct intel_crtc *intel_crtc = to_intel_crtc(encoder->base.crtc);
	enum pipe pipe = intel_crtc->pipe;
253 254
	uint32_t tmp;

255 256
	DRM_DEBUG_KMS("Disable audio codec on pipe %c\n", pipe_name(pipe));

257 258
	mutex_lock(&dev_priv->av_mutex);

259 260 261 262 263 264 265 266 267 268 269
	/* Disable timestamps */
	tmp = I915_READ(HSW_AUD_CFG(pipe));
	tmp &= ~AUD_CONFIG_N_VALUE_INDEX;
	tmp |= AUD_CONFIG_N_PROG_ENABLE;
	tmp &= ~AUD_CONFIG_UPPER_N_MASK;
	tmp &= ~AUD_CONFIG_LOWER_N_MASK;
	if (intel_pipe_has_type(intel_crtc, INTEL_OUTPUT_DISPLAYPORT))
		tmp |= AUD_CONFIG_N_VALUE_INDEX;
	I915_WRITE(HSW_AUD_CFG(pipe), tmp);

	/* Invalidate ELD */
270
	tmp = I915_READ(HSW_AUD_PIN_ELD_CP_VLD);
271
	tmp &= ~AUDIO_ELD_VALID(pipe);
272
	tmp &= ~AUDIO_OUTPUT_ENABLE(pipe);
273
	I915_WRITE(HSW_AUD_PIN_ELD_CP_VLD, tmp);
274 275

	mutex_unlock(&dev_priv->av_mutex);
276 277 278 279
}

static void hsw_audio_codec_enable(struct drm_connector *connector,
				   struct intel_encoder *encoder,
280
				   const struct drm_display_mode *adjusted_mode)
281 282
{
	struct drm_i915_private *dev_priv = connector->dev->dev_private;
283
	struct intel_crtc *intel_crtc = to_intel_crtc(encoder->base.crtc);
284
	enum pipe pipe = intel_crtc->pipe;
285
	struct i915_audio_component *acomp = dev_priv->audio_component;
286
	const uint8_t *eld = connector->eld;
287 288 289
	struct intel_digital_port *intel_dig_port =
		enc_to_dig_port(&encoder->base);
	enum port port = intel_dig_port->port;
290 291
	uint32_t tmp;
	int len, i;
292
	int n, rate;
293

294
	DRM_DEBUG_KMS("Enable audio codec on pipe %c, %u bytes ELD\n",
295
		      pipe_name(pipe), drm_eld_size(eld));
296

297 298
	mutex_lock(&dev_priv->av_mutex);

299 300
	/* Enable audio presence detect, invalidate ELD */
	tmp = I915_READ(HSW_AUD_PIN_ELD_CP_VLD);
301 302
	tmp |= AUDIO_OUTPUT_ENABLE(pipe);
	tmp &= ~AUDIO_ELD_VALID(pipe);
303
	I915_WRITE(HSW_AUD_PIN_ELD_CP_VLD, tmp);
304

305 306 307 308 309 310
	/*
	 * FIXME: We're supposed to wait for vblank here, but we have vblanks
	 * disabled during the mode set. The proper fix would be to push the
	 * rest of the setup into a vblank work item, queued here, but the
	 * infrastructure is not there yet.
	 */
311

312 313
	/* Reset ELD write address */
	tmp = I915_READ(HSW_AUD_DIP_ELD_CTRL(pipe));
314
	tmp &= ~IBX_ELD_ADDRESS_MASK;
315
	I915_WRITE(HSW_AUD_DIP_ELD_CTRL(pipe), tmp);
316

317
	/* Up to 84 bytes of hw ELD buffer */
318 319
	len = min(drm_eld_size(eld), 84);
	for (i = 0; i < len / 4; i++)
320
		I915_WRITE(HSW_AUD_EDID_DATA(pipe), *((uint32_t *)eld + i));
321

322
	/* ELD valid */
323
	tmp = I915_READ(HSW_AUD_PIN_ELD_CP_VLD);
324
	tmp |= AUDIO_ELD_VALID(pipe);
325
	I915_WRITE(HSW_AUD_PIN_ELD_CP_VLD, tmp);
326 327 328 329 330 331 332 333

	/* Enable timestamps */
	tmp = I915_READ(HSW_AUD_CFG(pipe));
	tmp &= ~AUD_CONFIG_N_VALUE_INDEX;
	tmp &= ~AUD_CONFIG_PIXEL_CLOCK_HDMI_MASK;
	if (intel_pipe_has_type(intel_crtc, INTEL_OUTPUT_DISPLAYPORT))
		tmp |= AUD_CONFIG_N_VALUE_INDEX;
	else
334
		tmp |= audio_config_hdmi_pixel_clock(adjusted_mode);
335 336

	tmp &= ~AUD_CONFIG_N_PROG_ENABLE;
337
	if (audio_rate_need_prog(intel_crtc, adjusted_mode)) {
338 339 340 341 342 343 344 345
		if (!acomp)
			rate = 0;
		else if (port >= PORT_A && port <= PORT_E)
			rate = acomp->aud_sample_rate[port];
		else {
			DRM_ERROR("invalid port: %d\n", port);
			rate = 0;
		}
346
		n = audio_config_get_n(adjusted_mode, rate);
347 348 349 350 351 352
		if (n != 0)
			tmp = audio_config_setup_n_reg(n, tmp);
		else
			DRM_DEBUG_KMS("no suitable N value is found\n");
	}

353
	I915_WRITE(HSW_AUD_CFG(pipe), tmp);
354 355

	mutex_unlock(&dev_priv->av_mutex);
356 357
}

358 359 360 361 362 363 364 365 366 367 368 369 370 371 372
static void ilk_audio_codec_disable(struct intel_encoder *encoder)
{
	struct drm_i915_private *dev_priv = encoder->base.dev->dev_private;
	struct intel_crtc *intel_crtc = to_intel_crtc(encoder->base.crtc);
	struct intel_digital_port *intel_dig_port =
		enc_to_dig_port(&encoder->base);
	enum port port = intel_dig_port->port;
	enum pipe pipe = intel_crtc->pipe;
	uint32_t tmp, eldv;
	int aud_config;
	int aud_cntrl_st2;

	DRM_DEBUG_KMS("Disable audio codec on port %c, pipe %c\n",
		      port_name(port), pipe_name(pipe));

373 374 375
	if (WARN_ON(port == PORT_A))
		return;

376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396
	if (HAS_PCH_IBX(dev_priv->dev)) {
		aud_config = IBX_AUD_CFG(pipe);
		aud_cntrl_st2 = IBX_AUD_CNTL_ST2;
	} else if (IS_VALLEYVIEW(dev_priv)) {
		aud_config = VLV_AUD_CFG(pipe);
		aud_cntrl_st2 = VLV_AUD_CNTL_ST2;
	} else {
		aud_config = CPT_AUD_CFG(pipe);
		aud_cntrl_st2 = CPT_AUD_CNTRL_ST2;
	}

	/* Disable timestamps */
	tmp = I915_READ(aud_config);
	tmp &= ~AUD_CONFIG_N_VALUE_INDEX;
	tmp |= AUD_CONFIG_N_PROG_ENABLE;
	tmp &= ~AUD_CONFIG_UPPER_N_MASK;
	tmp &= ~AUD_CONFIG_LOWER_N_MASK;
	if (intel_pipe_has_type(intel_crtc, INTEL_OUTPUT_DISPLAYPORT))
		tmp |= AUD_CONFIG_N_VALUE_INDEX;
	I915_WRITE(aud_config, tmp);

397
	eldv = IBX_ELD_VALID(port);
398 399 400 401 402 403 404

	/* Invalidate ELD */
	tmp = I915_READ(aud_cntrl_st2);
	tmp &= ~eldv;
	I915_WRITE(aud_cntrl_st2, tmp);
}

405 406
static void ilk_audio_codec_enable(struct drm_connector *connector,
				   struct intel_encoder *encoder,
407
				   const struct drm_display_mode *adjusted_mode)
408 409
{
	struct drm_i915_private *dev_priv = connector->dev->dev_private;
410
	struct intel_crtc *intel_crtc = to_intel_crtc(encoder->base.crtc);
411 412 413 414
	struct intel_digital_port *intel_dig_port =
		enc_to_dig_port(&encoder->base);
	enum port port = intel_dig_port->port;
	enum pipe pipe = intel_crtc->pipe;
415 416
	uint8_t *eld = connector->eld;
	uint32_t eldv;
417 418
	uint32_t tmp;
	int len, i;
419 420 421 422
	int hdmiw_hdmiedid;
	int aud_config;
	int aud_cntl_st;
	int aud_cntrl_st2;
423 424

	DRM_DEBUG_KMS("Enable audio codec on port %c, pipe %c, %u bytes ELD\n",
425
		      port_name(port), pipe_name(pipe), drm_eld_size(eld));
426

427 428 429
	if (WARN_ON(port == PORT_A))
		return;

430 431 432 433 434 435
	/*
	 * FIXME: We're supposed to wait for vblank here, but we have vblanks
	 * disabled during the mode set. The proper fix would be to push the
	 * rest of the setup into a vblank work item, queued here, but the
	 * infrastructure is not there yet.
	 */
436 437 438 439 440 441 442 443 444 445 446 447 448 449 450 451 452 453

	if (HAS_PCH_IBX(connector->dev)) {
		hdmiw_hdmiedid = IBX_HDMIW_HDMIEDID(pipe);
		aud_config = IBX_AUD_CFG(pipe);
		aud_cntl_st = IBX_AUD_CNTL_ST(pipe);
		aud_cntrl_st2 = IBX_AUD_CNTL_ST2;
	} else if (IS_VALLEYVIEW(connector->dev)) {
		hdmiw_hdmiedid = VLV_HDMIW_HDMIEDID(pipe);
		aud_config = VLV_AUD_CFG(pipe);
		aud_cntl_st = VLV_AUD_CNTL_ST(pipe);
		aud_cntrl_st2 = VLV_AUD_CNTL_ST2;
	} else {
		hdmiw_hdmiedid = CPT_HDMIW_HDMIEDID(pipe);
		aud_config = CPT_AUD_CFG(pipe);
		aud_cntl_st = CPT_AUD_CNTL_ST(pipe);
		aud_cntrl_st2 = CPT_AUD_CNTRL_ST2;
	}

454
	eldv = IBX_ELD_VALID(port);
455

456
	/* Invalidate ELD */
457 458 459
	tmp = I915_READ(aud_cntrl_st2);
	tmp &= ~eldv;
	I915_WRITE(aud_cntrl_st2, tmp);
460

461
	/* Reset ELD write address */
462
	tmp = I915_READ(aud_cntl_st);
463
	tmp &= ~IBX_ELD_ADDRESS_MASK;
464
	I915_WRITE(aud_cntl_st, tmp);
465

466
	/* Up to 84 bytes of hw ELD buffer */
467 468
	len = min(drm_eld_size(eld), 84);
	for (i = 0; i < len / 4; i++)
469 470
		I915_WRITE(hdmiw_hdmiedid, *((uint32_t *)eld + i));

471
	/* ELD valid */
472 473 474
	tmp = I915_READ(aud_cntrl_st2);
	tmp |= eldv;
	I915_WRITE(aud_cntrl_st2, tmp);
475 476 477 478 479 480 481 482 483

	/* Enable timestamps */
	tmp = I915_READ(aud_config);
	tmp &= ~AUD_CONFIG_N_VALUE_INDEX;
	tmp &= ~AUD_CONFIG_N_PROG_ENABLE;
	tmp &= ~AUD_CONFIG_PIXEL_CLOCK_HDMI_MASK;
	if (intel_pipe_has_type(intel_crtc, INTEL_OUTPUT_DISPLAYPORT))
		tmp |= AUD_CONFIG_N_VALUE_INDEX;
	else
484
		tmp |= audio_config_hdmi_pixel_clock(adjusted_mode);
485
	I915_WRITE(aud_config, tmp);
486 487
}

488 489 490 491 492 493 494 495
/**
 * intel_audio_codec_enable - Enable the audio codec for HD audio
 * @intel_encoder: encoder on which to enable audio
 *
 * The enable sequences may only be performed after enabling the transcoder and
 * port, and after completed link training.
 */
void intel_audio_codec_enable(struct intel_encoder *intel_encoder)
496
{
497 498
	struct drm_encoder *encoder = &intel_encoder->base;
	struct intel_crtc *crtc = to_intel_crtc(encoder->crtc);
499
	const struct drm_display_mode *adjusted_mode = &crtc->config->base.adjusted_mode;
500 501 502
	struct drm_connector *connector;
	struct drm_device *dev = encoder->dev;
	struct drm_i915_private *dev_priv = dev->dev_private;
503 504 505
	struct i915_audio_component *acomp = dev_priv->audio_component;
	struct intel_digital_port *intel_dig_port = enc_to_dig_port(encoder);
	enum port port = intel_dig_port->port;
506

507
	connector = drm_select_eld(encoder);
508 509 510 511 512 513 514 515 516
	if (!connector)
		return;

	DRM_DEBUG_DRIVER("ELD on [CONNECTOR:%d:%s], [ENCODER:%d:%s]\n",
			 connector->base.id,
			 connector->name,
			 connector->encoder->base.id,
			 connector->encoder->name);

517 518 519 520 521
	/* ELD Conn_Type */
	connector->eld[5] &= ~(3 << 2);
	if (intel_pipe_has_type(crtc, INTEL_OUTPUT_DISPLAYPORT))
		connector->eld[5] |= (1 << 2);

522
	connector->eld[6] = drm_av_sync_delay(connector, adjusted_mode) / 2;
523

524
	if (dev_priv->display.audio_codec_enable)
525 526
		dev_priv->display.audio_codec_enable(connector, intel_encoder,
						     adjusted_mode);
527 528

	if (acomp && acomp->audio_ops && acomp->audio_ops->pin_eld_notify)
529
		acomp->audio_ops->pin_eld_notify(acomp->audio_ops->audio_ptr, (int) port);
530 531 532 533
}

/**
 * intel_audio_codec_disable - Disable the audio codec for HD audio
534
 * @intel_encoder: encoder on which to disable audio
535 536 537 538
 *
 * The disable sequences must be performed before disabling the transcoder or
 * port.
 */
539
void intel_audio_codec_disable(struct intel_encoder *intel_encoder)
540
{
541 542
	struct drm_encoder *encoder = &intel_encoder->base;
	struct drm_device *dev = encoder->dev;
543
	struct drm_i915_private *dev_priv = dev->dev_private;
544 545 546
	struct i915_audio_component *acomp = dev_priv->audio_component;
	struct intel_digital_port *intel_dig_port = enc_to_dig_port(encoder);
	enum port port = intel_dig_port->port;
547 548

	if (dev_priv->display.audio_codec_disable)
549 550 551
		dev_priv->display.audio_codec_disable(intel_encoder);

	if (acomp && acomp->audio_ops && acomp->audio_ops->pin_eld_notify)
552
		acomp->audio_ops->pin_eld_notify(acomp->audio_ops->audio_ptr, (int) port);
553 554 555 556 557 558 559 560 561 562
}

/**
 * intel_init_audio - Set up chip specific audio functions
 * @dev: drm device
 */
void intel_init_audio(struct drm_device *dev)
{
	struct drm_i915_private *dev_priv = dev->dev_private;

563 564
	if (IS_G4X(dev)) {
		dev_priv->display.audio_codec_enable = g4x_audio_codec_enable;
565
		dev_priv->display.audio_codec_disable = g4x_audio_codec_disable;
566 567
	} else if (IS_VALLEYVIEW(dev)) {
		dev_priv->display.audio_codec_enable = ilk_audio_codec_enable;
568
		dev_priv->display.audio_codec_disable = ilk_audio_codec_disable;
569 570 571 572 573
	} else if (IS_HASWELL(dev) || INTEL_INFO(dev)->gen >= 8) {
		dev_priv->display.audio_codec_enable = hsw_audio_codec_enable;
		dev_priv->display.audio_codec_disable = hsw_audio_codec_disable;
	} else if (HAS_PCH_SPLIT(dev)) {
		dev_priv->display.audio_codec_enable = ilk_audio_codec_enable;
574
		dev_priv->display.audio_codec_disable = ilk_audio_codec_disable;
575
	}
576
}
I
Imre Deak 已提交
577 578 579 580 581 582 583 584 585 586 587

static void i915_audio_component_get_power(struct device *dev)
{
	intel_display_power_get(dev_to_i915(dev), POWER_DOMAIN_AUDIO);
}

static void i915_audio_component_put_power(struct device *dev)
{
	intel_display_power_put(dev_to_i915(dev), POWER_DOMAIN_AUDIO);
}

588 589 590 591 592 593
static void i915_audio_component_codec_wake_override(struct device *dev,
						     bool enable)
{
	struct drm_i915_private *dev_priv = dev_to_i915(dev);
	u32 tmp;

594
	if (!IS_SKYLAKE(dev_priv) && !IS_KABYLAKE(dev_priv))
595 596 597 598 599 600 601 602 603 604 605 606 607 608 609 610 611 612 613
		return;

	/*
	 * Enable/disable generating the codec wake signal, overriding the
	 * internal logic to generate the codec wake to controller.
	 */
	tmp = I915_READ(HSW_AUD_CHICKENBIT);
	tmp &= ~SKL_AUD_CODEC_WAKE_SIGNAL;
	I915_WRITE(HSW_AUD_CHICKENBIT, tmp);
	usleep_range(1000, 1500);

	if (enable) {
		tmp = I915_READ(HSW_AUD_CHICKENBIT);
		tmp |= SKL_AUD_CODEC_WAKE_SIGNAL;
		I915_WRITE(HSW_AUD_CHICKENBIT, tmp);
		usleep_range(1000, 1500);
	}
}

I
Imre Deak 已提交
614 615 616 617 618 619 620 621 622 623
/* Get CDCLK in kHz  */
static int i915_audio_component_get_cdclk_freq(struct device *dev)
{
	struct drm_i915_private *dev_priv = dev_to_i915(dev);
	int ret;

	if (WARN_ON_ONCE(!HAS_DDI(dev_priv)))
		return -ENODEV;

	intel_display_power_get(dev_priv, POWER_DOMAIN_AUDIO);
624 625
	ret = dev_priv->display.get_display_clock_speed(dev_priv->dev);

I
Imre Deak 已提交
626 627 628 629 630
	intel_display_power_put(dev_priv, POWER_DOMAIN_AUDIO);

	return ret;
}

631 632 633 634 635 636 637 638 639
static int i915_audio_component_sync_audio_rate(struct device *dev,
						int port, int rate)
{
	struct drm_i915_private *dev_priv = dev_to_i915(dev);
	struct drm_device *drm_dev = dev_priv->dev;
	struct intel_encoder *intel_encoder;
	struct intel_digital_port *intel_dig_port;
	struct intel_crtc *crtc;
	struct drm_display_mode *mode;
640
	struct i915_audio_component *acomp = dev_priv->audio_component;
641 642
	enum pipe pipe = -1;
	u32 tmp;
643
	int n;
644

645
	/* HSW, BDW, SKL, KBL need this fix */
646
	if (!IS_SKYLAKE(dev_priv) &&
647 648 649
	    !IS_KABYLAKE(dev_priv) &&
	    !IS_BROADWELL(dev_priv) &&
	    !IS_HASWELL(dev_priv))
650 651 652 653 654 655 656 657 658 659 660 661 662 663 664 665 666 667 668 669 670 671 672 673 674 675 676 677
		return 0;

	mutex_lock(&dev_priv->av_mutex);
	/* 1. get the pipe */
	for_each_intel_encoder(drm_dev, intel_encoder) {
		if (intel_encoder->type != INTEL_OUTPUT_HDMI)
			continue;
		intel_dig_port = enc_to_dig_port(&intel_encoder->base);
		if (port == intel_dig_port->port) {
			crtc = to_intel_crtc(intel_encoder->base.crtc);
			if (!crtc) {
				DRM_DEBUG_KMS("%s: crtc is NULL\n", __func__);
				continue;
			}
			pipe = crtc->pipe;
			break;
		}
	}

	if (pipe == INVALID_PIPE) {
		DRM_DEBUG_KMS("no pipe for the port %c\n", port_name(port));
		mutex_unlock(&dev_priv->av_mutex);
		return -ENODEV;
	}
	DRM_DEBUG_KMS("pipe %c connects port %c\n",
				  pipe_name(pipe), port_name(port));
	mode = &crtc->config->base.adjusted_mode;

678 679 680
	/* port must be valid now, otherwise the pipe will be invalid */
	acomp->aud_sample_rate[port] = rate;

681 682 683 684 685 686 687 688 689 690 691 692 693 694 695 696 697 698 699 700
	/* 2. check whether to set the N/CTS/M manually or not */
	if (!audio_rate_need_prog(crtc, mode)) {
		tmp = I915_READ(HSW_AUD_CFG(pipe));
		tmp &= ~AUD_CONFIG_N_PROG_ENABLE;
		I915_WRITE(HSW_AUD_CFG(pipe), tmp);
		mutex_unlock(&dev_priv->av_mutex);
		return 0;
	}

	n = audio_config_get_n(mode, rate);
	if (n == 0) {
		DRM_DEBUG_KMS("Using automatic mode for N value on port %c\n",
					  port_name(port));
		tmp = I915_READ(HSW_AUD_CFG(pipe));
		tmp &= ~AUD_CONFIG_N_PROG_ENABLE;
		I915_WRITE(HSW_AUD_CFG(pipe), tmp);
		mutex_unlock(&dev_priv->av_mutex);
		return 0;
	}

701
	/* 3. set the N/CTS/M */
702
	tmp = I915_READ(HSW_AUD_CFG(pipe));
703
	tmp = audio_config_setup_n_reg(n, tmp);
704 705 706 707 708 709
	I915_WRITE(HSW_AUD_CFG(pipe), tmp);

	mutex_unlock(&dev_priv->av_mutex);
	return 0;
}

I
Imre Deak 已提交
710 711 712 713
static const struct i915_audio_component_ops i915_audio_component_ops = {
	.owner		= THIS_MODULE,
	.get_power	= i915_audio_component_get_power,
	.put_power	= i915_audio_component_put_power,
714
	.codec_wake_override = i915_audio_component_codec_wake_override,
I
Imre Deak 已提交
715
	.get_cdclk_freq	= i915_audio_component_get_cdclk_freq,
716
	.sync_audio_rate = i915_audio_component_sync_audio_rate,
I
Imre Deak 已提交
717 718 719 720 721 722
};

static int i915_audio_component_bind(struct device *i915_dev,
				     struct device *hda_dev, void *data)
{
	struct i915_audio_component *acomp = data;
723
	struct drm_i915_private *dev_priv = dev_to_i915(i915_dev);
724
	int i;
I
Imre Deak 已提交
725 726 727 728

	if (WARN_ON(acomp->ops || acomp->dev))
		return -EEXIST;

729
	drm_modeset_lock_all(dev_priv->dev);
I
Imre Deak 已提交
730 731
	acomp->ops = &i915_audio_component_ops;
	acomp->dev = i915_dev;
732 733 734
	BUILD_BUG_ON(MAX_PORTS != I915_MAX_PORTS);
	for (i = 0; i < ARRAY_SIZE(acomp->aud_sample_rate); i++)
		acomp->aud_sample_rate[i] = 0;
735
	dev_priv->audio_component = acomp;
736
	drm_modeset_unlock_all(dev_priv->dev);
I
Imre Deak 已提交
737 738 739 740 741 742 743 744

	return 0;
}

static void i915_audio_component_unbind(struct device *i915_dev,
					struct device *hda_dev, void *data)
{
	struct i915_audio_component *acomp = data;
745
	struct drm_i915_private *dev_priv = dev_to_i915(i915_dev);
I
Imre Deak 已提交
746

747
	drm_modeset_lock_all(dev_priv->dev);
I
Imre Deak 已提交
748 749
	acomp->ops = NULL;
	acomp->dev = NULL;
750
	dev_priv->audio_component = NULL;
751
	drm_modeset_unlock_all(dev_priv->dev);
I
Imre Deak 已提交
752 753 754 755 756 757 758 759 760 761 762 763 764 765 766 767 768 769 770 771 772 773 774 775 776 777 778 779 780 781 782 783 784 785 786 787 788 789 790 791 792 793 794 795 796 797 798 799 800 801 802 803
}

static const struct component_ops i915_audio_component_bind_ops = {
	.bind	= i915_audio_component_bind,
	.unbind	= i915_audio_component_unbind,
};

/**
 * i915_audio_component_init - initialize and register the audio component
 * @dev_priv: i915 device instance
 *
 * This will register with the component framework a child component which
 * will bind dynamically to the snd_hda_intel driver's corresponding master
 * component when the latter is registered. During binding the child
 * initializes an instance of struct i915_audio_component which it receives
 * from the master. The master can then start to use the interface defined by
 * this struct. Each side can break the binding at any point by deregistering
 * its own component after which each side's component unbind callback is
 * called.
 *
 * We ignore any error during registration and continue with reduced
 * functionality (i.e. without HDMI audio).
 */
void i915_audio_component_init(struct drm_i915_private *dev_priv)
{
	int ret;

	ret = component_add(dev_priv->dev->dev, &i915_audio_component_bind_ops);
	if (ret < 0) {
		DRM_ERROR("failed to add audio component (%d)\n", ret);
		/* continue with reduced functionality */
		return;
	}

	dev_priv->audio_component_registered = true;
}

/**
 * i915_audio_component_cleanup - deregister the audio component
 * @dev_priv: i915 device instance
 *
 * Deregisters the audio component, breaking any existing binding to the
 * corresponding snd_hda_intel driver's master component.
 */
void i915_audio_component_cleanup(struct drm_i915_private *dev_priv)
{
	if (!dev_priv->audio_component_registered)
		return;

	component_del(dev_priv->dev->dev, &i915_audio_component_bind_ops);
	dev_priv->audio_component_registered = false;
}