1 /*
2 * Copyright (c) 2022-2023 Huawei Device Co., Ltd.
3 *
4 * HDF is dual licensed: you can use it either under the terms of
5 * the GPL, or the BSD license, at your option.
6 * See the LICENSE file in the root of this repository for complete details.
7 */
8
9 #include "audio_usb_mixer.h"
10 #include <linux/bitops.h>
11 #include <linux/init.h>
12 #include <linux/list.h>
13 #include <linux/log2.h>
14 #include <linux/slab.h>
15 #include <linux/string.h>
16 #include <linux/usb.h>
17 #include <linux/usb/audio-v2.h>
18 #include <linux/usb/audio-v3.h>
19 #include <linux/usb/audio.h>
20
21 #include "audio_control.h"
22 #include "audio_core.h"
23 #include "audio_driver_log.h"
24 #include "audio_host.h"
25 #include "audio_usb_linux.h"
26 #include "audio_usb_validate_desc.h"
27
28 #define HDF_LOG_TAG HDF_AUDIO_USB
29
30 #define MAX_ID_ELEMS 256
31 #define KCTL_NAME_LEN 64
32 #define MAX_ITEM_NAME_LEN 64
33 #define HDR_BLENGTH_MAX 4
34
35 #define AUDIO_USB_CTL_ELEM_TYPE_NONE 0 /* invalid */
36 #define AUDIO_USB_CTL_ELEM_TYPE_BOOLEAN 1 /* boolean type */
37 #define AUDIO_USB_CTL_ELEM_TYPE_INTEGER 2 /* integer type */
38 #define AUDIO_USB_CTL_ELEM_TYPE_ENUMERATED 3 /* enumerated type */
39
40 #define AUDIO_USB_CTL_ELEM_IFACE_CARD 0 /* global control */
41 #define AUDIO_USB_CTL_ELEM_IFACE_HWDEP 1 /* hardware dependent device */
42 #define AUDIO_USB_CTL_ELEM_IFACE_MIXER 2 /* virtual mixer device */
43
44 #define CTRL_MIXER_BMA_MAIN 0x0100
45 #define CTRL_MIXER_BMA_MIC 0x0200
46 #define CTRL_MIXER_BMA_HEADSET 0x0300
47 #define CTRL_MIXER_BMA_PHONE 0x0400
48
49 #define USB_BA_SOURCE_ID_SIZE 1
50
51 #define USB_MIXER_DEF_RES_VAL 1
52 #define USB_MIXER_DEF_CHAN 1
53 #define USB_MIXER_DEF_MIN_VAL 1
54 #define USB_MIX_TYPE_INVALID (-1)
55
56 struct UsbMixerElemList {
57 struct UsbMixerInterface *mixer;
58 struct UsbMixerElemList *nextIdElem; /* list of controls with same id */
59 uint32_t id;
60 bool isStdInfo;
61 };
62
63 struct UsbMixerInterface {
64 struct AudioUsbDriver *audioUsbDriver;
65 struct usb_host_interface *hostIf;
66 struct list_head list;
67 uint32_t ignoreCtlError;
68 struct urb *urb;
69 struct UsbMixerElemList **idElems; /* array[MAX_ID_ELEMS], indexed by unit id */
70 struct usb_ctrlrequest *rcSetupPacket;
71 bool disconnected;
72 void (*PrivateFree)(struct UsbMixerInterface *mixer);
73 int32_t protocol; /* the usb audio specification version this interface complies to */
74 struct urb *rcUrb;
75 };
76
77 enum AudioUsbMixerType {
78 USB_MIXER_BOOLEAN = 0,
79 USB_MIXER_INV_BOOLEAN,
80 USB_MIXER_S8,
81 USB_MIXER_U8,
82 USB_MIXER_S16,
83 USB_MIXER_U16,
84 USB_MIXER_S32,
85 USB_MIXER_U32,
86 USB_MIXER_BESPOKEN, /* non-standard type */
87 };
88
89 #define MAX_CHANNELS 16 /* max logical channels */
90 #define USB_VAL_LEN_1 1
91 #define USB_VAL_LEN_2 2
92 #define USB_VAL_LEN_3 3
93 #define USB_VAL_LEN_4 4
94
95 #define USB_SHIFT_SIZE_3 3
96 #define USB_SHIFT_SIZE_4 4
97 #define USB_SHIFT_SIZE_8 8
98 #define USB_SHIFT_SIZE_16 16
99 #define USB_SHIFT_SIZE_24 24
100
101 #define USB_TIMEOUT 10
102
103 #define OVERF_LOWDIVISOR_NUM 8
104 #define VOLUME_RANGE 2
105
106 #define USB_DESCRIPTIONS_CONTAIN_100DB 100
107 #define USB_DESCRIPTIONS_CONTAIN_256DB 256
108 #define USB_DESCRIPTIONS_CONTAIN_9600DB 9600
109
110 #define CHANNEL_HDR_BLENGTH 7
111
112 #define ZERO_BASED_INTEGER 0xff
113 #define S8_MAX_VAL 0x100
114 #define S16_MAX_VAL 0x10000
115 #define S8_CAMPARE_VAL 0x80
116 #define S16_CAMPARE_VAL 0x8000
117
118 #define ARRAY_INDEX_0 0
119 #define ARRAY_INDEX_1 1
120 #define ARRAY_INDEX_2 2
121 #define ARRAY_INDEX_3 3
122 #define ARRAY_INDEX_4 4
123
124 #define DEFAULT_CHANNEL 0
125
126 #define PCM_TYPE_VAL 0x0100
127
128 struct UsbMixerElemInfo {
129 struct UsbMixerElemList head;
130 uint32_t control; /* CS or ICN (high byte) */
131 uint32_t cmask; /* channel mask bitmap */
132 uint32_t idxOff; /* Control index offset */
133 uint32_t chReadOnly;
134 uint32_t masterReadOnly;
135 int32_t channels;
136 int32_t valType;
137 int32_t min, max, res; /* min & max is volume range, res is volume reset state */
138 int32_t dBMin, dBMax;
139 int32_t cached;
140 int32_t cacheVal[MAX_CHANNELS];
141 uint8_t initialized;
142 uint8_t minMute;
143 void *privateData;
144 };
145
146 struct UsbMixerDBMap {
147 uint32_t min;
148 uint32_t max;
149 };
150
151 struct UsbMixerNameMap {
152 int32_t id;
153 const char *name;
154 int32_t control;
155 const struct UsbMixerDBMap *dB;
156 };
157
158 struct UsbMixerSelectorMap {
159 int32_t id;
160 int32_t count;
161 const char **names;
162 };
163
164 struct UsbAudioTerm {
165 int32_t id;
166 int32_t type;
167 int32_t channels;
168 uint32_t chconfig;
169 int32_t name;
170 };
171
172 struct UsbMixerBuild {
173 struct AudioUsbDriver *audioUsbDriver;
174 struct UsbMixerInterface *mixer;
175 uint8_t *buffer;
176 uint32_t bufLen;
177 DECLARE_BITMAP(unitBitMap, MAX_ID_ELEMS);
178 DECLARE_BITMAP(termBitMap, MAX_ID_ELEMS);
179 struct UsbAudioTerm oterm;
180 const struct UsbMixerNameMap *map;
181 const struct UsbMixerSelectorMap *selectorMap;
182 };
183
184 struct AudioUsbItermNameCombo {
185 int32_t type;
186 char *name;
187 };
188
189 struct AudioUsbFeatureControl {
190 uint32_t ctlMask;
191 int32_t control;
192 int32_t unitId;
193 uint32_t readOnlyMask;
194 int32_t nameId;
195 };
196
197 struct AudioUsbFeatureParam {
198 uint32_t masterBits;
199 uint32_t channels;
200 uint32_t controlSize;
201 uint8_t *bmaControls;
202 };
203
204 struct MixerUnitCtlParam {
205 int32_t numOuts;
206 int32_t itemChannels;
207 };
208
AudioUsbMixerElemInitStd(struct UsbMixerElemList * list,struct UsbMixerInterface * mixer,int32_t unitId)209 static void AudioUsbMixerElemInitStd(struct UsbMixerElemList *list, struct UsbMixerInterface *mixer, int32_t unitId)
210 {
211 if (list == NULL) {
212 AUDIO_DRIVER_LOG_ERR("param is null");
213 return;
214 }
215
216 list->mixer = mixer;
217 list->id = unitId;
218 }
219
AudioUsbAutoResume(struct AudioUsbDriver * audioUsbDriver)220 static int32_t AudioUsbAutoResume(struct AudioUsbDriver *audioUsbDriver)
221 {
222 int32_t err;
223
224 if (atomic_read(&audioUsbDriver->shutdown) != 0) {
225 AUDIO_DRIVER_LOG_ERR("atomic_read fail");
226 return HDF_FAILURE;
227 }
228
229 if (atomic_inc_return(&audioUsbDriver->active) != 1) {
230 AUDIO_DRIVER_LOG_DEBUG("atomic_inc_return success");
231 return HDF_SUCCESS;
232 }
233
234 err = usb_autopm_get_interface(audioUsbDriver->usbIf);
235 if (err < HDF_SUCCESS) {
236 /* rollback */
237 usb_autopm_put_interface(audioUsbDriver->usbIf);
238 atomic_dec(&audioUsbDriver->active);
239 AUDIO_DRIVER_LOG_ERR("usb_autopm_get_interface fail");
240 return err;
241 }
242
243 return HDF_SUCCESS;
244 }
245
246 /* lock the shutdown (disconnect) task and autoresume */
AudioUsbLockShutdown(struct AudioUsbDriver * audioUsbDriver)247 static int32_t AudioUsbLockShutdown(struct AudioUsbDriver *audioUsbDriver)
248 {
249 int32_t err;
250
251 atomic_inc(&audioUsbDriver->usageCount);
252 if (atomic_read(&audioUsbDriver->shutdown) != 0) {
253 if (atomic_dec_and_test(&audioUsbDriver->usageCount) != 0) {
254 AUDIO_DRIVER_LOG_ERR("atomic_dec_and_test fail");
255 wake_up(&audioUsbDriver->shutdownWait);
256 }
257 AUDIO_DRIVER_LOG_ERR("atomic_read fail");
258 return HDF_FAILURE;
259 }
260
261 err = AudioUsbAutoResume(audioUsbDriver);
262 if (err < HDF_SUCCESS) {
263 if (atomic_dec_and_test(&audioUsbDriver->usageCount) != 0) {
264 AUDIO_DRIVER_LOG_ERR("atomic_dec_and_test fail");
265 wake_up(&audioUsbDriver->shutdownWait);
266 }
267 return err;
268 }
269 return HDF_SUCCESS;
270 }
271
AudioUsbAutoSuspend(struct AudioUsbDriver * audioUsbDriver)272 static void AudioUsbAutoSuspend(struct AudioUsbDriver *audioUsbDriver)
273 {
274 if (atomic_read(&audioUsbDriver->shutdown) != 0) {
275 AUDIO_DRIVER_LOG_ERR("The USB audio card has been shut down");
276 return;
277 }
278
279 if (atomic_dec_and_test(&audioUsbDriver->active) == 0) {
280 AUDIO_DRIVER_LOG_WARNING("The USB audio card is not active");
281 return;
282 }
283
284 usb_autopm_put_interface(audioUsbDriver->usbIf);
285 }
286
287 /* autosuspend and unlock the shutdown */
AudioUsbUnlockShutdown(struct AudioUsbDriver * audioUsbDriver)288 static void AudioUsbUnlockShutdown(struct AudioUsbDriver *audioUsbDriver)
289 {
290 AudioUsbAutoSuspend(audioUsbDriver);
291 if (atomic_dec_and_test(&audioUsbDriver->usageCount) != 0) {
292 wake_up(&audioUsbDriver->shutdownWait);
293 }
294 }
295
AudioUsbFindMap(const struct UsbMixerNameMap * usbMixerNameMap,int32_t unitId,int32_t control)296 static const struct UsbMixerNameMap *AudioUsbFindMap(
297 const struct UsbMixerNameMap *usbMixerNameMap, int32_t unitId, int32_t control)
298 {
299 for (; usbMixerNameMap != NULL && usbMixerNameMap->id != 0; usbMixerNameMap++) {
300 if (usbMixerNameMap->id == unitId &&
301 (control == 0 || usbMixerNameMap->control == 0 || control == usbMixerNameMap->control)) {
302 return usbMixerNameMap;
303 }
304 }
305
306 AUDIO_DRIVER_LOG_WARNING("usbMixerNameMap error");
307 return NULL;
308 }
309
310 /* get the mapped name if the unit matches */
AudioUsbCheckMappedName(const struct UsbMixerNameMap * usbMixerNameMap,char * buf,int32_t bufLen)311 static int32_t AudioUsbCheckMappedName(const struct UsbMixerNameMap *usbMixerNameMap, char *buf, int32_t bufLen)
312 {
313 if (usbMixerNameMap == NULL || usbMixerNameMap->name == NULL) {
314 return 0; /* 0 for usbMixerNameMap name lenght */
315 }
316
317 bufLen--;
318 return strlcpy(buf, usbMixerNameMap->name, bufLen);
319 }
320
321 /* ignore the error value if ignoreCtlError flag is set */
AudioUsbFilterError(struct UsbMixerElemInfo * mixElemInfo,int32_t err)322 static inline int32_t AudioUsbFilterError(struct UsbMixerElemInfo *mixElemInfo, int32_t err)
323 {
324 if (mixElemInfo == NULL || mixElemInfo->head.mixer == NULL) {
325 AUDIO_DRIVER_LOG_ERR("param is null");
326 return HDF_ERR_INVALID_PARAM;
327 }
328
329 return (mixElemInfo->head.mixer->ignoreCtlError != 0) ? 0 : err;
330 }
331
332 /* get the mapped selector source name */
AudioUsbCheckMappedSelectorName(struct UsbMixerBuild * state,int32_t unitId,int32_t index,char * buf,int32_t bufLen)333 static int32_t AudioUsbCheckMappedSelectorName(
334 struct UsbMixerBuild *state, int32_t unitId, int32_t index, char *buf, int32_t bufLen)
335 {
336 const struct UsbMixerSelectorMap *usbMixerSelectorMap = NULL;
337 (void)bufLen;
338
339 if (state == NULL || state->selectorMap == NULL || buf == NULL) {
340 AUDIO_DRIVER_LOG_ERR("param is null");
341 return HDF_FAILURE;
342 }
343
344 for (usbMixerSelectorMap = state->selectorMap; usbMixerSelectorMap != NULL && usbMixerSelectorMap->id != 0;
345 usbMixerSelectorMap++) {
346 if (usbMixerSelectorMap->id == unitId && index < usbMixerSelectorMap->count) {
347 return strlcpy(buf, usbMixerSelectorMap->names[index], bufLen);
348 }
349 }
350
351 return HDF_FAILURE;
352 }
353
354 /* find an audio control unit with the given unit id */
AudioUsbFindAudioControlUnit(struct UsbMixerBuild * state,unsigned char unit)355 static void *AudioUsbFindAudioControlUnit(struct UsbMixerBuild *state, unsigned char unit)
356 {
357 /* we just parse the header */
358 struct uac_feature_unit_descriptor *featureUnitDesc = NULL;
359 bool lenth = false;
360 bool subtypeInput = false;
361 bool subtypeRate = false;
362 bool unitId = false;
363
364 featureUnitDesc = AudioUsbFindDesc(state->buffer, state->bufLen, featureUnitDesc, USB_DT_CS_INTERFACE);
365
366 while (featureUnitDesc != NULL) {
367 lenth = featureUnitDesc->bLength >= HDR_BLENGTH_MAX;
368 subtypeInput = featureUnitDesc->bDescriptorSubtype >= UAC_INPUT_TERMINAL;
369 subtypeRate = featureUnitDesc->bDescriptorSubtype <= UAC3_SAMPLE_RATE_CONVERTER;
370 unitId = featureUnitDesc->bUnitID == unit;
371 if (lenth && subtypeInput && subtypeRate && unitId) {
372 return featureUnitDesc;
373 }
374 featureUnitDesc = AudioUsbFindDesc(state->buffer, state->bufLen, featureUnitDesc, USB_DT_CS_INTERFACE);
375 }
376
377 AUDIO_DRIVER_LOG_ERR("featureUnitDesc is null");
378 return NULL;
379 }
380
381 /* copy a string with the given id */
AudioUsbCopyStringDesc(struct AudioUsbDriver * audioUsbDriver,int32_t index,char * buf,int32_t maxLen)382 static uint32_t AudioUsbCopyStringDesc(struct AudioUsbDriver *audioUsbDriver, int32_t index, char *buf, int32_t maxLen)
383 {
384 int32_t len = usb_string(audioUsbDriver->dev, index, buf, maxLen - 1);
385 if (len < 0) {
386 AUDIO_DRIVER_LOG_ERR("len error, len = %d", len);
387 return 0; /* if usb_string error, default len is 0 */
388 }
389
390 buf[len] = 0;
391 return len;
392 }
393
394 /* convert from the byte/word on usb descriptor to the zero-based integer */
AudioUsbConvertSignedValue(struct UsbMixerElemInfo * mixElemInfo,int32_t value)395 static int32_t AudioUsbConvertSignedValue(struct UsbMixerElemInfo *mixElemInfo, int32_t value)
396 {
397 switch (mixElemInfo->valType) {
398 case USB_MIXER_BOOLEAN:
399 value = value != 0 ? 1 : 0; /* 1 is reached; 0 is not reached */
400 break;
401 case USB_MIXER_INV_BOOLEAN:
402 value = value != 0 ? 0 : 1; /* 1 is reached; 0 is not reached */
403 break;
404 case USB_MIXER_S8:
405 value &= ZERO_BASED_INTEGER;
406 if (value >= S8_CAMPARE_VAL) {
407 value = value - S8_MAX_VAL;
408 }
409 break;
410 case USB_MIXER_U8:
411 value = value & ZERO_BASED_INTEGER;
412 break;
413 case USB_MIXER_S16:
414 value = value & 0xffff;
415 if (value >= S16_CAMPARE_VAL) {
416 value = value - S16_MAX_VAL;
417 }
418 break;
419 case USB_MIXER_U16:
420 value = value & 0xffff;
421 break;
422 default:
423 AUDIO_DRIVER_LOG_ERR("valType not reached");
424 }
425 return value;
426 }
427
428 /* convert from the zero-based int32_t to the byte/word for usb descriptor */
AudioUsbConvertBytesValue(struct UsbMixerElemInfo * mixElemInfo,int32_t value)429 static int32_t AudioUsbConvertBytesValue(struct UsbMixerElemInfo *mixElemInfo, int32_t value)
430 {
431 int32_t temp = 0;
432
433 switch (mixElemInfo->valType) {
434 case USB_MIXER_BOOLEAN:
435 temp = value != 0 ? 1 : 0; /* 1 is reached; 0 is not reached */
436 break;
437 case USB_MIXER_INV_BOOLEAN:
438 temp = value != 0 ? 0 : 1; /* 1 is reached; 0 is not reached */
439 break;
440 case USB_MIXER_S16:
441 case USB_MIXER_U16:
442 temp = value & 0xffff;
443 break;
444 case USB_MIXER_S8:
445 case USB_MIXER_U8:
446 temp = value & ZERO_BASED_INTEGER;
447 break;
448 default:
449 AUDIO_DRIVER_LOG_ERR("valType not reached");
450 temp = 0; /* 1 is reached; 0 is not reached */
451 break;
452 }
453 return temp;
454 }
455
AudioUsbGetRelativeValue(struct UsbMixerElemInfo * mixElemInfo,int32_t value)456 static int32_t AudioUsbGetRelativeValue(struct UsbMixerElemInfo *mixElemInfo, int32_t value)
457 {
458 if (mixElemInfo->res == 0) { /* 0 is volume reset off */
459 mixElemInfo->res = 1; /* 1 is volume reset on */
460 }
461
462 if (value < mixElemInfo->min) {
463 return 0; /* if value error, return default value 0 */
464 }
465 if (value >= mixElemInfo->max) {
466 return (mixElemInfo->max - mixElemInfo->min + mixElemInfo->res - 1) / mixElemInfo->res;
467 }
468
469 return (value - mixElemInfo->min) / mixElemInfo->res;
470 }
471
AudioUsbGetAbsValue(struct UsbMixerElemInfo * mixElemInfo,int32_t value)472 static int32_t AudioUsbGetAbsValue(struct UsbMixerElemInfo *mixElemInfo, int32_t value)
473 {
474 if (value < 0) {
475 return mixElemInfo->min;
476 }
477 if (mixElemInfo->res == 0) {
478 mixElemInfo->res = 1;
479 }
480 value *= mixElemInfo->res;
481 value += mixElemInfo->min;
482 if (value > mixElemInfo->max) {
483 return mixElemInfo->max;
484 }
485 return value;
486 }
487
AudioUsbCtlValueSize(int32_t valType)488 static int32_t AudioUsbCtlValueSize(int32_t valType)
489 {
490 switch (valType) {
491 case USB_MIXER_S32:
492 case USB_MIXER_U32:
493 return USB_MIXER_S16;
494 case USB_MIXER_S16:
495 case USB_MIXER_U16:
496 return USB_MIXER_S8;
497 default:
498 AUDIO_DRIVER_LOG_ERR("not find usb mixer type %d", valType);
499 return USB_MIXER_INV_BOOLEAN;
500 }
501 }
502
503 /* retrieve a mixer value */
AudioUsbMixerCtrlIntf(struct UsbMixerInterface * mixer)504 static inline int32_t AudioUsbMixerCtrlIntf(struct UsbMixerInterface *mixer)
505 {
506 struct usb_interface_descriptor *inteDesc = NULL;
507
508 inteDesc = AudioUsbGetIfaceDesc(mixer->hostIf);
509 if (inteDesc == NULL) {
510 AUDIO_DRIVER_LOG_ERR("inteDesc is null");
511 return HDF_FAILURE;
512 }
513 return inteDesc->bInterfaceNumber;
514 }
515
AudioUsbGetCtlValueV1(struct UsbMixerElemInfo * mixElemInfo,int32_t request,int32_t valIdx,int32_t * value)516 static int32_t AudioUsbGetCtlValueV1(
517 struct UsbMixerElemInfo *mixElemInfo, int32_t request, int32_t valIdx, int32_t *value)
518 {
519 struct AudioUsbDriver *audioUsbDriver = mixElemInfo->head.mixer->audioUsbDriver;
520 uint8_t buf[USB_VAL_LEN_2] = {0};
521 int32_t valLen = mixElemInfo->valType >= USB_MIXER_S16 ? USB_VAL_LEN_2 : USB_VAL_LEN_1;
522 int32_t timeout = USB_TIMEOUT;
523 int32_t idx = 0;
524 int32_t err;
525 struct AudioUsbCtlMsgParam usbCtlMsgParam;
526
527 err = AudioUsbLockShutdown(audioUsbDriver);
528 if (err < HDF_SUCCESS) {
529 return HDF_ERR_IO;
530 }
531
532 while (timeout-- > 0) {
533 idx = AudioUsbMixerCtrlIntf(mixElemInfo->head.mixer) | (mixElemInfo->head.id << USB_SHIFT_SIZE_8);
534 usbCtlMsgParam.pipe = usb_rcvctrlpipe(audioUsbDriver->dev, 0);
535 usbCtlMsgParam.request = request;
536 usbCtlMsgParam.requestType = USB_RECIP_INTERFACE | USB_TYPE_CLASS | USB_DIR_IN;
537 usbCtlMsgParam.value = valIdx;
538 usbCtlMsgParam.index = idx;
539
540 err = AudioUsbCtlMsg(audioUsbDriver->dev, &usbCtlMsgParam, buf, valLen);
541 if (err >= valLen) {
542 *value = AudioUsbConvertSignedValue(mixElemInfo, AudioUsbCombineBytes(buf, valLen));
543 err = 0;
544 AudioUsbUnlockShutdown(audioUsbDriver);
545 return err;
546 } else if (err == -ETIMEDOUT) {
547 AudioUsbUnlockShutdown(audioUsbDriver);
548 return err;
549 }
550 }
551 AUDIO_DRIVER_LOG_ERR("cannot get ctl value: req = %#x, wValue = %#x, wIndex = %#x, type = %d\n", request, valIdx,
552 idx, mixElemInfo->valType);
553 err = -EINVAL;
554 AudioUsbUnlockShutdown(audioUsbDriver);
555 return err;
556 }
557
AudioUsbGetCtlValueV2(struct UsbMixerElemInfo * mixElemInfo,int32_t request,int32_t valIdx,int32_t * value)558 static int32_t AudioUsbGetCtlValueV2(
559 struct UsbMixerElemInfo *mixElemInfo, int32_t request, int32_t valIdx, int32_t *value)
560 {
561 struct AudioUsbDriver *audioUsbDriver = mixElemInfo->head.mixer->audioUsbDriver;
562 /* enough space for one range */
563 uint8_t buf[sizeof(uint16_t) + USB_VAL_LEN_3 * sizeof(uint32_t)];
564 uint8_t *valTemp = NULL;
565 int32_t ret, valSize, size, shift;
566 struct AudioUsbCtlMsgParam usbCtlMsgParam;
567
568 valSize = AudioUsbCtlValueSize(mixElemInfo->valType);
569 if (request == UAC_GET_CUR) {
570 usbCtlMsgParam.request = UAC2_CS_CUR;
571 size = valSize;
572 } else {
573 usbCtlMsgParam.request = UAC2_CS_RANGE;
574 size = sizeof(uint16_t) + USB_VAL_LEN_3 * valSize;
575 }
576
577 AudioUsbLockShutdown(audioUsbDriver);
578 usbCtlMsgParam.index = AudioUsbMixerCtrlIntf(mixElemInfo->head.mixer) | (mixElemInfo->head.id << USB_SHIFT_SIZE_8);
579 usbCtlMsgParam.pipe = usb_rcvctrlpipe(audioUsbDriver->dev, 0);
580 usbCtlMsgParam.requestType = USB_RECIP_INTERFACE | USB_TYPE_CLASS | USB_DIR_IN;
581 usbCtlMsgParam.value = valIdx;
582
583 (void)memset_s(buf, sizeof(buf), 0, sizeof(buf));
584 ret = AudioUsbCtlMsg(audioUsbDriver->dev, &usbCtlMsgParam, buf, size);
585 AudioUsbUnlockShutdown(audioUsbDriver);
586
587 if (ret < HDF_SUCCESS) {
588 AUDIO_DRIVER_LOG_ERR("cannot get ctl type = %d\n", mixElemInfo->valType);
589 return ret;
590 }
591
592 switch (request) {
593 case UAC_GET_CUR:
594 valTemp = buf;
595 break;
596 case UAC_GET_RES:
597 shift = sizeof(uint16_t) + valSize * USB_VAL_LEN_2;
598 valTemp = buf + shift;
599 break;
600 case UAC_GET_MIN:
601 shift = sizeof(uint16_t);
602 valTemp = buf + shift;
603 break;
604 case UAC_GET_MAX:
605 shift = sizeof(uint16_t) + valSize;
606 valTemp = buf + shift;
607 break;
608 default:
609 return HDF_ERR_INVALID_PARAM;
610 }
611
612 *value = AudioUsbConvertSignedValue(mixElemInfo, AudioUsbCombineBytes(valTemp, valSize));
613
614 return HDF_SUCCESS;
615 }
616
AudioUsbGetCtlValue(struct UsbMixerElemInfo * mixElemInfo,int32_t request,int32_t valIdx,int32_t * value)617 static int32_t AudioUsbGetCtlValue(
618 struct UsbMixerElemInfo *mixElemInfo, int32_t request, int32_t valIdx, int32_t *value)
619 {
620 valIdx += mixElemInfo->idxOff;
621
622 if (mixElemInfo->head.mixer->protocol == UAC_VERSION_1) {
623 return AudioUsbGetCtlValueV1(mixElemInfo, request, valIdx, value);
624 } else {
625 return AudioUsbGetCtlValueV2(mixElemInfo, request, valIdx, value);
626 }
627 }
628
AudioUsbGetCurCtlValue(struct UsbMixerElemInfo * mixElemInfo,int32_t valIdx,int32_t * value)629 static int32_t AudioUsbGetCurCtlValue(struct UsbMixerElemInfo *mixElemInfo, int32_t valIdx, int32_t *value)
630 {
631 return AudioUsbGetCtlValue(mixElemInfo, UAC_GET_CUR, valIdx, value);
632 }
633
AudioUsbGetCurMixRaw(struct UsbMixerElemInfo * mixElemInfo,int32_t channel,int32_t * value)634 static inline int32_t AudioUsbGetCurMixRaw(struct UsbMixerElemInfo *mixElemInfo, int32_t channel, int32_t *value)
635 {
636 return AudioUsbGetCtlValue(mixElemInfo, UAC_GET_CUR, (mixElemInfo->control << USB_SHIFT_SIZE_8) | channel, value);
637 }
638
AudioUsbGetCurMixValue(struct UsbMixerElemInfo * mixElemInfo,int32_t channel,int32_t index,int32_t * value)639 int32_t AudioUsbGetCurMixValue(struct UsbMixerElemInfo *mixElemInfo, int32_t channel, int32_t index, int32_t *value)
640 {
641 if (mixElemInfo->cached & (1 << channel)) {
642 *value = mixElemInfo->cacheVal[index];
643 return HDF_SUCCESS;
644 }
645
646 if (index >= MAX_CHANNELS) {
647 AUDIO_DRIVER_LOG_ERR("index is invalid");
648 return HDF_FAILURE;
649 }
650
651 if (AudioUsbGetCurMixRaw(mixElemInfo, channel, value) < HDF_SUCCESS) {
652 return HDF_FAILURE;
653 }
654
655 mixElemInfo->cached |= 1 << channel; // channel mask
656 mixElemInfo->cacheVal[index] = *value;
657 return HDF_SUCCESS;
658 }
659
660 /* set a mixer value */
AudioUsbMixerSetCtlValue(struct UsbMixerElemInfo * mixElemInfo,int32_t request,int32_t valIdx,int32_t valueSet)661 int32_t AudioUsbMixerSetCtlValue(
662 struct UsbMixerElemInfo *mixElemInfo, int32_t request, int32_t valIdx, int32_t valueSet)
663 {
664 struct AudioUsbDriver *audioUsbDriver = mixElemInfo->head.mixer->audioUsbDriver;
665 uint8_t buf[USB_VAL_LEN_4] = {0};
666 int32_t valLen, err;
667 int32_t timeout = USB_TIMEOUT;
668 struct AudioUsbCtlMsgParam usbCtlMsgParam;
669
670 valIdx += mixElemInfo->idxOff;
671
672 if (mixElemInfo->head.mixer->protocol == UAC_VERSION_1) {
673 valLen = mixElemInfo->valType >= USB_MIXER_S16 ? USB_VAL_LEN_2 : USB_VAL_LEN_1;
674 } else { /* UAC_VERSION_2/3 */
675 valLen = AudioUsbCtlValueSize(mixElemInfo->valType);
676 if (request != UAC_SET_CUR) {
677 AUDIO_DEVICE_LOG_INFO("RANGE setting not yet supported\n");
678 return -EINVAL;
679 }
680 request = UAC2_CS_CUR;
681 }
682
683 valueSet = AudioUsbConvertBytesValue(mixElemInfo, valueSet);
684 buf[ARRAY_INDEX_0] = valueSet & ZERO_BASED_INTEGER;
685 buf[ARRAY_INDEX_1] = (valueSet >> USB_SHIFT_SIZE_8) & ZERO_BASED_INTEGER;
686 buf[ARRAY_INDEX_2] = (valueSet >> USB_SHIFT_SIZE_16) & ZERO_BASED_INTEGER;
687 buf[ARRAY_INDEX_3] = (valueSet >> USB_SHIFT_SIZE_24) & ZERO_BASED_INTEGER;
688
689 err = AudioUsbLockShutdown(audioUsbDriver);
690 if (err < HDF_SUCCESS) {
691 AUDIO_DEVICE_LOG_INFO("AudioUsbLockShutdown failed\n");
692 return HDF_ERR_IO;
693 }
694 while (timeout-- > 0) {
695 usbCtlMsgParam.index =
696 AudioUsbMixerCtrlIntf(mixElemInfo->head.mixer) | (mixElemInfo->head.id << USB_SHIFT_SIZE_8);
697
698 usbCtlMsgParam.pipe = usb_sndctrlpipe(audioUsbDriver->dev, 0);
699 usbCtlMsgParam.request = request;
700 usbCtlMsgParam.requestType = USB_RECIP_INTERFACE | USB_TYPE_CLASS | USB_DIR_OUT;
701 usbCtlMsgParam.value = valIdx;
702
703 err = AudioUsbCtlMsg(audioUsbDriver->dev, &usbCtlMsgParam, buf, valLen);
704 if (err >= HDF_SUCCESS) {
705 AudioUsbUnlockShutdown(audioUsbDriver);
706 return HDF_SUCCESS;
707 } else if (err == -ETIMEDOUT) {
708 AudioUsbUnlockShutdown(audioUsbDriver);
709 return err;
710 }
711 }
712 AudioUsbUnlockShutdown(audioUsbDriver);
713 return HDF_ERR_INVALID_PARAM;
714 }
715
AudioUsbSetCurCtlValue(struct UsbMixerElemInfo * mixElemInfo,int32_t valIdx,int32_t value)716 static int32_t AudioUsbSetCurCtlValue(struct UsbMixerElemInfo *mixElemInfo, int32_t valIdx, int32_t value)
717 {
718 return AudioUsbMixerSetCtlValue(mixElemInfo, UAC_SET_CUR, valIdx, value);
719 }
720
AudioUsbSetCurMixValue(struct UsbMixerElemInfo * mixElemInfo,int32_t channel,int32_t index,int32_t value)721 int32_t AudioUsbSetCurMixValue(struct UsbMixerElemInfo *mixElemInfo, int32_t channel, int32_t index, int32_t value)
722 {
723 uint32_t readOnly;
724
725 if (channel < 0) {
726 AUDIO_DEVICE_LOG_ERR("error channel value = %d", channel);
727 return HDF_ERR_INVALID_PARAM;
728 }
729 readOnly = channel == 0 ? mixElemInfo->masterReadOnly : mixElemInfo->chReadOnly & (1 << (channel - 1));
730 if (readOnly != 0) {
731 AUDIO_DEVICE_LOG_DEBUG("%s(): channel %d of control %d is readOnly\n", __func__, channel, mixElemInfo->control);
732 return HDF_SUCCESS;
733 }
734
735 if (AudioUsbMixerSetCtlValue(
736 mixElemInfo, UAC_SET_CUR, (mixElemInfo->control << USB_SHIFT_SIZE_8) | channel, value) < HDF_SUCCESS) {
737 return HDF_FAILURE;
738 }
739
740 mixElemInfo->cached |= 1 << channel;
741 mixElemInfo->cacheVal[index] = value;
742 return HDF_SUCCESS;
743 }
744
745 static int32_t AudioUsbParseUnit(struct UsbMixerBuild *state, int32_t unitId);
746
AudioUsbCheckMatrixBitmap(const uint8_t * bmap,int32_t itemChannels,int32_t outChannel,int32_t numOuts)747 static int32_t AudioUsbCheckMatrixBitmap(const uint8_t *bmap, int32_t itemChannels,
748 int32_t outChannel, int32_t numOuts)
749 {
750 int32_t idx = itemChannels * numOuts + outChannel;
751 int32_t bit = idx >> USB_SHIFT_SIZE_3;
752 int32_t map = idx & CHANNEL_HDR_BLENGTH;
753 return bmap[bit] & (S8_CAMPARE_VAL >> map);
754 }
755
AudioUsbGetTermNameSub(struct UsbAudioTerm * usbAudioTerm,uint8_t * name,uint32_t len)756 static int32_t AudioUsbGetTermNameSub(struct UsbAudioTerm *usbAudioTerm, uint8_t *name, uint32_t len)
757 {
758 char *itemName = "Main";
759
760 switch (usbAudioTerm->type) {
761 case 0x0300 ... 0x0307: /* Output, Speaker, Headphone, HMD Audio, Desktop Speaker, Room Speaker, Com Speaker,
762 LFE */
763 case 0x0600 ... 0x0607: /* External In, Analog In, Digital In, Line, Legacy In, IEC958 In, 1394 DA Stream, 1394
764 DV Stream */
765 case 0x0700 ... 0x0713: /* Embedded, Noise Source, Equalization Noise, CD, DAT, DCC, MiniDisk, Analog Tape,
766 Phonograph, VCR Audio, Video Disk Audio, DVD Audio, TV Tuner Audio, Satellite Rec
767 Audio, Cable Tuner Audio, DSS Audio, Radio Receiver, Radio Transmitter, Multi-Track
768 Recorder, Synthesizer */
769 (void)strcpy_s(name, len, itemName);
770 return strlen(itemName);
771 default:
772 return 0; /* item name lenth */
773 }
774 }
775
AudioUsbGetTermName(struct AudioUsbDriver * audioUsbDriver,struct UsbAudioTerm * usbAudioTerm,uint8_t * name,int32_t maxLen,int32_t termOnly)776 static int32_t AudioUsbGetTermName(struct AudioUsbDriver *audioUsbDriver, struct UsbAudioTerm *usbAudioTerm,
777 uint8_t *name, int32_t maxLen, int32_t termOnly)
778 {
779 int32_t len;
780
781 if (usbAudioTerm->name) {
782 len = AudioUsbCopyStringDesc(audioUsbDriver, usbAudioTerm->name, name, maxLen);
783 if (len != 0) {
784 return len;
785 }
786 }
787
788 /* virtual type - not a real terminal */
789 if ((usbAudioTerm->type >> USB_SHIFT_SIZE_16) != 0) {
790 if (termOnly != 0) {
791 return 0; // name length
792 }
793 switch (usbAudioTerm->type >> USB_SHIFT_SIZE_16) {
794 case UAC3_SELECTOR_UNIT:
795 (void)strcpy_s(name, KCTL_NAME_LEN, "Selector");
796 return strlen("Selector");
797 case UAC3_PROCESSING_UNIT:
798 (void)strcpy_s(name, KCTL_NAME_LEN, "Process Unit");
799 return strlen("Process Unit");
800 case UAC3_EXTENSION_UNIT:
801 (void)strcpy_s(name, KCTL_NAME_LEN, "Ext Unit");
802 return strlen("Ext Unit");
803 case UAC3_MIXER_UNIT:
804 (void)strcpy_s(name, KCTL_NAME_LEN, "Mixer");
805 return strlen("Mixer");
806 default:
807 return sprintf_s(name, KCTL_NAME_LEN, "Unit %d", usbAudioTerm->id);
808 }
809 }
810
811 switch (usbAudioTerm->type & 0xff00) {
812 case CTRL_MIXER_BMA_MAIN:
813 (void)strcpy_s(name, KCTL_NAME_LEN, "Main");
814 return strlen("Main");
815 case CTRL_MIXER_BMA_MIC:
816 (void)strcpy_s(name, KCTL_NAME_LEN, "Mic");
817 return strlen("Mic");
818 case CTRL_MIXER_BMA_HEADSET:
819 (void)strcpy_s(name, KCTL_NAME_LEN, "Main");
820 return strlen("Main");
821 case CTRL_MIXER_BMA_PHONE:
822 (void)strcpy_s(name, KCTL_NAME_LEN, "Phone");
823 return strlen("Phone");
824 default:
825 break;
826 }
827
828 return AudioUsbGetTermNameSub(usbAudioTerm, name, KCTL_NAME_LEN);
829 }
830
AudioUsbCtrlIntf(struct AudioUsbDriver * audioUsbDriver)831 static inline int32_t AudioUsbCtrlIntf(struct AudioUsbDriver *audioUsbDriver)
832 {
833 struct usb_interface_descriptor *inteDesc = NULL;
834
835 inteDesc = AudioUsbGetIfaceDesc(audioUsbDriver->ctrlIntf);
836
837 return inteDesc->bInterfaceNumber;
838 }
839
840 /* Get logical cluster information for UAC3 devices */
AudioUsbGetClusterChannelsV3(struct UsbMixerBuild * state,uint32_t clusterId)841 static int32_t AudioUsbGetClusterChannelsV3(struct UsbMixerBuild *state, uint32_t clusterId)
842 {
843 int32_t err;
844 struct uac3_cluster_header_descriptor uacHeader;
845
846 struct AudioUsbCtlMsgParam usbCtlMsgParam;
847
848 usbCtlMsgParam.pipe = usb_rcvctrlpipe(state->audioUsbDriver->dev, 0);
849 usbCtlMsgParam.request = UAC3_CS_REQ_HIGH_CAPABILITY_DESCRIPTOR;
850 usbCtlMsgParam.requestType = USB_RECIP_INTERFACE | USB_TYPE_CLASS | USB_DIR_IN;
851 usbCtlMsgParam.value = clusterId;
852 usbCtlMsgParam.index = AudioUsbCtrlIntf(state->audioUsbDriver);
853
854 err = AudioUsbCtlMsg(state->audioUsbDriver->dev, &usbCtlMsgParam, &uacHeader, sizeof(uacHeader));
855 if (err < 0) {
856 AUDIO_DRIVER_LOG_ERR("cannot request logical cluster ID: %d (err: %d)\n", clusterId, err);
857 return err;
858 }
859 if (err != sizeof(uacHeader)) {
860 err = -EIO;
861 AUDIO_DRIVER_LOG_ERR("cannot request logical cluster ID: %d (err: %d)\n", clusterId, err);
862 return err;
863 }
864
865 return uacHeader.bNrChannels;
866 }
867
868 /* Get number of channels for a Mixer Unit */
AudioUsbMixerUnitGetChannels(struct UsbMixerBuild * state,struct uac_mixer_unit_descriptor * desc)869 static int32_t AudioUsbMixerUnitGetChannels(struct UsbMixerBuild *state, struct uac_mixer_unit_descriptor *desc)
870 {
871 int32_t muChannels;
872 uint32_t temp;
873
874 if (state->mixer->protocol == UAC_VERSION_3) {
875 muChannels = AudioUsbGetClusterChannelsV3(state, uac3_mixer_unit_wClusterDescrID(desc));
876 } else {
877 temp = sizeof(*desc) + desc->bNrInPins + 1;
878 if (desc->bLength < temp) {
879 return 0; // channel number
880 }
881 muChannels = uac_mixer_unit_bNrChannels(desc);
882 }
883 return muChannels;
884 }
885
886 /* Parse Input Terminal Unit */
887 static int32_t AudioUsbCheckInputTermSub(struct UsbMixerBuild *state, int32_t id, struct UsbAudioTerm *term);
888
AudioUsbParseTermUac1ItermUnit(struct UsbMixerBuild * state,struct UsbAudioTerm * term,void * unitDesc,int32_t id)889 static int32_t AudioUsbParseTermUac1ItermUnit(
890 struct UsbMixerBuild *state, struct UsbAudioTerm *term, void *unitDesc, int32_t id)
891 {
892 struct uac_input_terminal_descriptor *inptTermDesc = unitDesc;
893
894 term->type = le16_to_cpu(inptTermDesc->wTerminalType);
895 term->channels = inptTermDesc->bNrChannels;
896 term->chconfig = le16_to_cpu(inptTermDesc->wChannelConfig);
897 term->name = inptTermDesc->iTerminal;
898 return HDF_SUCCESS;
899 }
900
AudioUsbParseTermMixerUnit(struct UsbMixerBuild * state,struct UsbAudioTerm * term,void * unitDesc,int32_t id)901 static int32_t AudioUsbParseTermMixerUnit(
902 struct UsbMixerBuild *state, struct UsbAudioTerm *term, void *unitDesc, int32_t id)
903 {
904 struct uac_mixer_unit_descriptor *mixUnitDesc = unitDesc;
905 int32_t protocol = state->mixer->protocol;
906 int32_t err;
907
908 err = AudioUsbMixerUnitGetChannels(state, mixUnitDesc);
909 if (err <= HDF_SUCCESS) {
910 return err;
911 }
912
913 term->type = UAC3_MIXER_UNIT << USB_SHIFT_SIZE_16; /* virtual type */
914 term->channels = err;
915 if (protocol != UAC_VERSION_3) {
916 term->chconfig = uac_mixer_unit_wChannelConfig(mixUnitDesc, protocol);
917 term->name = uac_mixer_unit_iMixer(mixUnitDesc);
918 }
919 return HDF_SUCCESS;
920 }
921
AudioUsbParseTermSelectorUnit(struct UsbMixerBuild * state,struct UsbAudioTerm * term,void * unitDesc,int32_t id)922 static int32_t AudioUsbParseTermSelectorUnit(
923 struct UsbMixerBuild *state, struct UsbAudioTerm *term, void *unitDesc, int32_t id)
924 {
925 struct uac_selector_unit_descriptor *selUnitDesc = unitDesc;
926 int32_t err;
927
928 /* call recursively to retrieve the channel info */
929 err = AudioUsbCheckInputTermSub(state, selUnitDesc->baSourceID[0], term);
930 if (err < HDF_SUCCESS)
931 return err;
932 term->type = UAC3_SELECTOR_UNIT << USB_SHIFT_SIZE_16; /* virtual type */
933 term->id = id;
934 if (state->mixer->protocol != UAC_VERSION_3)
935 term->name = uac_selector_unit_iSelector(selUnitDesc);
936 return HDF_SUCCESS;
937 }
938
AudioUsbParseTermProcUnit(struct UsbMixerBuild * state,struct UsbAudioTerm * term,void * unitDesc,int32_t id,int32_t uacProcessingUnit)939 static int32_t AudioUsbParseTermProcUnit(
940 struct UsbMixerBuild *state, struct UsbAudioTerm *term, void *unitDesc, int32_t id, int32_t uacProcessingUnit)
941 {
942 struct uac_processing_unit_descriptor *procUnitDesc = unitDesc;
943 int32_t protocol = state->mixer->protocol;
944 int32_t err;
945 AUDIO_DRIVER_LOG_DEBUG("entry");
946
947 if (procUnitDesc->bNrInPins) {
948 err = AudioUsbCheckInputTermSub(state, procUnitDesc->baSourceID[0], term);
949 if (err < HDF_SUCCESS) {
950 AUDIO_DRIVER_LOG_ERR("AudioUsbCheckInputTermSub if failed");
951 return err;
952 }
953 }
954
955 term->type = uacProcessingUnit << USB_SHIFT_SIZE_16;
956 term->id = id;
957
958 if (protocol == UAC_VERSION_3) {
959 AUDIO_DRIVER_LOG_INFO("UAC_VERSION_3 is not support");
960 return HDF_SUCCESS;
961 }
962 if (!term->channels) {
963 term->channels = uac_processing_unit_bNrChannels(procUnitDesc);
964 term->chconfig = uac_processing_unit_wChannelConfig(procUnitDesc, protocol);
965 }
966 term->name = uac_processing_unit_iProcessing(procUnitDesc, protocol);
967 return HDF_SUCCESS;
968 }
969
AudioUsbCheckInputTermSub(struct UsbMixerBuild * state,int32_t id,struct UsbAudioTerm * term)970 static int32_t AudioUsbCheckInputTermSub(struct UsbMixerBuild *state, int32_t id, struct UsbAudioTerm *term)
971 {
972 int32_t protocol = state->mixer->protocol;
973 void *hdrRet = NULL;
974 uint8_t *hdr = NULL;
975
976 for (;;) {
977 /* a loop in the terminal chain? */
978 if (test_and_set_bit(id, state->termBitMap)) {
979 AUDIO_DRIVER_LOG_ERR("test_and_set_bit failed");
980 return HDF_ERR_INVALID_PARAM;
981 }
982
983 hdrRet = AudioUsbFindAudioControlUnit(state, id);
984 if (hdrRet == NULL || !AudioUsbValidateAudioDesc(hdrRet, protocol)) {
985 break; /* bad descriptor */
986 }
987
988 hdr = hdrRet;
989 term->id = id;
990
991 // here use version and UAC interface descriptor subtypes to determine the parsing function.
992 switch (((protocol << USB_SHIFT_SIZE_8) | hdr[USB_VAL_LEN_2])) {
993 case 0x0006: // UAC_VERSION_1 << 8 | UAC_FEATURE_UNIT
994 case 0x2006: // UAC_VERSION_2 << 8 | UAC_FEATURE_UNIT
995 case 0x3007: // UAC_VERSION_3 << 8 | UAC3_FEATURE_UNIT
996 id = ((struct uac_feature_unit_descriptor *)hdrRet)->bSourceID;
997 break; /* continue to parse */
998 case 0x0002: // UAC_VERSION_1 << 8 | UAC_INPUT_TERMINAL
999 return AudioUsbParseTermUac1ItermUnit(state, term, hdrRet, id);
1000 case 0x0004: // UAC_VERSION_1 << 8 | UAC_MIXER_UNIT
1001 case 0x2004: // UAC_VERSION_2 << 8 | UAC_MIXER_UNIT
1002 case 0x3005: // UAC_VERSION_3 << 8 | UAC3_MIXER_UNIT
1003 return AudioUsbParseTermMixerUnit(state, term, hdrRet, id);
1004 case 0x0005: // UAC_VERSION_1 << 8 | UAC_SELECTOR_UNIT
1005 case 0x2005: // UAC_VERSION_2 << 8 | UAC_SELECTOR_UNIT
1006 case 0x200b: // UAC_VERSION_2 << 8 | UAC2_CLOCK_SELECTOR
1007 case 0x3006: // UAC_VERSION_3 << 8 | UAC3_SELECTOR_UNIT
1008 case 0x300c: // UAC_VERSION_3 << 8 | UAC3_CLOCK_SELECTOR
1009 return AudioUsbParseTermSelectorUnit(state, term, hdrRet, id);
1010 case 0x0007: // UAC_VERSION_1 << 8 | UAC1_PROCESSING_UNIT
1011 case 0x2008: // UAC_VERSION_2 << 8 | UAC2_PROCESSING_UNIT_V2
1012 case 0x3009: // UAC_VERSION_3 << 8 | UAC3_PROCESSING_UNIT
1013 return AudioUsbParseTermProcUnit(state, term, hdrRet, id, UAC3_PROCESSING_UNIT);
1014 case 0x0008: // UAC_VERSION_1 << 8 | UAC1_EXTENSION_UNIT
1015 case 0x2009: // UAC_VERSION_2 << 8 | UAC2_EXTENSION_UNIT_V2
1016 case 0x300a: // UAC_VERSION_3 << 8 | UAC3_EXTENSION_UNIT
1017 return AudioUsbParseTermProcUnit(state, term, hdrRet, id, UAC3_EXTENSION_UNIT);
1018 default:
1019 AUDIO_DRIVER_LOG_ERR("error UAC interface descriptor");
1020 return HDF_DEV_ERR_NO_DEVICE;
1021 }
1022 }
1023 AUDIO_DRIVER_LOG_ERR("error no device");
1024 return HDF_DEV_ERR_NO_DEVICE;
1025 }
1026
AudioUsbCheckInputTerm(struct UsbMixerBuild * state,int32_t id,struct UsbAudioTerm * term)1027 static int32_t AudioUsbCheckInputTerm(struct UsbMixerBuild *state, int32_t id, struct UsbAudioTerm *term)
1028 {
1029 (void)memset_s(term, sizeof(*term), 0, sizeof(*term));
1030 (void)memset_s(state->termBitMap, sizeof(state->termBitMap), 0, sizeof(state->termBitMap));
1031 return AudioUsbCheckInputTermSub(state, id, term);
1032 }
1033
1034 /* feature unit control information */
1035 struct AudioUsbFeatureControlInfo {
1036 int32_t control;
1037 const char *name;
1038 int32_t type; /* data type for uac1 */
1039 int32_t typeUac2; /* data type for uac2 if different from uac1, else -1 */
1040 };
1041
1042 static const struct AudioUsbFeatureControlInfo g_audioFeatureInfo[] = {
1043 {UAC_FU_MUTE, "Mute", USB_MIXER_INV_BOOLEAN, USB_MIX_TYPE_INVALID},
1044 {UAC_FU_VOLUME, "Volume", USB_MIXER_S16, USB_MIX_TYPE_INVALID},
1045 {UAC_FU_BASS, "Tone Control - Bass", USB_MIXER_S8, USB_MIX_TYPE_INVALID},
1046 {UAC_FU_MID, "Tone Control - Mid", USB_MIXER_S8, USB_MIX_TYPE_INVALID},
1047 {UAC_FU_TREBLE, "Tone Control - Treble", USB_MIXER_S8, USB_MIX_TYPE_INVALID},
1048 {UAC_FU_GRAPHIC_EQUALIZER, "Graphic Equalizer", USB_MIXER_S8, USB_MIX_TYPE_INVALID},
1049 {UAC_FU_AUTOMATIC_GAIN, "Auto Gain Control", USB_MIXER_BOOLEAN, USB_MIX_TYPE_INVALID},
1050 {UAC_FU_DELAY, "Delay Control", USB_MIXER_U16, USB_MIXER_U32 },
1051 {UAC_FU_BASS_BOOST, "Bass Boost", USB_MIXER_BOOLEAN, USB_MIX_TYPE_INVALID},
1052 {UAC_FU_LOUDNESS, "Loudness", USB_MIXER_BOOLEAN, USB_MIX_TYPE_INVALID},
1053 {UAC2_FU_INPUT_GAIN, "Input Gain Control", USB_MIXER_S16, USB_MIX_TYPE_INVALID},
1054 {UAC2_FU_INPUT_GAIN_PAD, "Input Gain Pad Control", USB_MIXER_S16, USB_MIX_TYPE_INVALID},
1055 {UAC2_FU_PHASE_INVERTER, "Phase Inverter Control", USB_MIXER_BOOLEAN, USB_MIX_TYPE_INVALID},
1056 };
1057
AudioUsbCtlGetMaxVal(struct UsbMixerElemInfo * mixElemInfo,int32_t minChannel)1058 static void AudioUsbCtlGetMaxVal(struct UsbMixerElemInfo *mixElemInfo, int32_t minChannel)
1059 {
1060 int32_t saved, temp, check;
1061
1062 if (AudioUsbGetCurMixRaw(mixElemInfo, minChannel, &saved) < 0) {
1063 mixElemInfo->initialized = 1; /* 1 is initialized on */
1064 return;
1065 }
1066 // No endless loop
1067 for (;;) {
1068 temp = saved;
1069 if (temp < mixElemInfo->max) {
1070 temp = temp + mixElemInfo->res;
1071 } else {
1072 temp = temp - mixElemInfo->res;
1073 }
1074
1075 if (temp < mixElemInfo->min || temp > mixElemInfo->max) {
1076 break;
1077 }
1078 if (AudioUsbSetCurMixValue(mixElemInfo, minChannel, 0, temp) != HDF_SUCCESS) {
1079 break;
1080 }
1081 if (AudioUsbGetCurMixRaw(mixElemInfo, minChannel, &check) != HDF_SUCCESS) {
1082 break;
1083 }
1084 if (temp == check) {
1085 break;
1086 }
1087 mixElemInfo->res *= VOLUME_RANGE;
1088 }
1089 (void)AudioUsbSetCurMixValue(mixElemInfo, minChannel, 0, saved);
1090 }
1091
AudioUsbCtlGetMinMaxValSub(struct UsbMixerElemInfo * mixElemInfo)1092 static int32_t AudioUsbCtlGetMinMaxValSub(struct UsbMixerElemInfo *mixElemInfo)
1093 {
1094 int32_t minChannel = 0;
1095 int32_t i;
1096 int32_t request = mixElemInfo->control << USB_SHIFT_SIZE_8;
1097 if (mixElemInfo->cmask) {
1098 for (i = 0; i < MAX_CHANNELS; i++) {
1099 if (mixElemInfo->cmask & (1 << i)) {
1100 minChannel = i + 1;
1101 break;
1102 }
1103 }
1104 }
1105 if (AudioUsbGetCtlValue(mixElemInfo, UAC_GET_MAX, request, &mixElemInfo->max) < HDF_SUCCESS ||
1106 AudioUsbGetCtlValue(mixElemInfo, UAC_GET_MIN, request, &mixElemInfo->min) < HDF_SUCCESS) {
1107 AUDIO_DRIVER_LOG_ERR("%d:%d: cannot get min/max values for control %d (id %d)\n", mixElemInfo->head.id,
1108 AudioUsbMixerCtrlIntf(mixElemInfo->head.mixer), mixElemInfo->control, mixElemInfo->head.id);
1109 return HDF_ERR_INVALID_PARAM;
1110 }
1111
1112 if (AudioUsbGetCtlValue(mixElemInfo, UAC_GET_RES, request, &mixElemInfo->res) < HDF_SUCCESS) {
1113 mixElemInfo->res = USB_MIXER_DEF_RES_VAL;
1114 } else {
1115 int32_t lastValidRes = mixElemInfo->res;
1116 while (mixElemInfo->res > USB_MIXER_DEF_RES_VAL) {
1117 if (AudioUsbMixerSetCtlValue(mixElemInfo, UAC_SET_RES, request, mixElemInfo->res / VOLUME_RANGE) <
1118 HDF_SUCCESS) {
1119 break;
1120 }
1121 mixElemInfo->res /= VOLUME_RANGE;
1122 }
1123 if (AudioUsbGetCtlValue(mixElemInfo, UAC_GET_RES, request, &mixElemInfo->res) < HDF_SUCCESS) {
1124 mixElemInfo->res = lastValidRes;
1125 }
1126 }
1127 if (mixElemInfo->res == 0) {
1128 mixElemInfo->res = USB_MIXER_DEF_RES_VAL;
1129 }
1130
1131 if (mixElemInfo->min + mixElemInfo->res < mixElemInfo->max) {
1132 AudioUsbCtlGetMaxVal(mixElemInfo, minChannel);
1133 }
1134
1135 return HDF_SUCCESS;
1136 }
1137
AudioUsbCtlGetMinMaxVal(struct UsbMixerElemInfo * mixElemInfo,int32_t default_min,struct AudioKcontrol * kcontrol)1138 static int32_t AudioUsbCtlGetMinMaxVal(
1139 struct UsbMixerElemInfo *mixElemInfo, int32_t default_min, struct AudioKcontrol *kcontrol)
1140 {
1141 /* for failsafe */
1142 mixElemInfo->min = default_min;
1143 mixElemInfo->max = mixElemInfo->min + 1;
1144 mixElemInfo->res = USB_MIXER_DEF_RES_VAL;
1145 mixElemInfo->dBMin = mixElemInfo->dBMax = 0;
1146
1147 if (mixElemInfo->valType == USB_MIXER_BOOLEAN || mixElemInfo->valType == USB_MIXER_INV_BOOLEAN) {
1148 mixElemInfo->initialized = 1;
1149 } else {
1150 AudioUsbCtlGetMinMaxValSub(mixElemInfo);
1151 }
1152
1153 mixElemInfo->dBMin = (AudioUsbConvertSignedValue(mixElemInfo, mixElemInfo->min) * USB_DESCRIPTIONS_CONTAIN_100DB) /
1154 USB_DESCRIPTIONS_CONTAIN_256DB;
1155 mixElemInfo->dBMax = (AudioUsbConvertSignedValue(mixElemInfo, mixElemInfo->max) * USB_DESCRIPTIONS_CONTAIN_100DB) /
1156 USB_DESCRIPTIONS_CONTAIN_256DB;
1157 if (mixElemInfo->dBMin > mixElemInfo->dBMax) {
1158 /* something is wrong; assume it's either from/to 0dB */
1159 if (mixElemInfo->dBMin < 0) {
1160 mixElemInfo->dBMax = 0;
1161 } else if (mixElemInfo->dBMin > 0) {
1162 mixElemInfo->dBMin = 0;
1163 }
1164 if (mixElemInfo->dBMin > mixElemInfo->dBMax) {
1165 /* totally crap, return an error */
1166 AUDIO_DRIVER_LOG_ERR("mixElemInfo is invalid.");
1167 OsalMemFree(mixElemInfo->privateData);
1168 OsalMemFree(mixElemInfo);
1169 return HDF_FAILURE;
1170 }
1171 } else {
1172 /* if the max volume is too low, it's likely a bogus range;
1173 * here we use -96dB as the threshold
1174 */
1175 if (mixElemInfo->dBMax <= -USB_DESCRIPTIONS_CONTAIN_9600DB) {
1176 AUDIO_DRIVER_LOG_INFO("%d:%d: bogus dB values (%d/%d), disabling dB reporting\n", mixElemInfo->head.id,
1177 AudioUsbMixerCtrlIntf(mixElemInfo->head.mixer), mixElemInfo->dBMin, mixElemInfo->dBMax);
1178 mixElemInfo->dBMin = mixElemInfo->dBMax = 0;
1179 }
1180 }
1181 return HDF_SUCCESS;
1182 }
1183
1184 /* get a feature/mixer unit info */
AudioUsbMixerCtlFeatureInfo(const struct AudioKcontrol * kcontrol,struct AudioCtrlElemInfo * ctrlElemInfo)1185 static int32_t AudioUsbMixerCtlFeatureInfo(const struct AudioKcontrol *kcontrol, struct AudioCtrlElemInfo *ctrlElemInfo)
1186 {
1187 struct UsbMixerElemInfo *mixElemInfo = (struct UsbMixerElemInfo *)((volatile uintptr_t)kcontrol->privateValue);
1188 AUDIO_DEVICE_LOG_INFO("entry.");
1189
1190 if (mixElemInfo->valType == USB_MIXER_BOOLEAN || mixElemInfo->valType == USB_MIXER_INV_BOOLEAN) {
1191 ctrlElemInfo->type = AUDIO_USB_CTL_ELEM_TYPE_BOOLEAN;
1192 } else {
1193 ctrlElemInfo->type = AUDIO_USB_CTL_ELEM_TYPE_INTEGER;
1194 }
1195 ctrlElemInfo->count = mixElemInfo->channels;
1196 if (mixElemInfo->valType == USB_MIXER_BOOLEAN || mixElemInfo->valType == USB_MIXER_INV_BOOLEAN) {
1197 ctrlElemInfo->min = 0;
1198 ctrlElemInfo->max = 1;
1199 } else {
1200 ctrlElemInfo->min = 0;
1201 ctrlElemInfo->max = (mixElemInfo->max - mixElemInfo->min + mixElemInfo->res - 1) / mixElemInfo->res;
1202 }
1203 return HDF_SUCCESS;
1204 }
1205
1206 /* get the current value from feature/mixer unit */
AudioUsbMixerCtlFeatureGet(const struct AudioKcontrol * kcontrol,struct AudioCtrlElemValue * ctrlElemValue)1207 static int32_t AudioUsbMixerCtlFeatureGet(
1208 const struct AudioKcontrol *kcontrol, struct AudioCtrlElemValue *ctrlElemValue)
1209 {
1210 struct UsbMixerElemInfo *mixElemInfo = (struct UsbMixerElemInfo *)((volatile uintptr_t)kcontrol->privateValue);
1211 int32_t value, err;
1212 AUDIO_DEVICE_LOG_INFO("entry");
1213
1214 ctrlElemValue->value[0] = mixElemInfo->min;
1215 ctrlElemValue->value[1] = mixElemInfo->max;
1216
1217 err = AudioUsbGetCurMixValue(mixElemInfo, DEFAULT_CHANNEL, DEFAULT_CHANNEL, &value);
1218 if (err < HDF_SUCCESS) {
1219 return AudioUsbFilterError(mixElemInfo, err);
1220 }
1221 value = AudioUsbGetRelativeValue(mixElemInfo, value);
1222 ctrlElemValue->value[0] = value;
1223
1224 return HDF_SUCCESS;
1225 }
1226
1227 /* get the current value from feature/mixer unit */
AudioUsbMixerCtlFeatureMultGet(const struct AudioKcontrol * kcontrol,struct AudioCtrlElemValue * ctrlElemValue)1228 static int32_t AudioUsbMixerCtlFeatureMultGet(
1229 const struct AudioKcontrol *kcontrol, struct AudioCtrlElemValue *ctrlElemValue)
1230 {
1231 struct UsbMixerElemInfo *mixElemInfo = (struct UsbMixerElemInfo *)((volatile uintptr_t)kcontrol->privateValue);
1232 int32_t value, err;
1233 ctrlElemValue->value[0] = mixElemInfo->min;
1234 ctrlElemValue->value[1] = mixElemInfo->max;
1235
1236 err = AudioUsbGetCurMixValue(mixElemInfo, DEFAULT_CHANNEL, DEFAULT_CHANNEL, &value);
1237 if (err < HDF_SUCCESS) {
1238 return AudioUsbFilterError(mixElemInfo, err);
1239 }
1240 value = AudioUsbGetRelativeValue(mixElemInfo, value);
1241 ctrlElemValue->value[0] = value > 0 ? false : true;
1242
1243 return HDF_SUCCESS;
1244 }
1245
1246 /* put the current value to feature/mixer unit */
AudioUsbmixerCtlFeatureSet(const struct AudioKcontrol * kcontrol,const struct AudioCtrlElemValue * ctrlElemValue)1247 static int32_t AudioUsbmixerCtlFeatureSet(
1248 const struct AudioKcontrol *kcontrol, const struct AudioCtrlElemValue *ctrlElemValue)
1249 {
1250 struct UsbMixerElemInfo *mixElemInfo = (struct UsbMixerElemInfo *)((volatile uintptr_t)kcontrol->privateValue);
1251 int32_t value, oval, err;
1252
1253 err = AudioUsbGetCurMixValue(mixElemInfo, DEFAULT_CHANNEL, DEFAULT_CHANNEL, &oval);
1254 if (err < HDF_SUCCESS) {
1255 return AudioUsbFilterError(mixElemInfo, err);
1256 }
1257 value = ctrlElemValue->value[0];
1258 value = AudioUsbGetAbsValue(mixElemInfo, value);
1259 if (value != oval) {
1260 AudioUsbSetCurMixValue(mixElemInfo, DEFAULT_CHANNEL, DEFAULT_CHANNEL, value);
1261 }
1262
1263 return HDF_SUCCESS;
1264 }
1265
1266 /* put the current value to feature/mixer unit */
AudioUsbMixerCtlFeatureMultSet(const struct AudioKcontrol * kcontrol,const struct AudioCtrlElemValue * ctrlElemValue)1267 static int32_t AudioUsbMixerCtlFeatureMultSet(
1268 const struct AudioKcontrol *kcontrol, const struct AudioCtrlElemValue *ctrlElemValue)
1269 {
1270 struct UsbMixerElemInfo *mixElemInfo = (struct UsbMixerElemInfo *)((volatile uintptr_t)kcontrol->privateValue);
1271 int32_t value, oval, err;
1272
1273 err = AudioUsbGetCurMixValue(mixElemInfo, DEFAULT_CHANNEL, DEFAULT_CHANNEL, &oval);
1274 if (err < HDF_SUCCESS) {
1275 return AudioUsbFilterError(mixElemInfo, err);
1276 }
1277
1278 value = AudioUsbGetAbsValue(mixElemInfo, ctrlElemValue->value[0] > DEFAULT_CHANNEL ? false : true);
1279 if (value != oval) {
1280 AudioUsbSetCurMixValue(mixElemInfo, DEFAULT_CHANNEL, DEFAULT_CHANNEL, value);
1281 }
1282
1283 return HDF_SUCCESS;
1284 }
1285
1286 static struct AudioKcontrol g_usbFeatureUnitCtl = {
1287 .iface = AUDIO_USB_CTL_ELEM_IFACE_MIXER,
1288 .name = "", /* will be filled later manually */
1289 .Info = AudioUsbMixerCtlFeatureInfo,
1290 .Get = AudioUsbMixerCtlFeatureGet,
1291 .Set = AudioUsbmixerCtlFeatureSet,
1292 };
1293
1294 static struct AudioKcontrol g_usbFeatureUnitCtlMult = {
1295 .iface = AUDIO_USB_CTL_ELEM_IFACE_MIXER,
1296 .name = "", /* will be filled later manually */
1297 .Info = AudioUsbMixerCtlFeatureInfo,
1298 .Get = AudioUsbMixerCtlFeatureMultGet,
1299 .Set = AudioUsbMixerCtlFeatureMultSet,
1300 };
1301
1302 /* the read-only variant */
1303 static struct AudioKcontrol g_usbFeatureUnitCtlRo = {
1304 .iface = AUDIO_USB_CTL_ELEM_IFACE_MIXER,
1305 .name = "", /* will be filled later manually */
1306 .Info = AudioUsbMixerCtlFeatureInfo,
1307 .Get = AudioUsbMixerCtlFeatureGet,
1308 .Set = NULL,
1309 };
1310
1311 /* build a feature control */
AudioUsbAppendCtlName(struct AudioKcontrol * kcontrol,const char * str,int32_t size)1312 static size_t AudioUsbAppendCtlName(struct AudioKcontrol *kcontrol, const char *str, int32_t size)
1313 {
1314 return strlcat(kcontrol->name, str, size);
1315 }
1316
AudioUsbGetFeatureControlInfo(int32_t control)1317 static const struct AudioUsbFeatureControlInfo *AudioUsbGetFeatureControlInfo(int32_t control)
1318 {
1319 int32_t i;
1320
1321 for (i = 0; i < ARRAY_SIZE(g_audioFeatureInfo); ++i) {
1322 if (g_audioFeatureInfo[i].control == control) {
1323 return &g_audioFeatureInfo[i];
1324 }
1325 }
1326 return NULL;
1327 }
1328
AudioUsbFeatureCtlInit(struct UsbMixerInterface * mixer,struct AudioKcontrol ** kcontrol,struct UsbMixerElemInfo * mixElemInfo,struct AudioUsbFeatureControl * featureControl)1329 static int32_t AudioUsbFeatureCtlInit(struct UsbMixerInterface *mixer, struct AudioKcontrol **kcontrol,
1330 struct UsbMixerElemInfo *mixElemInfo, struct AudioUsbFeatureControl *featureControl)
1331 {
1332 const struct AudioUsbFeatureControlInfo *ctlInfo = NULL;
1333 int32_t i;
1334 int32_t channel = 0;
1335
1336 AudioUsbMixerElemInitStd(&mixElemInfo->head, mixer, featureControl->unitId);
1337 mixElemInfo->control = featureControl->control;
1338 mixElemInfo->cmask = featureControl->ctlMask;
1339
1340 ctlInfo = AudioUsbGetFeatureControlInfo(featureControl->control);
1341 if (ctlInfo == NULL) {
1342 OsalMemFree(mixElemInfo->privateData);
1343 OsalMemFree(mixElemInfo);
1344 AUDIO_DEVICE_LOG_ERR("AudioUsbGetFeatureControlInfo failed.");
1345 return HDF_FAILURE;
1346 }
1347
1348 if (mixer->protocol == UAC_VERSION_1) {
1349 mixElemInfo->valType = ctlInfo->type;
1350 } else { /* UAC_VERSION_2 */
1351 mixElemInfo->valType = ctlInfo->typeUac2 >= 0 ? ctlInfo->typeUac2 : ctlInfo->type;
1352 }
1353 if (featureControl->ctlMask == 0) {
1354 mixElemInfo->channels = 1; /* 1 is first channel */
1355 mixElemInfo->masterReadOnly = featureControl->readOnlyMask;
1356 } else {
1357 for (i = 0; i < USB_SHIFT_SIZE_16; i++) {
1358 if (featureControl->ctlMask & (1 << i)) {
1359 channel++;
1360 }
1361 }
1362 mixElemInfo->channels = channel;
1363 mixElemInfo->chReadOnly = featureControl->readOnlyMask;
1364 }
1365
1366 if (mixElemInfo->channels == featureControl->readOnlyMask) {
1367 *kcontrol = &g_usbFeatureUnitCtlRo;
1368 } else {
1369 *kcontrol = &g_usbFeatureUnitCtl;
1370 }
1371
1372 if (featureControl->control == UAC_FU_MUTE) {
1373 *kcontrol = &g_usbFeatureUnitCtlMult;
1374 }
1375 DListHeadInit(&((*kcontrol)->list));
1376 return HDF_SUCCESS;
1377 }
1378
AudioUsbSetVolumeItemName(struct UsbMixerBuild * state,struct AudioKcontrol * kcontrol,struct UsbAudioTerm * usbAudioTerm,struct AudioUsbFeatureControl * featureControl,const struct UsbMixerNameMap * map)1379 static void AudioUsbSetVolumeItemName(struct UsbMixerBuild *state, struct AudioKcontrol *kcontrol,
1380 struct UsbAudioTerm *usbAudioTerm, struct AudioUsbFeatureControl *featureControl, const struct UsbMixerNameMap *map)
1381 {
1382 struct UsbMixerInterface *mixer = state->mixer;
1383 struct UsbAudioTerm *oterm = &state->oterm;
1384 uint32_t len = 0;
1385 int32_t mappedName = 0;
1386
1387 len = AudioUsbCheckMappedName(map, kcontrol->name, KCTL_NAME_LEN);
1388 mappedName = len != 0;
1389 if (len == 0 && featureControl->nameId != 0) {
1390 len = AudioUsbCopyStringDesc(mixer->audioUsbDriver, featureControl->nameId, kcontrol->name, KCTL_NAME_LEN);
1391 }
1392
1393 if (len == 0) {
1394 if (usbAudioTerm != NULL) {
1395 len = AudioUsbGetTermName(mixer->audioUsbDriver, usbAudioTerm, kcontrol->name, KCTL_NAME_LEN, 1);
1396 }
1397 if (len == 0 && oterm != NULL) {
1398 len = AudioUsbGetTermName(mixer->audioUsbDriver, oterm, kcontrol->name, KCTL_NAME_LEN, 1);
1399 }
1400 if (len == 0) {
1401 (void)snprintf_s(kcontrol->name, KCTL_NAME_LEN + 1, KCTL_NAME_LEN, "Feature %d", featureControl->unitId);
1402 }
1403 }
1404 if (mappedName == 0 && oterm != NULL && !(oterm->type >> USB_SHIFT_SIZE_16)) {
1405 if ((oterm->type & 0xff00) == PCM_TYPE_VAL) {
1406 AudioUsbAppendCtlName(kcontrol, " Capture", KCTL_NAME_LEN);
1407 } else {
1408 AudioUsbAppendCtlName(kcontrol, " Playback", KCTL_NAME_LEN);
1409 }
1410 }
1411 AudioUsbAppendCtlName(kcontrol, featureControl->control == UAC_FU_MUTE ? " Mute" : " Volume", KCTL_NAME_LEN);
1412 }
1413
AudioUsbSetKctlItermName(struct UsbMixerBuild * state,struct AudioKcontrol * kcontrol,struct UsbAudioTerm * usbAudioTerm,struct AudioUsbFeatureControl * featureControl)1414 static int32_t AudioUsbSetKctlItermName(struct UsbMixerBuild *state, struct AudioKcontrol *kcontrol,
1415 struct UsbAudioTerm *usbAudioTerm, struct AudioUsbFeatureControl *featureControl)
1416 {
1417 uint32_t len = 0;
1418 bool mappedName = 0;
1419 struct UsbMixerInterface *mixer = state->mixer;
1420 const struct UsbMixerNameMap *imap = state->map;
1421 struct UsbAudioTerm *oterm = &state->oterm;
1422 const struct UsbMixerNameMap *map = NULL;
1423
1424 map = AudioUsbFindMap(imap, featureControl->unitId, featureControl->control);
1425 if (!(map == NULL || map->name != NULL || map->dB != NULL)) {
1426 AUDIO_DRIVER_LOG_ERR("param is null");
1427 return HDF_FAILURE;
1428 }
1429
1430 len = AudioUsbCheckMappedName(map, kcontrol->name, KCTL_NAME_LEN);
1431 mappedName = len != 0;
1432 if (len == 0 && featureControl->nameId != 0) {
1433 len = AudioUsbCopyStringDesc(mixer->audioUsbDriver, featureControl->nameId, kcontrol->name, KCTL_NAME_LEN);
1434 }
1435
1436 switch (featureControl->control) {
1437 case UAC_FU_VOLUME:
1438 AudioUsbSetVolumeItemName(state, kcontrol, usbAudioTerm, featureControl, map);
1439 break;
1440 case UAC_FU_MUTE:
1441 if (!mappedName && oterm != NULL && !(oterm->type >> USB_SHIFT_SIZE_16)) {
1442 if ((oterm->type & 0xff00) == PCM_TYPE_VAL) {
1443 AudioUsbAppendCtlName(kcontrol, "Capture", KCTL_NAME_LEN);
1444 } else {
1445 AudioUsbAppendCtlName(kcontrol, "Playback", KCTL_NAME_LEN);
1446 }
1447 }
1448 AudioUsbAppendCtlName(
1449 kcontrol, featureControl->control == UAC_FU_MUTE ? " Mute" : " Volume", KCTL_NAME_LEN);
1450 break;
1451 default:
1452 if (len == 0) {
1453 strlcpy(kcontrol->name, g_audioFeatureInfo[featureControl->control - 1].name, KCTL_NAME_LEN);
1454 }
1455 break;
1456 }
1457 return HDF_SUCCESS;
1458 }
1459
UsbBuildFeatureCtlSubInitKcontrol(struct AudioCard * audioCard,struct AudioKcontrol * kcontrol,struct UsbMixerElemInfo * mixElemInfo)1460 static void UsbBuildFeatureCtlSubInitKcontrol(struct AudioCard *audioCard, struct AudioKcontrol *kcontrol,
1461 struct UsbMixerElemInfo *mixElemInfo)
1462 {
1463 struct AudioKcontrol *kControl = NULL;
1464 kControl = AudioAddControl(audioCard, kcontrol);
1465 if (kControl == NULL) {
1466 OsalMemFree(mixElemInfo->privateData);
1467 OsalMemFree(mixElemInfo);
1468 OsalMemFree(kcontrol->name);
1469 return;
1470 }
1471
1472 DListInsertHead(&kControl->list, &audioCard->controls);
1473 }
1474
AudioUsbBuildFeatureCtlSub(struct UsbMixerBuild * state,struct UsbAudioTerm * usbAudioTerm,struct AudioUsbFeatureControl * featureControl)1475 static void AudioUsbBuildFeatureCtlSub(
1476 struct UsbMixerBuild *state, struct UsbAudioTerm *usbAudioTerm, struct AudioUsbFeatureControl *featureControl)
1477 {
1478 struct AudioKcontrol *kcontrol = NULL;
1479 struct UsbMixerElemInfo *mixElemInfo = NULL;
1480 struct AudioCard *audioCard = NULL;
1481 int ret;
1482
1483 if (featureControl->control == UAC_FU_GRAPHIC_EQUALIZER) {
1484 AUDIO_DEVICE_LOG_INFO("not supported yet");
1485 return;
1486 }
1487
1488 mixElemInfo = OsalMemCalloc(sizeof(*mixElemInfo));
1489 if (!mixElemInfo) {
1490 AUDIO_DEVICE_LOG_ERR("OsalMemCalloc is failed");
1491 return;
1492 }
1493
1494 ret = AudioUsbFeatureCtlInit(state->mixer, &kcontrol, mixElemInfo, featureControl);
1495 if (ret != HDF_SUCCESS || kcontrol == NULL) {
1496 AUDIO_DEVICE_LOG_INFO("AudioUsbFeatureCtlInit fail or kcontrol is null");
1497 OsalMemFree(mixElemInfo->privateData);
1498 OsalMemFree(mixElemInfo);
1499 return;
1500 }
1501
1502 kcontrol->name = (char *)OsalMemCalloc(KCTL_NAME_LEN);
1503 if (kcontrol->name == NULL) {
1504 AUDIO_DEVICE_LOG_ERR("OsalMemCalloc name is failed");
1505 OsalMemFree(mixElemInfo->privateData);
1506 OsalMemFree(mixElemInfo);
1507 return;
1508 }
1509 ret = AudioUsbSetKctlItermName(state, kcontrol, usbAudioTerm, featureControl);
1510 if (ret != HDF_SUCCESS) {
1511 OsalMemFree(mixElemInfo->privateData);
1512 OsalMemFree(mixElemInfo);
1513 OsalMemFree(kcontrol->name);
1514 return;
1515 }
1516
1517 /* get min/max values */
1518 ret = AudioUsbCtlGetMinMaxVal(mixElemInfo, 0, kcontrol);
1519 if (ret != HDF_SUCCESS || mixElemInfo->max <= mixElemInfo->min) {
1520 AUDIO_DEVICE_LOG_INFO("AudioUsbCtlGetMinMaxVal fail or mixElemInfo->min error");
1521 OsalMemFree(mixElemInfo->privateData);
1522 OsalMemFree(mixElemInfo);
1523 OsalMemFree(kcontrol->name);
1524 return;
1525 }
1526
1527 audioCard = state->mixer->audioUsbDriver->audioCard;
1528 kcontrol->privateValue = (unsigned long)(uintptr_t)(void *)mixElemInfo;
1529
1530 UsbBuildFeatureCtlSubInitKcontrol(audioCard, kcontrol, mixElemInfo);
1531 }
1532
AudioUsbBuildFeatureCtl(struct UsbMixerBuild * state,void * rawDesc,struct UsbAudioTerm * usbAudioTerm,struct AudioUsbFeatureControl * featureControl)1533 static void AudioUsbBuildFeatureCtl(struct UsbMixerBuild *state, void *rawDesc, struct UsbAudioTerm *usbAudioTerm,
1534 struct AudioUsbFeatureControl *featureControl)
1535 {
1536 struct uac_feature_unit_descriptor *desc = rawDesc;
1537 featureControl->nameId = uac_feature_unit_iFeature(desc);
1538
1539 AudioUsbBuildFeatureCtlSub(state, usbAudioTerm, featureControl);
1540 }
1541
AudioUsbParseFeatureDescriptorParam(struct UsbMixerBuild * state,void * ftrSub,struct AudioUsbFeatureParam * featureParam)1542 static int32_t AudioUsbParseFeatureDescriptorParam(
1543 struct UsbMixerBuild *state, void *ftrSub, struct AudioUsbFeatureParam *featureParam)
1544 {
1545 struct uac_feature_unit_descriptor *hdr = ftrSub;
1546
1547 if (state->mixer->protocol == UAC_VERSION_1) {
1548 featureParam->controlSize = hdr->bControlSize;
1549 featureParam->channels = (hdr->bLength - CHANNEL_HDR_BLENGTH) / featureParam->controlSize - 1;
1550 featureParam->bmaControls = hdr->bmaControls;
1551 } else { /* UAC_VERSION_3 */
1552 AUDIO_DEVICE_LOG_ERR("not support!");
1553 return HDF_FAILURE;
1554 }
1555 featureParam->masterBits = AudioUsbCombineBytes(featureParam->bmaControls, featureParam->controlSize);
1556 switch (state->audioUsbDriver->usbId) {
1557 case 0x08bb2702: /* PCM2702 */
1558 featureParam->masterBits &= ~UAC_CONTROL_BIT(UAC_FU_VOLUME);
1559 break;
1560 case 0x1130f211: /* TP6911 */
1561 featureParam->channels = 0;
1562 break;
1563 default:
1564 AUDIO_DEVICE_LOG_ERR("usbID err!");
1565 return HDF_FAILURE;
1566 }
1567 return HDF_SUCCESS;
1568 }
1569
1570 /* parse a feature unit; most of controls are defined here. */
AudioUsbParseFeatureUnit(struct UsbMixerBuild * state,int32_t unitId,void * ftrSub)1571 static int32_t AudioUsbParseFeatureUnit(struct UsbMixerBuild *state, int32_t unitId, void *ftrSub)
1572 {
1573 struct UsbAudioTerm usbAudioTerm;
1574 int32_t i, j, err;
1575 struct uac_feature_unit_descriptor *hdr = ftrSub;
1576 struct AudioUsbFeatureControl featureControl;
1577 struct AudioUsbFeatureParam featureParam;
1578 uint32_t chBits, mask;
1579
1580 err = AudioUsbParseFeatureDescriptorParam(state, ftrSub, &featureParam);
1581 if (err < HDF_SUCCESS) {
1582 return err;
1583 }
1584
1585 featureControl.unitId = unitId;
1586 /* parse the source unit */
1587 err = AudioUsbParseUnit(state, hdr->bSourceID);
1588 if (err < HDF_SUCCESS) {
1589 return err;
1590 }
1591
1592 err = AudioUsbCheckInputTerm(state, hdr->bSourceID, &usbAudioTerm);
1593 if (err < HDF_SUCCESS) {
1594 return err;
1595 }
1596
1597 for (i = 0; i < USB_TIMEOUT; i++) {
1598 chBits = 0;
1599 featureControl.control = g_audioFeatureInfo[i].control;
1600 for (j = 0; j < featureParam.channels; j++) {
1601 mask = AudioUsbCombineBytes(
1602 featureParam.bmaControls + featureParam.controlSize * (j + 1), featureParam.controlSize);
1603 if (mask & (1 << i)) {
1604 chBits |= (1 << j);
1605 }
1606 }
1607 featureControl.readOnlyMask = 0;
1608 if (chBits & 1) {
1609 featureControl.ctlMask = chBits;
1610 AudioUsbBuildFeatureCtl(state, ftrSub, &usbAudioTerm, &featureControl);
1611 }
1612 if (featureParam.masterBits & (1 << i)) {
1613 featureControl.ctlMask = 0;
1614 AudioUsbBuildFeatureCtl(state, ftrSub, &usbAudioTerm, &featureControl);
1615 }
1616 }
1617
1618 return HDF_SUCCESS;
1619 }
1620
AudioUsbMixerBitmapOverflow(struct uac_mixer_unit_descriptor * desc,int32_t protocol,int32_t numIns,int32_t numOuts)1621 static bool AudioUsbMixerBitmapOverflow(
1622 struct uac_mixer_unit_descriptor *desc, int32_t protocol, int32_t numIns, int32_t numOuts)
1623 {
1624 uint8_t *hdr = (uint8_t *)desc;
1625 uint8_t *controls = uac_mixer_unit_bmControls(desc, protocol);
1626 size_t restVal;
1627 uint32_t numVal, ctlTem, hdrTem;
1628
1629 switch (protocol) {
1630 case UAC_VERSION_1:
1631 default:
1632 restVal = 1; /* 1 is iMixer */
1633 break;
1634 case UAC_VERSION_2:
1635 restVal = 2; /* 2 is bmControls + iMixer */
1636 break;
1637 case UAC_VERSION_3:
1638 restVal = 6; /* 6 is bmControls + wMixerDescrStr */
1639 break;
1640 }
1641 numVal = (numIns * numOuts + CHANNEL_HDR_BLENGTH) / OVERF_LOWDIVISOR_NUM;
1642 ctlTem = (uintptr_t)(controls + numVal + restVal);
1643 hdrTem = (uintptr_t)(hdr + hdr[0]);
1644 return ctlTem > hdrTem;
1645 }
1646
UsbBuildMixerUnitCtlInitKcontrol(struct AudioKcontrol * kcontrol,struct UsbMixerElemInfo * mixElemInfo)1647 static void UsbBuildMixerUnitCtlInitKcontrol(struct AudioKcontrol *kcontrol, struct UsbMixerElemInfo *mixElemInfo)
1648 {
1649 kcontrol = &g_usbFeatureUnitCtl;
1650 kcontrol->name = (char *)OsalMemCalloc(KCTL_NAME_LEN);
1651 if (kcontrol->name == NULL) {
1652 AUDIO_DEVICE_LOG_ERR("OsalMemCalloc name is failed");
1653 OsalMemFree(mixElemInfo->privateData);
1654 OsalMemFree(mixElemInfo);
1655 return;
1656 }
1657 kcontrol->privateValue = (unsigned long)(uintptr_t)(void *)mixElemInfo;
1658 DListHeadInit(&kcontrol->list);
1659 }
1660
AudioUsbBuildMixerUnitCtl(struct UsbMixerBuild * state,struct uac_mixer_unit_descriptor * desc,struct MixerUnitCtlParam * mixCtlParam,int32_t unitId,struct UsbAudioTerm * usbAudioTerm)1661 static void AudioUsbBuildMixerUnitCtl(struct UsbMixerBuild *state, struct uac_mixer_unit_descriptor *desc,
1662 struct MixerUnitCtlParam *mixCtlParam, int32_t unitId, struct UsbAudioTerm *usbAudioTerm)
1663 {
1664 struct UsbMixerElemInfo *mixElemInfo = NULL;
1665 uint32_t i;
1666 struct AudioKcontrol *kcontrol = NULL;
1667 uint8_t *controls = NULL;
1668 int32_t len;
1669 const struct UsbMixerNameMap *map = NULL;
1670 struct AudioCard *audioCard = NULL;
1671
1672 map = AudioUsbFindMap(state->map, unitId, 0);
1673 if (!(map == NULL || map->name != NULL || map->dB != NULL)) {
1674 AUDIO_DRIVER_LOG_ERR("param is null");
1675 return;
1676 }
1677
1678 mixElemInfo = OsalMemCalloc(sizeof(*mixElemInfo));
1679 if (mixElemInfo == NULL) {
1680 AUDIO_DEVICE_LOG_ERR("OsalMemCalloc failed");
1681 return;
1682 }
1683 AudioUsbMixerElemInitStd(&mixElemInfo->head, state->mixer, unitId);
1684 mixElemInfo->control = mixCtlParam->itemChannels + 1; /* based on 1 */
1685 mixElemInfo->valType = USB_MIXER_S16;
1686 for (i = 0; i < mixCtlParam->numOuts; i++) {
1687 controls = uac_mixer_unit_bmControls(desc, state->mixer->protocol);
1688 if (controls != NULL &&
1689 AudioUsbCheckMatrixBitmap(controls, mixCtlParam->itemChannels, i, mixCtlParam->numOuts)) {
1690 mixElemInfo->cmask |= (1 << i);
1691 mixElemInfo->channels++;
1692 }
1693 }
1694
1695 /* get min/max values */
1696 AudioUsbCtlGetMinMaxVal(mixElemInfo, 0, NULL);
1697
1698 UsbBuildMixerUnitCtlInitKcontrol(kcontrol, mixElemInfo);
1699 len = AudioUsbCheckMappedName(map, kcontrol->name, KCTL_NAME_LEN);
1700 if (len == 0 && AudioUsbGetTermName(state->audioUsbDriver, usbAudioTerm, kcontrol->name, KCTL_NAME_LEN, 0) == 0) {
1701 (void)sprintf_s(kcontrol->name, KCTL_NAME_LEN, "Mixer Source %d", mixCtlParam->itemChannels + 1);
1702 }
1703
1704 AudioUsbAppendCtlName(kcontrol, " Volume", KCTL_NAME_LEN);
1705 audioCard = state->audioUsbDriver->audioCard;
1706
1707 if (AudioAddControl(audioCard, kcontrol) == NULL) {
1708 OsalMemFree(mixElemInfo->privateData);
1709 OsalMemFree(mixElemInfo);
1710 OsalMemFree(kcontrol->name);
1711 return;
1712 }
1713 DListInsertHead(&kcontrol->list, &audioCard->controls);
1714 }
1715
AudioUsbParseMixerUnitSub(int32_t itemChannels,struct UsbMixerBuild * state,struct MixerUnitCtlParam mixCtlParam,struct uac_mixer_unit_descriptor * desc)1716 static bool AudioUsbParseMixerUnitSub(int32_t itemChannels, struct UsbMixerBuild *state,
1717 struct MixerUnitCtlParam mixCtlParam, struct uac_mixer_unit_descriptor *desc)
1718 {
1719 int32_t outChannel;
1720 uint8_t *control = NULL;
1721
1722 for (outChannel = 0; outChannel < mixCtlParam.numOuts; outChannel++) {
1723 control = uac_mixer_unit_bmControls(desc, state->mixer->protocol);
1724 if (control != NULL && AudioUsbCheckMatrixBitmap(control, itemChannels, outChannel, mixCtlParam.numOuts)) {
1725 return true;
1726 }
1727 }
1728
1729 return false;
1730 }
1731
AudioUsbParseMixerUnit(struct UsbMixerBuild * state,int32_t unitId,void * rawDesc)1732 static int32_t AudioUsbParseMixerUnit(struct UsbMixerBuild *state, int32_t unitId, void *rawDesc)
1733 {
1734 struct uac_mixer_unit_descriptor *desc = rawDesc;
1735 struct UsbAudioTerm usbAudioTerm;
1736 int32_t inputPins, pin, err;
1737 int32_t numIns = 0;
1738 int32_t itemChannels = 0;
1739 struct MixerUnitCtlParam mixCtlParam = {0};
1740
1741 err = AudioUsbMixerUnitGetChannels(state, desc);
1742 if (err < 0) {
1743 AUDIO_DEVICE_LOG_ERR("invalid MIXER UNIT descriptor %d\n", unitId);
1744 return err;
1745 }
1746
1747 mixCtlParam.numOuts = err;
1748 inputPins = desc->bNrInPins;
1749
1750 for (pin = 0; pin < inputPins; pin++) {
1751 err = AudioUsbParseUnit(state, desc->baSourceID[pin]);
1752 if (err < HDF_SUCCESS || mixCtlParam.numOuts == 0) {
1753 continue;
1754 }
1755
1756 err = AudioUsbCheckInputTerm(state, desc->baSourceID[pin], &usbAudioTerm);
1757 if (err < HDF_SUCCESS) {
1758 return err;
1759 }
1760 numIns += usbAudioTerm.channels;
1761 if (AudioUsbMixerBitmapOverflow(desc, state->mixer->protocol, numIns, mixCtlParam.numOuts)) {
1762 break;
1763 }
1764 for (; itemChannels < numIns; itemChannels++) {
1765 if (AudioUsbParseMixerUnitSub(itemChannels, state, mixCtlParam, desc)) {
1766 mixCtlParam.itemChannels = itemChannels;
1767 AudioUsbBuildMixerUnitCtl(state, desc, &mixCtlParam, unitId, &usbAudioTerm);
1768 }
1769 }
1770 }
1771 return HDF_SUCCESS;
1772 }
1773
AudioUsbMixerCtlSelectorInfo(const struct AudioKcontrol * kcontrol,struct AudioCtrlElemInfo * ctrlElemInfo)1774 static int32_t AudioUsbMixerCtlSelectorInfo(
1775 const struct AudioKcontrol *kcontrol, struct AudioCtrlElemInfo *ctrlElemInfo)
1776 {
1777 (void)kcontrol;
1778 (void)ctrlElemInfo;
1779 return HDF_SUCCESS;
1780 }
1781
1782 /* get callback for selector unit */
AudioUsbMixerCtlSelectorGet(const struct AudioKcontrol * kcontrol,struct AudioCtrlElemValue * ctrlElemValue)1783 static int32_t AudioUsbMixerCtlSelectorGet(
1784 const struct AudioKcontrol *kcontrol, struct AudioCtrlElemValue *ctrlElemValue)
1785 {
1786 struct UsbMixerElemInfo *mixElemInfo = (struct UsbMixerElemInfo *)((volatile uintptr_t)kcontrol->privateValue);
1787 int32_t value, err;
1788
1789 err = AudioUsbGetCurCtlValue(mixElemInfo, mixElemInfo->control << USB_SHIFT_SIZE_8, &value);
1790 if (err < HDF_SUCCESS) {
1791 ctrlElemValue->value[0] = 0;
1792 return AudioUsbFilterError(mixElemInfo, err);
1793 }
1794 value = AudioUsbGetRelativeValue(mixElemInfo, value);
1795 ctrlElemValue->value[0] = value;
1796 return HDF_SUCCESS;
1797 }
1798
1799 /* put callback for selector unit */
AudioUsbMixerCtlSelectorSet(const struct AudioKcontrol * kcontrol,const struct AudioCtrlElemValue * ctrlElemValue)1800 static int32_t AudioUsbMixerCtlSelectorSet(
1801 const struct AudioKcontrol *kcontrol, const struct AudioCtrlElemValue *ctrlElemValue)
1802 {
1803 struct UsbMixerElemInfo *mixElemInfo = (struct UsbMixerElemInfo *)((volatile uintptr_t)kcontrol->privateValue);
1804 int32_t value;
1805 int32_t err;
1806 int32_t outValue = 0;
1807
1808 err = AudioUsbGetCurCtlValue(mixElemInfo, mixElemInfo->control << USB_SHIFT_SIZE_8, &outValue);
1809 if (err < HDF_SUCCESS) {
1810 return AudioUsbFilterError(mixElemInfo, err);
1811 }
1812 value = ctrlElemValue->value[0];
1813 value = AudioUsbGetAbsValue(mixElemInfo, value);
1814 if (value != outValue) {
1815 err = AudioUsbSetCurCtlValue(mixElemInfo, mixElemInfo->control << USB_SHIFT_SIZE_8, value);
1816 return err;
1817 }
1818 return HDF_SUCCESS;
1819 }
1820
1821 /* alsa control interface for selector unit */
1822 static struct AudioKcontrol g_mixerSelectUnitCtl = {
1823 .iface = AUDIO_USB_CTL_ELEM_IFACE_MIXER,
1824 .name = "", /* will be filled later */
1825 .Info = AudioUsbMixerCtlSelectorInfo,
1826 .Get = AudioUsbMixerCtlSelectorGet,
1827 .Set = AudioUsbMixerCtlSelectorSet,
1828 };
1829
AudioUsbSetTermName(struct UsbMixerBuild * state,void * rawDesc,struct UsbMixerElemInfo * mixElemInfo,int32_t unitId)1830 static int32_t AudioUsbSetTermName(
1831 struct UsbMixerBuild *state, void *rawDesc, struct UsbMixerElemInfo *mixElemInfo, int32_t unitId)
1832 {
1833 struct uac_selector_unit_descriptor *desc = rawDesc;
1834 char **nameList = NULL;
1835 uint32_t i, len;
1836 struct UsbAudioTerm usbAudioTerm;
1837
1838 AudioUsbMixerElemInitStd(&mixElemInfo->head, state->mixer, unitId);
1839 mixElemInfo->valType = USB_MIXER_U8;
1840 mixElemInfo->channels = USB_MIXER_DEF_CHAN;
1841 mixElemInfo->min = USB_MIXER_DEF_MIN_VAL;
1842 mixElemInfo->max = desc->bNrInPins;
1843 mixElemInfo->res = USB_MIXER_DEF_RES_VAL;
1844 mixElemInfo->initialized = true;
1845 mixElemInfo->control = 0;
1846
1847 nameList = OsalMemCalloc(desc->bNrInPins * sizeof(char *));
1848 if (nameList == NULL) {
1849 AUDIO_DEVICE_LOG_ERR("OsalMemCalloc failed.");
1850 return HDF_ERR_MALLOC_FAIL;
1851 }
1852 for (i = 0; i < desc->bNrInPins; i++) {
1853 len = 0;
1854 nameList[i] = OsalMemCalloc(MAX_ITEM_NAME_LEN);
1855 if (nameList[i] == NULL) {
1856 for (i = 0; i < desc->bNrInPins; i++) {
1857 OsalMemFree(nameList[i]);
1858 }
1859 OsalMemFree(nameList);
1860 return HDF_ERR_MALLOC_FAIL;
1861 }
1862 len = AudioUsbCheckMappedSelectorName(state, unitId, i, nameList[i], MAX_ITEM_NAME_LEN);
1863 if (len != 0 && AudioUsbCheckInputTerm(state, desc->baSourceID[i], &usbAudioTerm) >= 0) {
1864 len = AudioUsbGetTermName(state->audioUsbDriver, &usbAudioTerm, nameList[i], MAX_ITEM_NAME_LEN, 0);
1865 }
1866 if (len == 0) {
1867 sprintf_s(nameList[i], MAX_ITEM_NAME_LEN, "Input %u", i);
1868 }
1869 }
1870 return HDF_SUCCESS;
1871 }
1872
AudioUsbSetCtlName(struct UsbMixerBuild * state,struct AudioKcontrol * kcontrol,struct uac_selector_unit_descriptor * desc,const struct UsbMixerNameMap * map)1873 static void AudioUsbSetCtlName(struct UsbMixerBuild *state, struct AudioKcontrol *kcontrol,
1874 struct uac_selector_unit_descriptor *desc, const struct UsbMixerNameMap *map)
1875 {
1876 uint32_t len;
1877 uint32_t nameId;
1878
1879 /* check the static mapping table at first */
1880 len = AudioUsbCheckMappedName(map, kcontrol->name, KCTL_NAME_LEN);
1881 if (len == 0) { /* no mapping */
1882 if (state->mixer->protocol != UAC_VERSION_3) {
1883 /* if iSelector is given, use it */
1884 nameId = (uint32_t)uac_selector_unit_iSelector(desc);
1885 if (nameId != 0) {
1886 len = AudioUsbCopyStringDesc(state->audioUsbDriver, nameId, kcontrol->name, KCTL_NAME_LEN);
1887 }
1888 }
1889
1890 if (len == 0) { /* pick up the terminal name at next */
1891 len = AudioUsbGetTermName(state->audioUsbDriver, &state->oterm, kcontrol->name, KCTL_NAME_LEN, 0);
1892 }
1893 if (len == 0) { /* use the fixed string "USB" as the last resort */
1894 strlcpy(kcontrol->name, "USB", KCTL_NAME_LEN);
1895 }
1896 /* and add the proper suffix */
1897 if (desc->bDescriptorSubtype == UAC2_CLOCK_SELECTOR || desc->bDescriptorSubtype == UAC3_CLOCK_SELECTOR) {
1898 AudioUsbAppendCtlName(kcontrol, " Clock Source", KCTL_NAME_LEN);
1899 } else if ((state->oterm.type & 0xff00) == PCM_TYPE_VAL) {
1900 AudioUsbAppendCtlName(kcontrol, " Capture Source", KCTL_NAME_LEN);
1901 } else {
1902 AudioUsbAppendCtlName(kcontrol, " Playback Source", KCTL_NAME_LEN);
1903 }
1904 }
1905 }
1906
UsbParseSelectorUnitInitKcontrol(struct UsbMixerBuild * state,struct uac_selector_unit_descriptor * desc,const struct UsbMixerNameMap * map,struct UsbMixerElemInfo * mixElemInfo)1907 static int32_t UsbParseSelectorUnitInitKcontrol(struct UsbMixerBuild *state,
1908 struct uac_selector_unit_descriptor *desc, const struct UsbMixerNameMap *map,
1909 struct UsbMixerElemInfo *mixElemInfo)
1910 {
1911 struct AudioKcontrol *kcontrol = NULL;
1912 struct AudioCard *audioCard = NULL;
1913 kcontrol = &g_mixerSelectUnitCtl;
1914 kcontrol->name = (char *)OsalMemCalloc(KCTL_NAME_LEN);
1915 if (kcontrol->name == NULL) {
1916 AUDIO_DEVICE_LOG_ERR("OsalMemCalloc name is failed");
1917 OsalMemFree(mixElemInfo->privateData);
1918 OsalMemFree(mixElemInfo);
1919 return HDF_ERR_MALLOC_FAIL;
1920 }
1921 DListHeadInit(&kcontrol->list);
1922
1923 AudioUsbSetCtlName(state, kcontrol, desc, map);
1924 audioCard = state->audioUsbDriver->audioCard;
1925 kcontrol->privateValue = (unsigned long)(uintptr_t)(void *)mixElemInfo;
1926
1927 if (AudioAddControl(audioCard, kcontrol) == NULL) {
1928 OsalMemFree(mixElemInfo->privateData);
1929 OsalMemFree(mixElemInfo);
1930 OsalMemFree(kcontrol->name);
1931 return HDF_FAILURE;
1932 }
1933
1934 DListInsertHead(&kcontrol->list, &audioCard->controls);
1935 return HDF_SUCCESS;
1936 }
1937
AudioUsbParseSelectorUnit(struct UsbMixerBuild * state,int32_t unitId,void * rawDesc)1938 static int32_t AudioUsbParseSelectorUnit(struct UsbMixerBuild *state, int32_t unitId, void *rawDesc)
1939 {
1940 struct uac_selector_unit_descriptor *desc = rawDesc;
1941 uint32_t i;
1942 int32_t err;
1943 struct UsbMixerElemInfo *mixElemInfo = NULL;
1944 const struct UsbMixerNameMap *map = NULL;
1945
1946 for (i = 0; i < desc->bNrInPins; i++) {
1947 err = AudioUsbParseUnit(state, desc->baSourceID[i]);
1948 if (err < HDF_SUCCESS) {
1949 AUDIO_DEVICE_LOG_ERR("AudioUsbParseUnit is failed");
1950 return err;
1951 }
1952 }
1953
1954 if (desc->bNrInPins == USB_BA_SOURCE_ID_SIZE) {
1955 return HDF_SUCCESS;
1956 }
1957 map = AudioUsbFindMap(state->map, unitId, 0);
1958 if (!(map == NULL || map->name != NULL || map->dB != NULL)) {
1959 AUDIO_DRIVER_LOG_ERR("param is null");
1960 return HDF_FAILURE;
1961 }
1962
1963 mixElemInfo = OsalMemCalloc(sizeof(*mixElemInfo));
1964 if (mixElemInfo == NULL) {
1965 AUDIO_DEVICE_LOG_ERR("OsalMemCalloc failed");
1966 return HDF_ERR_MALLOC_FAIL;
1967 }
1968
1969 err = AudioUsbSetTermName(state, rawDesc, mixElemInfo, unitId);
1970 if (err != HDF_SUCCESS) {
1971 OsalMemFree(mixElemInfo->privateData);
1972 OsalMemFree(mixElemInfo);
1973 return err;
1974 }
1975
1976 return UsbParseSelectorUnitInitKcontrol(state, desc, map, mixElemInfo);
1977 }
1978
1979 /* parse an audio unit recursively */
AudioUsbParseUnit(struct UsbMixerBuild * state,int unitId)1980 static int32_t AudioUsbParseUnit(struct UsbMixerBuild *state, int unitId)
1981 {
1982 unsigned char *unitDesc = NULL;
1983 uint32_t type;
1984 int protocol = state->mixer->protocol;
1985
1986 AUDIO_DEVICE_LOG_INFO("entry");
1987 if (test_and_set_bit(unitId, state->unitBitMap)) {
1988 return HDF_SUCCESS; /* the unit already visited */
1989 }
1990 unitDesc = AudioUsbFindAudioControlUnit(state, unitId);
1991 if (unitDesc == NULL) {
1992 AUDIO_DRIVER_LOG_ERR("unit %d not found!\n", unitId);
1993 return HDF_ERR_INVALID_PARAM;
1994 }
1995
1996 if (!AudioUsbValidateAudioDesc(unitDesc, protocol)) {
1997 AUDIO_DRIVER_LOG_DEBUG("invalid unit %d\n", unitId);
1998 return HDF_SUCCESS; /* skip invalid unit */
1999 }
2000
2001 // here use version and UAC interface descriptor subtypes to determine the parsing function.
2002 type = (protocol << USB_SHIFT_SIZE_8) | unitDesc[USB_VAL_LEN_2];
2003 switch (type) {
2004 case 0x0002: // UAC_VERSION_1, UAC_INPUT_TERMINAL
2005 case 0x2002: // UAC_VERSION_2, UAC_INPUT_TERMINAL
2006 return HDF_SUCCESS;
2007 case 0x0004: // UAC_VERSION_1, UAC_MIXER_UNIT
2008 case 0x2004: // UAC_VERSION_2, UAC_MIXER_UNIT
2009 return AudioUsbParseMixerUnit(state, unitId, unitDesc);
2010 case 0x0005: // UAC_VERSION_1, UAC_SELECTOR_UNIT
2011 case 0x2005: // UAC_VERSION_2, UAC_SELECTOR_UNIT
2012 case 0x200b: // UAC_VERSION_2, UAC2_CLOCK_SELECTOR
2013 return AudioUsbParseSelectorUnit(state, unitId, unitDesc);
2014 case 0x0006: // UAC_VERSION_1, UAC_FEATURE_UNIT
2015 case 0x2006: // UAC_VERSION_2, UAC_FEATURE_UNIT
2016 return AudioUsbParseFeatureUnit(state, unitId, unitDesc);
2017 case 0x0007: // UAC_VERSION_1, UAC1_PROCESSING_UNIT
2018 case 0x2008: // UAC_VERSION_2, UAC2_PROCESSING_UNIT_V2
2019 case 0x0008: // UAC_VERSION_1, UAC1_EXTENSION_UNIT
2020 case 0x2009: // UAC_VERSION_2, UAC2_EXTENSION_UNIT_V2
2021 case 0x2007: // UAC_VERSION_2, UAC2_EFFECT_UNIT
2022 case 0x200a: // UAC_VERSION_3, UAC3_EXTENSION_UNIT
2023 return HDF_SUCCESS;
2024 default:
2025 AUDIO_DRIVER_LOG_ERR("unit %u: unexpected type 0x%02x\n", unitId, unitDesc[ARRAY_INDEX_2]);
2026 return HDF_ERR_INVALID_PARAM;
2027 }
2028 }
2029
AudioUsbMixerDisconnect(struct UsbMixerInterface * mixer)2030 void AudioUsbMixerDisconnect(struct UsbMixerInterface *mixer)
2031 {
2032 if (mixer->disconnected) {
2033 AUDIO_DEVICE_LOG_WARNING("mixer is disconnected");
2034 return;
2035 }
2036 if (mixer->urb != NULL) {
2037 usb_kill_urb(mixer->urb);
2038 }
2039 if (mixer->rcUrb != NULL) {
2040 usb_kill_urb(mixer->rcUrb);
2041 }
2042 if (mixer->PrivateFree != NULL) {
2043 mixer->PrivateFree(mixer);
2044 }
2045 mixer->disconnected = true;
2046 }
2047
AudioUsbMixerFree(struct UsbMixerInterface * mixer)2048 static void AudioUsbMixerFree(struct UsbMixerInterface *mixer)
2049 {
2050 /* kill pending URBs */
2051 AudioUsbMixerDisconnect(mixer);
2052
2053 OsalMemFree(mixer->idElems);
2054 if (mixer->urb != NULL) {
2055 kfree(mixer->urb->transfer_buffer);
2056 usb_free_urb(mixer->urb);
2057 }
2058 usb_free_urb(mixer->rcUrb);
2059 OsalMemFree(mixer->rcSetupPacket);
2060 OsalMemFree(mixer);
2061 }
2062
AudioUsbMixerControls(struct UsbMixerInterface * mixer)2063 static int32_t AudioUsbMixerControls(struct UsbMixerInterface *mixer)
2064 {
2065 struct UsbMixerBuild state;
2066 int32_t err;
2067 void *pAfter = NULL;
2068 struct uac1_output_terminal_descriptor *desc = NULL;
2069
2070 if (mixer == NULL || mixer->hostIf == NULL) {
2071 AUDIO_DEVICE_LOG_ERR("mixer or mixer->hostIf is null");
2072 return HDF_ERR_INVALID_PARAM;
2073 }
2074 (void)memset_s(&state, sizeof(state), 0, sizeof(state));
2075 state.audioUsbDriver = mixer->audioUsbDriver;
2076 state.mixer = mixer;
2077 state.buffer = mixer->hostIf->extra;
2078 state.bufLen = mixer->hostIf->extralen;
2079
2080 pAfter = AudioUsbFindCsintDesc(mixer->hostIf->extra, mixer->hostIf->extralen, pAfter, UAC_OUTPUT_TERMINAL);
2081 while (pAfter != NULL) {
2082 if (!AudioUsbValidateAudioDesc(pAfter, mixer->protocol)) {
2083 pAfter = AudioUsbFindCsintDesc(mixer->hostIf->extra, mixer->hostIf->extralen, pAfter, UAC_OUTPUT_TERMINAL);
2084 continue;
2085 }
2086 if (mixer->protocol == UAC_VERSION_1) {
2087 desc = pAfter;
2088 set_bit(desc->bTerminalID, state.unitBitMap);
2089 state.oterm.name = desc->iTerminal;
2090 state.oterm.id = desc->bTerminalID;
2091 state.oterm.type = le16_to_cpu(desc->wTerminalType);
2092 AUDIO_DEVICE_LOG_DEBUG("name = %d id = %d type = %d", state.oterm.name, state.oterm.id, state.oterm.type);
2093
2094 err = AudioUsbParseUnit(&state, desc->bSourceID);
2095 if (err < HDF_SUCCESS && err != -EINVAL) {
2096 AUDIO_DEVICE_LOG_ERR("AudioUsbParseUnit is failed");
2097 return err;
2098 }
2099 }
2100 pAfter = AudioUsbFindCsintDesc(mixer->hostIf->extra, mixer->hostIf->extralen, pAfter, UAC_OUTPUT_TERMINAL);
2101 }
2102
2103 return HDF_SUCCESS;
2104 }
2105
AudioUsbChoiceUsbVersion(struct UsbMixerInterface * mixer)2106 static int32_t AudioUsbChoiceUsbVersion(struct UsbMixerInterface *mixer)
2107 {
2108 struct usb_interface_descriptor *inteDesc = AudioUsbGetIfaceDesc(mixer->hostIf);
2109 if (inteDesc == NULL) {
2110 AUDIO_DEVICE_LOG_ERR("inteDesc is null");
2111 return HDF_FAILURE;
2112 }
2113
2114 switch (inteDesc->bInterfaceProtocol) {
2115 case UAC_VERSION_1:
2116 mixer->protocol = UAC_VERSION_1;
2117 break;
2118 case UAC_VERSION_2:
2119 mixer->protocol = UAC_VERSION_2;
2120 break;
2121 case UAC_VERSION_3:
2122 mixer->protocol = UAC_VERSION_3;
2123 break;
2124 default:
2125 mixer->protocol = UAC_VERSION_1;
2126 break;
2127 }
2128 AUDIO_DEVICE_LOG_DEBUG("mixer protocol is %d", mixer->protocol);
2129
2130 return HDF_SUCCESS;
2131 }
2132
AudioUsbCreateMixer(struct AudioUsbDriver * audioUsbDriver,int32_t ctrlIf,int32_t ignoreError)2133 int32_t AudioUsbCreateMixer(struct AudioUsbDriver *audioUsbDriver, int32_t ctrlIf, int32_t ignoreError)
2134 {
2135 struct UsbMixerInterface *mixer = NULL;
2136
2137 AUDIO_DEVICE_LOG_INFO("entry");
2138 if (audioUsbDriver == NULL) {
2139 AUDIO_DEVICE_LOG_ERR("audioUsbDriver is null");
2140 return HDF_ERR_INVALID_PARAM;
2141 }
2142 mixer = OsalMemCalloc(sizeof(*mixer));
2143 if (mixer == NULL) {
2144 AUDIO_DEVICE_LOG_ERR("OsalMemCalloc mixer failed");
2145 return HDF_ERR_MALLOC_FAIL;
2146 }
2147 mixer->audioUsbDriver = audioUsbDriver;
2148 mixer->ignoreCtlError = ignoreError;
2149 mixer->idElems = OsalMemCalloc(sizeof(struct UsbMixerElemList) * MAX_ID_ELEMS);
2150 if (mixer->idElems == NULL) {
2151 AUDIO_DEVICE_LOG_ERR("OsalMemCalloc mixer->idElems failed");
2152 OsalMemFree(mixer);
2153 return HDF_ERR_MALLOC_FAIL;
2154 }
2155 mixer->hostIf = &usb_ifnum_to_if(audioUsbDriver->dev, ctrlIf)->altsetting[0];
2156 if (mixer->hostIf == NULL) {
2157 AUDIO_DEVICE_LOG_ERR("mixer->hostIf is null");
2158 AudioUsbMixerFree(mixer);
2159 return HDF_FAILURE;
2160 }
2161
2162 if (AudioUsbChoiceUsbVersion(mixer) != HDF_SUCCESS) {
2163 AUDIO_DEVICE_LOG_ERR("AudioUsbChoiceUsbVersion fail");
2164 AudioUsbMixerFree(mixer);
2165 return HDF_FAILURE;
2166 }
2167
2168 if (mixer->protocol != UAC_VERSION_3 && AudioUsbMixerControls(mixer) < 0) {
2169 AUDIO_DEVICE_LOG_ERR("AudioUsbMixerControls fail");
2170 AudioUsbMixerFree(mixer);
2171 return HDF_FAILURE;
2172 }
2173
2174 return HDF_SUCCESS;
2175 }
2176