patch_intelhdmi.c 20.2 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 27 28 29 30 31 32 33 34 35
/*
 *
 *  patch_intelhdmi.c - Patch for Intel HDMI codecs
 *
 *  Copyright(c) 2008 Intel Corporation. All rights reserved.
 *
 *  Authors:
 *  			Jiang Zhe <zhe.jiang@intel.com>
 *  			Wu Fengguang <wfg@linux.intel.com>
 *
 *  Maintained by:
 *  			Wu Fengguang <wfg@linux.intel.com>
 *
 *  This program is free software; you can redistribute it and/or modify it
 *  under the terms of the GNU General Public License as published by the Free
 *  Software Foundation; either version 2 of the License, or (at your option)
 *  any later version.
 *
 *  This program is distributed in the hope that it will be useful, but
 *  WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
 *  or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
 *  for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program; if not, write to the Free Software Foundation,
 *  Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
 */

#include <linux/init.h>
#include <linux/delay.h>
#include <linux/slab.h>
#include <sound/core.h>
#include "hda_codec.h"
#include "hda_local.h"

36 37
static hda_nid_t cvt_nid;	/* audio converter */
static hda_nid_t pin_nid;	/* HDMI output pin */
38 39 40 41 42

#define INTEL_HDMI_EVENT_TAG		0x08

struct intel_hdmi_spec {
	struct hda_pcm pcm_rec;
43
	struct hdmi_eld sink_eld;
44 45 46 47 48 49 50 51 52 53 54 55 56
};

struct hdmi_audio_infoframe {
	u8 type; /* 0x84 */
	u8 ver;  /* 0x01 */
	u8 len;  /* 0x0a */

	u8 checksum;	/* PB0 */
	u8 CC02_CT47;	/* CC in bits 0:2, CT in 4:7 */
	u8 SS01_SF24;
	u8 CXT04;
	u8 CA;
	u8 LFEPBL01_LSV36_DM_INH7;
W
Wu Fengguang 已提交
57
	u8 reserved[5];	/* PB6 - PB10 */
58 59
};

60 61 62 63 64 65 66 67 68 69 70 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 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131
/*
 * CEA speaker placement:
 *
 *        FLH       FCH        FRH
 *  FLW    FL  FLC   FC   FRC   FR   FRW
 *
 *                                  LFE
 *                     TC
 *
 *          RL  RLC   RC   RRC   RR
 *
 * The Left/Right Surround channel _notions_ LS/RS in SMPTE 320M corresponds to
 * CEA RL/RR; The SMPTE channel _assignment_ C/LFE is swapped to CEA LFE/FC.
 */
enum cea_speaker_placement {
	FL  = (1 <<  0),	/* Front Left           */
	FC  = (1 <<  1),	/* Front Center         */
	FR  = (1 <<  2),	/* Front Right          */
	FLC = (1 <<  3),	/* Front Left Center    */
	FRC = (1 <<  4),	/* Front Right Center   */
	RL  = (1 <<  5),	/* Rear Left            */
	RC  = (1 <<  6),	/* Rear Center          */
	RR  = (1 <<  7),	/* Rear Right           */
	RLC = (1 <<  8),	/* Rear Left Center     */
	RRC = (1 <<  9),	/* Rear Right Center    */
	LFE = (1 << 10),	/* Low Frequency Effect */
	FLW = (1 << 11),	/* Front Left Wide      */
	FRW = (1 << 12),	/* Front Right Wide     */
	FLH = (1 << 13),	/* Front Left High      */
	FCH = (1 << 14),	/* Front Center High    */
	FRH = (1 << 15),	/* Front Right High     */
	TC  = (1 << 16),	/* Top Center           */
};

/*
 * ELD SA bits in the CEA Speaker Allocation data block
 */
static int eld_speaker_allocation_bits[] = {
	[0] = FL | FR,
	[1] = LFE,
	[2] = FC,
	[3] = RL | RR,
	[4] = RC,
	[5] = FLC | FRC,
	[6] = RLC | RRC,
	/* the following are not defined in ELD yet */
	[7] = FLW | FRW,
	[8] = FLH | FRH,
	[9] = TC,
	[10] = FCH,
};

struct cea_channel_speaker_allocation {
	int ca_index;
	int speakers[8];

	/* derived values, just for convenience */
	int channels;
	int spk_mask;
};

/*
 * This is an ordered list!
 *
 * The preceding ones have better chances to be selected by
 * hdmi_setup_channel_allocation().
 */
static struct cea_channel_speaker_allocation channel_allocations[] = {
/* 			  channel:   8     7    6    5    4     3    2    1  */
{ .ca_index = 0x00,  .speakers = {   0,    0,   0,   0,   0,    0,  FR,  FL } },
				 /* 2.1 */
{ .ca_index = 0x01,  .speakers = {   0,    0,   0,   0,   0,  LFE,  FR,  FL } },
W
Wu Fengguang 已提交
132
				 /* Dolby Surround */
133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185
{ .ca_index = 0x02,  .speakers = {   0,    0,   0,   0,  FC,    0,  FR,  FL } },
{ .ca_index = 0x03,  .speakers = {   0,    0,   0,   0,  FC,  LFE,  FR,  FL } },
{ .ca_index = 0x04,  .speakers = {   0,    0,   0,  RC,   0,    0,  FR,  FL } },
{ .ca_index = 0x05,  .speakers = {   0,    0,   0,  RC,   0,  LFE,  FR,  FL } },
{ .ca_index = 0x06,  .speakers = {   0,    0,   0,  RC,  FC,    0,  FR,  FL } },
{ .ca_index = 0x07,  .speakers = {   0,    0,   0,  RC,  FC,  LFE,  FR,  FL } },
{ .ca_index = 0x08,  .speakers = {   0,    0,  RR,  RL,   0,    0,  FR,  FL } },
{ .ca_index = 0x09,  .speakers = {   0,    0,  RR,  RL,   0,  LFE,  FR,  FL } },
{ .ca_index = 0x0a,  .speakers = {   0,    0,  RR,  RL,  FC,    0,  FR,  FL } },
				 /* 5.1 */
{ .ca_index = 0x0b,  .speakers = {   0,    0,  RR,  RL,  FC,  LFE,  FR,  FL } },
{ .ca_index = 0x0c,  .speakers = {   0,   RC,  RR,  RL,   0,    0,  FR,  FL } },
{ .ca_index = 0x0d,  .speakers = {   0,   RC,  RR,  RL,   0,  LFE,  FR,  FL } },
{ .ca_index = 0x0e,  .speakers = {   0,   RC,  RR,  RL,  FC,    0,  FR,  FL } },
				 /* 6.1 */
{ .ca_index = 0x0f,  .speakers = {   0,   RC,  RR,  RL,  FC,  LFE,  FR,  FL } },
{ .ca_index = 0x10,  .speakers = { RRC,  RLC,  RR,  RL,   0,    0,  FR,  FL } },
{ .ca_index = 0x11,  .speakers = { RRC,  RLC,  RR,  RL,   0,  LFE,  FR,  FL } },
{ .ca_index = 0x12,  .speakers = { RRC,  RLC,  RR,  RL,  FC,    0,  FR,  FL } },
				 /* 7.1 */
{ .ca_index = 0x13,  .speakers = { RRC,  RLC,  RR,  RL,  FC,  LFE,  FR,  FL } },
{ .ca_index = 0x14,  .speakers = { FRC,  FLC,   0,   0,   0,    0,  FR,  FL } },
{ .ca_index = 0x15,  .speakers = { FRC,  FLC,   0,   0,   0,  LFE,  FR,  FL } },
{ .ca_index = 0x16,  .speakers = { FRC,  FLC,   0,   0,  FC,    0,  FR,  FL } },
{ .ca_index = 0x17,  .speakers = { FRC,  FLC,   0,   0,  FC,  LFE,  FR,  FL } },
{ .ca_index = 0x18,  .speakers = { FRC,  FLC,   0,  RC,   0,    0,  FR,  FL } },
{ .ca_index = 0x19,  .speakers = { FRC,  FLC,   0,  RC,   0,  LFE,  FR,  FL } },
{ .ca_index = 0x1a,  .speakers = { FRC,  FLC,   0,  RC,  FC,    0,  FR,  FL } },
{ .ca_index = 0x1b,  .speakers = { FRC,  FLC,   0,  RC,  FC,  LFE,  FR,  FL } },
{ .ca_index = 0x1c,  .speakers = { FRC,  FLC,  RR,  RL,   0,    0,  FR,  FL } },
{ .ca_index = 0x1d,  .speakers = { FRC,  FLC,  RR,  RL,   0,  LFE,  FR,  FL } },
{ .ca_index = 0x1e,  .speakers = { FRC,  FLC,  RR,  RL,  FC,    0,  FR,  FL } },
{ .ca_index = 0x1f,  .speakers = { FRC,  FLC,  RR,  RL,  FC,  LFE,  FR,  FL } },
{ .ca_index = 0x20,  .speakers = {   0,  FCH,  RR,  RL,  FC,    0,  FR,  FL } },
{ .ca_index = 0x21,  .speakers = {   0,  FCH,  RR,  RL,  FC,  LFE,  FR,  FL } },
{ .ca_index = 0x22,  .speakers = {  TC,    0,  RR,  RL,  FC,    0,  FR,  FL } },
{ .ca_index = 0x23,  .speakers = {  TC,    0,  RR,  RL,  FC,  LFE,  FR,  FL } },
{ .ca_index = 0x24,  .speakers = { FRH,  FLH,  RR,  RL,   0,    0,  FR,  FL } },
{ .ca_index = 0x25,  .speakers = { FRH,  FLH,  RR,  RL,   0,  LFE,  FR,  FL } },
{ .ca_index = 0x26,  .speakers = { FRW,  FLW,  RR,  RL,   0,    0,  FR,  FL } },
{ .ca_index = 0x27,  .speakers = { FRW,  FLW,  RR,  RL,   0,  LFE,  FR,  FL } },
{ .ca_index = 0x28,  .speakers = {  TC,   RC,  RR,  RL,  FC,    0,  FR,  FL } },
{ .ca_index = 0x29,  .speakers = {  TC,   RC,  RR,  RL,  FC,  LFE,  FR,  FL } },
{ .ca_index = 0x2a,  .speakers = { FCH,   RC,  RR,  RL,  FC,    0,  FR,  FL } },
{ .ca_index = 0x2b,  .speakers = { FCH,   RC,  RR,  RL,  FC,  LFE,  FR,  FL } },
{ .ca_index = 0x2c,  .speakers = {  TC,  FCH,  RR,  RL,  FC,    0,  FR,  FL } },
{ .ca_index = 0x2d,  .speakers = {  TC,  FCH,  RR,  RL,  FC,  LFE,  FR,  FL } },
{ .ca_index = 0x2e,  .speakers = { FRH,  FLH,  RR,  RL,  FC,    0,  FR,  FL } },
{ .ca_index = 0x2f,  .speakers = { FRH,  FLH,  RR,  RL,  FC,  LFE,  FR,  FL } },
{ .ca_index = 0x30,  .speakers = { FRW,  FLW,  RR,  RL,  FC,    0,  FR,  FL } },
{ .ca_index = 0x31,  .speakers = { FRW,  FLW,  RR,  RL,  FC,  LFE,  FR,  FL } },
};

186 187 188 189
/*
 * HDMI routines
 */

190
#ifdef BE_PARANOID
191
static void hdmi_get_dip_index(struct hda_codec *codec, hda_nid_t pin_nid,
192 193 194 195
				int *packet_index, int *byte_index)
{
	int val;

196 197
	val = snd_hda_codec_read(codec, pin_nid, 0,
				 AC_VERB_GET_HDMI_DIP_INDEX, 0);
198 199 200 201

	*packet_index = val >> 5;
	*byte_index = val & 0x1f;
}
202
#endif
203

204
static void hdmi_set_dip_index(struct hda_codec *codec, hda_nid_t pin_nid,
205 206 207 208 209 210
				int packet_index, int byte_index)
{
	int val;

	val = (packet_index << 5) | (byte_index & 0x1f);

211
	snd_hda_codec_write(codec, pin_nid, 0, AC_VERB_SET_HDMI_DIP_INDEX, val);
212 213
}

214
static void hdmi_write_dip_byte(struct hda_codec *codec, hda_nid_t pin_nid,
215 216
				unsigned char val)
{
217
	snd_hda_codec_write(codec, pin_nid, 0, AC_VERB_SET_HDMI_DIP_DATA, val);
218 219
}

220
static void hdmi_enable_output(struct hda_codec *codec, hda_nid_t pin_nid)
221
{
222
	/* Unmute */
223 224
	if (get_wcaps(codec, pin_nid) & AC_WCAP_OUT_AMP)
		snd_hda_codec_write(codec, pin_nid, 0,
225 226
				AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE);
	/* Enable pin out */
227 228
	snd_hda_codec_write(codec, pin_nid, 0,
			    AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT);
229 230
}

231 232 233
/*
 * Enable Audio InfoFrame Transmission
 */
234 235
static void hdmi_start_infoframe_trans(struct hda_codec *codec,
				       hda_nid_t pin_nid)
236
{
237 238
	hdmi_set_dip_index(codec, pin_nid, 0x0, 0x0);
	snd_hda_codec_write(codec, pin_nid, 0, AC_VERB_SET_HDMI_DIP_XMIT,
239 240
						AC_DIPXMIT_BEST);
}
241

242 243 244
/*
 * Disable Audio InfoFrame Transmission
 */
245 246
static void hdmi_stop_infoframe_trans(struct hda_codec *codec,
				      hda_nid_t pin_nid)
247
{
248 249
	hdmi_set_dip_index(codec, pin_nid, 0x0, 0x0);
	snd_hda_codec_write(codec, pin_nid, 0, AC_VERB_SET_HDMI_DIP_XMIT,
250
						AC_DIPXMIT_DISABLE);
251 252
}

253
static int hdmi_get_channel_count(struct hda_codec *codec, hda_nid_t nid)
254
{
255
	return 1 + snd_hda_codec_read(codec, nid, 0,
256 257 258
					AC_VERB_GET_CVT_CHAN_COUNT, 0);
}

259 260
static void hdmi_set_channel_count(struct hda_codec *codec,
				   hda_nid_t nid, int chs)
261
{
262
	snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_CVT_CHAN_COUNT, chs - 1);
263

264 265
#ifdef CONFIG_SND_DEBUG_VERBOSE
	if (chs != hdmi_get_channel_count(codec, nid))
266
		snd_printd(KERN_INFO "HDMI channel count: expect %d, get %d\n",
267 268
			   chs, hdmi_get_channel_count(codec, nid));
#endif
269 270
}

271
static void hdmi_debug_channel_mapping(struct hda_codec *codec, hda_nid_t nid)
272 273 274 275 276 277
{
#ifdef CONFIG_SND_DEBUG_VERBOSE
	int i;
	int slot;

	for (i = 0; i < 8; i++) {
278
		slot = snd_hda_codec_read(codec, nid, 0,
279
						AC_VERB_GET_HDMI_CHAN_SLOT, i);
280
		printk(KERN_DEBUG "HDMI: ASP channel %d => slot %d\n",
W
Wu Fengguang 已提交
281
						slot >> 4, slot & 0x7);
282 283 284 285 286 287
	}
#endif
}

static void hdmi_parse_eld(struct hda_codec *codec)
{
288
	struct intel_hdmi_spec *spec = codec->spec;
289
	struct hdmi_eld *eld = &spec->sink_eld;
290

291
	if (!snd_hdmi_get_eld(eld, codec, pin_nid))
292
		snd_hdmi_show_eld(eld);
293 294 295 296
}


/*
W
Wu Fengguang 已提交
297
 * Audio InfoFrame routines
298 299
 */

300
static void hdmi_debug_dip_size(struct hda_codec *codec, hda_nid_t pin_nid)
301 302 303 304 305
{
#ifdef CONFIG_SND_DEBUG_VERBOSE
	int i;
	int size;

306
	size = snd_hdmi_get_eld_size(codec, pin_nid);
307
	printk(KERN_DEBUG "HDMI: ELD buf size is %d\n", size);
308 309

	for (i = 0; i < 8; i++) {
310
		size = snd_hda_codec_read(codec, pin_nid, 0,
311
						AC_VERB_GET_HDMI_DIP_SIZE, i);
312
		printk(KERN_DEBUG "HDMI: DIP GP[%d] buf size is %d\n", i, size);
313 314 315 316
	}
#endif
}

317
static void hdmi_clear_dip_buffers(struct hda_codec *codec, hda_nid_t pin_nid)
318 319 320 321 322 323
{
#ifdef BE_PARANOID
	int i, j;
	int size;
	int pi, bi;
	for (i = 0; i < 8; i++) {
324
		size = snd_hda_codec_read(codec, pin_nid, 0,
325 326 327 328
						AC_VERB_GET_HDMI_DIP_SIZE, i);
		if (size == 0)
			continue;

329
		hdmi_set_dip_index(codec, pin_nid, i, 0x0);
330
		for (j = 1; j < 1000; j++) {
331 332
			hdmi_write_dip_byte(codec, pin_nid, 0x0);
			hdmi_get_dip_index(codec, pin_nid, &pi, &bi);
333 334 335 336 337 338 339
			if (pi != i)
				snd_printd(KERN_INFO "dip index %d: %d != %d\n",
						bi, pi, i);
			if (bi == 0) /* byte index wrapped around */
				break;
		}
		snd_printd(KERN_INFO
340 341
			"HDMI: DIP GP[%d] buf reported size=%d, written=%d\n",
			i, size, j);
342 343 344 345
	}
#endif
}

346
static void hdmi_fill_audio_infoframe(struct hda_codec *codec,
347 348
				      hda_nid_t pin_nid,
				      struct hdmi_audio_infoframe *ai)
349 350
{
	u8 *params = (u8 *)ai;
351
	u8 sum = 0;
352 353
	int i;

354 355
	hdmi_debug_dip_size(codec, pin_nid);
	hdmi_clear_dip_buffers(codec, pin_nid); /* be paranoid */
356

357 358 359 360
	for (i = 0; i < sizeof(ai); i++)
		sum += params[i];
	ai->checksum = - sum;

361
	hdmi_set_dip_index(codec, pin_nid, 0x0, 0x0);
362
	for (i = 0; i < sizeof(ai); i++)
363
		hdmi_write_dip_byte(codec, pin_nid, params[i]);
364 365
}

366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393
/*
 * Compute derived values in channel_allocations[].
 */
static void init_channel_allocations(void)
{
	int i, j;
	struct cea_channel_speaker_allocation *p;

	for (i = 0; i < ARRAY_SIZE(channel_allocations); i++) {
		p = channel_allocations + i;
		p->channels = 0;
		p->spk_mask = 0;
		for (j = 0; j < ARRAY_SIZE(p->speakers); j++)
			if (p->speakers[j]) {
				p->channels++;
				p->spk_mask |= p->speakers[j];
			}
	}
}

/*
 * The transformation takes two steps:
 *
 * 	eld->spk_alloc => (eld_speaker_allocation_bits[]) => spk_mask
 * 	      spk_mask => (channel_allocations[])         => ai->CA
 *
 * TODO: it could select the wrong CA from multiple candidates.
*/
394
static int hdmi_setup_channel_allocation(struct hda_codec *codec, hda_nid_t nid,
395 396 397
					 struct hdmi_audio_infoframe *ai)
{
	struct intel_hdmi_spec *spec = codec->spec;
398
	struct hdmi_eld *eld = &spec->sink_eld;
399 400 401 402 403 404 405 406 407 408 409
	int i;
	int spk_mask = 0;
	int channels = 1 + (ai->CC02_CT47 & 0x7);
	char buf[SND_PRINT_CHANNEL_ALLOCATION_ADVISED_BUFSIZE];

	/*
	 * CA defaults to 0 for basic stereo audio
	 */
	if (channels <= 2)
		return 0;

410 411 412 413 414 415 416 417
	/*
	 * HDMI sink's ELD info cannot always be retrieved for now, e.g.
	 * in console or for audio devices. Assume the highest speakers
	 * configuration, to _not_ prohibit multi-channel audio playback.
	 */
	if (!eld->spk_alloc)
		eld->spk_alloc = 0xffff;

418 419 420 421
	/*
	 * expand ELD's speaker allocation mask
	 *
	 * ELD tells the speaker mask in a compact(paired) form,
422
	 * expand ELD's notions to match the ones used by Audio InfoFrame.
423 424 425 426 427 428 429 430 431 432 433 434
	 */
	for (i = 0; i < ARRAY_SIZE(eld_speaker_allocation_bits); i++) {
		if (eld->spk_alloc & (1 << i))
			spk_mask |= eld_speaker_allocation_bits[i];
	}

	/* search for the first working match in the CA table */
	for (i = 0; i < ARRAY_SIZE(channel_allocations); i++) {
		if (channels == channel_allocations[i].channels &&
		    (spk_mask & channel_allocations[i].spk_mask) ==
				channel_allocations[i].spk_mask) {
			ai->CA = channel_allocations[i].ca_index;
435
			break;
436 437 438 439
		}
	}

	snd_print_channel_allocation(eld->spk_alloc, buf, sizeof(buf));
440 441 442 443 444
	snd_printdd(KERN_INFO
			"HDMI: select CA 0x%x for %d-channel allocation: %s\n",
			ai->CA, channels, buf);

	return ai->CA;
445 446
}

447 448
static void hdmi_setup_channel_mapping(struct hda_codec *codec, hda_nid_t nid,
				       struct hdmi_audio_infoframe *ai)
449
{
450 451
	int i;

452 453 454 455 456 457 458 459
	if (!ai->CA)
		return;

	/*
	 * TODO: adjust channel mapping if necessary
	 * ALSA sequence is front/surr/clfe/side?
	 */

460
	for (i = 0; i < 8; i++)
461
		snd_hda_codec_write(codec, nid, 0,
462 463 464
				    AC_VERB_SET_HDMI_CHAN_SLOT,
				    (i << 4) | i);

465
	hdmi_debug_channel_mapping(codec, nid);
466 467 468
}


469
static void hdmi_setup_audio_infoframe(struct hda_codec *codec, hda_nid_t nid,
470 471
					struct snd_pcm_substream *substream)
{
472
	struct hdmi_audio_infoframe ai = {
473 474 475 476 477 478
		.type		= 0x84,
		.ver		= 0x01,
		.len		= 0x0a,
		.CC02_CT47	= substream->runtime->channels - 1,
	};

479 480
	hdmi_setup_channel_allocation(codec, nid, &ai);
	hdmi_setup_channel_mapping(codec, nid, &ai);
481

482 483
	hdmi_fill_audio_infoframe(codec, pin_nid, &ai);
	hdmi_start_infoframe_trans(codec, pin_nid);
484 485 486 487 488 489 490 491 492 493 494 495
}


/*
 * Unsolicited events
 */

static void hdmi_intrinsic_event(struct hda_codec *codec, unsigned int res)
{
	int pind = !!(res & AC_UNSOL_RES_PD);
	int eldv = !!(res & AC_UNSOL_RES_ELDV);

496 497 498
	printk(KERN_INFO
		"HDMI hot plug event: Presence_Detect=%d ELD_Valid=%d\n",
		pind, eldv);
499 500 501 502 503 504 505 506 507 508 509 510 511

	if (pind && eldv) {
		hdmi_parse_eld(codec);
		/* TODO: do real things about ELD */
	}
}

static void hdmi_non_intrinsic_event(struct hda_codec *codec, unsigned int res)
{
	int subtag = (res & AC_UNSOL_RES_SUBTAG) >> AC_UNSOL_RES_SUBTAG_SHIFT;
	int cp_state = !!(res & AC_UNSOL_RES_CP_STATE);
	int cp_ready = !!(res & AC_UNSOL_RES_CP_READY);

512 513 514 515 516
	printk(KERN_INFO
		"HDMI content protection event: SUBTAG=0x%x CP_STATE=%d CP_READY=%d\n",
		subtag,
		cp_state,
		cp_ready);
517

518
	/* TODO */
519 520 521 522 523 524 525 526 527 528 529 530 531
	if (cp_state)
		;
	if (cp_ready)
		;
}


static void intel_hdmi_unsol_event(struct hda_codec *codec, unsigned int res)
{
	int tag = res >> AC_UNSOL_RES_TAG_SHIFT;
	int subtag = (res & AC_UNSOL_RES_SUBTAG) >> AC_UNSOL_RES_SUBTAG_SHIFT;

	if (tag != INTEL_HDMI_EVENT_TAG) {
532
		snd_printd(KERN_INFO "Unexpected HDMI event tag 0x%x\n", tag);
533 534 535 536 537 538 539 540 541 542 543 544 545
		return;
	}

	if (subtag == 0)
		hdmi_intrinsic_event(codec, res);
	else
		hdmi_non_intrinsic_event(codec, res);
}

/*
 * Callbacks
 */

546
static int intel_hdmi_playback_pcm_prepare(struct hda_pcm_stream *hinfo,
547
					   struct hda_codec *codec,
548 549
					   unsigned int stream_tag,
					   unsigned int format,
550
					   struct snd_pcm_substream *substream)
551
{
552 553
	hdmi_set_channel_count(codec, cvt_nid,
			       substream->runtime->channels);
554

555
	hdmi_setup_audio_infoframe(codec, cvt_nid, substream);
556

557
	snd_hda_codec_setup_stream(codec, hinfo->nid, stream_tag, 0, format);
558
	return 0;
559 560
}

561
static int intel_hdmi_playback_pcm_cleanup(struct hda_pcm_stream *hinfo,
562 563 564
					   struct hda_codec *codec,
					   struct snd_pcm_substream *substream)
{
565
	struct intel_hdmi_spec *spec = codec->spec;
566

567
	hdmi_stop_infoframe_trans(codec, pin_nid);
568

569
	snd_hda_codec_cleanup_stream(codec, hinfo->nid);
570 571 572 573 574 575 576 577
	return 0;
}

static struct hda_pcm_stream intel_hdmi_pcm_playback = {
	.substreams = 1,
	.channels_min = 2,
	.channels_max = 8,
	.ops = {
578 579
		.prepare = intel_hdmi_playback_pcm_prepare,
		.cleanup = intel_hdmi_playback_pcm_cleanup,
580 581 582 583 584 585 586 587 588 589 590
	},
};

static int intel_hdmi_build_pcms(struct hda_codec *codec)
{
	struct intel_hdmi_spec *spec = codec->spec;
	struct hda_pcm *info = &spec->pcm_rec;

	codec->num_pcms = 1;
	codec->pcm_info = info;

591 592 593
	/* NID to query formats and rates and setup streams */
	intel_hdmi_pcm_playback.nid = cvt_nid;

594 595 596 597 598 599 600 601 602 603 604 605
	info->name = "INTEL HDMI";
	info->pcm_type = HDA_PCM_TYPE_HDMI;
	info->stream[SNDRV_PCM_STREAM_PLAYBACK] = intel_hdmi_pcm_playback;

	return 0;
}

static int intel_hdmi_build_controls(struct hda_codec *codec)
{
	struct intel_hdmi_spec *spec = codec->spec;
	int err;

606
	err = snd_hda_create_spdif_out_ctls(codec, cvt_nid);
607 608 609 610 611 612 613 614
	if (err < 0)
		return err;

	return 0;
}

static int intel_hdmi_init(struct hda_codec *codec)
{
615
	hdmi_enable_output(codec, pin_nid);
616

617 618 619
	snd_hda_codec_write(codec, pin_nid, 0,
			    AC_VERB_SET_UNSOLICITED_ENABLE,
			    AC_USRSP_EN | INTEL_HDMI_EVENT_TAG);
620 621 622 623 624
	return 0;
}

static void intel_hdmi_free(struct hda_codec *codec)
{
T
Takashi Iwai 已提交
625 626 627 628
	struct intel_hdmi_spec *spec = codec->spec;

	snd_hda_eld_proc_free(codec, &spec->sink_eld);
	kfree(spec);
629 630 631 632 633 634 635 636 637 638
}

static struct hda_codec_ops intel_hdmi_patch_ops = {
	.init			= intel_hdmi_init,
	.free			= intel_hdmi_free,
	.build_pcms		= intel_hdmi_build_pcms,
	.build_controls 	= intel_hdmi_build_controls,
	.unsol_event		= intel_hdmi_unsol_event,
};

639
static int do_patch_intel_hdmi(struct hda_codec *codec)
640 641 642 643 644 645 646 647 648 649
{
	struct intel_hdmi_spec *spec;

	spec = kzalloc(sizeof(*spec), GFP_KERNEL);
	if (spec == NULL)
		return -ENOMEM;

	codec->spec = spec;
	codec->patch_ops = intel_hdmi_patch_ops;

650
	snd_hda_eld_proc_new(codec, &spec->sink_eld);
651

652 653
	init_channel_allocations();

654 655 656
	return 0;
}

657 658 659 660 661 662 663 664 665 666 667 668 669 670
static int patch_intel_hdmi(struct hda_codec *codec)
{
	cvt_nid = 0x02;
	pin_nid = 0x03;
	return do_patch_intel_hdmi(codec);
}

static int patch_intel_hdmi_ibexpeak(struct hda_codec *codec)
{
	cvt_nid = 0x02;
	pin_nid = 0x04;
	return do_patch_intel_hdmi(codec);
}

671
static struct hda_codec_preset snd_hda_preset_intelhdmi[] = {
672 673 674 675
	{ .id = 0x808629fb, .name = "G45 DEVCL",  .patch = patch_intel_hdmi },
	{ .id = 0x80862801, .name = "G45 DEVBLC", .patch = patch_intel_hdmi },
	{ .id = 0x80862802, .name = "G45 DEVCTG", .patch = patch_intel_hdmi },
	{ .id = 0x80862803, .name = "G45 DEVELK", .patch = patch_intel_hdmi },
676
	{ .id = 0x80862804, .name = "G45 DEVIBX", .patch = patch_intel_hdmi_ibexpeak },
677
	{ .id = 0x80860054, .name = "Q57 DEVIBX", .patch = patch_intel_hdmi_ibexpeak },
678
	{ .id = 0x10951392, .name = "SiI1392 HDMI",     .patch = patch_intel_hdmi },
679 680
	{} /* terminator */
};
681 682 683 684 685

MODULE_ALIAS("snd-hda-codec-id:808629fb");
MODULE_ALIAS("snd-hda-codec-id:80862801");
MODULE_ALIAS("snd-hda-codec-id:80862802");
MODULE_ALIAS("snd-hda-codec-id:80862803");
686
MODULE_ALIAS("snd-hda-codec-id:80862804");
687
MODULE_ALIAS("snd-hda-codec-id:80860054");
688 689 690 691 692 693 694 695 696 697 698 699 700 701 702 703 704 705 706 707 708 709
MODULE_ALIAS("snd-hda-codec-id:10951392");

MODULE_LICENSE("GPL");
MODULE_DESCRIPTION("Intel HDMI HD-audio codec");

static struct hda_codec_preset_list intel_list = {
	.preset = snd_hda_preset_intelhdmi,
	.owner = THIS_MODULE,
};

static int __init patch_intelhdmi_init(void)
{
	return snd_hda_add_codec_preset(&intel_list);
}

static void __exit patch_intelhdmi_exit(void)
{
	snd_hda_delete_codec_preset(&intel_list);
}

module_init(patch_intelhdmi_init)
module_exit(patch_intelhdmi_exit)