1/*- 2 * Copyright (c) 1999 Cameron Grant <cg@freebsd.org> 3 * All rights reserved. 4 * 5 * Redistribution and use in source and binary forms, with or without 6 * modification, are permitted provided that the following conditions 7 * are met: 8 * 1. Redistributions of source code must retain the above copyright --- 14 unchanged lines hidden (view full) --- 23 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 24 * SUCH DAMAGE. 25 */ 26 27#include <dev/sound/pcm/sound.h> 28 29#include "mixer_if.h" 30 |
31SND_DECLARE_FILE("$FreeBSD: head/sys/dev/sound/pcm/mixer.c 170815 2007-06-16 03:37:28Z ariff $"); |
32 33MALLOC_DEFINE(M_MIXER, "mixer", "mixer"); 34 35#define MIXER_NAMELEN 16 36struct snd_mixer { 37 KOBJ_FIELDS; |
38 void *devinfo; 39 int busy; 40 int hwvol_muted; 41 int hwvol_mixer; 42 int hwvol_step; |
43 int type; |
44 device_t dev; 45 u_int32_t hwvol_mute_level; 46 u_int32_t devs; 47 u_int32_t recdevs; 48 u_int32_t recsrc; 49 u_int16_t level[32]; 50 u_int8_t parent[32]; 51 u_int32_t child[32]; --- 26 unchanged lines hidden (view full) --- 78 [SOUND_MIXER_OGAIN] = 50, 79 [SOUND_MIXER_MONITOR] = 75, 80}; 81 82static char* snd_mixernames[SOUND_MIXER_NRDEVICES] = SOUND_DEVICE_NAMES; 83 84static d_open_t mixer_open; 85static d_close_t mixer_close; |
86static d_ioctl_t mixer_ioctl; |
87 88static struct cdevsw mixer_cdevsw = { 89 .d_version = D_VERSION, |
90 .d_open = mixer_open, 91 .d_close = mixer_close, 92 .d_ioctl = mixer_ioctl, 93 .d_name = "mixer", 94}; 95 96/** 97 * Keeps a count of mixer devices; used only by OSSv4 SNDCTL_SYSINFO ioctl. --- 23 unchanged lines hidden (view full) --- 121 for (i = 0; i < SOUND_MIXER_NRDEVICES; i++) 122 if (strncmp(devname, snd_mixernames[i], 123 strlen(snd_mixernames[i])) == 0) 124 return i; 125 return -1; 126} 127#endif 128 |
129#define MIXER_SET_UNLOCK(x, y) do { \ 130 if ((y) != 0) \ 131 snd_mtxunlock((x)->lock); \ 132} while(0) 133 134#define MIXER_SET_LOCK(x, y) do { \ 135 if ((y) != 0) \ 136 snd_mtxlock((x)->lock); \ 137} while(0) 138 |
139static int |
140mixer_set_softpcmvol(struct snd_mixer *m, struct snddev_info *d, 141 unsigned left, unsigned right) |
142{ 143 struct pcm_channel *c; |
144 int dropmtx, acquiremtx; |
145 |
146 if (!PCM_REGISTERED(d)) 147 return (EINVAL); |
148 |
149 if (mtx_owned(m->lock)) 150 dropmtx = 1; 151 else 152 dropmtx = 0; 153 154 if (!(d->flags & SD_F_MPSAFE) || mtx_owned(d->lock) != 0) 155 acquiremtx = 0; 156 else 157 acquiremtx = 1; 158 159 /* 160 * Be careful here. If we're coming from cdev ioctl, it is OK to 161 * not doing locking AT ALL (except on individual channel) since 162 * we've been heavily guarded by pcm cv, or if we're still 163 * under Giant influence. Since we also have mix_* calls, we cannot 164 * assume such protection and just do the lock as usuall. 165 */ 166 MIXER_SET_UNLOCK(m, dropmtx); 167 MIXER_SET_LOCK(d, acquiremtx); 168 |
169 if (CHN_EMPTY(d, channels.pcm.busy)) { 170 CHN_FOREACH(c, d, channels.pcm) { 171 CHN_LOCK(c); 172 if (c->direction == PCMDIR_PLAY && 173 (c->feederflags & (1 << FEEDER_VOLUME))) 174 chn_setvolume(c, left, right); 175 CHN_UNLOCK(c); 176 } 177 } else { 178 CHN_FOREACH(c, d, channels.pcm.busy) { 179 CHN_LOCK(c); 180 if (c->direction == PCMDIR_PLAY && 181 (c->feederflags & (1 << FEEDER_VOLUME))) 182 chn_setvolume(c, left, right); 183 CHN_UNLOCK(c); 184 } 185 } 186 |
187 MIXER_SET_UNLOCK(d, acquiremtx); 188 MIXER_SET_LOCK(m, dropmtx); |
189 |
190 return (0); |
191} 192 193static int 194mixer_set(struct snd_mixer *m, unsigned dev, unsigned lev) 195{ 196 struct snddev_info *d; 197 unsigned l, r, tl, tr; 198 u_int32_t parent = SOUND_MIXER_NONE, child = 0; 199 u_int32_t realdev; |
200 int i, dropmtx; |
201 202 if (m == NULL || dev >= SOUND_MIXER_NRDEVICES || 203 (0 == (m->devs & (1 << dev)))) 204 return -1; 205 206 l = min((lev & 0x00ff), 100); 207 r = min(((lev & 0xff00) >> 8), 100); 208 realdev = m->realdev[dev]; 209 210 d = device_get_softc(m->dev); 211 if (d == NULL) 212 return -1; 213 |
214 /* It is safe to drop this mutex due to Giant. */ 215 if (!(d->flags & SD_F_MPSAFE) && mtx_owned(m->lock) != 0) 216 dropmtx = 1; 217 else 218 dropmtx = 0; 219 220 MIXER_SET_UNLOCK(m, dropmtx); 221 |
222 /* TODO: recursive handling */ 223 parent = m->parent[dev]; 224 if (parent >= SOUND_MIXER_NRDEVICES) 225 parent = SOUND_MIXER_NONE; 226 if (parent == SOUND_MIXER_NONE) 227 child = m->child[dev]; 228 229 if (parent != SOUND_MIXER_NONE) { 230 tl = (l * (m->level[parent] & 0x00ff)) / 100; 231 tr = (r * ((m->level[parent] & 0xff00) >> 8)) / 100; 232 if (dev == SOUND_MIXER_PCM && (d->flags & SD_F_SOFTPCMVOL)) |
233 (void)mixer_set_softpcmvol(m, d, tl, tr); |
234 else if (realdev != SOUND_MIXER_NONE && |
235 MIXER_SET(m, realdev, tl, tr) < 0) { 236 MIXER_SET_LOCK(m, dropmtx); |
237 return -1; |
238 } |
239 } else if (child != 0) { 240 for (i = 0; i < SOUND_MIXER_NRDEVICES; i++) { 241 if (!(child & (1 << i)) || m->parent[i] != dev) 242 continue; 243 realdev = m->realdev[i]; 244 tl = (l * (m->level[i] & 0x00ff)) / 100; 245 tr = (r * ((m->level[i] & 0xff00) >> 8)) / 100; 246 if (i == SOUND_MIXER_PCM && (d->flags & SD_F_SOFTPCMVOL)) |
247 (void)mixer_set_softpcmvol(m, d, tl, tr); |
248 else if (realdev != SOUND_MIXER_NONE) 249 MIXER_SET(m, realdev, tl, tr); 250 } 251 realdev = m->realdev[dev]; 252 if (realdev != SOUND_MIXER_NONE && |
253 MIXER_SET(m, realdev, l, r) < 0) { 254 MIXER_SET_LOCK(m, dropmtx); |
255 return -1; |
256 } |
257 } else { 258 if (dev == SOUND_MIXER_PCM && (d->flags & SD_F_SOFTPCMVOL)) |
259 (void)mixer_set_softpcmvol(m, d, l, r); |
260 else if (realdev != SOUND_MIXER_NONE && |
261 MIXER_SET(m, realdev, l, r) < 0) { 262 MIXER_SET_LOCK(m, dropmtx); |
263 return -1; |
264 } |
265 } 266 267 m->level[dev] = l | (r << 8); 268 |
269 MIXER_SET_LOCK(m, dropmtx); 270 |
271 return 0; 272} 273 274static int 275mixer_get(struct snd_mixer *mixer, int dev) 276{ 277 if ((dev < SOUND_MIXER_NRDEVICES) && (mixer->devs & (1 << dev))) 278 return mixer->level[dev]; |
279 else 280 return -1; |
281} 282 283static int 284mixer_setrecsrc(struct snd_mixer *mixer, u_int32_t src) 285{ |
286 struct snddev_info *d; 287 int dropmtx; 288 289 d = device_get_softc(mixer->dev); 290 if (d == NULL) 291 return -1; 292 if (!(d->flags & SD_F_MPSAFE) && mtx_owned(mixer->lock) != 0) 293 dropmtx = 1; 294 else 295 dropmtx = 0; |
296 src &= mixer->recdevs; 297 if (src == 0) 298 src = SOUND_MASK_MIC; |
299 /* It is safe to drop this mutex due to Giant. */ 300 MIXER_SET_UNLOCK(mixer, dropmtx); |
301 mixer->recsrc = MIXER_SETRECSRC(mixer, src); |
302 MIXER_SET_LOCK(mixer, dropmtx); |
303 return 0; 304} 305 306static int 307mixer_getrecsrc(struct snd_mixer *mixer) 308{ 309 return mixer->recsrc; 310} --- 224 unchanged lines hidden (view full) --- 535} 536 537void * 538mix_getdevinfo(struct snd_mixer *m) 539{ 540 return m->devinfo; 541} 542 |
543static struct snd_mixer * 544mixer_obj_create(device_t dev, kobj_class_t cls, void *devinfo, 545 int type, const char *desc) |
546{ |
547 struct snd_mixer *m; |
548 int i; |
549 |
550 KASSERT(dev != NULL && cls != NULL && devinfo != NULL, 551 ("%s(): NULL data dev=%p cls=%p devinfo=%p", 552 __func__, dev, cls, devinfo)); 553 KASSERT(type == MIXER_TYPE_PRIMARY || type == MIXER_TYPE_SECONDARY, 554 ("invalid mixer type=%d", type)); 555 |
556 m = (struct snd_mixer *)kobj_create(cls, M_MIXER, M_WAITOK | M_ZERO); |
557 snprintf(m->name, sizeof(m->name), "%s:mixer", 558 device_get_nameunit(dev)); 559 if (desc != NULL) { 560 strlcat(m->name, ":", sizeof(m->name)); 561 strlcat(m->name, desc, sizeof(m->name)); 562 } 563 m->lock = snd_mtxcreate(m->name, (type == MIXER_TYPE_PRIMARY) ? 564 "primary pcm mixer" : "secondary pcm mixer"); 565 m->type = type; |
566 m->devinfo = devinfo; 567 m->busy = 0; 568 m->dev = dev; |
569 for (i = 0; i < (sizeof(m->parent) / sizeof(m->parent[0])); i++) { |
570 m->parent[i] = SOUND_MIXER_NONE; 571 m->child[i] = 0; 572 m->realdev[i] = i; 573 } 574 |
575 if (MIXER_INIT(m)) { 576 snd_mtxlock(m->lock); 577 snd_mtxfree(m->lock); 578 kobj_delete((kobj_t)m, M_MIXER); 579 return (NULL); 580 } |
581 |
582 return (m); 583} 584 585int 586mixer_delete(struct snd_mixer *m) 587{ 588 KASSERT(m != NULL, ("NULL snd_mixer")); 589 KASSERT(m->type == MIXER_TYPE_SECONDARY, 590 ("%s(): illegal mixer type=%d", __func__, m->type)); 591 592 snd_mtxlock(m->lock); 593 594 MIXER_UNINIT(m); 595 596 snd_mtxfree(m->lock); 597 kobj_delete((kobj_t)m, M_MIXER); 598 599 --mixer_count; 600 601 return (0); 602} 603 604struct snd_mixer * 605mixer_create(device_t dev, kobj_class_t cls, void *devinfo, const char *desc) 606{ 607 struct snd_mixer *m; 608 609 m = mixer_obj_create(dev, cls, devinfo, MIXER_TYPE_SECONDARY, desc); 610 611 if (m != NULL) 612 ++mixer_count; 613 614 return (m); 615} 616 617int 618mixer_init(device_t dev, kobj_class_t cls, void *devinfo) 619{ 620 struct snddev_info *snddev; 621 struct snd_mixer *m; 622 u_int16_t v; 623 struct cdev *pdev; 624 int i, unit, devunit, val; 625 626 m = mixer_obj_create(dev, cls, devinfo, MIXER_TYPE_PRIMARY, NULL); 627 if (m == NULL) 628 return (-1); 629 |
630 for (i = 0; i < SOUND_MIXER_NRDEVICES; i++) { 631 v = snd_mixerdefaults[i]; 632 633 if (resource_int_value(device_get_name(dev), 634 device_get_unit(dev), snd_mixernames[i], &val) == 0) { 635 if (val >= 0 && val <= 100) { 636 v = (u_int16_t) val; 637 } --- 33 unchanged lines hidden (view full) --- 671 if (m->child[i] != 0) 672 printf(" child=0x%08x", m->child[i]); 673 printf("\n"); 674 } 675 if (snddev->flags & SD_F_SOFTPCMVOL) 676 device_printf(dev, "Soft PCM mixer ENABLED\n"); 677 } 678 |
679 return (0); |
680} 681 682int 683mixer_uninit(device_t dev) 684{ 685 int i; 686 struct snddev_info *d; 687 struct snd_mixer *m; 688 struct cdev *pdev; 689 690 d = device_get_softc(dev); 691 pdev = mixer_get_devt(dev); 692 if (d == NULL || pdev == NULL || pdev->si_drv1 == NULL) 693 return EBADF; |
694 |
695 m = pdev->si_drv1; |
696 KASSERT(m != NULL, ("NULL snd_mixer")); 697 KASSERT(m->type == MIXER_TYPE_PRIMARY, 698 ("%s(): illegal mixer type=%d", __func__, m->type)); 699 |
700 snd_mtxlock(m->lock); 701 702 if (m->busy) { 703 snd_mtxunlock(m->lock); 704 return EBUSY; 705 } 706 707 pdev->si_drv1 = NULL; --- 139 unchanged lines hidden (view full) --- 847 right += right_step * m->hwvol_step; 848 if (right < 0) 849 right = 0; 850 mixer_set(m, m->hwvol_mixer, left | right << 8); 851 } 852 snd_mtxunlock(m->lock); 853} 854 |
855int 856mixer_busy(struct snd_mixer *m) 857{ 858 KASSERT(m != NULL, ("NULL snd_mixer")); 859 860 return (m->busy); 861} 862 863int 864mix_set(struct snd_mixer *m, u_int dev, u_int left, u_int right) 865{ 866 int ret; 867 868 KASSERT(m != NULL, ("NULL snd_mixer")); 869 870 snd_mtxlock(m->lock); 871 ret = mixer_set(m, dev, left | (right << 8)); 872 snd_mtxunlock(m->lock); 873 874 return ((ret != 0) ? ENXIO : 0); 875} 876 877int 878mix_get(struct snd_mixer *m, u_int dev) 879{ 880 int ret; 881 882 KASSERT(m != NULL, ("NULL snd_mixer")); 883 884 snd_mtxlock(m->lock); 885 ret = mixer_get(m, dev); 886 snd_mtxunlock(m->lock); 887 888 return (ret); 889} 890 891int 892mix_setrecsrc(struct snd_mixer *m, u_int32_t src) 893{ 894 int ret; 895 896 KASSERT(m != NULL, ("NULL snd_mixer")); 897 898 snd_mtxlock(m->lock); 899 ret = mixer_setrecsrc(m, src); 900 snd_mtxunlock(m->lock); 901 902 return ((ret != 0) ? ENXIO : 0); 903} 904 905u_int32_t 906mix_getrecsrc(struct snd_mixer *m) 907{ 908 u_int32_t ret; 909 910 KASSERT(m != NULL, ("NULL snd_mixer")); 911 912 snd_mtxlock(m->lock); 913 ret = mixer_getrecsrc(m); 914 snd_mtxunlock(m->lock); 915 916 return (ret); 917} 918 919int 920mix_get_type(struct snd_mixer *m) 921{ 922 KASSERT(m != NULL, ("NULL snd_mixer")); 923 924 return (m->type); 925} 926 |
927/* ----------------------------------------------------------------------- */ 928 929static int 930mixer_open(struct cdev *i_dev, int flags, int mode, struct thread *td) 931{ |
932 struct snddev_info *d; |
933 struct snd_mixer *m; 934 |
935 936 if (i_dev == NULL || i_dev->si_drv1 == NULL) 937 return (EBADF); 938 |
939 m = i_dev->si_drv1; |
940 d = device_get_softc(m->dev); 941 if (!PCM_REGISTERED(d)) 942 return (EBADF); |
943 |
944 /* XXX Need Giant magic entry ??? */ |
945 |
946 snd_mtxlock(m->lock); 947 m->busy = 1; |
948 snd_mtxunlock(m->lock); |
949 950 return (0); |
951} 952 953static int 954mixer_close(struct cdev *i_dev, int flags, int mode, struct thread *td) 955{ |
956 struct snddev_info *d; |
957 struct snd_mixer *m; |
958 int ret; |
959 |
960 if (i_dev == NULL || i_dev->si_drv1 == NULL) 961 return (EBADF); 962 |
963 m = i_dev->si_drv1; |
964 d = device_get_softc(m->dev); 965 if (!PCM_REGISTERED(d)) 966 return (EBADF); |
967 |
968 /* XXX Need Giant magic entry ??? */ |
969 |
970 snd_mtxlock(m->lock); 971 ret = (m->busy == 0) ? EBADF : 0; 972 m->busy = 0; |
973 snd_mtxunlock(m->lock); |
974 975 return (ret); |
976} 977 |
978static int 979mixer_ioctl(struct cdev *i_dev, u_long cmd, caddr_t arg, int mode, 980 struct thread *td) 981{ 982 struct snddev_info *d; 983 int ret; 984 985 if (i_dev == NULL || i_dev->si_drv1 == NULL) 986 return (EBADF); 987 988 d = device_get_softc(((struct snd_mixer *)i_dev->si_drv1)->dev); 989 if (!PCM_REGISTERED(d)) 990 return (EBADF); 991 992 PCM_GIANT_ENTER(d); 993 PCM_ACQUIRE_QUICK(d); 994 995 ret = mixer_ioctl_cmd(i_dev, cmd, arg, mode, td, MIXER_CMD_CDEV); 996 997 PCM_RELEASE_QUICK(d); 998 PCM_GIANT_LEAVE(d); 999 1000 return (ret); 1001} 1002 1003/* 1004 * XXX Make sure you can guarantee concurrency safety before calling this 1005 * function, be it through Giant, PCM_CV_*, etc ! 1006 */ |
1007int |
1008mixer_ioctl_cmd(struct cdev *i_dev, u_long cmd, caddr_t arg, int mode, 1009 struct thread *td, int from) |
1010{ 1011 struct snd_mixer *m; 1012 int ret, *arg_i = (int *)arg; 1013 int v = -1, j = cmd & 0xff; 1014 1015 m = i_dev->si_drv1; 1016 1017 if (m == NULL) |
1018 return (EBADF); |
1019 1020 snd_mtxlock(m->lock); |
1021 if (from == MIXER_CMD_CDEV && !m->busy) { |
1022 snd_mtxunlock(m->lock); |
1023 return (EBADF); |
1024 } 1025 1026 if (cmd == SNDCTL_MIXERINFO) { 1027 snd_mtxunlock(m->lock); |
1028 return (mixer_oss_mixerinfo(i_dev, (oss_mixerinfo *)arg)); |
1029 } 1030 1031 if ((cmd & MIXER_WRITE(0)) == MIXER_WRITE(0)) { 1032 if (j == SOUND_MIXER_RECSRC) 1033 ret = mixer_setrecsrc(m, *arg_i); 1034 else 1035 ret = mixer_set(m, j, *arg_i); 1036 snd_mtxunlock(m->lock); |
1037 return ((ret == 0) ? 0 : ENXIO); |
1038 } 1039 1040 if ((cmd & MIXER_READ(0)) == MIXER_READ(0)) { 1041 switch (j) { 1042 case SOUND_MIXER_DEVMASK: 1043 case SOUND_MIXER_CAPS: 1044 case SOUND_MIXER_STEREODEVS: 1045 v = mix_getdevs(m); --- 7 unchanged lines hidden (view full) --- 1053 v = mixer_getrecsrc(m); 1054 break; 1055 1056 default: 1057 v = mixer_get(m, j); 1058 } 1059 *arg_i = v; 1060 snd_mtxunlock(m->lock); |
1061 return ((v != -1) ? 0 : ENXIO); |
1062 } 1063 1064 ret = 0; 1065 1066 switch (cmd) { 1067 /** @todo Double check return values, error codes. */ 1068 case SNDCTL_SYSINFO: |
1069 snd_mtxunlock(m->lock); |
1070 sound_oss_sysinfo((oss_sysinfo *)arg); |
1071 return (ret); |
1072 break; 1073 case SNDCTL_AUDIOINFO: |
1074 snd_mtxunlock(m->lock); 1075 return (dsp_oss_audioinfo(i_dev, (oss_audioinfo *)arg)); |
1076 break; 1077 case SNDCTL_DSP_GET_RECSRC_NAMES: 1078 bcopy((void *)&m->enuminfo, arg, sizeof(oss_mixer_enuminfo)); 1079 break; 1080 case SNDCTL_DSP_GET_RECSRC: 1081 ret = mixer_get_recroute(m, arg_i); 1082 break; 1083 case SNDCTL_DSP_SET_RECSRC: 1084 ret = mixer_set_recroute(m, *arg_i); 1085 break; 1086 case OSS_GETVERSION: 1087 *arg_i = SOUND_VERSION; 1088 break; 1089 default: 1090 ret = ENXIO; |
1091 break; |
1092 } 1093 1094 snd_mtxunlock(m->lock); |
1095 1096 return (ret); |
1097} 1098 1099#ifdef USING_DEVFS 1100static void 1101mixer_clone(void *arg, 1102#if __FreeBSD_version >= 600034 1103 struct ucred *cred, 1104#endif 1105 char *name, int namelen, struct cdev **dev) 1106{ 1107 struct snddev_info *d; 1108 1109 if (*dev != NULL) 1110 return; 1111 if (strcmp(name, "mixer") == 0) { 1112 d = devclass_get_softc(pcm_devclass, snd_unit); |
1113 if (PCM_REGISTERED(d) && d->mixer_dev != NULL) { |
1114 *dev = d->mixer_dev; 1115 dev_ref(*dev); 1116 } 1117 } 1118} 1119 1120static void 1121mixer_sysinit(void *p) --- 35 unchanged lines hidden (view full) --- 1157 * @retval EINVAL oss_mixerinfo::dev specified a bad value 1158 * @retval 0 success 1159 */ 1160int 1161mixer_oss_mixerinfo(struct cdev *i_dev, oss_mixerinfo *mi) 1162{ 1163 struct snddev_info *d; 1164 struct snd_mixer *m; |
1165 int nmix, i; |
1166 1167 /* 1168 * If probing the device handling the ioctl, make sure it's a mixer 1169 * device. (This ioctl is valid on audio, mixer, and midi devices.) 1170 */ |
1171 if (mi->dev == -1 && i_dev->si_devsw != &mixer_cdevsw) 1172 return (EINVAL); |
1173 1174 d = NULL; 1175 m = NULL; |
1176 nmix = 0; |
1177 1178 /* 1179 * There's a 1:1 relationship between mixers and PCM devices, so 1180 * begin by iterating over PCM devices and search for our mixer. 1181 */ 1182 for (i = 0; pcm_devclass != NULL && 1183 i < devclass_get_maxunit(pcm_devclass); i++) { 1184 d = devclass_get_softc(pcm_devclass, i); |
1185 if (!PCM_REGISTERED(d)) |
1186 continue; 1187 |
1188 /* XXX Need Giant magic entry */ 1189 |
1190 /* See the note in function docblock. */ 1191 mtx_assert(d->lock, MA_NOTOWNED); |
1192 pcm_lock(d); 1193 |
1194 if (d->mixer_dev != NULL && d->mixer_dev->si_drv1 != NULL && 1195 ((mi->dev == -1 && d->mixer_dev == i_dev) || 1196 mi->dev == nmix)) { 1197 m = d->mixer_dev->si_drv1; 1198 mtx_lock(m->lock); |
1199 |
1200 /* 1201 * At this point, the following synchronization stuff 1202 * has happened: 1203 * - a specific PCM device is locked. 1204 * - a specific mixer device has been locked, so be 1205 * sure to unlock when existing. 1206 */ 1207 bzero((void *)mi, sizeof(*mi)); 1208 mi->dev = nmix; 1209 snprintf(mi->id, sizeof(mi->id), "mixer%d", i); 1210 strlcpy(mi->name, m->name, sizeof(mi->name)); 1211 mi->modify_counter = m->modify_counter; 1212 mi->card_number = i; 1213 /* 1214 * Currently, FreeBSD assumes 1:1 relationship between 1215 * a pcm and mixer devices, so this is hardcoded to 0. 1216 */ 1217 mi->port_number = 0; |
1218 |
1219 /** 1220 * @todo Fill in @sa oss_mixerinfo::mixerhandle. 1221 * @note From 4Front: "mixerhandle is an arbitrary 1222 * string that identifies the mixer better than 1223 * the device number (mixerinfo.dev). Device 1224 * numbers may change depending on the order the 1225 * drivers are loaded. However the handle should 1226 * remain the same provided that the sound card 1227 * is not moved to another PCI slot." 1228 */ |
1229 |
1230 /** 1231 * @note 1232 * @sa oss_mixerinfo::magic is a reserved field. 1233 * 1234 * @par 1235 * From 4Front: "magic is usually 0. However some 1236 * devices may have dedicated setup utilities and the 1237 * magic field may contain an unique driver specific 1238 * value (managed by [4Front])." 1239 */ |
1240 |
1241 mi->enabled = device_is_attached(m->dev) ? 1 : 0; 1242 /** 1243 * The only flag for @sa oss_mixerinfo::caps is 1244 * currently MIXER_CAP_VIRTUAL, which I'm not sure we 1245 * really worry about. 1246 */ 1247 /** 1248 * Mixer extensions currently aren't supported, so 1249 * leave @sa oss_mixerinfo::nrext blank for now. 1250 */ 1251 /** 1252 * @todo Fill in @sa oss_mixerinfo::priority (requires 1253 * touching drivers?) 1254 * @note The priority field is for mixer applets to 1255 * determine which mixer should be the default, with 0 1256 * being least preferred and 10 being most preferred. 1257 * From 4Front: "OSS drivers like ICH use higher 1258 * values (10) because such chips are known to be used 1259 * only on motherboards. Drivers for high end pro 1260 * devices use 0 because they will never be the 1261 * default mixer. Other devices use values 1 to 9 1262 * depending on the estimated probability of being the 1263 * default device. 1264 * 1265 * XXX Described by Hannu@4Front, but not found in 1266 * soundcard.h. 1267 strlcpy(mi->devnode, d->mixer_dev->si_name, 1268 sizeof(mi->devnode)); 1269 mi->legacy_device = i; 1270 */ 1271 mtx_unlock(m->lock); 1272 } else 1273 ++nmix; |
1274 |
1275 pcm_unlock(d); |
1276 |
1277 if (m != NULL) 1278 return (0); 1279 } |
1280 |
1281 return (EINVAL); |
1282} |