intel_audio.c 23.9 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>
Imre Deak's avatar
Imre Deak committed
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
53
54
 *
 * 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.)
 */

55
static const struct {
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
	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 },
};

71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
/* 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 },
};

96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
/* get AUD_CONFIG_PIXEL_CLOCK_HDMI_* value for mode */
static u32 audio_config_hdmi_pixel_clock(struct drm_display_mode *mode)
{
	int i;

	for (i = 0; i < ARRAY_SIZE(hdmi_audio_clock); i++) {
		if (mode->clock == hdmi_audio_clock[i].clock)
			break;
	}

	if (i == ARRAY_SIZE(hdmi_audio_clock)) {
		DRM_DEBUG_KMS("HDMI audio pixel clock setting for %d not found, falling back to defaults\n", mode->clock);
		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;
}

118
119
120
121
122
123
124
125
126
127
128
129
130
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;
}

131
132
133
134
135
136
137
138
139
140
141
142
143
144
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;
}

145
146
/* check whether N/CTS/M need be set manually */
static bool audio_rate_need_prog(struct intel_crtc *crtc,
147
				 const struct drm_display_mode *mode)
148
149
150
151
152
153
154
155
156
{
	if (((mode->clock == TMDS_297M) ||
		 (mode->clock == TMDS_296M)) &&
		intel_pipe_has_type(crtc, INTEL_OUTPUT_HDMI))
		return true;
	else
		return false;
}

157
158
159
160
161
162
163
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;
164
165
	uint32_t tmp;
	int i;
166

167
168
	tmp = I915_READ(reg_eldv);
	tmp &= bits_eldv;
169

170
	if (!tmp)
171
172
		return false;

173
174
175
	tmp = I915_READ(reg_elda);
	tmp &= ~bits_elda;
	I915_WRITE(reg_elda, tmp);
176

177
	for (i = 0; i < drm_eld_size(eld) / 4; i++)
178
179
180
181
182
183
		if (I915_READ(reg_edid) != *((uint32_t *)eld + i))
			return false;

	return true;
}

184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
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);
}

203
204
205
static void g4x_audio_codec_enable(struct drm_connector *connector,
				   struct intel_encoder *encoder,
				   struct drm_display_mode *mode)
206
207
208
209
{
	struct drm_i915_private *dev_priv = connector->dev->dev_private;
	uint8_t *eld = connector->eld;
	uint32_t eldv;
210
211
	uint32_t tmp;
	int len, i;
212

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

215
216
	tmp = I915_READ(G4X_AUD_VID_DID);
	if (tmp == INTEL_AUDIO_DEVBLC || tmp == INTEL_AUDIO_DEVCL)
217
218
219
220
221
222
		eldv = G4X_ELDV_DEVCL_DEVBLC;
	else
		eldv = G4X_ELDV_DEVCTG;

	if (intel_eld_uptodate(connector,
			       G4X_AUD_CNTL_ST, eldv,
223
			       G4X_AUD_CNTL_ST, G4X_ELD_ADDR_MASK,
224
225
226
			       G4X_HDMIW_HDMIEDID))
		return;

227
	tmp = I915_READ(G4X_AUD_CNTL_ST);
228
	tmp &= ~(eldv | G4X_ELD_ADDR_MASK);
229
230
	len = (tmp >> 9) & 0x1f;		/* ELD buffer size */
	I915_WRITE(G4X_AUD_CNTL_ST, tmp);
231

232
	len = min(drm_eld_size(eld) / 4, len);
233
234
235
236
	DRM_DEBUG_DRIVER("ELD size %d\n", len);
	for (i = 0; i < len; i++)
		I915_WRITE(G4X_HDMIW_HDMIEDID, *((uint32_t *)eld + i));

237
238
239
	tmp = I915_READ(G4X_AUD_CNTL_ST);
	tmp |= eldv;
	I915_WRITE(G4X_AUD_CNTL_ST, tmp);
240
241
}

242
243
static void hsw_audio_codec_disable(struct intel_encoder *encoder)
{
244
245
246
	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;
247
248
	uint32_t tmp;

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

251
252
	mutex_lock(&dev_priv->av_mutex);

253
254
255
256
257
258
259
260
261
262
263
	/* 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 */
264
	tmp = I915_READ(HSW_AUD_PIN_ELD_CP_VLD);
265
	tmp &= ~AUDIO_ELD_VALID(pipe);
266
	tmp &= ~AUDIO_OUTPUT_ENABLE(pipe);
267
	I915_WRITE(HSW_AUD_PIN_ELD_CP_VLD, tmp);
268
269

	mutex_unlock(&dev_priv->av_mutex);
270
271
272
273
274
}

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

288
	DRM_DEBUG_KMS("Enable audio codec on pipe %c, %u bytes ELD\n",
289
		      pipe_name(pipe), drm_eld_size(eld));
290

291
292
	mutex_lock(&dev_priv->av_mutex);

293
294
	/* Enable audio presence detect, invalidate ELD */
	tmp = I915_READ(HSW_AUD_PIN_ELD_CP_VLD);
295
296
	tmp |= AUDIO_OUTPUT_ENABLE(pipe);
	tmp &= ~AUDIO_ELD_VALID(pipe);
297
	I915_WRITE(HSW_AUD_PIN_ELD_CP_VLD, tmp);
298

299
300
301
302
303
304
	/*
	 * 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.
	 */
305

306
307
	/* Reset ELD write address */
	tmp = I915_READ(HSW_AUD_DIP_ELD_CTRL(pipe));
308
	tmp &= ~IBX_ELD_ADDRESS_MASK;
309
	I915_WRITE(HSW_AUD_DIP_ELD_CTRL(pipe), tmp);
310

311
	/* Up to 84 bytes of hw ELD buffer */
312
313
	len = min(drm_eld_size(eld), 84);
	for (i = 0; i < len / 4; i++)
314
		I915_WRITE(HSW_AUD_EDID_DATA(pipe), *((uint32_t *)eld + i));
315

316
	/* ELD valid */
317
	tmp = I915_READ(HSW_AUD_PIN_ELD_CP_VLD);
318
	tmp |= AUDIO_ELD_VALID(pipe);
319
	I915_WRITE(HSW_AUD_PIN_ELD_CP_VLD, tmp);
320
321
322
323
324
325
326
327
328

	/* 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
		tmp |= audio_config_hdmi_pixel_clock(mode);
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346

	tmp &= ~AUD_CONFIG_N_PROG_ENABLE;
	if (audio_rate_need_prog(intel_crtc, mode)) {
		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;
		}
		n = audio_config_get_n(mode, rate);
		if (n != 0)
			tmp = audio_config_setup_n_reg(n, tmp);
		else
			DRM_DEBUG_KMS("no suitable N value is found\n");
	}

347
	I915_WRITE(HSW_AUD_CFG(pipe), tmp);
348
349

	mutex_unlock(&dev_priv->av_mutex);
350
351
}

352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
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));

367
368
369
	if (WARN_ON(port == PORT_A))
		return;

370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
	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);

391
	eldv = IBX_ELD_VALID(port);
392
393
394
395
396
397
398

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

399
400
401
static void ilk_audio_codec_enable(struct drm_connector *connector,
				   struct intel_encoder *encoder,
				   struct drm_display_mode *mode)
402
403
{
	struct drm_i915_private *dev_priv = connector->dev->dev_private;
404
	struct intel_crtc *intel_crtc = to_intel_crtc(encoder->base.crtc);
405
406
407
408
	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;
409
410
	uint8_t *eld = connector->eld;
	uint32_t eldv;
411
412
	uint32_t tmp;
	int len, i;
413
414
415
416
	int hdmiw_hdmiedid;
	int aud_config;
	int aud_cntl_st;
	int aud_cntrl_st2;
417
418

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

421
422
423
	if (WARN_ON(port == PORT_A))
		return;

424
425
426
427
428
429
	/*
	 * 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.
	 */
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447

	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;
	}

448
	eldv = IBX_ELD_VALID(port);
449

450
	/* Invalidate ELD */
451
452
453
	tmp = I915_READ(aud_cntrl_st2);
	tmp &= ~eldv;
	I915_WRITE(aud_cntrl_st2, tmp);
454

455
	/* Reset ELD write address */
456
	tmp = I915_READ(aud_cntl_st);
457
	tmp &= ~IBX_ELD_ADDRESS_MASK;
458
	I915_WRITE(aud_cntl_st, tmp);
459

460
	/* Up to 84 bytes of hw ELD buffer */
461
462
	len = min(drm_eld_size(eld), 84);
	for (i = 0; i < len / 4; i++)
463
464
		I915_WRITE(hdmiw_hdmiedid, *((uint32_t *)eld + i));

465
	/* ELD valid */
466
467
468
	tmp = I915_READ(aud_cntrl_st2);
	tmp |= eldv;
	I915_WRITE(aud_cntrl_st2, tmp);
469
470
471
472
473
474
475
476
477
478
479

	/* 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
		tmp |= audio_config_hdmi_pixel_clock(mode);
	I915_WRITE(aud_config, tmp);
480
481
}

482
483
484
485
486
487
488
489
/**
 * 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)
490
{
491
492
	struct drm_encoder *encoder = &intel_encoder->base;
	struct intel_crtc *crtc = to_intel_crtc(encoder->crtc);
493
	struct drm_display_mode *mode = &crtc->config->base.adjusted_mode;
494
495
496
	struct drm_connector *connector;
	struct drm_device *dev = encoder->dev;
	struct drm_i915_private *dev_priv = dev->dev_private;
497
498
499
	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;
500
501
502
503
504
505
506
507
508
509
510

	connector = drm_select_eld(encoder, mode);
	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);

511
512
513
514
515
	/* ELD Conn_Type */
	connector->eld[5] &= ~(3 << 2);
	if (intel_pipe_has_type(crtc, INTEL_OUTPUT_DISPLAYPORT))
		connector->eld[5] |= (1 << 2);

516
517
	connector->eld[6] = drm_av_sync_delay(connector, mode) / 2;

518
519
	if (dev_priv->display.audio_codec_enable)
		dev_priv->display.audio_codec_enable(connector, intel_encoder, mode);
520
521

	if (acomp && acomp->audio_ops && acomp->audio_ops->pin_eld_notify)
522
		acomp->audio_ops->pin_eld_notify(acomp->audio_ops->audio_ptr, (int) port);
523
524
525
526
527
528
529
530
531
}

/**
 * intel_audio_codec_disable - Disable the audio codec for HD audio
 * @encoder: encoder on which to disable audio
 *
 * The disable sequences must be performed before disabling the transcoder or
 * port.
 */
532
void intel_audio_codec_disable(struct intel_encoder *intel_encoder)
533
{
534
535
	struct drm_encoder *encoder = &intel_encoder->base;
	struct drm_device *dev = encoder->dev;
536
	struct drm_i915_private *dev_priv = dev->dev_private;
537
538
539
	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;
540
541

	if (dev_priv->display.audio_codec_disable)
542
543
544
		dev_priv->display.audio_codec_disable(intel_encoder);

	if (acomp && acomp->audio_ops && acomp->audio_ops->pin_eld_notify)
545
		acomp->audio_ops->pin_eld_notify(acomp->audio_ops->audio_ptr, (int) port);
546
547
548
549
550
551
552
553
554
555
}

/**
 * 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;

556
557
	if (IS_G4X(dev)) {
		dev_priv->display.audio_codec_enable = g4x_audio_codec_enable;
558
		dev_priv->display.audio_codec_disable = g4x_audio_codec_disable;
559
560
	} else if (IS_VALLEYVIEW(dev)) {
		dev_priv->display.audio_codec_enable = ilk_audio_codec_enable;
561
		dev_priv->display.audio_codec_disable = ilk_audio_codec_disable;
562
563
564
565
566
	} 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;
567
		dev_priv->display.audio_codec_disable = ilk_audio_codec_disable;
568
	}
569
}
Imre Deak's avatar
Imre Deak committed
570
571
572
573
574
575
576
577
578
579
580

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);
}

581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
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;

	if (!IS_SKYLAKE(dev_priv))
		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);
	}
}

Imre Deak's avatar
Imre Deak committed
607
608
609
610
611
612
613
614
615
616
/* 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);
617
618
	ret = dev_priv->display.get_display_clock_speed(dev_priv->dev);

Imre Deak's avatar
Imre Deak committed
619
620
621
622
623
	intel_display_power_put(dev_priv, POWER_DOMAIN_AUDIO);

	return ret;
}

624
625
626
627
628
629
630
631
632
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;
633
	struct i915_audio_component *acomp = dev_priv->audio_component;
634
635
	enum pipe pipe = -1;
	u32 tmp;
636
	int n;
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669

	/* HSW, BDW SKL need this fix */
	if (!IS_SKYLAKE(dev_priv) &&
		!IS_BROADWELL(dev_priv) &&
		!IS_HASWELL(dev_priv))
		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;

670
671
672
	/* port must be valid now, otherwise the pipe will be invalid */
	acomp->aud_sample_rate[port] = rate;

673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
	/* 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;
	}

693
	/* 3. set the N/CTS/M */
694
	tmp = I915_READ(HSW_AUD_CFG(pipe));
695
	tmp = audio_config_setup_n_reg(n, tmp);
696
697
698
699
700
701
	I915_WRITE(HSW_AUD_CFG(pipe), tmp);

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

Imre Deak's avatar
Imre Deak committed
702
703
704
705
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,
706
	.codec_wake_override = i915_audio_component_codec_wake_override,
Imre Deak's avatar
Imre Deak committed
707
	.get_cdclk_freq	= i915_audio_component_get_cdclk_freq,
708
	.sync_audio_rate = i915_audio_component_sync_audio_rate,
Imre Deak's avatar
Imre Deak committed
709
710
711
712
713
714
};

static int i915_audio_component_bind(struct device *i915_dev,
				     struct device *hda_dev, void *data)
{
	struct i915_audio_component *acomp = data;
715
	struct drm_i915_private *dev_priv = dev_to_i915(i915_dev);
716
	int i;
Imre Deak's avatar
Imre Deak committed
717
718
719
720

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

721
	drm_modeset_lock_all(dev_priv->dev);
Imre Deak's avatar
Imre Deak committed
722
723
	acomp->ops = &i915_audio_component_ops;
	acomp->dev = i915_dev;
724
725
726
	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;
727
	dev_priv->audio_component = acomp;
728
	drm_modeset_unlock_all(dev_priv->dev);
Imre Deak's avatar
Imre Deak committed
729
730
731
732
733
734
735
736

	return 0;
}

static void i915_audio_component_unbind(struct device *i915_dev,
					struct device *hda_dev, void *data)
{
	struct i915_audio_component *acomp = data;
737
	struct drm_i915_private *dev_priv = dev_to_i915(i915_dev);
Imre Deak's avatar
Imre Deak committed
738

739
	drm_modeset_lock_all(dev_priv->dev);
Imre Deak's avatar
Imre Deak committed
740
741
	acomp->ops = NULL;
	acomp->dev = NULL;
742
	dev_priv->audio_component = NULL;
743
	drm_modeset_unlock_all(dev_priv->dev);
Imre Deak's avatar
Imre Deak committed
744
745
746
747
748
749
750
751
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
}

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;
}