sys/dev/sound/usb/uaudio_pcm.c

   1 /* $FreeBSD$ */
   2
   3 /*-
   4  * SPDX-License-Identifier: BSD-2-Clause-FreeBSD
   5  *
   6  * Copyright (c) 2000-2002 Hiroyuki Aizu <aizu@navi.org>
   7  * Copyright (c) 2006 Hans Petter Selasky
   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 #ifdef HAVE_KERNEL_OPTION_HEADERS
  32 #include "opt_snd.h"
  33 #endif
  34
  35 #include <dev/sound/pcm/sound.h>
  36 #include <dev/sound/chip.h>
  37 #include <dev/sound/usb/uaudio.h>
  38
  39 #include "mixer_if.h"
  40
  41 /************************************************************/
  42 static void *
  43 ua_chan_init(kobj_t obj, void *devinfo, struct snd_dbuf *b, struct pcm_channel *c, int dir)
  44 {
  45         return (uaudio_chan_init(devinfo, b, c, dir));
  46 }
  47
  48 static int
  49 ua_chan_free(kobj_t obj, void *data)
  50 {
  51         return (uaudio_chan_free(data));
  52 }
  53
  54 static int
  55 ua_chan_setformat(kobj_t obj, void *data, uint32_t format)
  56 {
  57         /*
  58          * At this point, no need to query as we
  59          * shouldn't select an unsorted format
  60          */
  61         return (uaudio_chan_set_param_format(data, format));
  62 }
  63
  64 static uint32_t
  65 ua_chan_setspeed(kobj_t obj, void *data, uint32_t speed)
  66 {
  67         return (uaudio_chan_set_param_speed(data, speed));
  68 }
  69
  70 static uint32_t
  71 ua_chan_setblocksize(kobj_t obj, void *data, uint32_t blocksize)
  72 {
  73         return (uaudio_chan_set_param_blocksize(data, blocksize));
  74 }
  75
  76 static int
  77 ua_chan_setfragments(kobj_t obj, void *data, uint32_t blocksize, uint32_t blockcount)
  78 {
  79         return (uaudio_chan_set_param_fragments(data, blocksize, blockcount));
  80 }
  81
  82 static int
  83 ua_chan_trigger(kobj_t obj, void *data, int go)
  84 {
  85         if (PCMTRIG_COMMON(go)) {
  86                 if (go == PCMTRIG_START) {
  87                         uaudio_chan_start(data);
  88                 } else {
  89                         uaudio_chan_stop(data);
  90                 }
  91         }
  92         return (0);
  93 }
  94
  95 static uint32_t
  96 ua_chan_getptr(kobj_t obj, void *data)
  97 {
  98         return (uaudio_chan_getptr(data));
  99 }
 100
 101 static struct pcmchan_caps *
 102 ua_chan_getcaps(kobj_t obj, void *data)
 103 {
 104         return (uaudio_chan_getcaps(data));
 105 }
 106
 107 static struct pcmchan_matrix *
 108 ua_chan_getmatrix(kobj_t obj, void *data, uint32_t format)
 109 {
 110         return (uaudio_chan_getmatrix(data, format));
 111 }
 112
 113 static kobj_method_t ua_chan_methods[] = {
 114         KOBJMETHOD(channel_init, ua_chan_init),
 115         KOBJMETHOD(channel_free, ua_chan_free),
 116         KOBJMETHOD(channel_setformat, ua_chan_setformat),
 117         KOBJMETHOD(channel_setspeed, ua_chan_setspeed),
 118         KOBJMETHOD(channel_setblocksize, ua_chan_setblocksize),
 119         KOBJMETHOD(channel_setfragments, ua_chan_setfragments),
 120         KOBJMETHOD(channel_trigger, ua_chan_trigger),
 121         KOBJMETHOD(channel_getptr, ua_chan_getptr),
 122         KOBJMETHOD(channel_getcaps, ua_chan_getcaps),
 123         KOBJMETHOD(channel_getmatrix, ua_chan_getmatrix),
 124         KOBJMETHOD_END
 125 };
 126
 127 CHANNEL_DECLARE(ua_chan);
 128
 129 /************************************************************/
 130 static int
 131 ua_mixer_init(struct snd_mixer *m)
 132 {
 133         return (uaudio_mixer_init_sub(mix_getdevinfo(m), m));
 134 }
 135
 136 static int
 137 ua_mixer_set(struct snd_mixer *m, unsigned type, unsigned left, unsigned right)
 138 {
 139         struct mtx *mtx = mixer_get_lock(m);
 140         uint8_t do_unlock;
 141
 142         if (mtx_owned(mtx)) {
 143                 do_unlock = 0;
 144         } else {
 145                 do_unlock = 1;
 146                 mtx_lock(mtx);
 147         }
 148         uaudio_mixer_set(mix_getdevinfo(m), m, type, left, right);
 149         if (do_unlock) {
 150                 mtx_unlock(mtx);
 151         }
 152         return (left | (right << 8));
 153 }
 154
 155 static uint32_t
 156 ua_mixer_setrecsrc(struct snd_mixer *m, uint32_t src)
 157 {
 158         struct mtx *mtx = mixer_get_lock(m);
 159         int retval;
 160         uint8_t do_unlock;
 161
 162         if (mtx_owned(mtx)) {
 163                 do_unlock = 0;
 164         } else {
 165                 do_unlock = 1;
 166                 mtx_lock(mtx);
 167         }
 168         retval = uaudio_mixer_setrecsrc(mix_getdevinfo(m), m, src);
 169         if (do_unlock) {
 170                 mtx_unlock(mtx);
 171         }
 172         return (retval);
 173 }
 174
 175 static int
 176 ua_mixer_uninit(struct snd_mixer *m)
 177 {
 178         return (uaudio_mixer_uninit_sub(mix_getdevinfo(m), m));
 179 }
 180
 181 static kobj_method_t ua_mixer_methods[] = {
 182         KOBJMETHOD(mixer_init, ua_mixer_init),
 183         KOBJMETHOD(mixer_uninit, ua_mixer_uninit),
 184         KOBJMETHOD(mixer_set, ua_mixer_set),
 185         KOBJMETHOD(mixer_setrecsrc, ua_mixer_setrecsrc),
 186         KOBJMETHOD_END
 187 };
 188
 189 MIXER_DECLARE(ua_mixer);
 190 /************************************************************/
 191
 192 static int
 193 ua_probe(device_t dev)
 194 {
 195         struct sndcard_func *func;
 196
 197         /* the parent device has already been probed */
 198
 199         func = device_get_ivars(dev);
 200
 201         if ((func == NULL) ||
 202             (func->func != SCF_PCM)) {
 203                 return (ENXIO);
 204         }
 205         device_set_desc(dev, "USB audio");
 206
 207         return (BUS_PROBE_DEFAULT);
 208 }
 209
 210 static int
 211 ua_attach(device_t dev)
 212 {
 213         return (uaudio_attach_sub(dev, &ua_mixer_class, &ua_chan_class));
 214 }
 215
 216 static int
 217 ua_detach(device_t dev)
 218 {
 219         return (uaudio_detach_sub(dev));
 220 }
 221
 222 /************************************************************/
 223
 224 static device_method_t ua_pcm_methods[] = {
 225         /* Device interface */
 226         DEVMETHOD(device_probe, ua_probe),
 227         DEVMETHOD(device_attach, ua_attach),
 228         DEVMETHOD(device_detach, ua_detach),
 229
 230         DEVMETHOD_END
 231 };
 232
 233 static driver_t ua_pcm_driver = {
 234         "pcm",
 235         ua_pcm_methods,
 236         PCM_SOFTC_SIZE,
 237 };
 238
 239 DRIVER_MODULE(ua_pcm, uaudio, ua_pcm_driver, pcm_devclass, 0, 0);
 240 MODULE_DEPEND(ua_pcm, uaudio, 1, 1, 1);
 241 MODULE_DEPEND(ua_pcm, sound, SOUND_MINVER, SOUND_PREFVER, SOUND_MAXVER);
 242 MODULE_VERSION(ua_pcm, 1);