hdacc.c revision 230331
168651Skris/*- 268651Skris * Copyright (c) 2006 Stephane E. Potvin <sepotvin@videotron.ca> 368651Skris * Copyright (c) 2006 Ariff Abdullah <ariff@FreeBSD.org> 468651Skris * Copyright (c) 2008-2012 Alexander Motin <mav@FreeBSD.org> 568651Skris * All rights reserved. 668651Skris * 768651Skris * Redistribution and use in source and binary forms, with or without 868651Skris * modification, are permitted provided that the following conditions 968651Skris * are met: 1068651Skris * 1. Redistributions of source code must retain the above copyright 1168651Skris * notice, this list of conditions and the following disclaimer. 1268651Skris * 2. Redistributions in binary form must reproduce the above copyright 1368651Skris * notice, this list of conditions and the following disclaimer in the 1468651Skris * documentation and/or other materials provided with the distribution. 1568651Skris * 1668651Skris * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND 1768651Skris * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 1868651Skris * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 1968651Skris * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE 2068651Skris * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 2168651Skris * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 2268651Skris * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 2368651Skris * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 2468651Skris * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 2568651Skris * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 2668651Skris * SUCH DAMAGE. 2768651Skris */ 2868651Skris 2968651Skris/* 3068651Skris * Intel High Definition Audio (CODEC) driver for FreeBSD. 3168651Skris */ 3268651Skris 3368651Skris#ifdef HAVE_KERNEL_OPTION_HEADERS 3468651Skris#include "opt_snd.h" 3568651Skris#endif 3668651Skris 3768651Skris#include <dev/sound/pcm/sound.h> 3868651Skris 3968651Skris#include <sys/ctype.h> 4068651Skris 4168651Skris#include <dev/sound/pci/hda/hda_reg.h> 4268651Skris#include <dev/sound/pci/hda/hdac.h> 4368651Skris 4468651SkrisSND_DECLARE_FILE("$FreeBSD: head/sys/dev/sound/pci/hda/hdacc.c 230331 2012-01-19 11:18:21Z mav $"); 4568651Skris 4668651Skrisstruct hdacc_fg { 4768651Skris device_t dev; 4868651Skris nid_t nid; 4968651Skris uint8_t type; 5068651Skris uint32_t subsystem_id; 5168651Skris}; 5268651Skris 5368651Skrisstruct hdacc_softc { 5468651Skris device_t dev; 5568651Skris struct mtx *lock; 5668651Skris nid_t cad; 5768651Skris device_t streams[2][16]; 5868651Skris device_t tags[64]; 5968651Skris int fgcnt; 6068651Skris struct hdacc_fg *fgs; 6168651Skris}; 6268651Skris 6368651Skris#define hdacc_lock(codec) snd_mtxlock((codec)->lock) 6468651Skris#define hdacc_unlock(codec) snd_mtxunlock((codec)->lock) 6568651Skris#define hdacc_lockassert(codec) snd_mtxassert((codec)->lock) 6668651Skris#define hdacc_lockowned(codec) mtx_owned((codec)->lock) 6768651Skris 68160814SsimonMALLOC_DEFINE(M_HDACC, "hdacc", "HDA CODEC"); 6968651Skris 7068651Skris/* CODECs */ 7168651Skrisstatic const struct { 7268651Skris uint32_t id; 7368651Skris uint16_t revid; 7468651Skris char *name; 7568651Skris} hdacc_codecs[] = { 7668651Skris { HDA_CODEC_CS4206, 0, "Cirrus Logic CS4206" }, 7768651Skris { HDA_CODEC_CS4207, 0, "Cirrus Logic CS4207" }, 7868651Skris { HDA_CODEC_CS4210, 0, "Cirrus Logic CS4210" }, 7968651Skris { HDA_CODEC_ALC221, 0, "Realtek ALC221" }, 80246772Sjkim { HDA_CODEC_ALC260, 0, "Realtek ALC260" }, 81246772Sjkim { HDA_CODEC_ALC262, 0, "Realtek ALC262" }, 82246772Sjkim { HDA_CODEC_ALC267, 0, "Realtek ALC267" }, 83246772Sjkim { HDA_CODEC_ALC268, 0, "Realtek ALC268" }, 8468651Skris { HDA_CODEC_ALC269, 0, "Realtek ALC269" }, 8568651Skris { HDA_CODEC_ALC270, 0, "Realtek ALC270" }, 8668651Skris { HDA_CODEC_ALC272, 0, "Realtek ALC272" }, 8768651Skris { HDA_CODEC_ALC273, 0, "Realtek ALC273" }, 8868651Skris { HDA_CODEC_ALC275, 0, "Realtek ALC275" }, 8968651Skris { HDA_CODEC_ALC276, 0, "Realtek ALC276" }, 9068651Skris { HDA_CODEC_ALC660, 0, "Realtek ALC660-VD" }, 9168651Skris { HDA_CODEC_ALC662, 0x0002, "Realtek ALC662 rev2" }, 9268651Skris { HDA_CODEC_ALC662, 0, "Realtek ALC662" }, 9368651Skris { HDA_CODEC_ALC663, 0, "Realtek ALC663" }, 9468651Skris { HDA_CODEC_ALC665, 0, "Realtek ALC665" }, 9568651Skris { HDA_CODEC_ALC861, 0x0340, "Realtek ALC660" }, 9668651Skris { HDA_CODEC_ALC861, 0, "Realtek ALC861" }, 9768651Skris { HDA_CODEC_ALC861VD, 0, "Realtek ALC861-VD" }, 9868651Skris { HDA_CODEC_ALC880, 0, "Realtek ALC880" }, 9968651Skris { HDA_CODEC_ALC882, 0, "Realtek ALC882" }, 10068651Skris { HDA_CODEC_ALC883, 0, "Realtek ALC883" }, 10168651Skris { HDA_CODEC_ALC885, 0x0101, "Realtek ALC889A" }, 10268651Skris { HDA_CODEC_ALC885, 0x0103, "Realtek ALC889A" }, 10368651Skris { HDA_CODEC_ALC885, 0, "Realtek ALC885" }, 10468651Skris { HDA_CODEC_ALC887, 0, "Realtek ALC887" }, 10568651Skris { HDA_CODEC_ALC888, 0x0101, "Realtek ALC1200" }, 10668651Skris { HDA_CODEC_ALC888, 0, "Realtek ALC888" }, 10768651Skris { HDA_CODEC_ALC889, 0, "Realtek ALC889" }, 10868651Skris { HDA_CODEC_ALC892, 0, "Realtek ALC892" }, 10968651Skris { HDA_CODEC_ALC899, 0, "Realtek ALC899" }, 11068651Skris { HDA_CODEC_AD1882, 0, "Analog Devices AD1882" }, 11168651Skris { HDA_CODEC_AD1882A, 0, "Analog Devices AD1882A" }, 11268651Skris { HDA_CODEC_AD1883, 0, "Analog Devices AD1883" }, 113 { HDA_CODEC_AD1884, 0, "Analog Devices AD1884" }, 114 { HDA_CODEC_AD1884A, 0, "Analog Devices AD1884A" }, 115 { HDA_CODEC_AD1981HD, 0, "Analog Devices AD1981HD" }, 116 { HDA_CODEC_AD1983, 0, "Analog Devices AD1983" }, 117 { HDA_CODEC_AD1984, 0, "Analog Devices AD1984" }, 118 { HDA_CODEC_AD1984A, 0, "Analog Devices AD1984A" }, 119 { HDA_CODEC_AD1984B, 0, "Analog Devices AD1984B" }, 120 { HDA_CODEC_AD1986A, 0, "Analog Devices AD1986A" }, 121 { HDA_CODEC_AD1987, 0, "Analog Devices AD1987" }, 122 { HDA_CODEC_AD1988, 0, "Analog Devices AD1988A" }, 123 { HDA_CODEC_AD1988B, 0, "Analog Devices AD1988B" }, 124 { HDA_CODEC_AD1989A, 0, "Analog Devices AD1989A" }, 125 { HDA_CODEC_AD1989B, 0, "Analog Devices AD1989B" }, 126 { HDA_CODEC_CMI9880, 0, "CMedia CMI9880" }, 127 { HDA_CODEC_CXD9872RDK, 0, "Sigmatel CXD9872RD/K" }, 128 { HDA_CODEC_CXD9872AKD, 0, "Sigmatel CXD9872AKD" }, 129 { HDA_CODEC_STAC9200D, 0, "Sigmatel STAC9200D" }, 130 { HDA_CODEC_STAC9204X, 0, "Sigmatel STAC9204X" }, 131 { HDA_CODEC_STAC9204D, 0, "Sigmatel STAC9204D" }, 132 { HDA_CODEC_STAC9205X, 0, "Sigmatel STAC9205X" }, 133 { HDA_CODEC_STAC9205D, 0, "Sigmatel STAC9205D" }, 134 { HDA_CODEC_STAC9220, 0, "Sigmatel STAC9220" }, 135 { HDA_CODEC_STAC9220_A1, 0, "Sigmatel STAC9220_A1" }, 136 { HDA_CODEC_STAC9220_A2, 0, "Sigmatel STAC9220_A2" }, 137 { HDA_CODEC_STAC9221, 0, "Sigmatel STAC9221" }, 138 { HDA_CODEC_STAC9221_A2, 0, "Sigmatel STAC9221_A2" }, 139 { HDA_CODEC_STAC9221D, 0, "Sigmatel STAC9221D" }, 140 { HDA_CODEC_STAC922XD, 0, "Sigmatel STAC9220D/9223D" }, 141 { HDA_CODEC_STAC9227X, 0, "Sigmatel STAC9227X" }, 142 { HDA_CODEC_STAC9227D, 0, "Sigmatel STAC9227D" }, 143 { HDA_CODEC_STAC9228X, 0, "Sigmatel STAC9228X" }, 144 { HDA_CODEC_STAC9228D, 0, "Sigmatel STAC9228D" }, 145 { HDA_CODEC_STAC9229X, 0, "Sigmatel STAC9229X" }, 146 { HDA_CODEC_STAC9229D, 0, "Sigmatel STAC9229D" }, 147 { HDA_CODEC_STAC9230X, 0, "Sigmatel STAC9230X" }, 148 { HDA_CODEC_STAC9230D, 0, "Sigmatel STAC9230D" }, 149 { HDA_CODEC_STAC9250, 0, "Sigmatel STAC9250" }, 150 { HDA_CODEC_STAC9251, 0, "Sigmatel STAC9251" }, 151 { HDA_CODEC_STAC9271X, 0, "Sigmatel STAC9271X" }, 152 { HDA_CODEC_STAC9271D, 0, "Sigmatel STAC9271D" }, 153 { HDA_CODEC_STAC9272X, 0, "Sigmatel STAC9272X" }, 154 { HDA_CODEC_STAC9272D, 0, "Sigmatel STAC9272D" }, 155 { HDA_CODEC_STAC9273X, 0, "Sigmatel STAC9273X" }, 156 { HDA_CODEC_STAC9273D, 0, "Sigmatel STAC9273D" }, 157 { HDA_CODEC_STAC9274, 0, "Sigmatel STAC9274" }, 158 { HDA_CODEC_STAC9274D, 0, "Sigmatel STAC9274D" }, 159 { HDA_CODEC_STAC9274X5NH, 0, "Sigmatel STAC9274X5NH" }, 160 { HDA_CODEC_STAC9274D5NH, 0, "Sigmatel STAC9274D5NH" }, 161 { HDA_CODEC_STAC9872AK, 0, "Sigmatel STAC9872AK" }, 162 { HDA_CODEC_IDT92HD005, 0, "IDT 92HD005" }, 163 { HDA_CODEC_IDT92HD005D, 0, "IDT 92HD005D" }, 164 { HDA_CODEC_IDT92HD206X, 0, "IDT 92HD206X" }, 165 { HDA_CODEC_IDT92HD206D, 0, "IDT 92HD206D" }, 166 { HDA_CODEC_IDT92HD700X, 0, "IDT 92HD700X" }, 167 { HDA_CODEC_IDT92HD700D, 0, "IDT 92HD700D" }, 168 { HDA_CODEC_IDT92HD71B5, 0, "IDT 92HD71B5" }, 169 { HDA_CODEC_IDT92HD71B7, 0, "IDT 92HD71B7" }, 170 { HDA_CODEC_IDT92HD71B8, 0, "IDT 92HD71B8" }, 171 { HDA_CODEC_IDT92HD73C1, 0, "IDT 92HD73C1" }, 172 { HDA_CODEC_IDT92HD73D1, 0, "IDT 92HD73D1" }, 173 { HDA_CODEC_IDT92HD73E1, 0, "IDT 92HD73E1" }, 174 { HDA_CODEC_IDT92HD75B3, 0, "IDT 92HD75B3" }, 175 { HDA_CODEC_IDT92HD75BX, 0, "IDT 92HD75BX" }, 176 { HDA_CODEC_IDT92HD81B1C, 0, "IDT 92HD81B1C" }, 177 { HDA_CODEC_IDT92HD81B1X, 0, "IDT 92HD81B1X" }, 178 { HDA_CODEC_IDT92HD83C1C, 0, "IDT 92HD83C1C" }, 179 { HDA_CODEC_IDT92HD83C1X, 0, "IDT 92HD83C1X" }, 180 { HDA_CODEC_CX20549, 0, "Conexant CX20549 (Venice)" }, 181 { HDA_CODEC_CX20551, 0, "Conexant CX20551 (Waikiki)" }, 182 { HDA_CODEC_CX20561, 0, "Conexant CX20561 (Hermosa)" }, 183 { HDA_CODEC_CX20582, 0, "Conexant CX20582 (Pebble)" }, 184 { HDA_CODEC_CX20583, 0, "Conexant CX20583 (Pebble HSF)" }, 185 { HDA_CODEC_CX20584, 0, "Conexant CX20584" }, 186 { HDA_CODEC_CX20585, 0, "Conexant CX20585" }, 187 { HDA_CODEC_CX20588, 0, "Conexant CX20588" }, 188 { HDA_CODEC_CX20590, 0, "Conexant CX20590" }, 189 { HDA_CODEC_CX20631, 0, "Conexant CX20631" }, 190 { HDA_CODEC_CX20632, 0, "Conexant CX20632" }, 191 { HDA_CODEC_CX20641, 0, "Conexant CX20641" }, 192 { HDA_CODEC_CX20642, 0, "Conexant CX20642" }, 193 { HDA_CODEC_CX20651, 0, "Conexant CX20651" }, 194 { HDA_CODEC_CX20652, 0, "Conexant CX20652" }, 195 { HDA_CODEC_CX20664, 0, "Conexant CX20664" }, 196 { HDA_CODEC_CX20665, 0, "Conexant CX20665" }, 197 { HDA_CODEC_VT1708_8, 0, "VIA VT1708_8" }, 198 { HDA_CODEC_VT1708_9, 0, "VIA VT1708_9" }, 199 { HDA_CODEC_VT1708_A, 0, "VIA VT1708_A" }, 200 { HDA_CODEC_VT1708_B, 0, "VIA VT1708_B" }, 201 { HDA_CODEC_VT1709_0, 0, "VIA VT1709_0" }, 202 { HDA_CODEC_VT1709_1, 0, "VIA VT1709_1" }, 203 { HDA_CODEC_VT1709_2, 0, "VIA VT1709_2" }, 204 { HDA_CODEC_VT1709_3, 0, "VIA VT1709_3" }, 205 { HDA_CODEC_VT1709_4, 0, "VIA VT1709_4" }, 206 { HDA_CODEC_VT1709_5, 0, "VIA VT1709_5" }, 207 { HDA_CODEC_VT1709_6, 0, "VIA VT1709_6" }, 208 { HDA_CODEC_VT1709_7, 0, "VIA VT1709_7" }, 209 { HDA_CODEC_VT1708B_0, 0, "VIA VT1708B_0" }, 210 { HDA_CODEC_VT1708B_1, 0, "VIA VT1708B_1" }, 211 { HDA_CODEC_VT1708B_2, 0, "VIA VT1708B_2" }, 212 { HDA_CODEC_VT1708B_3, 0, "VIA VT1708B_3" }, 213 { HDA_CODEC_VT1708B_4, 0, "VIA VT1708B_4" }, 214 { HDA_CODEC_VT1708B_5, 0, "VIA VT1708B_5" }, 215 { HDA_CODEC_VT1708B_6, 0, "VIA VT1708B_6" }, 216 { HDA_CODEC_VT1708B_7, 0, "VIA VT1708B_7" }, 217 { HDA_CODEC_VT1708S_0, 0, "VIA VT1708S_0" }, 218 { HDA_CODEC_VT1708S_1, 0, "VIA VT1708S_1" }, 219 { HDA_CODEC_VT1708S_2, 0, "VIA VT1708S_2" }, 220 { HDA_CODEC_VT1708S_3, 0, "VIA VT1708S_3" }, 221 { HDA_CODEC_VT1708S_4, 0, "VIA VT1708S_4" }, 222 { HDA_CODEC_VT1708S_5, 0, "VIA VT1708S_5" }, 223 { HDA_CODEC_VT1708S_6, 0, "VIA VT1708S_6" }, 224 { HDA_CODEC_VT1708S_7, 0, "VIA VT1708S_7" }, 225 { HDA_CODEC_VT1702_0, 0, "VIA VT1702_0" }, 226 { HDA_CODEC_VT1702_1, 0, "VIA VT1702_1" }, 227 { HDA_CODEC_VT1702_2, 0, "VIA VT1702_2" }, 228 { HDA_CODEC_VT1702_3, 0, "VIA VT1702_3" }, 229 { HDA_CODEC_VT1702_4, 0, "VIA VT1702_4" }, 230 { HDA_CODEC_VT1702_5, 0, "VIA VT1702_5" }, 231 { HDA_CODEC_VT1702_6, 0, "VIA VT1702_6" }, 232 { HDA_CODEC_VT1702_7, 0, "VIA VT1702_7" }, 233 { HDA_CODEC_VT1716S_0, 0, "VIA VT1716S_0" }, 234 { HDA_CODEC_VT1716S_1, 0, "VIA VT1716S_1" }, 235 { HDA_CODEC_VT1718S_0, 0, "VIA VT1718S_0" }, 236 { HDA_CODEC_VT1718S_1, 0, "VIA VT1718S_1" }, 237 { HDA_CODEC_VT1802_0, 0, "VIA VT1802_0" }, 238 { HDA_CODEC_VT1802_1, 0, "VIA VT1802_1" }, 239 { HDA_CODEC_VT1812, 0, "VIA VT1812" }, 240 { HDA_CODEC_VT1818S, 0, "VIA VT1818S" }, 241 { HDA_CODEC_VT1828S, 0, "VIA VT1828S" }, 242 { HDA_CODEC_VT2002P_0, 0, "VIA VT2002P_0" }, 243 { HDA_CODEC_VT2002P_1, 0, "VIA VT2002P_1" }, 244 { HDA_CODEC_VT2020, 0, "VIA VT2020" }, 245 { HDA_CODEC_ATIRS600_1, 0, "ATI RS600" }, 246 { HDA_CODEC_ATIRS600_2, 0, "ATI RS600" }, 247 { HDA_CODEC_ATIRS690, 0, "ATI RS690/780" }, 248 { HDA_CODEC_ATIR6XX, 0, "ATI R6xx" }, 249 { HDA_CODEC_NVIDIAMCP67, 0, "NVIDIA MCP67" }, 250 { HDA_CODEC_NVIDIAMCP73, 0, "NVIDIA MCP73" }, 251 { HDA_CODEC_NVIDIAMCP78, 0, "NVIDIA MCP78" }, 252 { HDA_CODEC_NVIDIAMCP78_2, 0, "NVIDIA MCP78" }, 253 { HDA_CODEC_NVIDIAMCP7A, 0, "NVIDIA MCP7A" }, 254 { HDA_CODEC_NVIDIAGT220, 0, "NVIDIA GT220" }, 255 { HDA_CODEC_NVIDIAGT21X, 0, "NVIDIA GT21x" }, 256 { HDA_CODEC_NVIDIAMCP89, 0, "NVIDIA MCP89" }, 257 { HDA_CODEC_NVIDIAGT240, 0, "NVIDIA GT240" }, 258 { HDA_CODEC_INTELIP, 0, "Intel Ibex Peak" }, 259 { HDA_CODEC_INTELBL, 0, "Intel Bearlake" }, 260 { HDA_CODEC_INTELCA, 0, "Intel Cantiga" }, 261 { HDA_CODEC_INTELEL, 0, "Intel Eaglelake" }, 262 { HDA_CODEC_INTELIP2, 0, "Intel Ibex Peak" }, 263 { HDA_CODEC_INTELCPT, 0, "Intel Cougar Point" }, 264 { HDA_CODEC_INTELPPT, 0, "Intel Panther Point" }, 265 { HDA_CODEC_INTELCL, 0, "Intel Crestline" }, 266 { HDA_CODEC_SII1390, 0, "Silicon Image SiI1390" }, 267 { HDA_CODEC_SII1392, 0, "Silicon Image SiI1392" }, 268 /* Unknown CODECs */ 269 { HDA_CODEC_ALCXXXX, 0, "Realtek" }, 270 { HDA_CODEC_ADXXXX, 0, "Analog Devices" }, 271 { HDA_CODEC_CSXXXX, 0, "Cirrus Logic" }, 272 { HDA_CODEC_CMIXXXX, 0, "CMedia" }, 273 { HDA_CODEC_STACXXXX, 0, "Sigmatel" }, 274 { HDA_CODEC_SIIXXXX, 0, "Silicon Image" }, 275 { HDA_CODEC_AGEREXXXX, 0, "Lucent/Agere Systems" }, 276 { HDA_CODEC_CXXXXX, 0, "Conexant" }, 277 { HDA_CODEC_VTXXXX, 0, "VIA" }, 278 { HDA_CODEC_ATIXXXX, 0, "ATI" }, 279 { HDA_CODEC_NVIDIAXXXX, 0, "NVIDIA" }, 280 { HDA_CODEC_INTELXXXX, 0, "Intel" }, 281 { HDA_CODEC_IDTXXXX, 0, "IDT" }, 282}; 283#define HDACC_CODECS_LEN (sizeof(hdacc_codecs) / sizeof(hdacc_codecs[0])) 284 285static int 286hdacc_suspend(device_t dev) 287{ 288 289 HDA_BOOTHVERBOSE( 290 device_printf(dev, "Suspend...\n"); 291 ); 292 bus_generic_suspend(dev); 293 HDA_BOOTHVERBOSE( 294 device_printf(dev, "Suspend done\n"); 295 ); 296 return (0); 297} 298 299static int 300hdacc_resume(device_t dev) 301{ 302 303 HDA_BOOTHVERBOSE( 304 device_printf(dev, "Resume...\n"); 305 ); 306 bus_generic_resume(dev); 307 HDA_BOOTHVERBOSE( 308 device_printf(dev, "Resume done\n"); 309 ); 310 return (0); 311} 312 313static int 314hdacc_probe(device_t dev) 315{ 316 uint32_t id, revid; 317 char buf[128]; 318 int i; 319 320 id = ((uint32_t)hda_get_vendor_id(dev) << 16) + hda_get_device_id(dev); 321 revid = ((uint32_t)hda_get_revision_id(dev) << 8) + hda_get_stepping_id(dev); 322 323 for (i = 0; i < HDACC_CODECS_LEN; i++) { 324 if (!HDA_DEV_MATCH(hdacc_codecs[i].id, id)) 325 continue; 326 if (hdacc_codecs[i].revid != 0 && 327 hdacc_codecs[i].revid != revid) 328 continue; 329 break; 330 } 331 if (i < HDACC_CODECS_LEN) { 332 if ((hdacc_codecs[i].id & 0xffff) != 0xffff) 333 strlcpy(buf, hdacc_codecs[i].name, sizeof(buf)); 334 else 335 snprintf(buf, sizeof(buf), "%s (0x%04x)", 336 hdacc_codecs[i].name, hda_get_device_id(dev)); 337 } else 338 snprintf(buf, sizeof(buf), "Generic (0x%04x)", id); 339 strlcat(buf, " HDA CODEC", sizeof(buf)); 340 device_set_desc_copy(dev, buf); 341 return (BUS_PROBE_DEFAULT); 342} 343 344static int 345hdacc_attach(device_t dev) 346{ 347 struct hdacc_softc *codec = device_get_softc(dev); 348 device_t child; 349 int cad = (intptr_t)device_get_ivars(dev); 350 uint32_t subnode; 351 int startnode; 352 int endnode; 353 int i, n; 354 355 codec->lock = HDAC_GET_MTX(device_get_parent(dev), dev); 356 codec->dev = dev; 357 codec->cad = cad; 358 359 hdacc_lock(codec); 360 subnode = hda_command(dev, 361 HDA_CMD_GET_PARAMETER(0, 0x0, HDA_PARAM_SUB_NODE_COUNT)); 362 hdacc_unlock(codec); 363 if (subnode == HDA_INVALID) 364 return (EIO); 365 codec->fgcnt = HDA_PARAM_SUB_NODE_COUNT_TOTAL(subnode); 366 startnode = HDA_PARAM_SUB_NODE_COUNT_START(subnode); 367 endnode = startnode + codec->fgcnt; 368 369 HDA_BOOTVERBOSE( 370 device_printf(dev, 371 "Root Node at nid=0: %d subnodes %d-%d\n", 372 HDA_PARAM_SUB_NODE_COUNT_TOTAL(subnode), 373 startnode, endnode - 1); 374 ); 375 376 codec->fgs = malloc(sizeof(struct hdacc_fg) * codec->fgcnt, 377 M_HDACC, M_ZERO | M_WAITOK); 378 for (i = startnode, n = 0; i < endnode; i++, n++) { 379 codec->fgs[n].nid = i; 380 hdacc_lock(codec); 381 codec->fgs[n].type = 382 HDA_PARAM_FCT_GRP_TYPE_NODE_TYPE(hda_command(dev, 383 HDA_CMD_GET_PARAMETER(0, i, HDA_PARAM_FCT_GRP_TYPE))); 384 codec->fgs[n].subsystem_id = hda_command(dev, 385 HDA_CMD_GET_SUBSYSTEM_ID(0, i)); 386 hdacc_unlock(codec); 387 codec->fgs[n].dev = child = device_add_child(dev, NULL, -1); 388 if (child == NULL) { 389 device_printf(dev, "Failed to add function device\n"); 390 continue; 391 } 392 device_set_ivars(child, &codec->fgs[n]); 393 } 394 395 bus_generic_attach(dev); 396 397 return (0); 398} 399 400static int 401hdacc_detach(device_t dev) 402{ 403 404 return (device_delete_children(dev)); 405} 406 407static int 408hdacc_child_location_str(device_t dev, device_t child, char *buf, 409 size_t buflen) 410{ 411 struct hdacc_fg *fg = device_get_ivars(child); 412 413 snprintf(buf, buflen, "nid=%d", fg->nid); 414 return (0); 415} 416 417static int 418hdacc_child_pnpinfo_str_method(device_t dev, device_t child, char *buf, 419 size_t buflen) 420{ 421 struct hdacc_fg *fg = device_get_ivars(child); 422 423 snprintf(buf, buflen, "type=0x%02x subsystem=0x%08x", 424 fg->type, fg->subsystem_id); 425 return (0); 426} 427 428static int 429hdacc_print_child(device_t dev, device_t child) 430{ 431 struct hdacc_fg *fg = device_get_ivars(child); 432 int retval; 433 434 retval = bus_print_child_header(dev, child); 435 retval += printf(" at nid %d", fg->nid); 436 retval += bus_print_child_footer(dev, child); 437 438 return (retval); 439} 440 441static void 442hdacc_probe_nomatch(device_t dev, device_t child) 443{ 444 struct hdacc_softc *codec = device_get_softc(dev); 445 struct hdacc_fg *fg = device_get_ivars(child); 446 447 device_printf(child, "<%s %s Function Group> at nid %d on %s " 448 "(no driver attached)\n", 449 device_get_desc(dev), 450 fg->type == HDA_PARAM_FCT_GRP_TYPE_NODE_TYPE_AUDIO ? "Audio" : 451 (fg->type == HDA_PARAM_FCT_GRP_TYPE_NODE_TYPE_MODEM ? "Modem" : 452 "Unknown"), fg->nid, device_get_nameunit(dev)); 453 HDA_BOOTHVERBOSE( 454 device_printf(dev, "Power down FG nid=%d to the D3 state...\n", 455 fg->nid); 456 ); 457 hdacc_lock(codec); 458 hda_command(dev, HDA_CMD_SET_POWER_STATE(0, 459 fg->nid, HDA_CMD_POWER_STATE_D3)); 460 hdacc_unlock(codec); 461} 462 463static int 464hdacc_read_ivar(device_t dev, device_t child, int which, uintptr_t *result) 465{ 466 struct hdacc_fg *fg = device_get_ivars(child); 467 468 switch (which) { 469 case HDA_IVAR_NODE_ID: 470 *result = fg->nid; 471 break; 472 case HDA_IVAR_NODE_TYPE: 473 *result = fg->type; 474 break; 475 case HDA_IVAR_SUBSYSTEM_ID: 476 *result = fg->subsystem_id; 477 break; 478 default: 479 return(BUS_READ_IVAR(device_get_parent(dev), dev, 480 which, result)); 481 } 482 return (0); 483} 484 485static struct mtx * 486hdacc_get_mtx(device_t dev, device_t child) 487{ 488 struct hdacc_softc *codec = device_get_softc(dev); 489 490 return (codec->lock); 491} 492 493static uint32_t 494hdacc_codec_command(device_t dev, device_t child, uint32_t verb) 495{ 496 497 return (HDAC_CODEC_COMMAND(device_get_parent(dev), dev, verb)); 498} 499 500static int 501hdacc_stream_alloc(device_t dev, device_t child, int dir, int format, 502 int stripe, uint32_t **dmapos) 503{ 504 struct hdacc_softc *codec = device_get_softc(dev); 505 int stream; 506 507 stream = HDAC_STREAM_ALLOC(device_get_parent(dev), dev, 508 dir, format, stripe, dmapos); 509 if (stream > 0) 510 codec->streams[dir][stream] = child; 511 return (stream); 512} 513 514static void 515hdacc_stream_free(device_t dev, device_t child, int dir, int stream) 516{ 517 struct hdacc_softc *codec = device_get_softc(dev); 518 519 codec->streams[dir][stream] = NULL; 520 HDAC_STREAM_FREE(device_get_parent(dev), dev, dir, stream); 521} 522 523static int 524hdacc_stream_start(device_t dev, device_t child, 525 int dir, int stream, bus_addr_t buf, int blksz, int blkcnt) 526{ 527 528 return (HDAC_STREAM_START(device_get_parent(dev), dev, 529 dir, stream, buf, blksz, blkcnt)); 530} 531 532static void 533hdacc_stream_stop(device_t dev, device_t child, int dir, int stream) 534{ 535 536 HDAC_STREAM_STOP(device_get_parent(dev), dev, dir, stream); 537} 538 539static void 540hdacc_stream_reset(device_t dev, device_t child, int dir, int stream) 541{ 542 543 HDAC_STREAM_RESET(device_get_parent(dev), dev, dir, stream); 544} 545 546static uint32_t 547hdacc_stream_getptr(device_t dev, device_t child, int dir, int stream) 548{ 549 550 return (HDAC_STREAM_GETPTR(device_get_parent(dev), dev, dir, stream)); 551} 552 553static void 554hdacc_stream_intr(device_t dev, int dir, int stream) 555{ 556 struct hdacc_softc *codec = device_get_softc(dev); 557 device_t child; 558 559 if ((child = codec->streams[dir][stream]) != NULL); 560 HDAC_STREAM_INTR(child, dir, stream); 561} 562 563static int 564hdacc_unsol_alloc(device_t dev, device_t child, int wanted) 565{ 566 struct hdacc_softc *codec = device_get_softc(dev); 567 int tag; 568 569 wanted &= 0x3f; 570 tag = wanted; 571 do { 572 if (codec->tags[tag] == NULL) { 573 codec->tags[tag] = child; 574 HDAC_UNSOL_ALLOC(device_get_parent(dev), dev, tag); 575 return (tag); 576 } 577 tag++; 578 tag &= 0x3f; 579 } while (tag != wanted); 580 return (-1); 581} 582 583static void 584hdacc_unsol_free(device_t dev, device_t child, int tag) 585{ 586 struct hdacc_softc *codec = device_get_softc(dev); 587 588 KASSERT(tag >= 0 && tag <= 0x3f, ("Wrong tag value %d\n", tag)); 589 codec->tags[tag] = NULL; 590 HDAC_UNSOL_FREE(device_get_parent(dev), dev, tag); 591} 592 593static void 594hdacc_unsol_intr(device_t dev, uint32_t resp) 595{ 596 struct hdacc_softc *codec = device_get_softc(dev); 597 device_t child; 598 int tag; 599 600 tag = resp >> 26; 601 if ((child = codec->tags[tag]) != NULL) 602 HDAC_UNSOL_INTR(child, resp); 603 else 604 device_printf(codec->dev, "Unexpected unsolicited " 605 "response with tag %d: %08x\n", tag, resp); 606} 607 608static void 609hdacc_pindump(device_t dev) 610{ 611 device_t *devlist; 612 int devcount, i; 613 614 if (device_get_children(dev, &devlist, &devcount) != 0) 615 return; 616 for (i = 0; i < devcount; i++) 617 HDAC_PINDUMP(devlist[i]); 618 free(devlist, M_TEMP); 619} 620 621static device_method_t hdacc_methods[] = { 622 /* device interface */ 623 DEVMETHOD(device_probe, hdacc_probe), 624 DEVMETHOD(device_attach, hdacc_attach), 625 DEVMETHOD(device_detach, hdacc_detach), 626 DEVMETHOD(device_suspend, hdacc_suspend), 627 DEVMETHOD(device_resume, hdacc_resume), 628 /* Bus interface */ 629 DEVMETHOD(bus_child_location_str, hdacc_child_location_str), 630 DEVMETHOD(bus_child_pnpinfo_str, hdacc_child_pnpinfo_str_method), 631 DEVMETHOD(bus_print_child, hdacc_print_child), 632 DEVMETHOD(bus_probe_nomatch, hdacc_probe_nomatch), 633 DEVMETHOD(bus_read_ivar, hdacc_read_ivar), 634 DEVMETHOD(hdac_get_mtx, hdacc_get_mtx), 635 DEVMETHOD(hdac_codec_command, hdacc_codec_command), 636 DEVMETHOD(hdac_stream_alloc, hdacc_stream_alloc), 637 DEVMETHOD(hdac_stream_free, hdacc_stream_free), 638 DEVMETHOD(hdac_stream_start, hdacc_stream_start), 639 DEVMETHOD(hdac_stream_stop, hdacc_stream_stop), 640 DEVMETHOD(hdac_stream_reset, hdacc_stream_reset), 641 DEVMETHOD(hdac_stream_getptr, hdacc_stream_getptr), 642 DEVMETHOD(hdac_stream_intr, hdacc_stream_intr), 643 DEVMETHOD(hdac_unsol_alloc, hdacc_unsol_alloc), 644 DEVMETHOD(hdac_unsol_free, hdacc_unsol_free), 645 DEVMETHOD(hdac_unsol_intr, hdacc_unsol_intr), 646 DEVMETHOD(hdac_pindump, hdacc_pindump), 647 { 0, 0 } 648}; 649 650static driver_t hdacc_driver = { 651 "hdacc", 652 hdacc_methods, 653 sizeof(struct hdacc_softc), 654}; 655 656static devclass_t hdacc_devclass; 657 658DRIVER_MODULE(snd_hda, hdac, hdacc_driver, hdacc_devclass, 0, 0); 659