patch_intelhdmi.c 26.0 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"

W
Wu Fengguang 已提交
36 37 38 39 40 41 42 43 44
/*
 * The HDMI/DisplayPort configuration can be highly dynamic. A graphics device
 * could support two independent pipes, each of them can be connected to one or
 * more ports (DVI, HDMI or DisplayPort).
 *
 * The HDA correspondence of pipes/ports are converter/pin nodes.
 */
#define INTEL_HDMI_CVTS	2
#define INTEL_HDMI_PINS	3
45

W
Wu Fengguang 已提交
46 47 48 49
static char *intel_hdmi_pcm_names[INTEL_HDMI_CVTS] = {
	"INTEL HDMI 0",
	"INTEL HDMI 1",
};
50 51

struct intel_hdmi_spec {
W
Wu Fengguang 已提交
52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70
	int num_cvts;
	int num_pins;
	hda_nid_t cvt[INTEL_HDMI_CVTS+1];  /* audio sources */
	hda_nid_t pin[INTEL_HDMI_PINS+1];  /* audio sinks */

	/*
	 * source connection for each pin
	 */
	hda_nid_t pin_cvt[INTEL_HDMI_PINS+1];

	/*
	 * HDMI sink attached to each pin
	 */
	struct hdmi_eld sink_eld[INTEL_HDMI_PINS];

	/*
	 * export one pcm per pipe
	 */
	struct hda_pcm	pcm_rec[INTEL_HDMI_CVTS];
71 72 73 74 75 76 77 78 79 80 81 82 83
};

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 已提交
84
	u8 reserved[5];	/* PB6 - PB10 */
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 132 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
/*
 * 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 已提交
159
				 /* Dolby Surround */
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 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212
{ .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 } },
};

W
Wu Fengguang 已提交
213

214 215 216 217
/*
 * HDA/HDMI auto parsing
 */

W
Wu Fengguang 已提交
218 219 220 221 222 223 224 225 226 227 228 229
static int hda_node_index(hda_nid_t *nids, hda_nid_t nid)
{
	int i;

	for (i = 0; nids[i]; i++)
		if (nids[i] == nid)
			return i;

	snd_printk(KERN_WARNING "HDMI: nid %d not registered\n", nid);
	return -EINVAL;
}

230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261
static int intel_hdmi_read_pin_conn(struct hda_codec *codec, hda_nid_t pin_nid)
{
	struct intel_hdmi_spec *spec = codec->spec;
	hda_nid_t conn_list[HDA_MAX_CONNECTIONS];
	int conn_len, curr;
	int index;

	if (!(get_wcaps(codec, pin_nid) & AC_WCAP_CONN_LIST)) {
		snd_printk(KERN_WARNING
			   "HDMI: pin %d wcaps %#x "
			   "does not support connection list\n",
			   pin_nid, get_wcaps(codec, pin_nid));
		return -EINVAL;
	}

	conn_len = snd_hda_get_connections(codec, pin_nid, conn_list,
					   HDA_MAX_CONNECTIONS);
	if (conn_len > 1)
		curr = snd_hda_codec_read(codec, pin_nid, 0,
					  AC_VERB_GET_CONNECT_SEL, 0);
	else
		curr = 0;

	index = hda_node_index(spec->pin, pin_nid);
	if (index < 0)
		return -EINVAL;

	spec->pin_cvt[index] = conn_list[curr];

	return 0;
}

262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280
static void hdmi_get_show_eld(struct hda_codec *codec, hda_nid_t pin_nid,
			      struct hdmi_eld *eld)
{
	if (!snd_hdmi_get_eld(eld, codec, pin_nid))
		snd_hdmi_show_eld(eld);
}

static void hdmi_present_sense(struct hda_codec *codec, hda_nid_t pin_nid,
			       struct hdmi_eld *eld)
{
	int present = snd_hda_pin_sense(codec, pin_nid);

	eld->monitor_present	= !!(present & AC_PINSENSE_PRESENCE);
	eld->eld_valid		= !!(present & AC_PINSENSE_ELDV);

	if (present & AC_PINSENSE_ELDV)
		hdmi_get_show_eld(codec, pin_nid, eld);
}

281 282 283 284 285 286 287 288 289 290
static int intel_hdmi_add_pin(struct hda_codec *codec, hda_nid_t pin_nid)
{
	struct intel_hdmi_spec *spec = codec->spec;

	if (spec->num_pins >= INTEL_HDMI_PINS) {
		snd_printk(KERN_WARNING
			   "HDMI: no space for pin %d \n", pin_nid);
		return -EINVAL;
	}

291 292
	hdmi_present_sense(codec, pin_nid, &spec->sink_eld[spec->num_pins]);

293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346
	spec->pin[spec->num_pins] = pin_nid;
	spec->num_pins++;

	/*
	 * It is assumed that converter nodes come first in the node list and
	 * hence have been registered and usable now.
	 */
	return intel_hdmi_read_pin_conn(codec, pin_nid);
}

static int intel_hdmi_add_cvt(struct hda_codec *codec, hda_nid_t nid)
{
	struct intel_hdmi_spec *spec = codec->spec;

	if (spec->num_cvts >= INTEL_HDMI_CVTS) {
		snd_printk(KERN_WARNING
			   "HDMI: no space for converter %d \n", nid);
		return -EINVAL;
	}

	spec->cvt[spec->num_cvts] = nid;
	spec->num_cvts++;

	return 0;
}

static int intel_hdmi_parse_codec(struct hda_codec *codec)
{
	hda_nid_t nid;
	int i, nodes;

	nodes = snd_hda_get_sub_nodes(codec, codec->afg, &nid);
	if (!nid || nodes < 0) {
		snd_printk(KERN_WARNING "HDMI: failed to get afg sub nodes\n");
		return -EINVAL;
	}

	for (i = 0; i < nodes; i++, nid++) {
		unsigned int caps;
		unsigned int type;

		caps = snd_hda_param_read(codec, nid, AC_PAR_AUDIO_WIDGET_CAP);
		type = get_wcaps_type(caps);

		if (!(caps & AC_WCAP_DIGITAL))
			continue;

		switch (type) {
		case AC_WID_AUD_OUT:
			if (intel_hdmi_add_cvt(codec, nid) < 0)
				return -EINVAL;
			break;
		case AC_WID_PIN:
			caps = snd_hda_param_read(codec, nid, AC_PAR_PIN_CAP);
347
			if (!(caps & (AC_PINCAP_HDMI | AC_PINCAP_DP)))
348 349 350 351 352 353 354 355 356 357
				continue;
			if (intel_hdmi_add_pin(codec, nid) < 0)
				return -EINVAL;
			break;
		}
	}

	return 0;
}

358 359 360 361
/*
 * HDMI routines
 */

362
#ifdef BE_PARANOID
363
static void hdmi_get_dip_index(struct hda_codec *codec, hda_nid_t pin_nid,
364 365 366 367
				int *packet_index, int *byte_index)
{
	int val;

368 369
	val = snd_hda_codec_read(codec, pin_nid, 0,
				 AC_VERB_GET_HDMI_DIP_INDEX, 0);
370 371 372 373

	*packet_index = val >> 5;
	*byte_index = val & 0x1f;
}
374
#endif
375

376
static void hdmi_set_dip_index(struct hda_codec *codec, hda_nid_t pin_nid,
377 378 379 380 381 382
				int packet_index, int byte_index)
{
	int val;

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

383
	snd_hda_codec_write(codec, pin_nid, 0, AC_VERB_SET_HDMI_DIP_INDEX, val);
384 385
}

386
static void hdmi_write_dip_byte(struct hda_codec *codec, hda_nid_t pin_nid,
387 388
				unsigned char val)
{
389
	snd_hda_codec_write(codec, pin_nid, 0, AC_VERB_SET_HDMI_DIP_DATA, val);
390 391
}

392
static void hdmi_enable_output(struct hda_codec *codec, hda_nid_t pin_nid)
393
{
394
	/* Unmute */
395 396
	if (get_wcaps(codec, pin_nid) & AC_WCAP_OUT_AMP)
		snd_hda_codec_write(codec, pin_nid, 0,
397 398
				AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE);
	/* Enable pin out */
399 400
	snd_hda_codec_write(codec, pin_nid, 0,
			    AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT);
401 402
}

403 404 405
/*
 * Enable Audio InfoFrame Transmission
 */
406 407
static void hdmi_start_infoframe_trans(struct hda_codec *codec,
				       hda_nid_t pin_nid)
408
{
409 410
	hdmi_set_dip_index(codec, pin_nid, 0x0, 0x0);
	snd_hda_codec_write(codec, pin_nid, 0, AC_VERB_SET_HDMI_DIP_XMIT,
411 412
						AC_DIPXMIT_BEST);
}
413

414 415 416
/*
 * Disable Audio InfoFrame Transmission
 */
417 418
static void hdmi_stop_infoframe_trans(struct hda_codec *codec,
				      hda_nid_t pin_nid)
419
{
420 421
	hdmi_set_dip_index(codec, pin_nid, 0x0, 0x0);
	snd_hda_codec_write(codec, pin_nid, 0, AC_VERB_SET_HDMI_DIP_XMIT,
422
						AC_DIPXMIT_DISABLE);
423 424
}

425
static int hdmi_get_channel_count(struct hda_codec *codec, hda_nid_t nid)
426
{
427
	return 1 + snd_hda_codec_read(codec, nid, 0,
428 429 430
					AC_VERB_GET_CVT_CHAN_COUNT, 0);
}

431 432
static void hdmi_set_channel_count(struct hda_codec *codec,
				   hda_nid_t nid, int chs)
433
{
434
	if (chs != hdmi_get_channel_count(codec, nid))
435 436
		snd_hda_codec_write(codec, nid, 0,
				    AC_VERB_SET_CVT_CHAN_COUNT, chs - 1);
437 438
}

439 440
static void hdmi_debug_channel_mapping(struct hda_codec *codec,
				       hda_nid_t pin_nid)
441 442 443 444 445 446
{
#ifdef CONFIG_SND_DEBUG_VERBOSE
	int i;
	int slot;

	for (i = 0; i < 8; i++) {
447
		slot = snd_hda_codec_read(codec, pin_nid, 0,
448
						AC_VERB_GET_HDMI_CHAN_SLOT, i);
449
		printk(KERN_DEBUG "HDMI: ASP channel %d => slot %d\n",
450
						slot >> 4, slot & 0xf);
451 452 453 454 455 456
	}
#endif
}


/*
W
Wu Fengguang 已提交
457
 * Audio InfoFrame routines
458 459
 */

460
static void hdmi_debug_dip_size(struct hda_codec *codec, hda_nid_t pin_nid)
461 462 463 464 465
{
#ifdef CONFIG_SND_DEBUG_VERBOSE
	int i;
	int size;

466
	size = snd_hdmi_get_eld_size(codec, pin_nid);
467
	printk(KERN_DEBUG "HDMI: ELD buf size is %d\n", size);
468 469

	for (i = 0; i < 8; i++) {
470
		size = snd_hda_codec_read(codec, pin_nid, 0,
471
						AC_VERB_GET_HDMI_DIP_SIZE, i);
472
		printk(KERN_DEBUG "HDMI: DIP GP[%d] buf size is %d\n", i, size);
473 474 475 476
	}
#endif
}

477
static void hdmi_clear_dip_buffers(struct hda_codec *codec, hda_nid_t pin_nid)
478 479 480 481 482 483
{
#ifdef BE_PARANOID
	int i, j;
	int size;
	int pi, bi;
	for (i = 0; i < 8; i++) {
484
		size = snd_hda_codec_read(codec, pin_nid, 0,
485 486 487 488
						AC_VERB_GET_HDMI_DIP_SIZE, i);
		if (size == 0)
			continue;

489
		hdmi_set_dip_index(codec, pin_nid, i, 0x0);
490
		for (j = 1; j < 1000; j++) {
491 492
			hdmi_write_dip_byte(codec, pin_nid, 0x0);
			hdmi_get_dip_index(codec, pin_nid, &pi, &bi);
493 494 495 496 497 498 499
			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
500 501
			"HDMI: DIP GP[%d] buf reported size=%d, written=%d\n",
			i, size, j);
502 503 504 505
	}
#endif
}

506 507 508 509 510 511 512 513 514 515 516 517 518 519
static void hdmi_checksum_audio_infoframe(struct hdmi_audio_infoframe *ai)
{
	u8 *bytes = (u8 *)ai;
	u8 sum = 0;
	int i;

	ai->checksum = 0;

	for (i = 0; i < sizeof(*ai); i++)
		sum += bytes[i];

	ai->checksum = - sum;
}

520
static void hdmi_fill_audio_infoframe(struct hda_codec *codec,
521 522
				      hda_nid_t pin_nid,
				      struct hdmi_audio_infoframe *ai)
523
{
524
	u8 *bytes = (u8 *)ai;
525 526
	int i;

527 528
	hdmi_debug_dip_size(codec, pin_nid);
	hdmi_clear_dip_buffers(codec, pin_nid); /* be paranoid */
529

530
	hdmi_checksum_audio_infoframe(ai);
531

532
	hdmi_set_dip_index(codec, pin_nid, 0x0, 0x0);
533
	for (i = 0; i < sizeof(*ai); i++)
534
		hdmi_write_dip_byte(codec, pin_nid, bytes[i]);
535 536
}

537 538 539 540 541 542 543 544 545 546 547 548 549 550 551 552 553 554 555 556 557 558 559 560 561 562 563 564
/*
 * 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.
*/
565
static int hdmi_setup_channel_allocation(struct hda_codec *codec, hda_nid_t nid,
566 567 568
					 struct hdmi_audio_infoframe *ai)
{
	struct intel_hdmi_spec *spec = codec->spec;
W
Wu Fengguang 已提交
569
	struct hdmi_eld *eld;
570 571 572 573 574 575 576 577 578 579 580
	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;

W
Wu Fengguang 已提交
581 582 583 584 585
	i = hda_node_index(spec->pin_cvt, nid);
	if (i < 0)
		return 0;
	eld = &spec->sink_eld[i];

586 587 588 589 590 591 592 593
	/*
	 * 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;

594 595 596 597
	/*
	 * expand ELD's speaker allocation mask
	 *
	 * ELD tells the speaker mask in a compact(paired) form,
598
	 * expand ELD's notions to match the ones used by Audio InfoFrame.
599 600 601 602 603 604 605 606 607 608 609 610
	 */
	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;
611
			break;
612 613 614 615
		}
	}

	snd_print_channel_allocation(eld->spk_alloc, buf, sizeof(buf));
616 617 618 619 620
	snd_printdd(KERN_INFO
			"HDMI: select CA 0x%x for %d-channel allocation: %s\n",
			ai->CA, channels, buf);

	return ai->CA;
621 622
}

623 624
static void hdmi_setup_channel_mapping(struct hda_codec *codec,
				       hda_nid_t pin_nid,
625
				       struct hdmi_audio_infoframe *ai)
626
{
627 628
	int i;

629 630 631 632 633 634 635 636
	if (!ai->CA)
		return;

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

637
	for (i = 0; i < 8; i++)
638
		snd_hda_codec_write(codec, pin_nid, 0,
639 640 641
				    AC_VERB_SET_HDMI_CHAN_SLOT,
				    (i << 4) | i);

642
	hdmi_debug_channel_mapping(codec, pin_nid);
643 644
}

W
Wu Fengguang 已提交
645 646 647 648 649 650 651 652 653 654 655 656 657 658 659 660 661 662 663 664 665
static bool hdmi_infoframe_uptodate(struct hda_codec *codec, hda_nid_t pin_nid,
				    struct hdmi_audio_infoframe *ai)
{
	u8 *bytes = (u8 *)ai;
	u8 val;
	int i;

	if (snd_hda_codec_read(codec, pin_nid, 0, AC_VERB_GET_HDMI_DIP_XMIT, 0)
							    != AC_DIPXMIT_BEST)
		return false;

	hdmi_set_dip_index(codec, pin_nid, 0x0, 0x0);
	for (i = 0; i < sizeof(*ai); i++) {
		val = snd_hda_codec_read(codec, pin_nid, 0,
					 AC_VERB_GET_HDMI_DIP_DATA, 0);
		if (val != bytes[i])
			return false;
	}

	return true;
}
666

667
static void hdmi_setup_audio_infoframe(struct hda_codec *codec, hda_nid_t nid,
668 669
					struct snd_pcm_substream *substream)
{
W
Wu Fengguang 已提交
670 671 672
	struct intel_hdmi_spec *spec = codec->spec;
	hda_nid_t pin_nid;
	int i;
673
	struct hdmi_audio_infoframe ai = {
674 675 676 677 678 679
		.type		= 0x84,
		.ver		= 0x01,
		.len		= 0x0a,
		.CC02_CT47	= substream->runtime->channels - 1,
	};

680
	hdmi_setup_channel_allocation(codec, nid, &ai);
681

W
Wu Fengguang 已提交
682 683 684
	for (i = 0; i < spec->num_pins; i++) {
		if (spec->pin_cvt[i] != nid)
			continue;
685
		if (!spec->sink_eld[i].monitor_present)
W
Wu Fengguang 已提交
686 687 688
			continue;

		pin_nid = spec->pin[i];
W
Wu Fengguang 已提交
689
		if (!hdmi_infoframe_uptodate(codec, pin_nid, &ai)) {
690
			hdmi_setup_channel_mapping(codec, pin_nid, &ai);
W
Wu Fengguang 已提交
691 692 693 694
			hdmi_stop_infoframe_trans(codec, pin_nid);
			hdmi_fill_audio_infoframe(codec, pin_nid, &ai);
			hdmi_start_infoframe_trans(codec, pin_nid);
		}
W
Wu Fengguang 已提交
695
	}
696 697 698 699 700 701 702 703 704
}


/*
 * Unsolicited events
 */

static void hdmi_intrinsic_event(struct hda_codec *codec, unsigned int res)
{
W
Wu Fengguang 已提交
705 706
	struct intel_hdmi_spec *spec = codec->spec;
	int tag = res >> AC_UNSOL_RES_TAG_SHIFT;
707 708
	int pind = !!(res & AC_UNSOL_RES_PD);
	int eldv = !!(res & AC_UNSOL_RES_ELDV);
W
Wu Fengguang 已提交
709
	int index;
710

711
	printk(KERN_INFO
W
Wu Fengguang 已提交
712 713 714 715 716 717 718
		"HDMI hot plug event: Pin=%d Presence_Detect=%d ELD_Valid=%d\n",
		tag, pind, eldv);

	index = hda_node_index(spec->pin, tag);
	if (index < 0)
		return;

719 720
	spec->sink_eld[index].monitor_present = pind;
	spec->sink_eld[index].eld_valid = eldv;
721 722

	if (pind && eldv) {
723
		hdmi_get_show_eld(codec, spec->pin[index], &spec->sink_eld[index]);
724 725 726 727 728 729
		/* TODO: do real things about ELD */
	}
}

static void hdmi_non_intrinsic_event(struct hda_codec *codec, unsigned int res)
{
W
Wu Fengguang 已提交
730
	int tag = res >> AC_UNSOL_RES_TAG_SHIFT;
731 732 733 734
	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);

735
	printk(KERN_INFO
W
Wu Fengguang 已提交
736 737
		"HDMI CP event: PIN=%d SUBTAG=0x%x CP_STATE=%d CP_READY=%d\n",
		tag,
738 739 740
		subtag,
		cp_state,
		cp_ready);
741

742
	/* TODO */
743 744 745 746 747 748 749 750 751
	if (cp_state)
		;
	if (cp_ready)
		;
}


static void intel_hdmi_unsol_event(struct hda_codec *codec, unsigned int res)
{
W
Wu Fengguang 已提交
752
	struct intel_hdmi_spec *spec = codec->spec;
753 754 755
	int tag = res >> AC_UNSOL_RES_TAG_SHIFT;
	int subtag = (res & AC_UNSOL_RES_SUBTAG) >> AC_UNSOL_RES_SUBTAG_SHIFT;

W
Wu Fengguang 已提交
756
	if (hda_node_index(spec->pin, tag) < 0) {
757
		snd_printd(KERN_INFO "Unexpected HDMI event tag 0x%x\n", tag);
758 759 760 761 762 763 764 765 766 767 768 769 770
		return;
	}

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

/*
 * Callbacks
 */

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 void hdmi_setup_stream(struct hda_codec *codec, hda_nid_t nid,
			      u32 stream_tag, int format)
{
	int tag;
	int fmt;

	tag = snd_hda_codec_read(codec, nid, 0, AC_VERB_GET_CONV, 0) >> 4;
	fmt = snd_hda_codec_read(codec, nid, 0, AC_VERB_GET_STREAM_FORMAT, 0);

	snd_printdd("hdmi_setup_stream: "
		    "NID=0x%x, %sstream=0x%x, %sformat=0x%x\n",
		    nid,
		    tag == stream_tag ? "" : "new-",
		    stream_tag,
		    fmt == format ? "" : "new-",
		    format);

	if (tag != stream_tag)
		snd_hda_codec_write(codec, nid, 0,
				    AC_VERB_SET_CHANNEL_STREAMID, stream_tag << 4);
	if (fmt != format)
		snd_hda_codec_write(codec, nid, 0,
				    AC_VERB_SET_STREAM_FORMAT, format);
}

796
static int intel_hdmi_playback_pcm_prepare(struct hda_pcm_stream *hinfo,
797
					   struct hda_codec *codec,
798 799
					   unsigned int stream_tag,
					   unsigned int format,
800
					   struct snd_pcm_substream *substream)
801
{
W
Wu Fengguang 已提交
802
	hdmi_set_channel_count(codec, hinfo->nid,
803
			       substream->runtime->channels);
804

W
Wu Fengguang 已提交
805
	hdmi_setup_audio_infoframe(codec, hinfo->nid, substream);
806

807
	hdmi_setup_stream(codec, hinfo->nid, stream_tag, format);
808
	return 0;
809 810
}

811
static int intel_hdmi_playback_pcm_cleanup(struct hda_pcm_stream *hinfo,
812 813 814 815 816 817 818 819 820 821
					   struct hda_codec *codec,
					   struct snd_pcm_substream *substream)
{
	return 0;
}

static struct hda_pcm_stream intel_hdmi_pcm_playback = {
	.substreams = 1,
	.channels_min = 2,
	.ops = {
822 823
		.prepare = intel_hdmi_playback_pcm_prepare,
		.cleanup = intel_hdmi_playback_pcm_cleanup,
824 825 826 827 828 829
	},
};

static int intel_hdmi_build_pcms(struct hda_codec *codec)
{
	struct intel_hdmi_spec *spec = codec->spec;
W
Wu Fengguang 已提交
830 831
	struct hda_pcm *info = spec->pcm_rec;
	int i;
832

W
Wu Fengguang 已提交
833
	codec->num_pcms = spec->num_cvts;
834 835
	codec->pcm_info = info;

W
Wu Fengguang 已提交
836
	for (i = 0; i < codec->num_pcms; i++, info++) {
837 838 839 840 841
		unsigned int chans;

		chans = get_wcaps(codec, spec->cvt[i]);
		chans = get_wcaps_channels(chans);

W
Wu Fengguang 已提交
842 843 844 845 846
		info->name = intel_hdmi_pcm_names[i];
		info->pcm_type = HDA_PCM_TYPE_HDMI;
		info->stream[SNDRV_PCM_STREAM_PLAYBACK] =
							intel_hdmi_pcm_playback;
		info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid = spec->cvt[i];
847
		info->stream[SNDRV_PCM_STREAM_PLAYBACK].channels_max = chans;
W
Wu Fengguang 已提交
848
	}
849 850 851 852 853 854 855 856

	return 0;
}

static int intel_hdmi_build_controls(struct hda_codec *codec)
{
	struct intel_hdmi_spec *spec = codec->spec;
	int err;
W
Wu Fengguang 已提交
857
	int i;
858

W
Wu Fengguang 已提交
859 860 861 862 863
	for (i = 0; i < codec->num_pcms; i++) {
		err = snd_hda_create_spdif_out_ctls(codec, spec->cvt[i]);
		if (err < 0)
			return err;
	}
864 865 866 867 868 869

	return 0;
}

static int intel_hdmi_init(struct hda_codec *codec)
{
W
Wu Fengguang 已提交
870 871
	struct intel_hdmi_spec *spec = codec->spec;
	int i;
872

W
Wu Fengguang 已提交
873 874 875 876 877 878
	for (i = 0; spec->pin[i]; i++) {
		hdmi_enable_output(codec, spec->pin[i]);
		snd_hda_codec_write(codec, spec->pin[i], 0,
				    AC_VERB_SET_UNSOLICITED_ENABLE,
				    AC_USRSP_EN | spec->pin[i]);
	}
879 880 881 882 883
	return 0;
}

static void intel_hdmi_free(struct hda_codec *codec)
{
T
Takashi Iwai 已提交
884
	struct intel_hdmi_spec *spec = codec->spec;
W
Wu Fengguang 已提交
885 886 887 888
	int i;

	for (i = 0; i < spec->num_pins; i++)
		snd_hda_eld_proc_free(codec, &spec->sink_eld[i]);
T
Takashi Iwai 已提交
889 890

	kfree(spec);
891 892 893 894 895 896 897 898 899 900
}

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

901
static int patch_intel_hdmi(struct hda_codec *codec)
902 903
{
	struct intel_hdmi_spec *spec;
W
Wu Fengguang 已提交
904
	int i;
905 906 907 908 909 910

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

	codec->spec = spec;
911 912 913 914 915
	if (intel_hdmi_parse_codec(codec) < 0) {
		codec->spec = NULL;
		kfree(spec);
		return -EINVAL;
	}
916 917
	codec->patch_ops = intel_hdmi_patch_ops;

W
Wu Fengguang 已提交
918 919
	for (i = 0; i < spec->num_pins; i++)
		snd_hda_eld_proc_new(codec, &spec->sink_eld[i], i);
920

921 922
	init_channel_allocations();

923 924 925
	return 0;
}

926
static struct hda_codec_preset snd_hda_preset_intelhdmi[] = {
927 928 929 930
	{ .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 },
931 932
	{ .id = 0x80862804, .name = "G45 DEVIBX", .patch = patch_intel_hdmi },
	{ .id = 0x80860054, .name = "Q57 DEVIBX", .patch = patch_intel_hdmi },
933
	{ .id = 0x10951392, .name = "SiI1392 HDMI",     .patch = patch_intel_hdmi },
934 935
	{} /* terminator */
};
936 937 938 939 940

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");
941
MODULE_ALIAS("snd-hda-codec-id:80862804");
942
MODULE_ALIAS("snd-hda-codec-id:80860054");
943 944 945 946 947 948 949 950 951 952 953 954 955 956 957 958 959 960 961 962 963 964
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)