sys/dev/sound/macio/tumbler.c

   1 /*-
   2  * SPDX-License-Identifier: BSD-2-Clause-FreeBSD AND BSD-3-Clause
   3  *
   4  * Copyright 2008 by Marco Trillo. All rights reserved.
   5  *
   6  * Redistribution and use in source and binary forms, with or without
   7  * modification, are permitted provided that the following conditions
   8  * are met:
   9  * 1. Redistributions of source code must retain the above copyright
  10  *    notice, this list of conditions and the following disclaimer.
  11  * 2. Redistributions in binary form must reproduce the above copyright
  12  *    notice, this list of conditions and the following disclaimer in the
  13  *    documentation and/or other materials provided with the distribution.
  14  *
  15  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
  16  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  17  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  18  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
  19  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
  20  * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  21  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
  22  * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
  23  * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  24  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  25  * SUCH DAMAGE.
  26  *
  27  * $FreeBSD$
  28  */
  29 /*-
  30  * Copyright (c) 2002, 2003 Tsubai Masanari.  All rights reserved.
  31  *
  32  * Redistribution and use in source and binary forms, with or without
  33  * modification, are permitted provided that the following conditions
  34  * are met:
  35  * 1. Redistributions of source code must retain the above copyright
  36  *    notice, this list of conditions and the following disclaimer.
  37  * 2. Redistributions in binary form must reproduce the above copyright
  38  *    notice, this list of conditions and the following disclaimer in the
  39  *    documentation and/or other materials provided with the distribution.
  40  * 3. The name of the author may not be used to endorse or promote products
  41  *    derived from this software without specific prior written permission.
  42  *
  43  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
  44  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  45  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  46  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
  47  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  48  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  49  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  50  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  51  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  52  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  53  *
  54  *      NetBSD: tumbler.c,v 1.28 2008/05/16 03:49:54 macallan Exp
  55  *      Id: tumbler.c,v 1.11 2002/10/31 17:42:13 tsubai Exp
  56  */
  57
  58 /*
  59  *      Apple I2S audio controller.
  60  */
  61
  62 #include <sys/param.h>
  63 #include <sys/systm.h>
  64 #include <sys/kernel.h>
  65 #include <sys/module.h>
  66 #include <sys/bus.h>
  67 #include <sys/malloc.h>
  68 #include <sys/lock.h>
  69 #include <sys/mutex.h>
  70 #include <machine/dbdma.h>
  71 #include <machine/intr_machdep.h>
  72 #include <machine/resource.h>
  73 #include <machine/bus.h>
  74 #include <machine/pio.h>
  75 #include <sys/rman.h>
  76
  77 #include <dev/iicbus/iicbus.h>
  78 #include <dev/iicbus/iiconf.h>
  79 #include <dev/ofw/ofw_bus.h>
  80
  81 #ifdef HAVE_KERNEL_OPTION_HEADERS
  82 #include "opt_snd.h"
  83 #endif
  84
  85 #include <dev/sound/pcm/sound.h>
  86
  87 #include "mixer_if.h"
  88
  89 extern kobj_class_t i2s_mixer_class;
  90 extern device_t i2s_mixer;
  91
  92 struct tumbler_softc
  93 {
  94         device_t sc_dev;
  95         uint32_t sc_addr;
  96 };
  97
  98 static int      tumbler_probe(device_t);
  99 static int      tumbler_attach(device_t);
 100 static int      tumbler_init(struct snd_mixer *m);
 101 static int      tumbler_uninit(struct snd_mixer *m);
 102 static int      tumbler_reinit(struct snd_mixer *m);
 103 static int      tumbler_set(struct snd_mixer *m, unsigned dev, unsigned left,
 104                     unsigned right);
 105 static u_int32_t        tumbler_setrecsrc(struct snd_mixer *m, u_int32_t src);
 106
 107 static device_method_t tumbler_methods[] = {
 108         /* Device interface. */
 109         DEVMETHOD(device_probe,         tumbler_probe),
 110         DEVMETHOD(device_attach,        tumbler_attach),
 111         { 0, 0 }
 112 };
 113
 114 static driver_t tumbler_driver = {
 115         "tumbler",
 116         tumbler_methods,
 117         sizeof(struct tumbler_softc)
 118 };
 119 static devclass_t tumbler_devclass;
 120
 121 DRIVER_MODULE(tumbler, iicbus, tumbler_driver, tumbler_devclass, 0, 0);
 122 MODULE_VERSION(tumbler, 1);
 123 MODULE_DEPEND(tumbler, iicbus, 1, 1, 1);
 124
 125 static kobj_method_t tumbler_mixer_methods[] = {
 126         KOBJMETHOD(mixer_init,          tumbler_init),
 127         KOBJMETHOD(mixer_uninit,        tumbler_uninit),
 128         KOBJMETHOD(mixer_reinit,        tumbler_reinit),
 129         KOBJMETHOD(mixer_set,           tumbler_set),
 130         KOBJMETHOD(mixer_setrecsrc,     tumbler_setrecsrc),
 131         KOBJMETHOD_END
 132 };
 133
 134 MIXER_DECLARE(tumbler_mixer);
 135
 136 #define TUMBLER_IICADDR         0x68    /* Tumbler I2C slave address */
 137
 138 /* Tumbler (Texas Instruments TAS3001) registers. */
 139 #define TUMBLER_MCR             0x01    /* Main control register (1byte) */
 140 #define TUMBLER_DRC             0x02    /* Dynamic Range Compression (2bytes) */
 141 #define TUMBLER_VOLUME          0x04    /* Volume (6bytes) */
 142 #define TUMBLER_TREBLE          0x05    /* Treble control (1byte) */
 143 #define TUMBLER_BASS            0x06    /* Bass control (1byte) */
 144 #define TUMBLER_MIXER1          0x07    /* Mixer1 (3bytes) */
 145 #define TUMBLER_MIXER2          0x08    /* Mixer2 (3bytes) */
 146 #define TUMBLER_LB0             0x0a    /* Left biquad 0 (15bytes) */
 147 #define TUMBLER_LB1             0x0b    /* Left biquad 1 (15bytes) */
 148 #define TUMBLER_LB2             0x0c    /* Left biquad 2 (15bytes) */
 149 #define TUMBLER_LB3             0x0d    /* Left biquad 3 (15bytes) */
 150 #define TUMBLER_LB4             0x0e    /* Left biquad 4 (15bytes) */
 151 #define TUMBLER_LB5             0x0f    /* Left biquad 5 (15bytes) */
 152 #define TUMBLER_RB0             0x13    /* Right biquad 0 (15bytes) */
 153 #define TUMBLER_RB1             0x14    /* Right biquad 1 (15bytes) */
 154 #define TUMBLER_RB2             0x15    /* Right biquad 2 (15bytes) */
 155 #define TUMBLER_RB3             0x16    /* Right biquad 3 (15bytes) */
 156 #define TUMBLER_RB4             0x17    /* Right biquad 4 (15bytes) */
 157 #define TUMBLER_RB5             0x18    /* Right biquad 5 (15bytes) */
 158 #define TUMBLER_MCR_FL  0x80    /* Fast load */
 159 #define TUMBLER_MCR_SC  0x40    /* SCLK frequency */
 160 #define  TUMBLER_MCR_SC_32      0x00    /*  32fs */
 161 #define  TUMBLER_MCR_SC_64      0x40    /*  64fs */
 162 #define TUMBLER_MCR_SM  0x30    /* Output serial port mode */
 163 #define  TUMBLER_MCR_SM_L       0x00    /*  Left justified */
 164 #define  TUMBLER_MCR_SM_R       0x10    /*  Right justified */
 165 #define  TUMBLER_MCR_SM_I2S 0x20        /*  I2S */
 166 #define TUMBLER_MCR_ISM    0x0C    /* Input serial mode */
 167 #define  TUMBLER_MCR_ISM_L 0x00
 168 #define  TUMBLER_MCR_ISM_R 0x04
 169 #define  TUMBLER_MCR_ISM_I2S 0x08
 170 #define TUMBLER_MCR_W   0x03    /* Serial port word length */
 171 #define  TUMBLER_MCR_W_16       0x00    /*  16 bit */
 172 #define  TUMBLER_MCR_W_18       0x01    /*  18 bit */
 173 #define  TUMBLER_MCR_W_20       0x02    /*  20 bit */
 174 #define TUMBLER_DRC_COMP_31 0xc0    /* 3:1 compression */
 175 #define TUMBLER_DRC_ENABLE  0x01    /* enable DRC */
 176 #define TUMBLER_DRC_DEFL_TH 0xa0    /* default compression threshold */
 177
 178 /*
 179  * Tumbler codec.
 180  */
 181
 182 struct tumbler_reg {
 183         u_char MCR[1];
 184         u_char DRC[2];
 185         u_char VOLUME[6];
 186         u_char TREBLE[1];
 187         u_char BASS[1];
 188         u_char MIXER1[3];
 189         u_char MIXER2[3];
 190         u_char LB0[15];
 191         u_char LB1[15];
 192         u_char LB2[15];
 193         u_char LB3[15];
 194         u_char LB4[15];
 195         u_char LB5[15];
 196         u_char RB0[15];
 197         u_char RB1[15];
 198         u_char RB2[15];
 199         u_char RB3[15];
 200         u_char RB4[15];
 201         u_char RB5[15];
 202 };
 203
 204 const struct tumbler_reg tumbler_initdata = {
 205         { TUMBLER_MCR_SC_64 | TUMBLER_MCR_SM_I2S |
 206           TUMBLER_MCR_ISM_I2S | TUMBLER_MCR_W_16 },             /* MCR */
 207         { TUMBLER_DRC_COMP_31, TUMBLER_DRC_DEFL_TH },           /* DRC */
 208         { 0, 0, 0, 0, 0, 0 },                                   /* VOLUME */
 209         { 0x72 },                                               /* TREBLE */
 210         { 0x3e },                                               /* BASS */
 211         { 0x10, 0x00, 0x00 },                                   /* MIXER1 */
 212         { 0x00, 0x00, 0x00 },                                   /* MIXER2 */
 213         { 0x10, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },     /* BIQUAD */
 214         { 0x10, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },     /* BIQUAD */
 215         { 0x10, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },     /* BIQUAD */
 216         { 0x10, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },     /* BIQUAD */
 217         { 0x10, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },     /* BIQUAD */
 218         { 0x10, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },     /* BIQUAD */
 219         { 0x10, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },     /* BIQUAD */
 220         { 0x10, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },     /* BIQUAD */
 221         { 0x10, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },     /* BIQUAD */
 222         { 0x10, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },     /* BIQUAD */
 223         { 0x10, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },     /* BIQUAD */
 224         { 0x10, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }      /* BIQUAD */
 225 };
 226
 227 const char tumbler_regsize[] = {
 228         0,                                      /* 0x00 */
 229         sizeof tumbler_initdata.MCR,            /* 0x01 */
 230         sizeof tumbler_initdata.DRC,            /* 0x02 */
 231         0,                                      /* 0x03 */
 232         sizeof tumbler_initdata.VOLUME,         /* 0x04 */
 233         sizeof tumbler_initdata.TREBLE,         /* 0x05 */
 234         sizeof tumbler_initdata.BASS,           /* 0x06 */
 235         sizeof tumbler_initdata.MIXER1,         /* 0x07 */
 236         sizeof tumbler_initdata.MIXER2,         /* 0x08 */
 237         0,                                      /* 0x09 */
 238         sizeof tumbler_initdata.LB0,            /* 0x0a */
 239         sizeof tumbler_initdata.LB1,            /* 0x0b */
 240         sizeof tumbler_initdata.LB2,            /* 0x0c */
 241         sizeof tumbler_initdata.LB3,            /* 0x0d */
 242         sizeof tumbler_initdata.LB4,            /* 0x0e */
 243         sizeof tumbler_initdata.LB5,            /* 0x0f */
 244         0,                                      /* 0x10 */
 245         0,                                      /* 0x11 */
 246         0,                                      /* 0x12 */
 247         sizeof tumbler_initdata.RB0,            /* 0x13 */
 248         sizeof tumbler_initdata.RB1,            /* 0x14 */
 249         sizeof tumbler_initdata.RB2,            /* 0x15 */
 250         sizeof tumbler_initdata.RB3,            /* 0x16 */
 251         sizeof tumbler_initdata.RB4,            /* 0x17 */
 252         sizeof tumbler_initdata.RB5             /* 0x18 */
 253 };
 254
 255 /* dB = 20 * log (x) table. */
 256 static u_int    tumbler_volume_table[100] = {
 257         0x00000148,   0x0000015C,   0x00000171,   0x00000186,   // -46.0,       -45.5,  -45.0,  -44.5,
 258         0x0000019E,   0x000001B6,   0x000001D0,   0x000001EB,   // -44.0,       -43.5,  -43.0,  -42.5,
 259         0x00000209,   0x00000227,   0x00000248,   0x0000026B,   // -42.0,       -41.5,  -41.0,  -40.5,
 260         0x0000028F,   0x000002B6,   0x000002DF,   0x0000030B,   // -40.0,       -39.5,  -39.0,  -38.5,
 261         0x00000339,   0x0000036A,   0x0000039E,   0x000003D5,   // -38.0,       -37.5,  -37.0,  -36.5,
 262         0x0000040F,   0x0000044C,   0x0000048D,   0x000004D2,   // -36.0,       -35.5,  -35.0,  -34.5,
 263         0x0000051C,   0x00000569,   0x000005BB,   0x00000612,   // -34.0,       -33.5,  -33.0,  -32.5,
 264         0x0000066E,   0x000006D0,   0x00000737,   0x000007A5,   // -32.0,       -31.5,  -31.0,  -30.5,
 265         0x00000818,   0x00000893,   0x00000915,   0x0000099F,   // -30.0,       -29.5,  -29.0,  -28.5,
 266         0x00000A31,   0x00000ACC,   0x00000B6F,   0x00000C1D,   // -28.0,       -27.5,  -27.0,  -26.5,
 267         0x00000CD5,   0x00000D97,   0x00000E65,   0x00000F40,   // -26.0,       -25.5,  -25.0,  -24.5,
 268         0x00001027,   0x0000111C,   0x00001220,   0x00001333,   // -24.0,       -23.5,  -23.0,  -22.5,
 269         0x00001456,   0x0000158A,   0x000016D1,   0x0000182B,   // -22.0,       -21.5,  -21.0,  -20.5,
 270         0x0000199A,   0x00001B1E,   0x00001CB9,   0x00001E6D,   // -20.0,       -19.5,  -19.0,  -18.5,
 271         0x0000203A,   0x00002223,   0x00002429,   0x0000264E,   // -18.0,       -17.5,  -17.0,  -16.5,
 272         0x00002893,   0x00002AFA,   0x00002D86,   0x00003039,   // -16.0,       -15.5,  -15.0,  -14.5,
 273         0x00003314,   0x0000361B,   0x00003950,   0x00003CB5,   // -14.0,       -13.5,  -13.0,  -12.5,
 274         0x0000404E,   0x0000441D,   0x00004827,   0x00004C6D,   // -12.0,       -11.5,  -11.0,  -10.5,
 275         0x000050F4,   0x000055C0,   0x00005AD5,   0x00006037,   // -10.0,       -9.5,   -9.0,   -8.5,
 276         0x000065EA,   0x00006BF4,   0x0000725A,   0x00007920,   // -8.0,        -7.5,   -7.0,   -6.5,
 277         0x0000804E,   0x000087EF,   0x00008FF6,   0x0000987D,   // -6.0,        -5.5,   -5.0,   -4.5,
 278         0x0000A186,   0x0000AB19,   0x0000B53C,   0x0000BFF9,   // -4.0,        -3.5,   -3.0,   -2.5,
 279         0x0000CB59,   0x0000D766,   0x0000E429,   0x0000F1AE,   // -2.0,        -1.5,   -1.0,   -0.5,
 280         0x00010000,   0x00010F2B,   0x00011F3D,   0x00013042,   // 0.0,   +0.5, +1.0,   +1.5,
 281         0x00014249,   0x00015562,   0x0001699C,   0x00017F09    // 2.0,   +2.5, +3.0,   +3.5,
 282 };
 283
 284 static int
 285 tumbler_write(struct tumbler_softc *sc, uint8_t reg, const void *data)
 286 {
 287         u_int size;
 288         uint8_t buf[16];
 289
 290         struct iic_msg msg[] = {
 291                 { sc->sc_addr, IIC_M_WR, 0, buf }
 292         };
 293
 294         KASSERT(reg < sizeof(tumbler_regsize), ("bad reg"));
 295         size = tumbler_regsize[reg];
 296         msg[0].len = size + 1;
 297         buf[0] = reg;
 298         memcpy(&buf[1], data, size);
 299
 300         iicbus_transfer(sc->sc_dev, msg, 1);
 301
 302         return (0);
 303 }
 304
 305 static int
 306 tumbler_probe(device_t dev)
 307 {
 308         const char *name;
 309
 310         name = ofw_bus_get_name(dev);
 311         if (name == NULL)
 312                 return (ENXIO);
 313
 314         if (strcmp(name, "deq") == 0 && iicbus_get_addr(dev) ==
 315             TUMBLER_IICADDR) {
 316                 device_set_desc(dev, "Texas Instruments TAS3001 Audio Codec");
 317                 return (0);
 318         }
 319
 320         return (ENXIO);
 321 }
 322
 323 static int
 324 tumbler_attach(device_t dev)
 325 {
 326         struct tumbler_softc *sc;
 327
 328         sc = device_get_softc(dev);
 329         sc->sc_dev = dev;
 330         sc->sc_addr = iicbus_get_addr(dev);
 331
 332         i2s_mixer_class = &tumbler_mixer_class;
 333         i2s_mixer = dev;
 334
 335         return (0);
 336 }
 337
 338 static int
 339 tumbler_init(struct snd_mixer *m)
 340 {
 341         struct tumbler_softc *sc;
 342         u_int           x = 0;
 343
 344         sc = device_get_softc(mix_getdevinfo(m));
 345
 346         tumbler_write(sc, TUMBLER_LB0, tumbler_initdata.LB0);
 347         tumbler_write(sc, TUMBLER_LB1, tumbler_initdata.LB1);
 348         tumbler_write(sc, TUMBLER_LB2, tumbler_initdata.LB2);
 349         tumbler_write(sc, TUMBLER_LB3, tumbler_initdata.LB3);
 350         tumbler_write(sc, TUMBLER_LB4, tumbler_initdata.LB4);
 351         tumbler_write(sc, TUMBLER_LB5, tumbler_initdata.LB5);
 352         tumbler_write(sc, TUMBLER_RB0, tumbler_initdata.RB0);
 353         tumbler_write(sc, TUMBLER_RB1, tumbler_initdata.RB1);
 354         tumbler_write(sc, TUMBLER_RB1, tumbler_initdata.RB1);
 355         tumbler_write(sc, TUMBLER_RB2, tumbler_initdata.RB2);
 356         tumbler_write(sc, TUMBLER_RB3, tumbler_initdata.RB3);
 357         tumbler_write(sc, TUMBLER_RB4, tumbler_initdata.RB4);
 358         tumbler_write(sc, TUMBLER_RB5, tumbler_initdata.RB5);
 359         tumbler_write(sc, TUMBLER_MCR, tumbler_initdata.MCR);
 360         tumbler_write(sc, TUMBLER_DRC, tumbler_initdata.DRC);
 361         tumbler_write(sc, TUMBLER_VOLUME, tumbler_initdata.VOLUME);
 362         tumbler_write(sc, TUMBLER_TREBLE, tumbler_initdata.TREBLE);
 363         tumbler_write(sc, TUMBLER_BASS, tumbler_initdata.BASS);
 364         tumbler_write(sc, TUMBLER_MIXER1, tumbler_initdata.MIXER1);
 365         tumbler_write(sc, TUMBLER_MIXER2, tumbler_initdata.MIXER2);
 366
 367         x |= SOUND_MASK_VOLUME;
 368         mix_setdevs(m, x);
 369
 370         return (0);
 371 }
 372
 373 static int
 374 tumbler_uninit(struct snd_mixer *m)
 375 {
 376         return (0);
 377 }
 378
 379 static int
 380 tumbler_reinit(struct snd_mixer *m)
 381 {
 382         return (0);
 383 }
 384
 385 static int
 386 tumbler_set(struct snd_mixer *m, unsigned dev, unsigned left, unsigned right)
 387 {
 388         struct tumbler_softc *sc;
 389         struct mtx *mixer_lock;
 390         int locked;
 391         u_int l, r;
 392         u_char reg[6];
 393
 394         sc = device_get_softc(mix_getdevinfo(m));
 395         mixer_lock = mixer_get_lock(m);
 396         locked = mtx_owned(mixer_lock);
 397
 398         switch (dev) {
 399         case SOUND_MIXER_VOLUME:
 400                 if (left > 100 || right > 100)
 401                         return (0);
 402
 403                 l = (left == 0 ? 0 : tumbler_volume_table[left - 1]);
 404                 r = (right == 0 ? 0 : tumbler_volume_table[right - 1]);
 405
 406                 reg[0] = (l & 0xff0000) >> 16;
 407                 reg[1] = (l & 0x00ff00) >> 8;
 408                 reg[2] = l & 0x0000ff;
 409                 reg[3] = (r & 0xff0000) >> 16;
 410                 reg[4] = (r & 0x00ff00) >> 8;
 411                 reg[5] = r & 0x0000ff;
 412
 413                 /*
 414                  * We need to unlock the mixer lock because iicbus_transfer()
 415                  * may sleep. The mixer lock itself is unnecessary here
 416                  * because it is meant to serialize hardware access, which
 417                  * is taken care of by the I2C layer, so this is safe.
 418                  */
 419
 420                 if (locked)
 421                         mtx_unlock(mixer_lock);
 422
 423                 tumbler_write(sc, TUMBLER_VOLUME, reg);
 424
 425                 if (locked)
 426                         mtx_lock(mixer_lock);
 427
 428                 return (left | (right << 8));
 429         }
 430
 431         return (0);
 432 }
 433
 434 static u_int32_t
 435 tumbler_setrecsrc(struct snd_mixer *m, u_int32_t src)
 436 {
 437         return (0);
 438 }