sys/dev/sound/pci/hda/hdaa_patches.c

   1 /*-
   2  * SPDX-License-Identifier: BSD-2-Clause-FreeBSD
   3  *
   4  * Copyright (c) 2006 Stephane E. Potvin <sepotvin@videotron.ca>
   5  * Copyright (c) 2006 Ariff Abdullah <ariff@FreeBSD.org>
   6  * Copyright (c) 2008-2012 Alexander Motin <mav@FreeBSD.org>
   7  * All rights reserved.
   8  *
   9  * Redistribution and use in source and binary forms, with or without
  10  * modification, are permitted provided that the following conditions
  11  * are met:
  12  * 1. Redistributions of source code must retain the above copyright
  13  *    notice, this list of conditions and the following disclaimer.
  14  * 2. Redistributions in binary form must reproduce the above copyright
  15  *    notice, this list of conditions and the following disclaimer in the
  16  *    documentation and/or other materials provided with the distribution.
  17  *
  18  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  19  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  20  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  21  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  22  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  23  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  24  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  25  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  26  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  27  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  28  * SUCH DAMAGE.
  29  */
  30
  31 /*
  32  * Intel High Definition Audio (Audio function quirks) driver for FreeBSD.
  33  */
  34
  35 #ifdef HAVE_KERNEL_OPTION_HEADERS
  36 #include "opt_snd.h"
  37 #endif
  38
  39 #include <dev/sound/pcm/sound.h>
  40
  41 #include <sys/ctype.h>
  42
  43 #include <dev/sound/pci/hda/hdac.h>
  44 #include <dev/sound/pci/hda/hdaa.h>
  45 #include <dev/sound/pci/hda/hda_reg.h>
  46
  47 SND_DECLARE_FILE("$FreeBSD$");
  48
  49 static const struct {
  50         uint32_t model;
  51         uint32_t id;
  52         uint32_t subsystemid;
  53         uint32_t set, unset;
  54         uint32_t gpio;
  55 } hdac_quirks[] = {
  56         /*
  57          * XXX Force stereo quirk. Monoural recording / playback
  58          *     on few codecs (especially ALC880) seems broken or
  59          *     perhaps unsupported.
  60          */
  61         { HDA_MATCH_ALL, HDA_MATCH_ALL, HDA_MATCH_ALL,
  62             HDAA_QUIRK_FORCESTEREO | HDAA_QUIRK_IVREF, 0,
  63             0 },
  64         { ACER_ALL_SUBVENDOR, HDA_MATCH_ALL, HDA_MATCH_ALL,
  65             0, 0,
  66             HDAA_GPIO_SET(0) },
  67         { ASUS_G2K_SUBVENDOR, HDA_CODEC_ALC660, HDA_MATCH_ALL,
  68             0, 0,
  69             HDAA_GPIO_SET(0) },
  70         { ASUS_M5200_SUBVENDOR, HDA_CODEC_ALC880, HDA_MATCH_ALL,
  71             0, 0,
  72             HDAA_GPIO_SET(0) },
  73         { ASUS_A7M_SUBVENDOR, HDA_CODEC_ALC880, HDA_MATCH_ALL,
  74             0, 0,
  75             HDAA_GPIO_SET(0) },
  76         { ASUS_A7T_SUBVENDOR, HDA_CODEC_ALC882, HDA_MATCH_ALL,
  77             0, 0,
  78             HDAA_GPIO_SET(0) },
  79         { ASUS_W2J_SUBVENDOR, HDA_CODEC_ALC882, HDA_MATCH_ALL,
  80             0, 0,
  81             HDAA_GPIO_SET(0) },
  82         { ASUS_U5F_SUBVENDOR, HDA_CODEC_AD1986A, HDA_MATCH_ALL,
  83             HDAA_QUIRK_EAPDINV, 0,
  84             0 },
  85         { ASUS_A8X_SUBVENDOR, HDA_CODEC_AD1986A, HDA_MATCH_ALL,
  86             HDAA_QUIRK_EAPDINV, 0,
  87             0 },
  88         { ASUS_F3JC_SUBVENDOR, HDA_CODEC_ALC861, HDA_MATCH_ALL,
  89             HDAA_QUIRK_OVREF, 0,
  90             0 },
  91         { UNIWILL_9075_SUBVENDOR, HDA_CODEC_ALC861, HDA_MATCH_ALL,
  92             HDAA_QUIRK_OVREF, 0,
  93             0 },
  94         /*{ ASUS_M2N_SUBVENDOR, HDA_CODEC_AD1988, HDA_MATCH_ALL,
  95             HDAA_QUIRK_IVREF80, HDAA_QUIRK_IVREF50 | HDAA_QUIRK_IVREF100,
  96             0 },*/
  97         { MEDION_MD95257_SUBVENDOR, HDA_CODEC_ALC880, HDA_MATCH_ALL,
  98             0, 0,
  99             HDAA_GPIO_SET(1) },
 100         { LENOVO_3KN100_SUBVENDOR, HDA_CODEC_AD1986A, HDA_MATCH_ALL,
 101             HDAA_QUIRK_EAPDINV | HDAA_QUIRK_SENSEINV, 0,
 102             0 },
 103         { SAMSUNG_Q1_SUBVENDOR, HDA_CODEC_AD1986A, HDA_MATCH_ALL,
 104             HDAA_QUIRK_EAPDINV, 0,
 105             0 },
 106         { APPLE_MB3_SUBVENDOR, HDA_CODEC_ALC885, HDA_MATCH_ALL,
 107             HDAA_QUIRK_OVREF50, 0,
 108             HDAA_GPIO_SET(0) },
 109         { APPLE_INTEL_MAC, HDA_CODEC_STAC9221, HDA_MATCH_ALL,
 110             0, 0,
 111             HDAA_GPIO_SET(0) | HDAA_GPIO_SET(1) },
 112         { APPLE_MACBOOKAIR31, HDA_CODEC_CS4206, HDA_MATCH_ALL,
 113             0, 0,
 114             HDAA_GPIO_SET(1) | HDAA_GPIO_SET(3) },
 115         { APPLE_MACBOOKPRO55, HDA_CODEC_CS4206, HDA_MATCH_ALL,
 116             0, 0,
 117             HDAA_GPIO_SET(1) | HDAA_GPIO_SET(3) },
 118         { APPLE_MACBOOKPRO71, HDA_CODEC_CS4206, HDA_MATCH_ALL,
 119             0, 0,
 120             HDAA_GPIO_SET(1) | HDAA_GPIO_SET(3) },
 121         { HDA_INTEL_MACBOOKPRO92, HDA_CODEC_CS4206, HDA_MATCH_ALL,
 122             0, 0,
 123             HDAA_GPIO_SET(1) | HDAA_GPIO_SET(3) },
 124         { DELL_D630_SUBVENDOR, HDA_CODEC_STAC9205X, HDA_MATCH_ALL,
 125             0, 0,
 126             HDAA_GPIO_SET(0) },
 127         { DELL_V1400_SUBVENDOR, HDA_CODEC_STAC9228X, HDA_MATCH_ALL,
 128             0, 0,
 129             HDAA_GPIO_SET(2) },
 130         { DELL_V1500_SUBVENDOR, HDA_CODEC_STAC9205X, HDA_MATCH_ALL,
 131             0, 0,
 132             HDAA_GPIO_SET(0) },
 133         { HDA_MATCH_ALL, HDA_CODEC_AD1988, HDA_MATCH_ALL,
 134             HDAA_QUIRK_IVREF80, HDAA_QUIRK_IVREF50 | HDAA_QUIRK_IVREF100,
 135             0 },
 136         { HDA_MATCH_ALL, HDA_CODEC_AD1988B, HDA_MATCH_ALL,
 137             HDAA_QUIRK_IVREF80, HDAA_QUIRK_IVREF50 | HDAA_QUIRK_IVREF100,
 138             0 },
 139         { HDA_MATCH_ALL, HDA_CODEC_CX20549, HDA_MATCH_ALL,
 140             0, HDAA_QUIRK_FORCESTEREO,
 141             0 },
 142         /* Mac Pro 1,1 requires ovref for proper volume level. */
 143         { 0x00000000, HDA_CODEC_ALC885, 0x106b0c00,
 144             0, HDAA_QUIRK_OVREF,
 145             0 }
 146 };
 147
 148 static void
 149 hdac_pin_patch(struct hdaa_widget *w)
 150 {
 151         const char *patch = NULL;
 152         uint32_t config, orig, id, subid;
 153         nid_t nid = w->nid;
 154
 155         config = orig = w->wclass.pin.config;
 156         id = hdaa_codec_id(w->devinfo);
 157         subid = hdaa_card_id(w->devinfo);
 158
 159         /* XXX: Old patches require complete review.
 160          * Now they may create more problem then solve due to
 161          * incorrect associations.
 162          */
 163         if (id == HDA_CODEC_ALC880 && subid == LG_LW20_SUBVENDOR) {
 164                 switch (nid) {
 165                 case 26:
 166                         config &= ~HDA_CONFIG_DEFAULTCONF_DEVICE_MASK;
 167                         config |= HDA_CONFIG_DEFAULTCONF_DEVICE_LINE_IN;
 168                         break;
 169                 case 27:
 170                         config &= ~HDA_CONFIG_DEFAULTCONF_DEVICE_MASK;
 171                         config |= HDA_CONFIG_DEFAULTCONF_DEVICE_HP_OUT;
 172                         break;
 173                 default:
 174                         break;
 175                 }
 176         } else if (id == HDA_CODEC_ALC880 &&
 177             (subid == CLEVO_D900T_SUBVENDOR ||
 178             subid == ASUS_M5200_SUBVENDOR)) {
 179                 /*
 180                  * Super broken BIOS
 181                  */
 182                 switch (nid) {
 183                 case 24:        /* MIC1 */
 184                         config &= ~HDA_CONFIG_DEFAULTCONF_DEVICE_MASK;
 185                         config |= HDA_CONFIG_DEFAULTCONF_DEVICE_MIC_IN;
 186                         break;
 187                 case 25:        /* XXX MIC2 */
 188                         config &= ~HDA_CONFIG_DEFAULTCONF_DEVICE_MASK;
 189                         config |= HDA_CONFIG_DEFAULTCONF_DEVICE_MIC_IN;
 190                         break;
 191                 case 26:        /* LINE1 */
 192                         config &= ~HDA_CONFIG_DEFAULTCONF_DEVICE_MASK;
 193                         config |= HDA_CONFIG_DEFAULTCONF_DEVICE_LINE_IN;
 194                         break;
 195                 case 27:        /* XXX LINE2 */
 196                         config &= ~HDA_CONFIG_DEFAULTCONF_DEVICE_MASK;
 197                         config |= HDA_CONFIG_DEFAULTCONF_DEVICE_LINE_IN;
 198                         break;
 199                 case 28:        /* CD */
 200                         config &= ~HDA_CONFIG_DEFAULTCONF_DEVICE_MASK;
 201                         config |= HDA_CONFIG_DEFAULTCONF_DEVICE_CD;
 202                         break;
 203                 }
 204         } else if (id == HDA_CODEC_ALC883 &&
 205             (subid == MSI_MS034A_SUBVENDOR ||
 206             HDA_DEV_MATCH(ACER_ALL_SUBVENDOR, subid))) {
 207                 switch (nid) {
 208                 case 25:
 209                         config &= ~(HDA_CONFIG_DEFAULTCONF_DEVICE_MASK |
 210                             HDA_CONFIG_DEFAULTCONF_CONNECTIVITY_MASK);
 211                         config |= (HDA_CONFIG_DEFAULTCONF_DEVICE_MIC_IN |
 212                             HDA_CONFIG_DEFAULTCONF_CONNECTIVITY_FIXED);
 213                         break;
 214                 case 28:
 215                         config &= ~(HDA_CONFIG_DEFAULTCONF_DEVICE_MASK |
 216                             HDA_CONFIG_DEFAULTCONF_CONNECTIVITY_MASK);
 217                         config |= (HDA_CONFIG_DEFAULTCONF_DEVICE_CD |
 218                             HDA_CONFIG_DEFAULTCONF_CONNECTIVITY_FIXED);
 219                         break;
 220                 }
 221         } else if (id == HDA_CODEC_CX20549 && subid ==
 222             HP_V3000_SUBVENDOR) {
 223                 switch (nid) {
 224                 case 18:
 225                         config &= ~HDA_CONFIG_DEFAULTCONF_CONNECTIVITY_MASK;
 226                         config |= HDA_CONFIG_DEFAULTCONF_CONNECTIVITY_NONE;
 227                         break;
 228                 case 20:
 229                         config &= ~(HDA_CONFIG_DEFAULTCONF_DEVICE_MASK |
 230                             HDA_CONFIG_DEFAULTCONF_CONNECTIVITY_MASK);
 231                         config |= (HDA_CONFIG_DEFAULTCONF_DEVICE_MIC_IN |
 232                             HDA_CONFIG_DEFAULTCONF_CONNECTIVITY_FIXED);
 233                         break;
 234                 case 21:
 235                         config &= ~(HDA_CONFIG_DEFAULTCONF_DEVICE_MASK |
 236                             HDA_CONFIG_DEFAULTCONF_CONNECTIVITY_MASK);
 237                         config |= (HDA_CONFIG_DEFAULTCONF_DEVICE_CD |
 238                             HDA_CONFIG_DEFAULTCONF_CONNECTIVITY_FIXED);
 239                         break;
 240                 }
 241         } else if (id == HDA_CODEC_CX20551 && subid ==
 242             HP_DV5000_SUBVENDOR) {
 243                 switch (nid) {
 244                 case 20:
 245                 case 21:
 246                         config &= ~HDA_CONFIG_DEFAULTCONF_CONNECTIVITY_MASK;
 247                         config |= HDA_CONFIG_DEFAULTCONF_CONNECTIVITY_NONE;
 248                         break;
 249                 }
 250         } else if (id == HDA_CODEC_ALC861 && subid ==
 251             ASUS_W6F_SUBVENDOR) {
 252                 switch (nid) {
 253                 case 11:
 254                         config &= ~(HDA_CONFIG_DEFAULTCONF_DEVICE_MASK |
 255                             HDA_CONFIG_DEFAULTCONF_CONNECTIVITY_MASK);
 256                         config |= (HDA_CONFIG_DEFAULTCONF_DEVICE_LINE_OUT |
 257                             HDA_CONFIG_DEFAULTCONF_CONNECTIVITY_FIXED);
 258                         break;
 259                 case 12:
 260                 case 14:
 261                 case 16:
 262                 case 31:
 263                 case 32:
 264                         config &= ~(HDA_CONFIG_DEFAULTCONF_DEVICE_MASK |
 265                             HDA_CONFIG_DEFAULTCONF_CONNECTIVITY_MASK);
 266                         config |= (HDA_CONFIG_DEFAULTCONF_DEVICE_MIC_IN |
 267                             HDA_CONFIG_DEFAULTCONF_CONNECTIVITY_FIXED);
 268                         break;
 269                 case 15:
 270                         config &= ~(HDA_CONFIG_DEFAULTCONF_DEVICE_MASK |
 271                             HDA_CONFIG_DEFAULTCONF_CONNECTIVITY_MASK);
 272                         config |= (HDA_CONFIG_DEFAULTCONF_DEVICE_HP_OUT |
 273                             HDA_CONFIG_DEFAULTCONF_CONNECTIVITY_JACK);
 274                         break;
 275                 }
 276         } else if (id == HDA_CODEC_ALC861 && subid ==
 277             UNIWILL_9075_SUBVENDOR) {
 278                 switch (nid) {
 279                 case 15:
 280                         config &= ~(HDA_CONFIG_DEFAULTCONF_DEVICE_MASK |
 281                             HDA_CONFIG_DEFAULTCONF_CONNECTIVITY_MASK);
 282                         config |= (HDA_CONFIG_DEFAULTCONF_DEVICE_HP_OUT |
 283                             HDA_CONFIG_DEFAULTCONF_CONNECTIVITY_JACK);
 284                         break;
 285                 }
 286         }
 287
 288         /* New patches */
 289         if (id == HDA_CODEC_AD1984A &&
 290             subid == LENOVO_X300_SUBVENDOR) {
 291                 switch (nid) {
 292                 case 17: /* Headphones with redirection */
 293                         patch = "as=1 seq=15";
 294                         break;
 295                 case 20: /* Two mics together */
 296                         patch = "as=2 seq=15";
 297                         break;
 298                 }
 299         } else if (id == HDA_CODEC_AD1986A &&
 300             (subid == ASUS_M2NPVMX_SUBVENDOR ||
 301             subid == ASUS_A8NVMCSM_SUBVENDOR ||
 302             subid == ASUS_P5PL2_SUBVENDOR)) {
 303                 switch (nid) {
 304                 case 26: /* Headphones with redirection */
 305                         patch = "as=1 seq=15";
 306                         break;
 307                 case 28: /* 5.1 out => 2.0 out + 1 input */
 308                         patch = "device=Line-in as=8 seq=1";
 309                         break;
 310                 case 29: /* Can't use this as input, as the only available mic
 311                           * preamplifier is busy by front panel mic (nid 31).
 312                           * If you want to use this rear connector as mic input,
 313                           * you have to disable the front panel one. */
 314                         patch = "as=0";
 315                         break;
 316                 case 31: /* Lot of inputs configured with as=15 and unusable */
 317                         patch = "as=8 seq=3";
 318                         break;
 319                 case 32:
 320                         patch = "as=8 seq=4";
 321                         break;
 322                 case 34:
 323                         patch = "as=8 seq=5";
 324                         break;
 325                 case 36:
 326                         patch = "as=8 seq=6";
 327                         break;
 328                 }
 329         } else if (id == HDA_CODEC_ALC260 &&
 330             HDA_DEV_MATCH(SONY_S5_SUBVENDOR, subid)) {
 331                 switch (nid) {
 332                 case 16:
 333                         patch = "seq=15 device=Headphones";
 334                         break;
 335                 }
 336         } else if (id == HDA_CODEC_ALC268) {
 337             if (subid == ACER_T5320_SUBVENDOR) {
 338                 switch (nid) {
 339                 case 20: /* Headphones Jack */
 340                         patch = "as=1 seq=15";
 341                         break;
 342                 }
 343             }
 344         } else if (id == HDA_CODEC_CX20561 &&
 345             subid == LENOVO_B450_SUBVENDOR) {
 346                 switch (nid) {
 347                 case 22:
 348                         patch = "as=1 seq=15";
 349                         break;
 350                 }
 351         } else if (id == HDA_CODEC_CX20561 &&
 352             subid == LENOVO_T400_SUBVENDOR) {
 353                 switch (nid) {
 354                 case 22:
 355                         patch = "as=1 seq=15";
 356                         break;
 357                 case 26:
 358                         patch = "as=1 seq=0";
 359                         break;
 360                 }
 361         } else if (id == HDA_CODEC_CX20590 &&
 362             (subid == LENOVO_X1_SUBVENDOR ||
 363             subid == LENOVO_X220_SUBVENDOR ||
 364             subid == LENOVO_T420_SUBVENDOR ||
 365             subid == LENOVO_T520_SUBVENDOR ||
 366             subid == LENOVO_G580_SUBVENDOR)) {
 367                 switch (nid) {
 368                 case 25:
 369                         patch = "as=1 seq=15";
 370                         break;
 371                 /*
 372                  * Group onboard mic and headphone mic
 373                  * together.  Fixes onboard mic.
 374                  */
 375                 case 27:
 376                         patch = "as=2 seq=15";
 377                         break;
 378                 case 35:
 379                         patch = "as=2";
 380                         break;
 381                 }
 382         } else if (id == HDA_CODEC_ALC269 &&
 383             (subid == LENOVO_X1CRBN_SUBVENDOR ||
 384             subid == LENOVO_T430_SUBVENDOR ||
 385             subid == LENOVO_T430S_SUBVENDOR ||
 386             subid == LENOVO_T530_SUBVENDOR)) {
 387                 switch (nid) {
 388                 case 21:
 389                         patch = "as=1 seq=15";
 390                         break;
 391                 }
 392         } else if (id == HDA_CODEC_ALC269 &&
 393             subid == ASUS_UX31A_SUBVENDOR) {
 394                 switch (nid) {
 395                 case 33:
 396                         patch = "as=1 seq=15";
 397                         break;
 398                 }
 399         } else if (id == HDA_CODEC_ALC892 &&
 400             subid == INTEL_DH87RL_SUBVENDOR) {
 401                 switch (nid) {
 402                 case 27:
 403                         patch = "as=1 seq=15";
 404                         break;
 405                 }
 406         } else if (id == HDA_CODEC_ALC292 &&
 407             subid == LENOVO_X120BS_SUBVENDOR) {
 408                 switch (nid) {
 409                 case 21:
 410                         patch = "as=1 seq=15";
 411                         break;
 412                 }
 413         }
 414
 415         if (patch != NULL)
 416                 config = hdaa_widget_pin_patch(config, patch);
 417         HDA_BOOTVERBOSE(
 418                 if (config != orig)
 419                         device_printf(w->devinfo->dev,
 420                             "Patching pin config nid=%u 0x%08x -> 0x%08x\n",
 421                             nid, orig, config);
 422         );
 423         w->wclass.pin.config = config;
 424 }
 425
 426 static void
 427 hdaa_widget_patch(struct hdaa_widget *w)
 428 {
 429         struct hdaa_devinfo *devinfo = w->devinfo;
 430         uint32_t orig;
 431         nid_t beeper = -1;
 432
 433         orig = w->param.widget_cap;
 434         /* On some codecs beeper is an input pin, but it is not recordable
 435            alone. Also most of BIOSes does not declare beeper pin.
 436            Change beeper pin node type to beeper to help parser. */
 437         switch (hdaa_codec_id(devinfo)) {
 438         case HDA_CODEC_AD1882:
 439         case HDA_CODEC_AD1883:
 440         case HDA_CODEC_AD1984:
 441         case HDA_CODEC_AD1984A:
 442         case HDA_CODEC_AD1984B:
 443         case HDA_CODEC_AD1987:
 444         case HDA_CODEC_AD1988:
 445         case HDA_CODEC_AD1988B:
 446         case HDA_CODEC_AD1989B:
 447                 beeper = 26;
 448                 break;
 449         case HDA_CODEC_ALC260:
 450                 beeper = 23;
 451                 break;
 452         }
 453         if (hda_get_vendor_id(devinfo->dev) == REALTEK_VENDORID &&
 454             hdaa_codec_id(devinfo) != HDA_CODEC_ALC260)
 455                 beeper = 29;
 456         if (w->nid == beeper) {
 457                 w->param.widget_cap &= ~HDA_PARAM_AUDIO_WIDGET_CAP_TYPE_MASK;
 458                 w->param.widget_cap |= HDA_PARAM_AUDIO_WIDGET_CAP_TYPE_BEEP_WIDGET <<
 459                     HDA_PARAM_AUDIO_WIDGET_CAP_TYPE_SHIFT;
 460                 w->waspin = 1;
 461         }
 462         /*
 463          * Clear "digital" flag from digital mic input, as its signal then goes
 464          * to "analog" mixer and this separation just limits functionaity.
 465          */
 466         if (hdaa_codec_id(devinfo) == HDA_CODEC_AD1984A &&
 467             w->nid == 23)
 468                 w->param.widget_cap &= ~HDA_PARAM_AUDIO_WIDGET_CAP_DIGITAL_MASK;
 469         HDA_BOOTVERBOSE(
 470                 if (w->param.widget_cap != orig) {
 471                         device_printf(w->devinfo->dev,
 472                             "Patching widget caps nid=%u 0x%08x -> 0x%08x\n",
 473                             w->nid, orig, w->param.widget_cap);
 474                 }
 475         );
 476
 477         if (w->type == HDA_PARAM_AUDIO_WIDGET_CAP_TYPE_PIN_COMPLEX)
 478                 hdac_pin_patch(w);
 479 }
 480
 481 void
 482 hdaa_patch(struct hdaa_devinfo *devinfo)
 483 {
 484         struct hdaa_widget *w;
 485         uint32_t id, subid, subsystemid;
 486         int i;
 487
 488         id = hdaa_codec_id(devinfo);
 489         subid = hdaa_card_id(devinfo);
 490         subsystemid = hda_get_subsystem_id(devinfo->dev);
 491
 492         /*
 493          * Quirks
 494          */
 495         for (i = 0; i < nitems(hdac_quirks); i++) {
 496                 if (!(HDA_DEV_MATCH(hdac_quirks[i].model, subid) &&
 497                     HDA_DEV_MATCH(hdac_quirks[i].id, id) &&
 498                     HDA_DEV_MATCH(hdac_quirks[i].subsystemid, subsystemid)))
 499                         continue;
 500                 devinfo->quirks |= hdac_quirks[i].set;
 501                 devinfo->quirks &= ~(hdac_quirks[i].unset);
 502                 devinfo->gpio = hdac_quirks[i].gpio;
 503         }
 504
 505         /* Apply per-widget patch. */
 506         for (i = devinfo->startnode; i < devinfo->endnode; i++) {
 507                 w = hdaa_widget_get(devinfo, i);
 508                 if (w == NULL)
 509                         continue;
 510                 hdaa_widget_patch(w);
 511         }
 512
 513         switch (id) {
 514         case HDA_CODEC_AD1983:
 515                 /*
 516                  * This CODEC has several possible usages, but none
 517                  * fit the parser best. Help parser to choose better.
 518                  */
 519                 /* Disable direct unmixed playback to get pcm volume. */
 520                 w = hdaa_widget_get(devinfo, 5);
 521                 if (w != NULL)
 522                         w->connsenable[0] = 0;
 523                 w = hdaa_widget_get(devinfo, 6);
 524                 if (w != NULL)
 525                         w->connsenable[0] = 0;
 526                 w = hdaa_widget_get(devinfo, 11);
 527                 if (w != NULL)
 528                         w->connsenable[0] = 0;
 529                 /* Disable mic and line selectors. */
 530                 w = hdaa_widget_get(devinfo, 12);
 531                 if (w != NULL)
 532                         w->connsenable[1] = 0;
 533                 w = hdaa_widget_get(devinfo, 13);
 534                 if (w != NULL)
 535                         w->connsenable[1] = 0;
 536                 /* Disable recording from mono playback mix. */
 537                 w = hdaa_widget_get(devinfo, 20);
 538                 if (w != NULL)
 539                         w->connsenable[3] = 0;
 540                 break;
 541         case HDA_CODEC_AD1986A:
 542                 /*
 543                  * This CODEC has overcomplicated input mixing.
 544                  * Make some cleaning there.
 545                  */
 546                 /* Disable input mono mixer. Not needed and not supported. */
 547                 w = hdaa_widget_get(devinfo, 43);
 548                 if (w != NULL)
 549                         w->enable = 0;
 550                 /* Disable any with any input mixing mesh. Use separately. */
 551                 w = hdaa_widget_get(devinfo, 39);
 552                 if (w != NULL)
 553                         w->enable = 0;
 554                 w = hdaa_widget_get(devinfo, 40);
 555                 if (w != NULL)
 556                         w->enable = 0;
 557                 w = hdaa_widget_get(devinfo, 41);
 558                 if (w != NULL)
 559                         w->enable = 0;
 560                 w = hdaa_widget_get(devinfo, 42);
 561                 if (w != NULL)
 562                         w->enable = 0;
 563                 /* Disable duplicate mixer node connector. */
 564                 w = hdaa_widget_get(devinfo, 15);
 565                 if (w != NULL)
 566                         w->connsenable[3] = 0;
 567                 /* There is only one mic preamplifier, use it effectively. */
 568                 w = hdaa_widget_get(devinfo, 31);
 569                 if (w != NULL) {
 570                         if ((w->wclass.pin.config &
 571                             HDA_CONFIG_DEFAULTCONF_DEVICE_MASK) ==
 572                             HDA_CONFIG_DEFAULTCONF_DEVICE_MIC_IN) {
 573                                 w = hdaa_widget_get(devinfo, 16);
 574                                 if (w != NULL)
 575                                     w->connsenable[2] = 0;
 576                         } else {
 577                                 w = hdaa_widget_get(devinfo, 15);
 578                                 if (w != NULL)
 579                                     w->connsenable[0] = 0;
 580                         }
 581                 }
 582                 w = hdaa_widget_get(devinfo, 32);
 583                 if (w != NULL) {
 584                         if ((w->wclass.pin.config &
 585                             HDA_CONFIG_DEFAULTCONF_DEVICE_MASK) ==
 586                             HDA_CONFIG_DEFAULTCONF_DEVICE_MIC_IN) {
 587                                 w = hdaa_widget_get(devinfo, 16);
 588                                 if (w != NULL)
 589                                     w->connsenable[0] = 0;
 590                         } else {
 591                                 w = hdaa_widget_get(devinfo, 15);
 592                                 if (w != NULL)
 593                                     w->connsenable[1] = 0;
 594                         }
 595                 }
 596
 597                 if (subid == ASUS_A8X_SUBVENDOR) {
 598                         /*
 599                          * This is just plain ridiculous.. There
 600                          * are several A8 series that share the same
 601                          * pci id but works differently (EAPD).
 602                          */
 603                         w = hdaa_widget_get(devinfo, 26);
 604                         if (w != NULL && w->type ==
 605                             HDA_PARAM_AUDIO_WIDGET_CAP_TYPE_PIN_COMPLEX &&
 606                             (w->wclass.pin.config &
 607                             HDA_CONFIG_DEFAULTCONF_CONNECTIVITY_MASK) !=
 608                             HDA_CONFIG_DEFAULTCONF_CONNECTIVITY_NONE)
 609                                 devinfo->quirks &=
 610                                     ~HDAA_QUIRK_EAPDINV;
 611                 }
 612                 break;
 613         case HDA_CODEC_AD1981HD:
 614                 /*
 615                  * This CODEC has very unusual design with several
 616                  * points inappropriate for the present parser.
 617                  */
 618                 /* Disable recording from mono playback mix. */
 619                 w = hdaa_widget_get(devinfo, 21);
 620                 if (w != NULL)
 621                         w->connsenable[3] = 0;
 622                 /* Disable rear to front mic mixer, use separately. */
 623                 w = hdaa_widget_get(devinfo, 31);
 624                 if (w != NULL)
 625                         w->enable = 0;
 626                 /* Disable direct playback, use mixer. */
 627                 w = hdaa_widget_get(devinfo, 5);
 628                 if (w != NULL)
 629                         w->connsenable[0] = 0;
 630                 w = hdaa_widget_get(devinfo, 6);
 631                 if (w != NULL)
 632                         w->connsenable[0] = 0;
 633                 w = hdaa_widget_get(devinfo, 9);
 634                 if (w != NULL)
 635                         w->connsenable[0] = 0;
 636                 w = hdaa_widget_get(devinfo, 24);
 637                 if (w != NULL)
 638                         w->connsenable[0] = 0;
 639                 break;
 640         case HDA_CODEC_ALC269:
 641                 /*
 642                  * ASUS EeePC 1001px has strange variant of ALC269 CODEC,
 643                  * that mutes speaker if unused mixer at NID 15 is muted.
 644                  * Probably CODEC incorrectly reports internal connections.
 645                  * Hide that muter from the driver.  There are several CODECs
 646                  * sharing this ID and I have not enough information about
 647                  * them to implement more universal solution.
 648                  */
 649                 if (subid == 0x84371043) {
 650                         w = hdaa_widget_get(devinfo, 15);
 651                         if (w != NULL)
 652                                 w->param.inamp_cap = 0;
 653                 }
 654                 break;
 655         case HDA_CODEC_CX20582:
 656         case HDA_CODEC_CX20583:
 657         case HDA_CODEC_CX20584:
 658         case HDA_CODEC_CX20585:
 659         case HDA_CODEC_CX20590:
 660                 /*
 661                  * These codecs have extra connectivity on record side
 662                  * too reach for the present parser.
 663                  */
 664                 w = hdaa_widget_get(devinfo, 20);
 665                 if (w != NULL)
 666                         w->connsenable[1] = 0;
 667                 w = hdaa_widget_get(devinfo, 21);
 668                 if (w != NULL)
 669                         w->connsenable[1] = 0;
 670                 w = hdaa_widget_get(devinfo, 22);
 671                 if (w != NULL)
 672                         w->connsenable[0] = 0;
 673                 break;
 674         case HDA_CODEC_VT1708S_0:
 675         case HDA_CODEC_VT1708S_1:
 676         case HDA_CODEC_VT1708S_2:
 677         case HDA_CODEC_VT1708S_3:
 678         case HDA_CODEC_VT1708S_4:
 679         case HDA_CODEC_VT1708S_5:
 680         case HDA_CODEC_VT1708S_6:
 681         case HDA_CODEC_VT1708S_7:
 682                 /*
 683                  * These codecs have hidden mic boost controls.
 684                  */
 685                 w = hdaa_widget_get(devinfo, 26);
 686                 if (w != NULL)
 687                         w->param.inamp_cap =
 688                             (40 << HDA_PARAM_OUTPUT_AMP_CAP_STEPSIZE_SHIFT) |
 689                             (3 << HDA_PARAM_OUTPUT_AMP_CAP_NUMSTEPS_SHIFT) |
 690                             (0 << HDA_PARAM_OUTPUT_AMP_CAP_OFFSET_SHIFT);
 691                 w = hdaa_widget_get(devinfo, 30);
 692                 if (w != NULL)
 693                         w->param.inamp_cap =
 694                             (40 << HDA_PARAM_OUTPUT_AMP_CAP_STEPSIZE_SHIFT) |
 695                             (3 << HDA_PARAM_OUTPUT_AMP_CAP_NUMSTEPS_SHIFT) |
 696                             (0 << HDA_PARAM_OUTPUT_AMP_CAP_OFFSET_SHIFT);
 697                 break;
 698         }
 699 }
 700
 701 static uint32_t
 702 hdaa_read_coef(device_t dev, nid_t nid, uint16_t idx)
 703 {
 704
 705         hda_command(dev, HDA_CMD_SET_COEFF_INDEX(0, nid, idx));
 706         return (hda_command(dev, HDA_CMD_GET_PROCESSING_COEFF(0, nid)));
 707 }
 708
 709 static uint32_t
 710 hdaa_write_coef(device_t dev, nid_t nid, uint16_t idx, uint16_t val)
 711 {
 712
 713         hda_command(dev, HDA_CMD_SET_COEFF_INDEX(0, nid, idx));
 714         return (hda_command(dev, HDA_CMD_SET_PROCESSING_COEFF(0, nid, val)));
 715 }
 716
 717 void
 718 hdaa_patch_direct(struct hdaa_devinfo *devinfo)
 719 {
 720         device_t dev = devinfo->dev;
 721         uint32_t id, subid, val;
 722
 723         id = hdaa_codec_id(devinfo);
 724         subid = hdaa_card_id(devinfo);
 725
 726         switch (id) {
 727         case HDA_CODEC_VT1708S_0:
 728         case HDA_CODEC_VT1708S_1:
 729         case HDA_CODEC_VT1708S_2:
 730         case HDA_CODEC_VT1708S_3:
 731         case HDA_CODEC_VT1708S_4:
 732         case HDA_CODEC_VT1708S_5:
 733         case HDA_CODEC_VT1708S_6:
 734         case HDA_CODEC_VT1708S_7:
 735                 /* Enable Mic Boost Volume controls. */
 736                 hda_command(dev, HDA_CMD_12BIT(0, devinfo->nid,
 737                     0xf98, 0x01));
 738                 /* Fall though */
 739         case HDA_CODEC_VT1818S:
 740                 /* Don't bypass mixer. */
 741                 hda_command(dev, HDA_CMD_12BIT(0, devinfo->nid,
 742                     0xf88, 0xc0));
 743                 break;
 744         case HDA_CODEC_ALC1150:
 745                 if (subid == 0xd9781462) {
 746                         /* Too low volume on MSI H170 GAMING M3. */
 747                         hdaa_write_coef(dev, 0x20, 0x07, 0x7cb);
 748                 }
 749                 break;
 750         }
 751         if (subid == APPLE_INTEL_MAC)
 752                 hda_command(dev, HDA_CMD_12BIT(0, devinfo->nid,
 753                     0x7e7, 0));
 754         if (id == HDA_CODEC_ALC269) {
 755                 if (subid == 0x16e31043 || subid == 0x831a1043 ||
 756                     subid == 0x834a1043 || subid == 0x83981043 ||
 757                     subid == 0x83ce1043) {
 758                         /*
 759                          * The ditital mics on some Asus laptops produce
 760                          * differential signals instead of expected stereo.
 761                          * That results in silence if downmix it to mono.
 762                          * To workaround, make codec to handle signal as mono.
 763                          */
 764                         val = hdaa_read_coef(dev, 0x20, 0x07);
 765                         hdaa_write_coef(dev, 0x20, 0x07, val|0x80);
 766                 }
 767                 if (subid == 0x15171043) {
 768                         /* Increase output amp on ASUS UX31A by +5dB. */
 769                         hdaa_write_coef(dev, 0x20, 0x12, 0x2800);
 770                 }
 771         }
 772 }