hdacc.c revision 256281
178064Sume/*- 262638Skris * Copyright (c) 2006 Stephane E. Potvin <sepotvin@videotron.ca> 355505Sshin * Copyright (c) 2006 Ariff Abdullah <ariff@FreeBSD.org> 455505Sshin * Copyright (c) 2008-2012 Alexander Motin <mav@FreeBSD.org> 555505Sshin * All rights reserved. 655505Sshin * 755505Sshin * Redistribution and use in source and binary forms, with or without 855505Sshin * modification, are permitted provided that the following conditions 955505Sshin * are met: 1055505Sshin * 1. Redistributions of source code must retain the above copyright 1155505Sshin * notice, this list of conditions and the following disclaimer. 1255505Sshin * 2. Redistributions in binary form must reproduce the above copyright 1355505Sshin * notice, this list of conditions and the following disclaimer in the 1455505Sshin * documentation and/or other materials provided with the distribution. 1555505Sshin * 1655505Sshin * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND 1755505Sshin * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 1855505Sshin * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 1955505Sshin * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE 2055505Sshin * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 2155505Sshin * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 2255505Sshin * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 2355505Sshin * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 2455505Sshin * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 2555505Sshin * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 2655505Sshin * SUCH DAMAGE. 2755505Sshin */ 2855505Sshin 2955505Sshin/* 3055505Sshin * Intel High Definition Audio (CODEC) driver for FreeBSD. 3155505Sshin */ 3255505Sshin 3355505Sshin#ifdef HAVE_KERNEL_OPTION_HEADERS 3455505Sshin#include "opt_snd.h" 3578064Sume#endif 3678064Sume 3755505Sshin#include <dev/sound/pcm/sound.h> 3855505Sshin 3955505Sshin#include <sys/ctype.h> 4078064Sume 4155505Sshin#include <dev/sound/pci/hda/hda_reg.h> 4255505Sshin#include <dev/sound/pci/hda/hdac.h> 4355505Sshin 4455505SshinSND_DECLARE_FILE("$FreeBSD: stable/10/sys/dev/sound/pci/hda/hdacc.c 247910 2013-03-07 07:54:50Z glebius $"); 4562638Skris 4655505Sshinstruct hdacc_fg { 4762638Skris device_t dev; 4855505Sshin nid_t nid; 4955505Sshin uint8_t type; 5055505Sshin uint32_t subsystem_id; 5155505Sshin}; 5262638Skris 5362638Skrisstruct hdacc_softc { 5462638Skris device_t dev; 5555505Sshin struct mtx *lock; 5655505Sshin nid_t cad; 5755505Sshin device_t streams[2][16]; 5855505Sshin device_t tags[64]; 5962638Skris int fgcnt; 6055505Sshin struct hdacc_fg *fgs; 6178064Sume}; 6278064Sume 6378064Sume#define hdacc_lock(codec) snd_mtxlock((codec)->lock) 6478064Sume#define hdacc_unlock(codec) snd_mtxunlock((codec)->lock) 6555505Sshin#define hdacc_lockassert(codec) snd_mtxassert((codec)->lock) 6655505Sshin#define hdacc_lockowned(codec) mtx_owned((codec)->lock) 6755505Sshin 6855505SshinMALLOC_DEFINE(M_HDACC, "hdacc", "HDA CODEC"); 6955505Sshin 7055505Sshin/* CODECs */ 7155505Sshinstatic const struct { 7255505Sshin uint32_t id; 7355505Sshin uint16_t revid; 7455505Sshin char *name; 7555505Sshin} hdacc_codecs[] = { 7655505Sshin { HDA_CODEC_CS4206, 0, "Cirrus Logic CS4206" }, 7755505Sshin { HDA_CODEC_CS4207, 0, "Cirrus Logic CS4207" }, 7855505Sshin { HDA_CODEC_CS4210, 0, "Cirrus Logic CS4210" }, 7955505Sshin { HDA_CODEC_ALC221, 0, "Realtek ALC221" }, 8055505Sshin { HDA_CODEC_ALC260, 0, "Realtek ALC260" }, 8155505Sshin { HDA_CODEC_ALC262, 0, "Realtek ALC262" }, 8255505Sshin { HDA_CODEC_ALC267, 0, "Realtek ALC267" }, 8355505Sshin { HDA_CODEC_ALC268, 0, "Realtek ALC268" }, 8455505Sshin { HDA_CODEC_ALC269, 0, "Realtek ALC269" }, 8555505Sshin { HDA_CODEC_ALC270, 0, "Realtek ALC270" }, 8655505Sshin { HDA_CODEC_ALC272, 0, "Realtek ALC272" }, 8755505Sshin { HDA_CODEC_ALC273, 0, "Realtek ALC273" }, 8855505Sshin { HDA_CODEC_ALC275, 0, "Realtek ALC275" }, 8955505Sshin { HDA_CODEC_ALC276, 0, "Realtek ALC276" }, 9055505Sshin { HDA_CODEC_ALC660, 0, "Realtek ALC660-VD" }, 9155505Sshin { HDA_CODEC_ALC662, 0x0002, "Realtek ALC662 rev2" }, 9255505Sshin { HDA_CODEC_ALC662, 0, "Realtek ALC662" }, 9355505Sshin { HDA_CODEC_ALC663, 0, "Realtek ALC663" }, 9455505Sshin { HDA_CODEC_ALC665, 0, "Realtek ALC665" }, 9555505Sshin { HDA_CODEC_ALC670, 0, "Realtek ALC670" }, 9655505Sshin { HDA_CODEC_ALC680, 0, "Realtek ALC680" }, 9755505Sshin { HDA_CODEC_ALC861, 0x0340, "Realtek ALC660" }, 9855505Sshin { HDA_CODEC_ALC861, 0, "Realtek ALC861" }, 9955505Sshin { HDA_CODEC_ALC861VD, 0, "Realtek ALC861-VD" }, 10055505Sshin { HDA_CODEC_ALC880, 0, "Realtek ALC880" }, 10155505Sshin { HDA_CODEC_ALC882, 0, "Realtek ALC882" }, 10255505Sshin { HDA_CODEC_ALC883, 0, "Realtek ALC883" }, 10355505Sshin { HDA_CODEC_ALC885, 0x0101, "Realtek ALC889A" }, 10455505Sshin { HDA_CODEC_ALC885, 0x0103, "Realtek ALC889A" }, 10555505Sshin { HDA_CODEC_ALC885, 0, "Realtek ALC885" }, 10655505Sshin { HDA_CODEC_ALC887, 0, "Realtek ALC887" }, 10755505Sshin { HDA_CODEC_ALC888, 0x0101, "Realtek ALC1200" }, 10855505Sshin { HDA_CODEC_ALC888, 0, "Realtek ALC888" }, 10955505Sshin { HDA_CODEC_ALC889, 0, "Realtek ALC889" }, 11055505Sshin { HDA_CODEC_ALC892, 0, "Realtek ALC892" }, 11155505Sshin { HDA_CODEC_ALC899, 0, "Realtek ALC899" }, 11255505Sshin { HDA_CODEC_AD1882, 0, "Analog Devices AD1882" }, 11355505Sshin { HDA_CODEC_AD1882A, 0, "Analog Devices AD1882A" }, 11455505Sshin { HDA_CODEC_AD1883, 0, "Analog Devices AD1883" }, 11555505Sshin { HDA_CODEC_AD1884, 0, "Analog Devices AD1884" }, 11655505Sshin { HDA_CODEC_AD1884A, 0, "Analog Devices AD1884A" }, 11755505Sshin { HDA_CODEC_AD1981HD, 0, "Analog Devices AD1981HD" }, 11855505Sshin { HDA_CODEC_AD1983, 0, "Analog Devices AD1983" }, 11955505Sshin { HDA_CODEC_AD1984, 0, "Analog Devices AD1984" }, 12055505Sshin { HDA_CODEC_AD1984A, 0, "Analog Devices AD1984A" }, 12155505Sshin { HDA_CODEC_AD1984B, 0, "Analog Devices AD1984B" }, 12255505Sshin { HDA_CODEC_AD1986A, 0, "Analog Devices AD1986A" }, 12355505Sshin { HDA_CODEC_AD1987, 0, "Analog Devices AD1987" }, 12455505Sshin { HDA_CODEC_AD1988, 0, "Analog Devices AD1988A" }, 12555505Sshin { HDA_CODEC_AD1988B, 0, "Analog Devices AD1988B" }, 12655505Sshin { HDA_CODEC_AD1989A, 0, "Analog Devices AD1989A" }, 12755505Sshin { HDA_CODEC_AD1989B, 0, "Analog Devices AD1989B" }, 12855505Sshin { HDA_CODEC_CA0110, 0, "Creative CA0110-IBG" }, 12955505Sshin { HDA_CODEC_CA0110_2, 0, "Creative CA0110-IBG" }, 13055505Sshin { HDA_CODEC_CA0132, 0, "Creative CA0132" }, 13155505Sshin { HDA_CODEC_SB0880, 0, "Creative SB0880 X-Fi" }, 13255505Sshin { HDA_CODEC_CMI9880, 0, "CMedia CMI9880" }, 13355505Sshin { HDA_CODEC_CMI98802, 0, "CMedia CMI9880" }, 13455505Sshin { HDA_CODEC_CXD9872RDK, 0, "Sigmatel CXD9872RD/K" }, 13555505Sshin { HDA_CODEC_CXD9872AKD, 0, "Sigmatel CXD9872AKD" }, 13655505Sshin { HDA_CODEC_STAC9200D, 0, "Sigmatel STAC9200D" }, 13755505Sshin { HDA_CODEC_STAC9204X, 0, "Sigmatel STAC9204X" }, 13855505Sshin { HDA_CODEC_STAC9204D, 0, "Sigmatel STAC9204D" }, 13955505Sshin { HDA_CODEC_STAC9205X, 0, "Sigmatel STAC9205X" }, 14055505Sshin { HDA_CODEC_STAC9205D, 0, "Sigmatel STAC9205D" }, 14155505Sshin { HDA_CODEC_STAC9220, 0, "Sigmatel STAC9220" }, 14255505Sshin { HDA_CODEC_STAC9220_A1, 0, "Sigmatel STAC9220_A1" }, 14355505Sshin { HDA_CODEC_STAC9220_A2, 0, "Sigmatel STAC9220_A2" }, 14455505Sshin { HDA_CODEC_STAC9221, 0, "Sigmatel STAC9221" }, 14555505Sshin { HDA_CODEC_STAC9221_A2, 0, "Sigmatel STAC9221_A2" }, 14655505Sshin { HDA_CODEC_STAC9221D, 0, "Sigmatel STAC9221D" }, 14755505Sshin { HDA_CODEC_STAC922XD, 0, "Sigmatel STAC9220D/9223D" }, 14855505Sshin { HDA_CODEC_STAC9227X, 0, "Sigmatel STAC9227X" }, 14955505Sshin { HDA_CODEC_STAC9227D, 0, "Sigmatel STAC9227D" }, 15055505Sshin { HDA_CODEC_STAC9228X, 0, "Sigmatel STAC9228X" }, 15155505Sshin { HDA_CODEC_STAC9228D, 0, "Sigmatel STAC9228D" }, 15255505Sshin { HDA_CODEC_STAC9229X, 0, "Sigmatel STAC9229X" }, 15355505Sshin { HDA_CODEC_STAC9229D, 0, "Sigmatel STAC9229D" }, 15455505Sshin { HDA_CODEC_STAC9230X, 0, "Sigmatel STAC9230X" }, 15555505Sshin { HDA_CODEC_STAC9230D, 0, "Sigmatel STAC9230D" }, 15655505Sshin { HDA_CODEC_STAC9250, 0, "Sigmatel STAC9250" }, 15755505Sshin { HDA_CODEC_STAC9251, 0, "Sigmatel STAC9251" }, 15855505Sshin { HDA_CODEC_STAC9255, 0, "Sigmatel STAC9255" }, 15955505Sshin { HDA_CODEC_STAC9255D, 0, "Sigmatel STAC9255D" }, 16055505Sshin { HDA_CODEC_STAC9254, 0, "Sigmatel STAC9254" }, 16155505Sshin { HDA_CODEC_STAC9254D, 0, "Sigmatel STAC9254D" }, 16255505Sshin { HDA_CODEC_STAC9271X, 0, "Sigmatel STAC9271X" }, 16355505Sshin { HDA_CODEC_STAC9271D, 0, "Sigmatel STAC9271D" }, 16455505Sshin { HDA_CODEC_STAC9272X, 0, "Sigmatel STAC9272X" }, 16555505Sshin { HDA_CODEC_STAC9272D, 0, "Sigmatel STAC9272D" }, 16655505Sshin { HDA_CODEC_STAC9273X, 0, "Sigmatel STAC9273X" }, 16755505Sshin { HDA_CODEC_STAC9273D, 0, "Sigmatel STAC9273D" }, 16855505Sshin { HDA_CODEC_STAC9274, 0, "Sigmatel STAC9274" }, 16955505Sshin { HDA_CODEC_STAC9274D, 0, "Sigmatel STAC9274D" }, 17055505Sshin { HDA_CODEC_STAC9274X5NH, 0, "Sigmatel STAC9274X5NH" }, 17155505Sshin { HDA_CODEC_STAC9274D5NH, 0, "Sigmatel STAC9274D5NH" }, 17255505Sshin { HDA_CODEC_STAC9872AK, 0, "Sigmatel STAC9872AK" }, 17355505Sshin { HDA_CODEC_IDT92HD005, 0, "IDT 92HD005" }, 17455505Sshin { HDA_CODEC_IDT92HD005D, 0, "IDT 92HD005D" }, 17555505Sshin { HDA_CODEC_IDT92HD206X, 0, "IDT 92HD206X" }, 17655505Sshin { HDA_CODEC_IDT92HD206D, 0, "IDT 92HD206D" }, 17755505Sshin { HDA_CODEC_IDT92HD66B1X5, 0, "IDT 92HD66B1X5" }, 17855505Sshin { HDA_CODEC_IDT92HD66B2X5, 0, "IDT 92HD66B2X5" }, 17955505Sshin { HDA_CODEC_IDT92HD66B3X5, 0, "IDT 92HD66B3X5" }, 18055505Sshin { HDA_CODEC_IDT92HD66C1X5, 0, "IDT 92HD66C1X5" }, 18155505Sshin { HDA_CODEC_IDT92HD66C2X5, 0, "IDT 92HD66C2X5" }, 18255505Sshin { HDA_CODEC_IDT92HD66C3X5, 0, "IDT 92HD66C3X5" }, 18355505Sshin { HDA_CODEC_IDT92HD66B1X3, 0, "IDT 92HD66B1X3" }, 18455505Sshin { HDA_CODEC_IDT92HD66B2X3, 0, "IDT 92HD66B2X3" }, 18555505Sshin { HDA_CODEC_IDT92HD66B3X3, 0, "IDT 92HD66B3X3" }, 18655505Sshin { HDA_CODEC_IDT92HD66C1X3, 0, "IDT 92HD66C1X3" }, 18755505Sshin { HDA_CODEC_IDT92HD66C2X3, 0, "IDT 92HD66C2X3" }, 18855505Sshin { HDA_CODEC_IDT92HD66C3_65, 0, "IDT 92HD66C3_65" }, 18955505Sshin { HDA_CODEC_IDT92HD700X, 0, "IDT 92HD700X" }, 19055505Sshin { HDA_CODEC_IDT92HD700D, 0, "IDT 92HD700D" }, 19155505Sshin { HDA_CODEC_IDT92HD71B5, 0, "IDT 92HD71B5" }, 19255505Sshin { HDA_CODEC_IDT92HD71B5_2, 0, "IDT 92HD71B5" }, 19355505Sshin { HDA_CODEC_IDT92HD71B6, 0, "IDT 92HD71B6" }, 19455505Sshin { HDA_CODEC_IDT92HD71B6_2, 0, "IDT 92HD71B6" }, 19555505Sshin { HDA_CODEC_IDT92HD71B7, 0, "IDT 92HD71B7" }, 19655505Sshin { HDA_CODEC_IDT92HD71B7_2, 0, "IDT 92HD71B7" }, 19755505Sshin { HDA_CODEC_IDT92HD71B8, 0, "IDT 92HD71B8" }, 19855505Sshin { HDA_CODEC_IDT92HD71B8_2, 0, "IDT 92HD71B8" }, 19955505Sshin { HDA_CODEC_IDT92HD73C1, 0, "IDT 92HD73C1" }, 20055505Sshin { HDA_CODEC_IDT92HD73D1, 0, "IDT 92HD73D1" }, 20155505Sshin { HDA_CODEC_IDT92HD73E1, 0, "IDT 92HD73E1" }, 20255505Sshin { HDA_CODEC_IDT92HD75B3, 0, "IDT 92HD75B3" }, 20355505Sshin { HDA_CODEC_IDT92HD75BX, 0, "IDT 92HD75BX" }, 20455505Sshin { HDA_CODEC_IDT92HD81B1C, 0, "IDT 92HD81B1C" }, 20555505Sshin { HDA_CODEC_IDT92HD81B1X, 0, "IDT 92HD81B1X" }, 20655505Sshin { HDA_CODEC_IDT92HD83C1C, 0, "IDT 92HD83C1C" }, 20755505Sshin { HDA_CODEC_IDT92HD83C1X, 0, "IDT 92HD83C1X" }, 20855505Sshin { HDA_CODEC_IDT92HD87B1_3, 0, "IDT 92HD87B1/3" }, 20955505Sshin { HDA_CODEC_IDT92HD87B2_4, 0, "IDT 92HD87B2/4" }, 21055505Sshin { HDA_CODEC_IDT92HD89C3, 0, "IDT 92HD89C3" }, 21155505Sshin { HDA_CODEC_IDT92HD89C2, 0, "IDT 92HD89C2" }, 21255505Sshin { HDA_CODEC_IDT92HD89C1, 0, "IDT 92HD89C1" }, 21355505Sshin { HDA_CODEC_IDT92HD89B3, 0, "IDT 92HD89B3" }, 21455505Sshin { HDA_CODEC_IDT92HD89B2, 0, "IDT 92HD89B2" }, 21555505Sshin { HDA_CODEC_IDT92HD89B1, 0, "IDT 92HD89B1" }, 21655505Sshin { HDA_CODEC_IDT92HD89E3, 0, "IDT 92HD89E3" }, 21755505Sshin { HDA_CODEC_IDT92HD89E2, 0, "IDT 92HD89E2" }, 21855505Sshin { HDA_CODEC_IDT92HD89E1, 0, "IDT 92HD89E1" }, 21955505Sshin { HDA_CODEC_IDT92HD89D3, 0, "IDT 92HD89D3" }, 22055505Sshin { HDA_CODEC_IDT92HD89D2, 0, "IDT 92HD89D2" }, 22155505Sshin { HDA_CODEC_IDT92HD89D1, 0, "IDT 92HD89D1" }, 22255505Sshin { HDA_CODEC_IDT92HD89F3, 0, "IDT 92HD89F3" }, 22355505Sshin { HDA_CODEC_IDT92HD89F2, 0, "IDT 92HD89F2" }, 22455505Sshin { HDA_CODEC_IDT92HD89F1, 0, "IDT 92HD89F1" }, 22555505Sshin { HDA_CODEC_IDT92HD90BXX, 0, "IDT 92HD90BXX" }, 22662638Skris { HDA_CODEC_IDT92HD91BXX, 0, "IDT 92HD91BXX" }, 22762638Skris { HDA_CODEC_IDT92HD93BXX, 0, "IDT 92HD93BXX" }, 22862638Skris { HDA_CODEC_IDT92HD98BXX, 0, "IDT 92HD98BXX" }, 22962638Skris { HDA_CODEC_IDT92HD99BXX, 0, "IDT 92HD99BXX" }, 23062638Skris { HDA_CODEC_CX20549, 0, "Conexant CX20549 (Venice)" }, 23162638Skris { HDA_CODEC_CX20551, 0, "Conexant CX20551 (Waikiki)" }, 23262638Skris { HDA_CODEC_CX20561, 0, "Conexant CX20561 (Hermosa)" }, 23362638Skris { HDA_CODEC_CX20582, 0, "Conexant CX20582 (Pebble)" }, 23462638Skris { HDA_CODEC_CX20583, 0, "Conexant CX20583 (Pebble HSF)" }, 23555505Sshin { HDA_CODEC_CX20584, 0, "Conexant CX20584" }, 23655505Sshin { HDA_CODEC_CX20585, 0, "Conexant CX20585" }, 23755505Sshin { HDA_CODEC_CX20588, 0, "Conexant CX20588" }, 23855505Sshin { HDA_CODEC_CX20590, 0, "Conexant CX20590" }, 23955505Sshin { HDA_CODEC_CX20631, 0, "Conexant CX20631" }, 24055505Sshin { HDA_CODEC_CX20632, 0, "Conexant CX20632" }, 24155505Sshin { HDA_CODEC_CX20641, 0, "Conexant CX20641" }, 24255505Sshin { HDA_CODEC_CX20642, 0, "Conexant CX20642" }, 24355505Sshin { HDA_CODEC_CX20651, 0, "Conexant CX20651" }, 24455505Sshin { HDA_CODEC_CX20652, 0, "Conexant CX20652" }, 24555505Sshin { HDA_CODEC_CX20664, 0, "Conexant CX20664" }, 24655505Sshin { HDA_CODEC_CX20665, 0, "Conexant CX20665" }, 24755505Sshin { HDA_CODEC_VT1708_8, 0, "VIA VT1708_8" }, 24855505Sshin { HDA_CODEC_VT1708_9, 0, "VIA VT1708_9" }, 24955505Sshin { HDA_CODEC_VT1708_A, 0, "VIA VT1708_A" }, 25055505Sshin { HDA_CODEC_VT1708_B, 0, "VIA VT1708_B" }, 25155505Sshin { HDA_CODEC_VT1709_0, 0, "VIA VT1709_0" }, 25255505Sshin { HDA_CODEC_VT1709_1, 0, "VIA VT1709_1" }, 25355505Sshin { HDA_CODEC_VT1709_2, 0, "VIA VT1709_2" }, 25455505Sshin { HDA_CODEC_VT1709_3, 0, "VIA VT1709_3" }, 25555505Sshin { HDA_CODEC_VT1709_4, 0, "VIA VT1709_4" }, 25655505Sshin { HDA_CODEC_VT1709_5, 0, "VIA VT1709_5" }, 25755505Sshin { HDA_CODEC_VT1709_6, 0, "VIA VT1709_6" }, 25878064Sume { HDA_CODEC_VT1709_7, 0, "VIA VT1709_7" }, 25978064Sume { HDA_CODEC_VT1708B_0, 0, "VIA VT1708B_0" }, 26055505Sshin { HDA_CODEC_VT1708B_1, 0, "VIA VT1708B_1" }, 26155505Sshin { HDA_CODEC_VT1708B_2, 0, "VIA VT1708B_2" }, 26278064Sume { HDA_CODEC_VT1708B_3, 0, "VIA VT1708B_3" }, 26355505Sshin { HDA_CODEC_VT1708B_4, 0, "VIA VT1708B_4" }, 26455505Sshin { HDA_CODEC_VT1708B_5, 0, "VIA VT1708B_5" }, 26555505Sshin { HDA_CODEC_VT1708B_6, 0, "VIA VT1708B_6" }, 26655505Sshin { HDA_CODEC_VT1708B_7, 0, "VIA VT1708B_7" }, 26755505Sshin { HDA_CODEC_VT1708S_0, 0, "VIA VT1708S_0" }, 26855505Sshin { HDA_CODEC_VT1708S_1, 0, "VIA VT1708S_1" }, 26955505Sshin { HDA_CODEC_VT1708S_2, 0, "VIA VT1708S_2" }, 27055505Sshin { HDA_CODEC_VT1708S_3, 0, "VIA VT1708S_3" }, 27155505Sshin { HDA_CODEC_VT1708S_4, 0, "VIA VT1708S_4" }, 27255505Sshin { HDA_CODEC_VT1708S_5, 0, "VIA VT1708S_5" }, 27355505Sshin { HDA_CODEC_VT1708S_6, 0, "VIA VT1708S_6" }, 274 { HDA_CODEC_VT1708S_7, 0, "VIA VT1708S_7" }, 275 { HDA_CODEC_VT1702_0, 0, "VIA VT1702_0" }, 276 { HDA_CODEC_VT1702_1, 0, "VIA VT1702_1" }, 277 { HDA_CODEC_VT1702_2, 0, "VIA VT1702_2" }, 278 { HDA_CODEC_VT1702_3, 0, "VIA VT1702_3" }, 279 { HDA_CODEC_VT1702_4, 0, "VIA VT1702_4" }, 280 { HDA_CODEC_VT1702_5, 0, "VIA VT1702_5" }, 281 { HDA_CODEC_VT1702_6, 0, "VIA VT1702_6" }, 282 { HDA_CODEC_VT1702_7, 0, "VIA VT1702_7" }, 283 { HDA_CODEC_VT1716S_0, 0, "VIA VT1716S_0" }, 284 { HDA_CODEC_VT1716S_1, 0, "VIA VT1716S_1" }, 285 { HDA_CODEC_VT1718S_0, 0, "VIA VT1718S_0" }, 286 { HDA_CODEC_VT1718S_1, 0, "VIA VT1718S_1" }, 287 { HDA_CODEC_VT1802_0, 0, "VIA VT1802_0" }, 288 { HDA_CODEC_VT1802_1, 0, "VIA VT1802_1" }, 289 { HDA_CODEC_VT1812, 0, "VIA VT1812" }, 290 { HDA_CODEC_VT1818S, 0, "VIA VT1818S" }, 291 { HDA_CODEC_VT1828S, 0, "VIA VT1828S" }, 292 { HDA_CODEC_VT2002P_0, 0, "VIA VT2002P_0" }, 293 { HDA_CODEC_VT2002P_1, 0, "VIA VT2002P_1" }, 294 { HDA_CODEC_VT2020, 0, "VIA VT2020" }, 295 { HDA_CODEC_ATIRS600_1, 0, "ATI RS600" }, 296 { HDA_CODEC_ATIRS600_2, 0, "ATI RS600" }, 297 { HDA_CODEC_ATIRS690, 0, "ATI RS690/780" }, 298 { HDA_CODEC_ATIR6XX, 0, "ATI R6xx" }, 299 { HDA_CODEC_NVIDIAMCP67, 0, "NVIDIA MCP67" }, 300 { HDA_CODEC_NVIDIAMCP73, 0, "NVIDIA MCP73" }, 301 { HDA_CODEC_NVIDIAMCP78, 0, "NVIDIA MCP78" }, 302 { HDA_CODEC_NVIDIAMCP78_2, 0, "NVIDIA MCP78" }, 303 { HDA_CODEC_NVIDIAMCP78_3, 0, "NVIDIA MCP78" }, 304 { HDA_CODEC_NVIDIAMCP78_4, 0, "NVIDIA MCP78" }, 305 { HDA_CODEC_NVIDIAMCP7A, 0, "NVIDIA MCP7A" }, 306 { HDA_CODEC_NVIDIAGT220, 0, "NVIDIA GT220" }, 307 { HDA_CODEC_NVIDIAGT21X, 0, "NVIDIA GT21x" }, 308 { HDA_CODEC_NVIDIAMCP89, 0, "NVIDIA MCP89" }, 309 { HDA_CODEC_NVIDIAGT240, 0, "NVIDIA GT240" }, 310 { HDA_CODEC_NVIDIAGTS450, 0, "NVIDIA GTS450" }, 311 { HDA_CODEC_NVIDIAGT440, 0, "NVIDIA GT440" }, 312 { HDA_CODEC_NVIDIAGTX550, 0, "NVIDIA GTX550" }, 313 { HDA_CODEC_NVIDIAGTX570, 0, "NVIDIA GTX570" }, 314 { HDA_CODEC_INTELIP, 0, "Intel Ibex Peak" }, 315 { HDA_CODEC_INTELBL, 0, "Intel Bearlake" }, 316 { HDA_CODEC_INTELCA, 0, "Intel Cantiga" }, 317 { HDA_CODEC_INTELEL, 0, "Intel Eaglelake" }, 318 { HDA_CODEC_INTELIP2, 0, "Intel Ibex Peak" }, 319 { HDA_CODEC_INTELCPT, 0, "Intel Cougar Point" }, 320 { HDA_CODEC_INTELPPT, 0, "Intel Panther Point" }, 321 { HDA_CODEC_INTELCL, 0, "Intel Crestline" }, 322 { HDA_CODEC_SII1390, 0, "Silicon Image SiI1390" }, 323 { HDA_CODEC_SII1392, 0, "Silicon Image SiI1392" }, 324 /* Unknown CODECs */ 325 { HDA_CODEC_ADXXXX, 0, "Analog Devices" }, 326 { HDA_CODEC_AGEREXXXX, 0, "Lucent/Agere Systems" }, 327 { HDA_CODEC_ALCXXXX, 0, "Realtek" }, 328 { HDA_CODEC_ATIXXXX, 0, "ATI" }, 329 { HDA_CODEC_CAXXXX, 0, "Creative" }, 330 { HDA_CODEC_CMIXXXX, 0, "CMedia" }, 331 { HDA_CODEC_CMIXXXX2, 0, "CMedia" }, 332 { HDA_CODEC_CSXXXX, 0, "Cirrus Logic" }, 333 { HDA_CODEC_CXXXXX, 0, "Conexant" }, 334 { HDA_CODEC_CHXXXX, 0, "Chrontel" }, 335 { HDA_CODEC_IDTXXXX, 0, "IDT" }, 336 { HDA_CODEC_INTELXXXX, 0, "Intel" }, 337 { HDA_CODEC_MOTOXXXX, 0, "Motorola" }, 338 { HDA_CODEC_NVIDIAXXXX, 0, "NVIDIA" }, 339 { HDA_CODEC_SIIXXXX, 0, "Silicon Image" }, 340 { HDA_CODEC_STACXXXX, 0, "Sigmatel" }, 341 { HDA_CODEC_VTXXXX, 0, "VIA" }, 342}; 343#define HDACC_CODECS_LEN (sizeof(hdacc_codecs) / sizeof(hdacc_codecs[0])) 344 345static int 346hdacc_suspend(device_t dev) 347{ 348 349 HDA_BOOTHVERBOSE( 350 device_printf(dev, "Suspend...\n"); 351 ); 352 bus_generic_suspend(dev); 353 HDA_BOOTHVERBOSE( 354 device_printf(dev, "Suspend done\n"); 355 ); 356 return (0); 357} 358 359static int 360hdacc_resume(device_t dev) 361{ 362 363 HDA_BOOTHVERBOSE( 364 device_printf(dev, "Resume...\n"); 365 ); 366 bus_generic_resume(dev); 367 HDA_BOOTHVERBOSE( 368 device_printf(dev, "Resume done\n"); 369 ); 370 return (0); 371} 372 373static int 374hdacc_probe(device_t dev) 375{ 376 uint32_t id, revid; 377 char buf[128]; 378 int i; 379 380 id = ((uint32_t)hda_get_vendor_id(dev) << 16) + hda_get_device_id(dev); 381 revid = ((uint32_t)hda_get_revision_id(dev) << 8) + hda_get_stepping_id(dev); 382 383 for (i = 0; i < HDACC_CODECS_LEN; i++) { 384 if (!HDA_DEV_MATCH(hdacc_codecs[i].id, id)) 385 continue; 386 if (hdacc_codecs[i].revid != 0 && 387 hdacc_codecs[i].revid != revid) 388 continue; 389 break; 390 } 391 if (i < HDACC_CODECS_LEN) { 392 if ((hdacc_codecs[i].id & 0xffff) != 0xffff) 393 strlcpy(buf, hdacc_codecs[i].name, sizeof(buf)); 394 else 395 snprintf(buf, sizeof(buf), "%s (0x%04x)", 396 hdacc_codecs[i].name, hda_get_device_id(dev)); 397 } else 398 snprintf(buf, sizeof(buf), "Generic (0x%04x)", id); 399 strlcat(buf, " HDA CODEC", sizeof(buf)); 400 device_set_desc_copy(dev, buf); 401 return (BUS_PROBE_DEFAULT); 402} 403 404static int 405hdacc_attach(device_t dev) 406{ 407 struct hdacc_softc *codec = device_get_softc(dev); 408 device_t child; 409 int cad = (intptr_t)device_get_ivars(dev); 410 uint32_t subnode; 411 int startnode; 412 int endnode; 413 int i, n; 414 415 codec->lock = HDAC_GET_MTX(device_get_parent(dev), dev); 416 codec->dev = dev; 417 codec->cad = cad; 418 419 hdacc_lock(codec); 420 subnode = hda_command(dev, 421 HDA_CMD_GET_PARAMETER(0, 0x0, HDA_PARAM_SUB_NODE_COUNT)); 422 hdacc_unlock(codec); 423 if (subnode == HDA_INVALID) 424 return (EIO); 425 codec->fgcnt = HDA_PARAM_SUB_NODE_COUNT_TOTAL(subnode); 426 startnode = HDA_PARAM_SUB_NODE_COUNT_START(subnode); 427 endnode = startnode + codec->fgcnt; 428 429 HDA_BOOTHVERBOSE( 430 device_printf(dev, 431 "Root Node at nid=0: %d subnodes %d-%d\n", 432 HDA_PARAM_SUB_NODE_COUNT_TOTAL(subnode), 433 startnode, endnode - 1); 434 ); 435 436 codec->fgs = malloc(sizeof(struct hdacc_fg) * codec->fgcnt, 437 M_HDACC, M_ZERO | M_WAITOK); 438 for (i = startnode, n = 0; i < endnode; i++, n++) { 439 codec->fgs[n].nid = i; 440 hdacc_lock(codec); 441 codec->fgs[n].type = 442 HDA_PARAM_FCT_GRP_TYPE_NODE_TYPE(hda_command(dev, 443 HDA_CMD_GET_PARAMETER(0, i, HDA_PARAM_FCT_GRP_TYPE))); 444 codec->fgs[n].subsystem_id = hda_command(dev, 445 HDA_CMD_GET_SUBSYSTEM_ID(0, i)); 446 hdacc_unlock(codec); 447 codec->fgs[n].dev = child = device_add_child(dev, NULL, -1); 448 if (child == NULL) { 449 device_printf(dev, "Failed to add function device\n"); 450 continue; 451 } 452 device_set_ivars(child, &codec->fgs[n]); 453 } 454 455 bus_generic_attach(dev); 456 457 return (0); 458} 459 460static int 461hdacc_detach(device_t dev) 462{ 463 struct hdacc_softc *codec = device_get_softc(dev); 464 int error; 465 466 error = device_delete_children(dev); 467 free(codec->fgs, M_HDACC); 468 return (error); 469} 470 471static int 472hdacc_child_location_str(device_t dev, device_t child, char *buf, 473 size_t buflen) 474{ 475 struct hdacc_fg *fg = device_get_ivars(child); 476 477 snprintf(buf, buflen, "nid=%d", fg->nid); 478 return (0); 479} 480 481static int 482hdacc_child_pnpinfo_str_method(device_t dev, device_t child, char *buf, 483 size_t buflen) 484{ 485 struct hdacc_fg *fg = device_get_ivars(child); 486 487 snprintf(buf, buflen, "type=0x%02x subsystem=0x%08x", 488 fg->type, fg->subsystem_id); 489 return (0); 490} 491 492static int 493hdacc_print_child(device_t dev, device_t child) 494{ 495 struct hdacc_fg *fg = device_get_ivars(child); 496 int retval; 497 498 retval = bus_print_child_header(dev, child); 499 retval += printf(" at nid %d", fg->nid); 500 retval += bus_print_child_footer(dev, child); 501 502 return (retval); 503} 504 505static void 506hdacc_probe_nomatch(device_t dev, device_t child) 507{ 508 struct hdacc_softc *codec = device_get_softc(dev); 509 struct hdacc_fg *fg = device_get_ivars(child); 510 511 device_printf(child, "<%s %s Function Group> at nid %d on %s " 512 "(no driver attached)\n", 513 device_get_desc(dev), 514 fg->type == HDA_PARAM_FCT_GRP_TYPE_NODE_TYPE_AUDIO ? "Audio" : 515 (fg->type == HDA_PARAM_FCT_GRP_TYPE_NODE_TYPE_MODEM ? "Modem" : 516 "Unknown"), fg->nid, device_get_nameunit(dev)); 517 HDA_BOOTVERBOSE( 518 device_printf(dev, "Subsystem ID: 0x%08x\n", 519 hda_get_subsystem_id(dev)); 520 ); 521 HDA_BOOTHVERBOSE( 522 device_printf(dev, "Power down FG nid=%d to the D3 state...\n", 523 fg->nid); 524 ); 525 hdacc_lock(codec); 526 hda_command(dev, HDA_CMD_SET_POWER_STATE(0, 527 fg->nid, HDA_CMD_POWER_STATE_D3)); 528 hdacc_unlock(codec); 529} 530 531static int 532hdacc_read_ivar(device_t dev, device_t child, int which, uintptr_t *result) 533{ 534 struct hdacc_fg *fg = device_get_ivars(child); 535 536 switch (which) { 537 case HDA_IVAR_NODE_ID: 538 *result = fg->nid; 539 break; 540 case HDA_IVAR_NODE_TYPE: 541 *result = fg->type; 542 break; 543 case HDA_IVAR_SUBSYSTEM_ID: 544 *result = fg->subsystem_id; 545 break; 546 default: 547 return(BUS_READ_IVAR(device_get_parent(dev), dev, 548 which, result)); 549 } 550 return (0); 551} 552 553static struct mtx * 554hdacc_get_mtx(device_t dev, device_t child) 555{ 556 struct hdacc_softc *codec = device_get_softc(dev); 557 558 return (codec->lock); 559} 560 561static uint32_t 562hdacc_codec_command(device_t dev, device_t child, uint32_t verb) 563{ 564 565 return (HDAC_CODEC_COMMAND(device_get_parent(dev), dev, verb)); 566} 567 568static int 569hdacc_stream_alloc(device_t dev, device_t child, int dir, int format, 570 int stripe, uint32_t **dmapos) 571{ 572 struct hdacc_softc *codec = device_get_softc(dev); 573 int stream; 574 575 stream = HDAC_STREAM_ALLOC(device_get_parent(dev), dev, 576 dir, format, stripe, dmapos); 577 if (stream > 0) 578 codec->streams[dir][stream] = child; 579 return (stream); 580} 581 582static void 583hdacc_stream_free(device_t dev, device_t child, int dir, int stream) 584{ 585 struct hdacc_softc *codec = device_get_softc(dev); 586 587 codec->streams[dir][stream] = NULL; 588 HDAC_STREAM_FREE(device_get_parent(dev), dev, dir, stream); 589} 590 591static int 592hdacc_stream_start(device_t dev, device_t child, 593 int dir, int stream, bus_addr_t buf, int blksz, int blkcnt) 594{ 595 596 return (HDAC_STREAM_START(device_get_parent(dev), dev, 597 dir, stream, buf, blksz, blkcnt)); 598} 599 600static void 601hdacc_stream_stop(device_t dev, device_t child, int dir, int stream) 602{ 603 604 HDAC_STREAM_STOP(device_get_parent(dev), dev, dir, stream); 605} 606 607static void 608hdacc_stream_reset(device_t dev, device_t child, int dir, int stream) 609{ 610 611 HDAC_STREAM_RESET(device_get_parent(dev), dev, dir, stream); 612} 613 614static uint32_t 615hdacc_stream_getptr(device_t dev, device_t child, int dir, int stream) 616{ 617 618 return (HDAC_STREAM_GETPTR(device_get_parent(dev), dev, dir, stream)); 619} 620 621static void 622hdacc_stream_intr(device_t dev, int dir, int stream) 623{ 624 struct hdacc_softc *codec = device_get_softc(dev); 625 device_t child; 626 627 if ((child = codec->streams[dir][stream]) != NULL) 628 HDAC_STREAM_INTR(child, dir, stream); 629} 630 631static int 632hdacc_unsol_alloc(device_t dev, device_t child, int wanted) 633{ 634 struct hdacc_softc *codec = device_get_softc(dev); 635 int tag; 636 637 wanted &= 0x3f; 638 tag = wanted; 639 do { 640 if (codec->tags[tag] == NULL) { 641 codec->tags[tag] = child; 642 HDAC_UNSOL_ALLOC(device_get_parent(dev), dev, tag); 643 return (tag); 644 } 645 tag++; 646 tag &= 0x3f; 647 } while (tag != wanted); 648 return (-1); 649} 650 651static void 652hdacc_unsol_free(device_t dev, device_t child, int tag) 653{ 654 struct hdacc_softc *codec = device_get_softc(dev); 655 656 KASSERT(tag >= 0 && tag <= 0x3f, ("Wrong tag value %d\n", tag)); 657 codec->tags[tag] = NULL; 658 HDAC_UNSOL_FREE(device_get_parent(dev), dev, tag); 659} 660 661static void 662hdacc_unsol_intr(device_t dev, uint32_t resp) 663{ 664 struct hdacc_softc *codec = device_get_softc(dev); 665 device_t child; 666 int tag; 667 668 tag = resp >> 26; 669 if ((child = codec->tags[tag]) != NULL) 670 HDAC_UNSOL_INTR(child, resp); 671 else 672 device_printf(codec->dev, "Unexpected unsolicited " 673 "response with tag %d: %08x\n", tag, resp); 674} 675 676static void 677hdacc_pindump(device_t dev) 678{ 679 device_t *devlist; 680 int devcount, i; 681 682 if (device_get_children(dev, &devlist, &devcount) != 0) 683 return; 684 for (i = 0; i < devcount; i++) 685 HDAC_PINDUMP(devlist[i]); 686 free(devlist, M_TEMP); 687} 688 689static device_method_t hdacc_methods[] = { 690 /* device interface */ 691 DEVMETHOD(device_probe, hdacc_probe), 692 DEVMETHOD(device_attach, hdacc_attach), 693 DEVMETHOD(device_detach, hdacc_detach), 694 DEVMETHOD(device_suspend, hdacc_suspend), 695 DEVMETHOD(device_resume, hdacc_resume), 696 /* Bus interface */ 697 DEVMETHOD(bus_child_location_str, hdacc_child_location_str), 698 DEVMETHOD(bus_child_pnpinfo_str, hdacc_child_pnpinfo_str_method), 699 DEVMETHOD(bus_print_child, hdacc_print_child), 700 DEVMETHOD(bus_probe_nomatch, hdacc_probe_nomatch), 701 DEVMETHOD(bus_read_ivar, hdacc_read_ivar), 702 DEVMETHOD(hdac_get_mtx, hdacc_get_mtx), 703 DEVMETHOD(hdac_codec_command, hdacc_codec_command), 704 DEVMETHOD(hdac_stream_alloc, hdacc_stream_alloc), 705 DEVMETHOD(hdac_stream_free, hdacc_stream_free), 706 DEVMETHOD(hdac_stream_start, hdacc_stream_start), 707 DEVMETHOD(hdac_stream_stop, hdacc_stream_stop), 708 DEVMETHOD(hdac_stream_reset, hdacc_stream_reset), 709 DEVMETHOD(hdac_stream_getptr, hdacc_stream_getptr), 710 DEVMETHOD(hdac_stream_intr, hdacc_stream_intr), 711 DEVMETHOD(hdac_unsol_alloc, hdacc_unsol_alloc), 712 DEVMETHOD(hdac_unsol_free, hdacc_unsol_free), 713 DEVMETHOD(hdac_unsol_intr, hdacc_unsol_intr), 714 DEVMETHOD(hdac_pindump, hdacc_pindump), 715 { 0, 0 } 716}; 717 718static driver_t hdacc_driver = { 719 "hdacc", 720 hdacc_methods, 721 sizeof(struct hdacc_softc), 722}; 723 724static devclass_t hdacc_devclass; 725 726DRIVER_MODULE(snd_hda, hdac, hdacc_driver, hdacc_devclass, 0, 0); 727