tree 3d38fdfd1e5a9d77cba08bdd325056b44b856a9f
parent 1bcb4078f92ee33de63e8f99d88e33d1842cea51
author Nicolas Reinecke <nr@das-labor.org> 1410019385 +0200
committer Edward O'Callaghan <eocallaghan@alterapraxis.com> 1410335741 +0200

lenovo/t520/hda_verb.h: update azalia codec config

Replace codec config copied form T530 with dumped values from T520
/sys/class/sound/card0/hdaudioC0D0/init_pin_configs.
Intel Azalia HDMI is always enabled, but DP isn't connected to a
connector.

Change-Id: Iabdae4a6669ff429d5769a1bb0c0fb1abc12ba82
Signed-off-by: Nicolas Reinecke <nr@das-labor.org>
Reviewed-on: http://review.coreboot.org/6849
Reviewed-by: Edward O'Callaghan <eocallaghan@alterapraxis.com>
Reviewed-by: Paul Menzel <paulepanter@users.sourceforge.net>
Tested-by: build bot (Jenkins)
