• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 /*
2  * Copyright (C) 2017 The Android Open Source Project
3  *
4  * Licensed under the Apache License, Version 2.0 (the "License");
5  * you may not use this file except in compliance with the License.
6  * You may obtain a copy of the License at
7  *
8  *      http://www.apache.org/licenses/LICENSE-2.0
9  *
10  * Unless required by applicable law or agreed to in writing, software
11  * distributed under the License is distributed on an "AS IS" BASIS,
12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13  * See the License for the specific language governing permissions and
14  * limitations under the License.
15  */
16 
17 #define LOG_TAG "audio_hw_usb"
18 
19 #include <errno.h>
20 #include <pthread.h>
21 #include <stdlib.h>
22 #include <log/log.h>
23 #include <cutils/str_parms.h>
24 #include <sys/ioctl.h>
25 #include <unistd.h>
26 #include <fcntl.h>
27 #include <sys/stat.h>
28 #include <system/audio.h>
29 #include <tinyalsa/asoundlib.h>
30 #include <audio_hw.h>
31 #include <cutils/properties.h>
32 #include <ctype.h>
33 #include <math.h>
34 
35 #ifdef USB_TUNNEL_ENABLED
36 #define USB_BUFF_SIZE           2048
37 #define CHANNEL_NUMBER_STR      "Channels: "
38 #define PLAYBACK_PROFILE_STR    "Playback:"
39 #define CAPTURE_PROFILE_STR     "Capture:"
40 #define DATA_PACKET_INTERVAL_STR "Data packet interval: "
41 #define USB_SIDETONE_GAIN_STR   "usb_sidetone_gain"
42 #define ABS_SUB(A, B) (((A) > (B)) ? ((A) - (B)):((B) - (A)))
43 #define SAMPLE_RATE_8000          8000
44 #define SAMPLE_RATE_11025         11025
45 #define DEFAULT_SERVICE_INTERVAL_US    1000
46 #define USBID_SIZE                16
47 
48 /* TODO: dynamically populate supported sample rates */
49 static uint32_t supported_sample_rates[] =
50     {192000, 176400, 96000, 88200, 64000, 48000, 44100};
51 static uint32_t supported_sample_rates_mask[2];
52 static const uint32_t MAX_SAMPLE_RATE_SIZE =
53         (sizeof(supported_sample_rates)/sizeof(supported_sample_rates[0]));
54 
55 // assert on sizeof bm v/s size of rates if needed
56 
57 typedef enum usb_usecase_type{
58     USB_PLAYBACK = 0,
59     USB_CAPTURE,
60 } usb_usecase_type_t;
61 
62 enum {
63     USB_SIDETONE_ENABLE_INDEX = 0,
64     USB_SIDETONE_VOLUME_INDEX,
65     USB_SIDETONE_MAX_INDEX,
66 };
67 
68 struct usb_device_config {
69     struct listnode list;
70     unsigned int bit_width;
71     unsigned int channel_count;
72     unsigned int rate_size;
73     unsigned int rates[MAX_SAMPLE_RATE_SIZE];
74     unsigned long service_interval_us;
75     usb_usecase_type_t type;
76 };
77 
78 struct usb_card_config {
79     struct listnode list;
80     audio_devices_t usb_device_type;
81     int usb_card;
82     struct listnode usb_device_conf_list;
83     struct mixer *usb_snd_mixer;
84     int usb_sidetone_index[USB_SIDETONE_MAX_INDEX];
85     int usb_sidetone_vol_min;
86     int usb_sidetone_vol_max;
87     char usbid[USBID_SIZE];
88 };
89 
90 struct usb_module {
91     struct listnode usb_card_conf_list;
92     struct audio_device *adev;
93     int sidetone_gain;
94     bool is_capture_supported;
95 };
96 
97 static struct usb_module *usbmod = NULL;
98 static bool usb_audio_debug_enable = false;
99 static int usb_sidetone_gain = 0;
100 
101 static const char * const usb_sidetone_enable_str[] = {
102     "Sidetone Playback Switch",
103     "Mic Playback Switch",
104 };
105 
106 static const char * const usb_sidetone_volume_str[] = {
107     "Sidetone Playback Volume",
108     "Mic Playback Volume",
109 };
110 
usb_mixer_print_enum(struct mixer_ctl * ctl)111 static void usb_mixer_print_enum(struct mixer_ctl *ctl)
112 {
113     unsigned int num_enums;
114     unsigned int i;
115     const char *string;
116 
117     num_enums = mixer_ctl_get_num_enums(ctl);
118 
119     for (i = 0; i < num_enums; i++) {
120         string = mixer_ctl_get_enum_string(ctl, i);
121         ALOGI("\t%s%s", mixer_ctl_get_value(ctl, 0) == (int)i ? ">" : "", string);
122     }
123 }
124 
usb_soundcard_detail_control(struct mixer * mixer,const char * control)125 static void usb_soundcard_detail_control(struct mixer *mixer, const char *control)
126 {
127     struct mixer_ctl *ctl;
128     enum mixer_ctl_type type;
129     unsigned int num_values;
130     unsigned int i;
131     int min, max;
132 
133     if (isdigit(control[0]))
134         ctl = mixer_get_ctl(mixer, atoi(control));
135     else
136         ctl = mixer_get_ctl_by_name(mixer, control);
137 
138     if (!ctl) {
139         fprintf(stderr, "Invalid mixer control\n");
140         return;
141     }
142 
143     type = mixer_ctl_get_type(ctl);
144     num_values = mixer_ctl_get_num_values(ctl);
145 
146     ALOGV("%s:", mixer_ctl_get_name(ctl));
147 
148     for (i = 0; i < num_values; i++) {
149         switch (type) {
150             case MIXER_CTL_TYPE_INT:
151                 ALOGV(" %d", mixer_ctl_get_value(ctl, i));
152                 break;
153             case MIXER_CTL_TYPE_BOOL:
154                 ALOGV(" %s", mixer_ctl_get_value(ctl, i) ? "On" : "Off");
155                 break;
156             case MIXER_CTL_TYPE_ENUM:
157                 usb_mixer_print_enum(ctl);
158                 break;
159             case MIXER_CTL_TYPE_BYTE:
160                 ALOGV(" 0x%02x", mixer_ctl_get_value(ctl, i));
161                 break;
162             default:
163                 ALOGV(" unknown");
164                 break;
165         }
166     }
167 
168     if (type == MIXER_CTL_TYPE_INT) {
169         min = mixer_ctl_get_range_min(ctl);
170         max = mixer_ctl_get_range_max(ctl);
171         ALOGV(" (range %d->%d)", min, max);
172     }
173 }
174 
usb_soundcard_list_controls(struct mixer * mixer)175 static void usb_soundcard_list_controls(struct mixer *mixer)
176 {
177     struct mixer_ctl *ctl;
178     const char *name, *type;
179     unsigned int num_ctls, num_values;
180     unsigned int i;
181 
182     num_ctls = mixer_get_num_ctls(mixer);
183 
184     ALOGV("Number of controls: %d\n", num_ctls);
185 
186     ALOGV("ctl\ttype\tnum\t%-40s value\n", "name");
187     for (i = 0; i < num_ctls; i++) {
188         ctl = mixer_get_ctl(mixer, i);
189         if (ctl != NULL) {
190             name = mixer_ctl_get_name(ctl);
191             type = mixer_ctl_get_type_string(ctl);
192             num_values = mixer_ctl_get_num_values(ctl);
193             ALOGV("%d\t%s\t%d\t%-40s", i, type, num_values, name);
194             if (name != NULL)
195                 usb_soundcard_detail_control(mixer, name);
196         }
197     }
198 }
199 
usb_set_dev_id_mixer_ctl(unsigned int usb_usecase_type,int card,char * dev_mixer_ctl_name)200 static int usb_set_dev_id_mixer_ctl(unsigned int usb_usecase_type, int card,
201                                     char *dev_mixer_ctl_name)
202 {
203     struct mixer_ctl *ctl;
204     unsigned int dev_token;
205     const unsigned int pcm_device_number = 0;
206 
207     /*
208      * usb_dev_token_id is 32 bit number and is defined as below:
209      * usb_sound_card_idx(31:16) | usb PCM device ID(15:8) | usb_usecase_type(7:0)
210      */
211     dev_token = (card << 16 ) |
212                 (pcm_device_number << 8) | (usb_usecase_type & 0xFF);
213 
214     ctl = mixer_get_ctl_by_name(usbmod->adev->mixer, dev_mixer_ctl_name);
215     if (!ctl) {
216        ALOGE("%s: Could not get ctl for mixer cmd - %s",
217              __func__, dev_mixer_ctl_name);
218        return -EINVAL;
219     }
220     mixer_ctl_set_value(ctl, 0, dev_token);
221 
222     return 0;
223 }
224 
usb_get_sample_rates(int type,char * rates_str,struct usb_device_config * config)225 static int usb_get_sample_rates(int type, char *rates_str,
226                                 struct usb_device_config *config)
227 {
228     uint32_t i;
229     char *next_sr_string, *temp_ptr;
230     uint32_t sr, min_sr, max_sr, sr_size = 0;
231 
232     /* Sample rate string can be in any of the folloing two bit_widthes:
233      * Rates: 8000 - 48000 (continuous)
234      * Rates: 8000, 44100, 48000
235      * Support both the bit_widths
236      */
237     ALOGV("%s: rates_str %s", __func__, rates_str);
238     next_sr_string = strtok_r(rates_str, "Rates: ", &temp_ptr);
239     if (next_sr_string == NULL) {
240         ALOGE("%s: could not find min rates string", __func__);
241         return -EINVAL;
242     }
243     if (strstr(rates_str, "continuous") != NULL) {
244         min_sr = (uint32_t)atoi(next_sr_string);
245         next_sr_string = strtok_r(NULL, " ,.-", &temp_ptr);
246         if (next_sr_string == NULL) {
247             ALOGE("%s: could not find max rates string", __func__);
248             return -EINVAL;
249         }
250         max_sr = (uint32_t)atoi(next_sr_string);
251 
252         for (i = 0; i < MAX_SAMPLE_RATE_SIZE; i++) {
253             if (supported_sample_rates[i] >= min_sr &&
254                 supported_sample_rates[i] <= max_sr) {
255                 config->rates[sr_size++] = supported_sample_rates[i];
256                 supported_sample_rates_mask[type] |= (1<<i);
257                 ALOGI_IF(usb_audio_debug_enable,
258                     "%s: continuous sample rate supported_sample_rates[%d] %d",
259                     __func__, i, supported_sample_rates[i]);
260             }
261         }
262     } else {
263         do {
264             sr = (uint32_t)atoi(next_sr_string);
265             for (i = 0; i < MAX_SAMPLE_RATE_SIZE; i++) {
266                 if (supported_sample_rates[i] == sr) {
267                     ALOGI_IF(usb_audio_debug_enable,
268                         "%s: sr %d, supported_sample_rates[%d] %d -> matches!!",
269                         __func__, sr, i, supported_sample_rates[i]);
270                     config->rates[sr_size++] = supported_sample_rates[i];
271                     supported_sample_rates_mask[type] |= (1<<i);
272                 }
273             }
274             next_sr_string = strtok_r(NULL, " ,.-", &temp_ptr);
275         } while (next_sr_string != NULL);
276     }
277     config->rate_size = sr_size;
278     return 0;
279 }
280 
usb_get_service_interval(const char * interval_str_start,struct usb_device_config * usb_device_info)281 static int usb_get_service_interval(const char *interval_str_start,
282                                     struct usb_device_config *usb_device_info)
283 {
284     unsigned long interval = 0;
285     char time_unit[8] = {0};
286     int multiplier = 0;
287     char *eol = strchr(interval_str_start, '\n');
288     if (!eol) {
289         ALOGE("%s: No EOL found", __func__);
290         return -1;
291     }
292     char *tmp = (char *)calloc(1, eol-interval_str_start+1);
293     if (!tmp) {
294         ALOGE("%s: failed to allocate tmp", __func__);
295         return -1;
296     }
297     memcpy(tmp, interval_str_start, eol-interval_str_start);
298     sscanf(tmp, "%lu %2s", &interval, &time_unit[0]);
299     if (!strcmp(time_unit, "us")) {
300         multiplier = 1;
301     } else if (!strcmp(time_unit, "ms")) {
302         multiplier = 1000;
303     } else if (!strcmp(time_unit, "s")) {
304         multiplier = 1000000;
305     } else {
306         ALOGE("%s: unknown time_unit %s, assume default", __func__, time_unit);
307         interval = DEFAULT_SERVICE_INTERVAL_US;
308         multiplier = 1;
309     }
310     interval *= multiplier;
311     ALOGV("%s: set service_interval_us %lu", __func__, interval);
312     usb_device_info->service_interval_us = interval;
313     free(tmp);
314     return 0;
315 }
316 
317 
usb_get_capability(int type,struct usb_card_config * usb_card_info,int card)318 static int usb_get_capability(int type,
319                               struct usb_card_config *usb_card_info,
320                               int card)
321 {
322     int32_t size = 0;
323     int32_t fd=-1;
324     int32_t channels_no;
325     char *str_start = NULL;
326     char *str_end = NULL;
327     char *channel_start = NULL;
328     char *bit_width_start = NULL;
329     char *rates_str_start = NULL;
330     char *target = NULL;
331     char *read_buf = NULL;
332     char *rates_str = NULL;
333     char *interval_str_start = NULL;
334     char path[128];
335     int ret = 0;
336     char *bit_width_str = NULL;
337     struct usb_device_config * usb_device_info;
338     bool check = false;
339     int tries=3;
340 
341     memset(path, 0, sizeof(path));
342     ALOGV("%s: for %s", __func__, (type == USB_PLAYBACK) ?
343           PLAYBACK_PROFILE_STR : CAPTURE_PROFILE_STR);
344 
345     /* TODO: convert the below to using alsa_utils */
346     ret = snprintf(path, sizeof(path), "/proc/asound/card%u/stream0",
347              card);
348     if (ret < 0) {
349         ALOGE("%s: failed on snprintf (%d) to path %s\n",
350           __func__, ret, path);
351         goto done;
352     }
353 
354     // TODO: figure up if this wait is needed any more
355     while (tries--) {
356         if (access(path, F_OK) < 0) {
357             ALOGW("stream %s doesn't exist retrying %d more times\n", path, tries);
358             sleep(1);
359             continue;
360         }
361     }
362 
363     fd = open(path, O_RDONLY);
364     if (fd <0) {
365         ALOGE("%s: error failed to open config file %s error: %d\n",
366               __func__, path, errno);
367         ret = -EINVAL;
368         goto done;
369     }
370 
371     read_buf = (char *)calloc(1, USB_BUFF_SIZE + 1);
372 
373     if (!read_buf) {
374         ALOGE("Failed to create read_buf");
375         ret = -ENOMEM;
376         goto done;
377     }
378 
379     if(read(fd, read_buf, USB_BUFF_SIZE) < 0) {
380         ALOGE("file read error\n");
381         goto done;
382     }
383     str_start = strstr(read_buf, ((type == USB_PLAYBACK) ?
384                        PLAYBACK_PROFILE_STR : CAPTURE_PROFILE_STR));
385     if (str_start == NULL) {
386         ALOGE("%s: error %s section not found in usb config file",
387                __func__, ((type == USB_PLAYBACK) ?
388                PLAYBACK_PROFILE_STR : CAPTURE_PROFILE_STR));
389         ret = -EINVAL;
390         goto done;
391     }
392     str_end = strstr(read_buf, ((type == USB_PLAYBACK) ?
393                        CAPTURE_PROFILE_STR : PLAYBACK_PROFILE_STR));
394     if (str_end > str_start)
395         check = true;
396 
397     ALOGV("%s: usb_config = %s, check %d\n", __func__, str_start, check);
398 
399     while (str_start != NULL) {
400         str_start = strstr(str_start, "Altset");
401         if ((str_start == NULL) || (check  && (str_start >= str_end))) {
402             ALOGV("%s: done parsing %s\n", __func__, str_start);
403             break;
404         }
405         ALOGV("%s: remaining string %s\n", __func__, str_start);
406         str_start += sizeof("Altset");
407         usb_device_info = calloc(1, sizeof(struct usb_device_config));
408         if (usb_device_info == NULL) {
409             ALOGE("%s: error unable to allocate memory",
410                   __func__);
411             ret = -ENOMEM;
412             break;
413         }
414         usb_device_info->type = type;
415         /* Bit bit_width parsing */
416         bit_width_start = strstr(str_start, "Format: ");
417         if (bit_width_start == NULL) {
418             ALOGI("%s: Could not find bit_width string", __func__);
419             free(usb_device_info);
420             continue;
421         }
422         target = strchr(bit_width_start, '\n');
423         if (target == NULL) {
424             ALOGI("%s:end of line not found", __func__);
425             free(usb_device_info);
426             continue;
427         }
428         size = target - bit_width_start;
429         if ((bit_width_str = (char *)malloc(size + 1)) == NULL) {
430             ALOGE("%s: unable to allocate memory to hold bit width strings",
431                   __func__);
432             ret = -EINVAL;
433             free(usb_device_info);
434             break;
435         }
436         memcpy(bit_width_str, bit_width_start, size);
437         bit_width_str[size] = '\0';
438         if (strstr(bit_width_str, "S16_LE"))
439             usb_device_info->bit_width = 16;
440         else if (strstr(bit_width_str, "S24_LE"))
441             usb_device_info->bit_width = 24;
442         else if (strstr(bit_width_str, "S24_3LE"))
443             usb_device_info->bit_width = 24;
444         else if (strstr(bit_width_str, "S32_LE"))
445             usb_device_info->bit_width = 32;
446 
447         if (bit_width_str)
448             free(bit_width_str);
449 
450         /* channels parsing */
451         channel_start = strstr(str_start, CHANNEL_NUMBER_STR);
452         if (channel_start == NULL) {
453             ALOGI("%s: could not find Channels string", __func__);
454             free(usb_device_info);
455             continue;
456         }
457         channels_no = atoi(channel_start + strlen(CHANNEL_NUMBER_STR));
458         usb_device_info->channel_count =  channels_no;
459 
460         /* Sample rates parsing */
461         rates_str_start = strstr(str_start, "Rates: ");
462         if (rates_str_start == NULL) {
463             ALOGI("%s: cant find rates string", __func__);
464             free(usb_device_info);
465             continue;
466         }
467         target = strchr(rates_str_start, '\n');
468         if (target == NULL) {
469             ALOGI("%s: end of line not found", __func__);
470             free(usb_device_info);
471             continue;
472         }
473         size = target - rates_str_start;
474         if ((rates_str = (char *)malloc(size + 1)) == NULL) {
475             ALOGE("%s: unable to allocate memory to hold sample rate strings",
476                   __func__);
477             ret = -EINVAL;
478             free(usb_device_info);
479             break;
480         }
481         memcpy(rates_str, rates_str_start, size);
482         rates_str[size] = '\0';
483         ret = usb_get_sample_rates(type, rates_str, usb_device_info);
484         if (rates_str)
485             free(rates_str);
486         if (ret < 0) {
487             ALOGE("%s: error unable to get sample rate values",
488                   __func__);
489             free(usb_device_info);
490             continue;
491         }
492         // Data packet interval is an optional field.
493         // Assume 1ms interval if this cannot be read
494         usb_device_info->service_interval_us = DEFAULT_SERVICE_INTERVAL_US;
495         interval_str_start = strstr(str_start, DATA_PACKET_INTERVAL_STR);
496         if (interval_str_start != NULL) {
497             interval_str_start += strlen(DATA_PACKET_INTERVAL_STR);
498             ret = usb_get_service_interval(interval_str_start, usb_device_info);
499             if (ret < 0) {
500                 ALOGE("%s: error unable to get service interval, assume default",
501                       __func__);
502             }
503         }
504         /* Add to list if every field is valid */
505         list_add_tail(&usb_card_info->usb_device_conf_list,
506                       &usb_device_info->list);
507     }
508 
509 done:
510     if (fd >= 0) close(fd);
511     if (read_buf) free(read_buf);
512     return ret;
513 }
514 
usb_get_usbid(struct usb_card_config * usb_card_info,int card)515 static int usb_get_usbid(struct usb_card_config *usb_card_info,
516                               int card)
517 {
518     int32_t fd=-1;
519     char path[128];
520     int ret = 0;
521 
522     memset(usb_card_info->usbid, 0, sizeof(usb_card_info->usbid));
523 
524     ret = snprintf(path, sizeof(path), "/proc/asound/card%u/usbid",
525              card);
526 
527     if (ret < 0) {
528         ALOGE("%s: failed on snprintf (%d) to path %s\n",
529           __func__, ret, path);
530         goto done;
531     }
532 
533     fd = open(path, O_RDONLY);
534     if (fd < 0) {
535         ALOGE("%s: error failed to open file %s error: %d\n",
536               __func__, path, errno);
537         ret = -EINVAL;
538         goto done;
539     }
540 
541     if (read(fd, usb_card_info->usbid, USBID_SIZE - 1) < 0) {
542         ALOGE("file read error\n");
543         ret = -EINVAL;
544         usb_card_info->usbid[0] = '\0';
545         goto done;
546     }
547 
548     strtok(usb_card_info->usbid, "\n");
549 
550 done:
551     if (fd >= 0)
552         close(fd);
553 
554     return ret;
555 }
556 
usb_get_device_playback_config(struct usb_card_config * usb_card_info,int card)557 static int usb_get_device_playback_config(struct usb_card_config *usb_card_info,
558                                     int card)
559 {
560     int ret;
561 
562     /* get capabilities */
563     if ((ret = usb_get_capability(USB_PLAYBACK, usb_card_info, card))) {
564         ALOGE("%s: could not get Playback capabilities from usb device",
565                __func__);
566         goto exit;
567     }
568     usb_set_dev_id_mixer_ctl(USB_PLAYBACK, card, "USB_AUDIO_RX dev_token");
569 
570 exit:
571 
572     return ret;
573 }
574 
usb_get_device_capture_config(struct usb_card_config * usb_card_info,int card)575 static int usb_get_device_capture_config(struct usb_card_config *usb_card_info,
576                                       int card)
577 {
578     int ret;
579 
580     /* get capabilities */
581     if ((ret = usb_get_capability(USB_CAPTURE, usb_card_info, card))) {
582         ALOGE("%s: could not get Playback capabilities from usb device",
583                __func__);
584         goto exit;
585     }
586     usb_set_dev_id_mixer_ctl(USB_CAPTURE, card, "USB_AUDIO_TX dev_token");
587 
588 exit:
589     return ret;
590 }
591 
usb_get_sidetone_mixer(struct usb_card_config * usb_card_info)592 static void usb_get_sidetone_mixer(struct usb_card_config *usb_card_info)
593 {
594     struct mixer_ctl *ctl;
595     unsigned int index;
596 
597     for (index = 0; index < USB_SIDETONE_MAX_INDEX; index++)
598         usb_card_info->usb_sidetone_index[index] = -1;
599 
600     usb_card_info->usb_snd_mixer = mixer_open(usb_card_info->usb_card);
601     for (index = 0;
602          index < sizeof(usb_sidetone_enable_str)/sizeof(usb_sidetone_enable_str[0]);
603          index++) {
604         ctl = mixer_get_ctl_by_name(usb_card_info->usb_snd_mixer,
605                                     usb_sidetone_enable_str[index]);
606         if (ctl) {
607             usb_card_info->usb_sidetone_index[USB_SIDETONE_ENABLE_INDEX] = index;
608             /* Disable device sidetone by default */
609             mixer_ctl_set_value(ctl, 0, false);
610             ALOGV("%s:: sidetone mixer Control found(%s) ... disabling by default",
611                    __func__, usb_sidetone_enable_str[index]);
612             break;
613         }
614     }
615 #ifdef USB_SIDETONE_VOLUME
616     for (index = 0;
617          index < sizeof(usb_sidetone_volume_str)/sizeof(usb_sidetone_volume_str[0]);
618          index++) {
619         ctl = mixer_get_ctl_by_name(usb_card_info->usb_snd_mixer,
620                                     usb_sidetone_volume_str[index]);
621         if (ctl) {
622             usb_card_info->usb_sidetone_index[USB_SIDETONE_VOLUME_INDEX] = index;
623             usb_card_info->usb_sidetone_vol_min = mixer_ctl_get_range_min(ctl);
624             usb_card_info->usb_sidetone_vol_max = mixer_ctl_get_range_max(ctl);
625             break;
626         }
627     }
628 #endif // USB_SIDETONE_VOLUME
629     if ((usb_card_info->usb_snd_mixer != NULL) && (usb_audio_debug_enable))
630         usb_soundcard_list_controls(usb_card_info->usb_snd_mixer);
631 
632     return;
633 }
634 
usb_output_device(audio_devices_t device)635 static inline bool usb_output_device(audio_devices_t device) {
636     // ignore accessory for now
637     if (device == AUDIO_DEVICE_OUT_USB_ACCESSORY) {
638         return false;
639     }
640     return audio_is_usb_out_device(device);
641 }
642 
usb_input_device(audio_devices_t device)643 static inline bool usb_input_device(audio_devices_t device) {
644     // ignore accessory for now
645     if (device == AUDIO_DEVICE_IN_USB_ACCESSORY) {
646         return false;
647     }
648     return audio_is_usb_in_device(device);
649 }
650 
usb_valid_device(audio_devices_t device)651 static bool usb_valid_device(audio_devices_t device)
652 {
653     return usb_output_device(device) ||
654            usb_input_device(device);
655 }
656 
usb_print_active_device(void)657 static void usb_print_active_device(void){
658     struct listnode *node_i, *node_j;
659     struct usb_device_config *dev_info;
660     struct usb_card_config *card_info;
661     unsigned int i;
662 
663     ALOGI("%s", __func__);
664     list_for_each(node_i, &usbmod->usb_card_conf_list) {
665         card_info = node_to_item(node_i, struct usb_card_config, list);
666         ALOGI("%s: card_dev_type (0x%x), card_no(%d)",
667                __func__,  card_info->usb_device_type, card_info->usb_card);
668         list_for_each(node_j, &card_info->usb_device_conf_list) {
669             dev_info = node_to_item(node_j, struct usb_device_config, list);
670             ALOGI("%s: bit-width(%d) channel(%d)",
671                    __func__, dev_info->bit_width, dev_info->channel_count);
672             for (i =  0; i < dev_info->rate_size; i++)
673                 ALOGI("%s: rate %d", __func__, dev_info->rates[i]);
674         }
675     }
676 }
677 
usb_get_best_bit_width(struct listnode * dev_list,unsigned int stream_bit_width,unsigned int * bit_width)678 static bool usb_get_best_bit_width(
679                             struct listnode *dev_list,
680                             unsigned int stream_bit_width,
681                             unsigned int *bit_width)
682 {
683     struct listnode *node_i;
684     struct usb_device_config *dev_info;
685     unsigned int candidate = 0;
686 
687     list_for_each(node_i, dev_list) {
688         dev_info = node_to_item(node_i, struct usb_device_config, list);
689         ALOGI_IF(usb_audio_debug_enable,
690                  "%s: USB bw(%d), stream bw(%d), candidate(%d)",
691                  __func__, dev_info->bit_width,
692                  stream_bit_width, candidate);
693         if (candidate == 0) {
694             ALOGV("%s: candidate bit-width (%d)",
695                   __func__, dev_info->bit_width);
696             candidate = dev_info->bit_width;
697         } else if (dev_info->bit_width > candidate) {
698             candidate = dev_info->bit_width;
699             ALOGV("%s: Found better candidate bit-width (%d)",
700                   __func__, dev_info->bit_width);
701         }
702     }
703     ALOGV("%s: Use the best candidate bw(%d)",
704           __func__, candidate);
705     *bit_width = candidate;
706 exit:
707     return true;
708 }
709 
usb_get_best_match_for_channels(struct listnode * dev_list,unsigned int bit_width,unsigned int stream_ch,unsigned int * channel_count)710 static bool usb_get_best_match_for_channels(
711                             struct listnode *dev_list,
712                             unsigned int bit_width,
713                             unsigned int stream_ch,
714                             unsigned int *channel_count)
715 {
716     struct listnode *node_i;
717     struct usb_device_config *dev_info;
718     unsigned int candidate = 0;
719 
720     list_for_each(node_i, dev_list) {
721         dev_info = node_to_item(node_i, struct usb_device_config, list);
722         ALOGI_IF(usb_audio_debug_enable,
723                  "%s: USB ch(%d)bw(%d), stream ch(%d)bw(%d), candidate(%d)",
724                  __func__, dev_info->channel_count, dev_info->bit_width,
725                  stream_ch, bit_width, candidate);
726         if (dev_info->bit_width != bit_width)
727             continue;
728         if (dev_info->channel_count== stream_ch) {
729             *channel_count = dev_info->channel_count;
730             ALOGV("%s: Found match channels (%d)",
731                   __func__, dev_info->channel_count);
732             goto exit;
733         } else if (candidate == 0)
734                 candidate = dev_info->channel_count;
735             /*
736             * If stream channel is 4, USB supports both 3 and 5, then
737             *  higher channel 5 is picked up instead of 3
738             */
739         else if (ABS_SUB(stream_ch, dev_info->channel_count) <
740                  ABS_SUB(stream_ch, candidate)) {
741             candidate = dev_info->channel_count;
742         } else if ((ABS_SUB(stream_ch, dev_info->channel_count) ==
743                     ABS_SUB(stream_ch, candidate)) &&
744                    (dev_info->channel_count > candidate)) {
745             candidate = dev_info->channel_count;
746         }
747     }
748     ALOGV("%s: No match found, use the best candidate ch(%d)",
749           __func__, candidate);
750     *channel_count = candidate;
751 exit:
752     return true;
753 
754 }
755 
usb_sample_rate_multiple(unsigned int stream_sample_rate,unsigned int base)756 static bool usb_sample_rate_multiple(
757                                      unsigned int stream_sample_rate,
758                                      unsigned int base)
759 {
760     return (((stream_sample_rate / base) * base) == stream_sample_rate);
761 }
762 
usb_find_sample_rate_candidate(unsigned int base,unsigned stream_rate,unsigned int usb_rate,unsigned int cur_candidate,unsigned int * update_candidate)763 static bool usb_find_sample_rate_candidate(unsigned int base,
764                                            unsigned stream_rate,
765                                            unsigned int usb_rate,
766                                            unsigned int cur_candidate,
767                                            unsigned int *update_candidate)
768 {
769     /* For sample rate, we should consider  fracational sample rate as high priority.
770     * For example, if the stream is 88.2kHz and USB device support both 44.1kH and
771     * 48kHz sample rate, we should pick 44.1kHz instead of 48kHz
772     */
773     if (!usb_sample_rate_multiple(cur_candidate, base) &&
774        usb_sample_rate_multiple(usb_rate, base)) {
775         *update_candidate = usb_rate;
776     } else if (usb_sample_rate_multiple(cur_candidate, base) &&
777                usb_sample_rate_multiple(usb_rate, base)) {
778         if (ABS_SUB(stream_rate, usb_rate) <
779             ABS_SUB(stream_rate, cur_candidate)) {
780             *update_candidate = usb_rate;
781         } else if ((ABS_SUB(stream_rate, usb_rate) ==
782                     ABS_SUB(stream_rate, cur_candidate)) &&
783                    (usb_rate > cur_candidate)) {
784             *update_candidate = usb_rate;
785         }
786     } else if (!usb_sample_rate_multiple(cur_candidate, base) &&
787                !usb_sample_rate_multiple(usb_rate, base)) {
788         if (ABS_SUB(stream_rate, usb_rate) <
789             ABS_SUB(stream_rate, cur_candidate)) {
790             *update_candidate = usb_rate;
791         } else if ((ABS_SUB(stream_rate, usb_rate) ==
792                     ABS_SUB(stream_rate, cur_candidate)) &&
793                    (usb_rate > cur_candidate)) {
794             *update_candidate = usb_rate;
795         }
796     }
797     return true;
798 }
799 
usb_get_best_match_for_sample_rate(struct listnode * dev_list,unsigned int bit_width,unsigned int channel_count,unsigned int stream_sample_rate,unsigned int * sr,unsigned int service_interval,bool do_service_interval_check)800 static bool usb_get_best_match_for_sample_rate (
801                             struct listnode *dev_list,
802                             unsigned int bit_width,
803                             unsigned int channel_count,
804                             unsigned int stream_sample_rate,
805                             unsigned int *sr,
806                             unsigned int service_interval,
807                             bool do_service_interval_check)
808 {
809     struct listnode *node_i;
810     struct usb_device_config *dev_info;
811     unsigned int candidate = 48000;
812     unsigned int base = SAMPLE_RATE_8000;
813     bool multiple_8k = usb_sample_rate_multiple(stream_sample_rate, base);
814     unsigned int i;
815 
816     ALOGV("%s: stm ch(%d)bw(%d)sr(%d), stream sample multiple of 8kHz(%d)",
817         __func__, channel_count, bit_width, stream_sample_rate, multiple_8k);
818 
819     list_for_each(node_i, dev_list) {
820         dev_info = node_to_item(node_i, struct usb_device_config, list);
821         ALOGI_IF(usb_audio_debug_enable,
822                  "%s: USB ch(%d)bw(%d), stm ch(%d)bw(%d)sr(%d), candidate(%d)",
823                  __func__, dev_info->channel_count, dev_info->bit_width,
824                  channel_count, bit_width, stream_sample_rate, candidate);
825         if ((dev_info->bit_width != bit_width) ||
826             (dev_info->channel_count != channel_count) ||
827             (do_service_interval_check && (dev_info->service_interval_us !=
828                                            service_interval)))
829             continue;
830 
831         candidate = 0;
832         for (i = 0; i < dev_info->rate_size; i++) {
833             ALOGI_IF(usb_audio_debug_enable,
834                      "%s: USB ch(%d)bw(%d)sr(%d), stm ch(%d)bw(%d)sr(%d), candidate(%d)",
835                      __func__, dev_info->channel_count,
836                      dev_info->bit_width, dev_info->rates[i],
837                      channel_count, bit_width, stream_sample_rate, candidate);
838             if (stream_sample_rate == dev_info->rates[i]) {
839                 *sr = dev_info->rates[i];
840                 ALOGV("%s: Found match sample rate (%d)",
841                       __func__, dev_info->rates[i]);
842                 goto exit;
843             } else if (candidate == 0) {
844                     candidate = dev_info->rates[i];
845                 /*
846                 * For sample rate, we should consider  fracational sample rate as high priority.
847                 * For example, if the stream is 88.2kHz and USB device support both 44.1kH and
848                 * 48kHz sample rate, we should pick 44.1kHz instead of 48kHz
849                 */
850             } else if (multiple_8k) {
851                 usb_find_sample_rate_candidate(SAMPLE_RATE_8000,
852                                                stream_sample_rate,
853                                                dev_info->rates[i],
854                                                candidate,
855                                                &candidate);
856             } else {
857                 usb_find_sample_rate_candidate(SAMPLE_RATE_11025,
858                                                stream_sample_rate,
859                                                dev_info->rates[i],
860                                                candidate,
861                                                &candidate);
862             }
863         }
864     }
865     ALOGV("%s: No match found, use the best candidate sr(%d)",
866           __func__, candidate);
867     *sr = candidate;
868 exit:
869     return true;
870 }
871 
usb_audio_backend_apply_policy(struct listnode * dev_list,unsigned int * bit_width,unsigned int * sample_rate,unsigned int * channel_count)872 static bool usb_audio_backend_apply_policy(struct listnode *dev_list,
873                                            unsigned int *bit_width,
874                                            unsigned int *sample_rate,
875                                            unsigned int *channel_count)
876 {
877     ALOGV("%s: from stream: bit-width(%d) sample_rate(%d) channels (%d)",
878            __func__, *bit_width, *sample_rate, *channel_count);
879     if (list_empty(dev_list)) {
880         *sample_rate = 48000;
881         *bit_width = 16;
882         *channel_count = 2;
883         ALOGE("%s: list is empty,fall back to default setting", __func__);
884         goto exit;
885     }
886     usb_get_best_bit_width(dev_list, *bit_width, bit_width);
887     usb_get_best_match_for_channels(dev_list,
888                                     *bit_width,
889                                     *channel_count,
890                                     channel_count);
891     usb_get_best_match_for_sample_rate(dev_list,
892                                        *bit_width,
893                                        *channel_count,
894                                        *sample_rate,
895                                        sample_rate,
896                                        0 /*service int*/,
897                                        false /*do service int check*/);
898 exit:
899     ALOGV("%s: Updated sample rate per profile: bit-width(%d) rate(%d) chs(%d)",
900            __func__, *bit_width, *sample_rate, *channel_count);
901     return true;
902 }
903 
usb_get_sidetone_gain(struct usb_card_config * card_info)904 static int usb_get_sidetone_gain(struct usb_card_config *card_info)
905 {
906     int gain = card_info->usb_sidetone_vol_min + usbmod->sidetone_gain;
907     if (gain > card_info->usb_sidetone_vol_max)
908         gain = card_info->usb_sidetone_vol_max;
909     return gain;
910 }
911 
audio_extn_usb_set_sidetone_gain(struct str_parms * parms,char * value,int len)912 void audio_extn_usb_set_sidetone_gain(struct str_parms *parms,
913                                 char *value, int len)
914 {
915     int err;
916 
917     err = str_parms_get_str(parms, USB_SIDETONE_GAIN_STR,
918                             value, len);
919     if (err >= 0) {
920         usb_sidetone_gain = pow(10.0, (float)(atoi(value))/10.0);
921         ALOGV("%s: sidetone gain(%s) decimal %d",
922               __func__, value, usb_sidetone_gain);
923         str_parms_del(parms, USB_SIDETONE_GAIN_STR);
924     }
925     return;
926 }
927 
audio_extn_usb_enable_sidetone(int device,bool enable)928 int audio_extn_usb_enable_sidetone(int device, bool enable)
929 {
930     int ret = -ENODEV;
931     struct listnode *node_i;
932     struct usb_card_config *card_info;
933     int i;
934     ALOGV("%s: card_dev_type (0x%x), sidetone enable(%d)",
935            __func__,  device, enable);
936 
937     list_for_each(node_i, &usbmod->usb_card_conf_list) {
938         card_info = node_to_item(node_i, struct usb_card_config, list);
939         ALOGV("%s: card_dev_type (0x%x), card_no(%d)",
940                __func__,  card_info->usb_device_type, card_info->usb_card);
941         if (usb_output_device(card_info->usb_device_type)) {
942             if ((i = card_info->usb_sidetone_index[USB_SIDETONE_ENABLE_INDEX]) != -1) {
943                 struct mixer_ctl *ctl = mixer_get_ctl_by_name(
944                                 card_info->usb_snd_mixer,
945                                 usb_sidetone_enable_str[i]);
946                 if (ctl)
947                     mixer_ctl_set_value(ctl, 0, enable);
948                 else
949                     break;
950 
951 #ifdef USB_SIDETONE_VOLUME
952                 if ((i = card_info->usb_sidetone_index[USB_SIDETONE_VOLUME_INDEX]) != -1) {
953                     ctl = mixer_get_ctl_by_name(
954                                 card_info->usb_snd_mixer,
955                                 usb_sidetone_volume_str[i]);
956                     if (ctl == NULL)
957                         ALOGV("%s: sidetone gain mixer command is not found",
958                                __func__);
959                     else if (enable)
960                         mixer_ctl_set_value(ctl, 0,
961                                             usb_get_sidetone_gain(card_info));
962                 }
963 #endif // USB_SIDETONE_VOLUME
964                 ret = 0;
965                 break;
966             }
967         }
968     }
969     return ret;
970 }
971 
audio_extn_usb_is_config_supported(unsigned int * bit_width,unsigned int * sample_rate,unsigned int * channel_count,bool is_playback)972 bool audio_extn_usb_is_config_supported(unsigned int *bit_width,
973                                         unsigned int *sample_rate,
974                                         unsigned int *channel_count,
975                                         bool is_playback)
976 {
977     struct listnode *node_i;
978     struct usb_card_config *card_info;
979 
980     ALOGV("%s: from stream: bit-width(%d) sample_rate(%d) ch(%d) is_playback(%d)",
981            __func__, *bit_width, *sample_rate, *channel_count, is_playback);
982     list_for_each(node_i, &usbmod->usb_card_conf_list) {
983         card_info = node_to_item(node_i, struct usb_card_config, list);
984         ALOGI_IF(usb_audio_debug_enable,
985                  "%s: card_dev_type (0x%x), card_no(%d)",
986                  __func__,  card_info->usb_device_type, card_info->usb_card);
987         /* Currently only apply the first playback sound card configuration */
988         if ((is_playback && usb_output_device(card_info->usb_device_type)) ||
989             (!is_playback && usb_input_device(card_info->usb_device_type))) {
990             usb_audio_backend_apply_policy(&card_info->usb_device_conf_list,
991                                            bit_width,
992                                            sample_rate,
993                                            channel_count);
994             break;
995         }
996     }
997     ALOGV("%s: updated: bit-width(%d) sample_rate(%d) channels (%d)",
998            __func__, *bit_width, *sample_rate, *channel_count);
999 
1000     return true;
1001 }
1002 
1003 #define _MAX(x, y) (((x) >= (y)) ? (x) : (y))
1004 #define _MIN(x, y) (((x) <= (y)) ? (x) : (y))
1005 
audio_extn_usb_get_max_channels(bool is_playback)1006 int audio_extn_usb_get_max_channels(bool is_playback)
1007 {
1008     struct listnode *node_i, *node_j;
1009     struct usb_device_config *dev_info;
1010     struct usb_card_config *card_info;
1011     unsigned int max_ch = 1;
1012     list_for_each(node_i, &usbmod->usb_card_conf_list) {
1013             card_info = node_to_item(node_i, struct usb_card_config, list);
1014             if (usb_output_device(card_info->usb_device_type) && !is_playback)
1015                 continue;
1016             else if (usb_input_device(card_info->usb_device_type) && is_playback)
1017                 continue;
1018 
1019             list_for_each(node_j, &card_info->usb_device_conf_list) {
1020                 dev_info = node_to_item(node_j, struct usb_device_config, list);
1021                 max_ch = _MAX(max_ch, dev_info->channel_count);
1022             }
1023     }
1024 
1025     return max_ch;
1026 }
1027 
audio_extn_usb_get_max_bit_width(bool is_playback)1028 int audio_extn_usb_get_max_bit_width(bool is_playback)
1029 {
1030     struct listnode *node_i, *node_j;
1031     struct usb_device_config *dev_info;
1032     struct usb_card_config *card_info;
1033     unsigned int max_bw = 16;
1034     list_for_each(node_i, &usbmod->usb_card_conf_list) {
1035             card_info = node_to_item(node_i, struct usb_card_config, list);
1036             if (usb_output_device(card_info->usb_device_type) && !is_playback)
1037                 continue;
1038             else if (usb_input_device(card_info->usb_device_type) && is_playback)
1039                 continue;
1040 
1041             list_for_each(node_j, &card_info->usb_device_conf_list) {
1042                 dev_info = node_to_item(node_j, struct usb_device_config, list);
1043                 max_bw = _MAX(max_bw, dev_info->bit_width);
1044             }
1045     }
1046 
1047     return max_bw;
1048 }
1049 
audio_extn_usb_sup_sample_rates(bool is_playback,uint32_t * sample_rates,uint32_t sample_rate_size)1050 int audio_extn_usb_sup_sample_rates(bool is_playback,
1051                                     uint32_t *sample_rates,
1052                                     uint32_t sample_rate_size)
1053 {
1054     struct listnode *node_i, *node_j;
1055     struct usb_device_config *dev_info;
1056     struct usb_card_config *card_info;
1057 
1058     int type = is_playback ? USB_PLAYBACK : USB_CAPTURE;
1059 
1060     ALOGV("%s supported_sample_rates_mask 0x%x", __func__, supported_sample_rates_mask[type]);
1061     uint32_t bm = supported_sample_rates_mask[type];
1062     uint32_t tries = _MIN(sample_rate_size, (uint32_t)__builtin_popcount(bm));
1063 
1064     int i = 0;
1065     while (tries--) {
1066         int idx = __builtin_ffs(bm) - 1;
1067         sample_rates[i++] = supported_sample_rates[idx];
1068         bm &= ~(1<<idx);
1069     }
1070 
1071     return i;
1072 }
1073 
audio_extn_usb_is_capture_supported()1074 bool audio_extn_usb_is_capture_supported()
1075 {
1076     if (usbmod == NULL) {
1077         ALOGE("%s: USB device object is NULL", __func__);
1078         return false;
1079     }
1080     ALOGV("%s: capture_supported %d",__func__,usbmod->is_capture_supported);
1081     return usbmod->is_capture_supported;
1082 }
1083 
audio_extn_usb_add_device(audio_devices_t device,int card)1084 void audio_extn_usb_add_device(audio_devices_t device, int card)
1085 {
1086     struct usb_card_config *usb_card_info;
1087     char check_debug_enable[PROPERTY_VALUE_MAX];
1088     struct listnode *node_i;
1089 
1090     property_get("audio.usb.enable.debug", check_debug_enable, NULL);
1091     if (atoi(check_debug_enable)) {
1092         usb_audio_debug_enable = true;
1093     }
1094 
1095     ALOGI_IF(usb_audio_debug_enable,
1096              "%s: parameters device(0x%x), card(%d)",
1097              __func__, device, card);
1098     if (usbmod == NULL) {
1099         ALOGE("%s: USB device object is NULL", __func__);
1100         goto exit;
1101     }
1102 
1103     if (!(usb_valid_device(device)) || (card < 0)) {
1104         ALOGE("%s:device(0x%x), card(%d)",
1105               __func__, device, card);
1106         goto exit;
1107     }
1108 
1109     list_for_each(node_i, &usbmod->usb_card_conf_list) {
1110         usb_card_info = node_to_item(node_i, struct usb_card_config, list);
1111         ALOGI_IF(usb_audio_debug_enable,
1112                  "%s: list has capability for card_dev_type (0x%x), card_no(%d)",
1113                  __func__,  usb_card_info->usb_device_type, usb_card_info->usb_card);
1114         /* If we have cached the capability */
1115         if ((usb_card_info->usb_device_type == device) && (usb_card_info->usb_card == card)) {
1116             ALOGV("%s: capability for device(0x%x), card(%d) is cached, no need to update",
1117                   __func__, device, card);
1118             goto exit;
1119         }
1120     }
1121     usb_card_info = calloc(1, sizeof(struct usb_card_config));
1122     if (usb_card_info == NULL) {
1123         ALOGE("%s: error unable to allocate memory",
1124               __func__);
1125         goto exit;
1126     }
1127     list_init(&usb_card_info->usb_device_conf_list);
1128     if (usb_output_device(device)) {
1129         if (usb_get_usbid(usb_card_info, card) < 0) {
1130             ALOGE("parse card %d usbid fail", card);
1131         }
1132 
1133         if (!usb_get_device_playback_config(usb_card_info, card)){
1134             usb_card_info->usb_card = card;
1135             usb_card_info->usb_device_type = device;
1136             usb_get_sidetone_mixer(usb_card_info);
1137             list_add_tail(&usbmod->usb_card_conf_list, &usb_card_info->list);
1138             goto exit;
1139         }
1140     } else if (usb_input_device(device)) {
1141         if (usb_get_usbid(usb_card_info, card) < 0) {
1142             ALOGE("parse card %d usbid fail", card);
1143         }
1144 
1145         if (!usb_get_device_capture_config(usb_card_info, card)) {
1146             usb_card_info->usb_card = card;
1147             usb_card_info->usb_device_type = device;
1148             usbmod->is_capture_supported = true;
1149             list_add_tail(&usbmod->usb_card_conf_list, &usb_card_info->list);
1150             goto exit;
1151         }
1152     } else {
1153         ALOGW("%s: unknown device 0x%x", __func__, device);
1154     }
1155     /* free memory in error case */
1156     if (usb_card_info != NULL)
1157         free(usb_card_info);
1158 exit:
1159     if (usb_audio_debug_enable)
1160         usb_print_active_device();
1161     return;
1162 }
1163 
audio_extn_usb_remove_device(audio_devices_t device,int card)1164 void audio_extn_usb_remove_device(audio_devices_t device, int card)
1165 {
1166     struct listnode *node_i, *temp_i;
1167     struct listnode *node_j, *temp_j;
1168     struct usb_device_config *dev_info;
1169     struct usb_card_config *card_info;
1170     unsigned int i;
1171 
1172     ALOGV("%s: device(0x%x), card(%d)",
1173            __func__, device, card);
1174 
1175     if (usbmod == NULL) {
1176         ALOGE("%s: USB device object is NULL", __func__);
1177         goto exit;
1178     }
1179 
1180     if (!(usb_valid_device(device)) || (card < 0)) {
1181         ALOGE("%s: Invalid parameters device(0x%x), card(%d)",
1182               __func__, device, card);
1183         goto exit;
1184     }
1185     list_for_each_safe(node_i, temp_i, &usbmod->usb_card_conf_list) {
1186         card_info = node_to_item(node_i, struct usb_card_config, list);
1187         ALOGV("%s: card_dev_type (0x%x), card_no(%d)",
1188                __func__,  card_info->usb_device_type, card_info->usb_card);
1189         if ((device == card_info->usb_device_type) && (card == card_info->usb_card)){
1190             list_for_each_safe(node_j, temp_j, &card_info->usb_device_conf_list) {
1191                 dev_info = node_to_item(node_j, struct usb_device_config, list);
1192                 ALOGV("%s: bit-width(%d) channel(%d)",
1193                        __func__, dev_info->bit_width, dev_info->channel_count);
1194                 for (i =  0; i < dev_info->rate_size; i++)
1195                     ALOGV("%s: rate %d", __func__, dev_info->rates[i]);
1196 
1197                 list_remove(node_j);
1198                 free(node_to_item(node_j, struct usb_device_config, list));
1199             }
1200             list_remove(node_i);
1201             if (card_info->usb_snd_mixer) {
1202                 mixer_close(card_info->usb_snd_mixer);
1203             }
1204             free(node_to_item(node_i, struct usb_card_config, list));
1205         }
1206     }
1207     if (audio_is_usb_in_device(device)) { // XXX not sure if we need to check for card
1208         usbmod->is_capture_supported = false;
1209         supported_sample_rates_mask[USB_CAPTURE] = 0;
1210     } else {
1211         supported_sample_rates_mask[USB_PLAYBACK] = 0;
1212     }
1213 
1214 exit:
1215     if (usb_audio_debug_enable)
1216         usb_print_active_device();
1217 
1218     return;
1219 }
1220 
audio_extn_usb_alive(int card)1221 bool audio_extn_usb_alive(int card) {
1222     char path[PATH_MAX] = {0};
1223     // snprintf should never fail
1224     (void) snprintf(path, sizeof(path), "/proc/asound/card%u/stream0", card);
1225     return access(path, F_OK) == 0;
1226 }
1227 
audio_extn_usb_find_service_interval(bool min,bool playback)1228 unsigned long audio_extn_usb_find_service_interval(bool min,
1229                                                    bool playback) {
1230     struct usb_card_config *card_info;
1231     struct usb_device_config *dev_info;
1232     struct listnode *node_i;
1233     struct listnode *node_j;
1234     unsigned long interval_us = min ? ULONG_MAX : 1; // 0 is invalid
1235     list_for_each(node_i, &usbmod->usb_card_conf_list) {
1236         card_info = node_to_item(node_i, struct usb_card_config, list);
1237         list_for_each(node_j, &card_info->usb_device_conf_list) {
1238             dev_info = node_to_item(node_j, struct usb_device_config, list);
1239             if ((playback && (dev_info->type == USB_PLAYBACK)) ||
1240                 (!playback && (dev_info->type == USB_CAPTURE))) {
1241                 interval_us = min ?
1242                         _MIN(interval_us, dev_info->service_interval_us) :
1243                         _MAX(interval_us, dev_info->service_interval_us);
1244             }
1245         }
1246         break;
1247     }
1248     return interval_us;
1249 }
1250 
audio_extn_usb_altset_for_service_interval(bool playback,unsigned long service_interval,uint32_t * bit_width,uint32_t * sample_rate,uint32_t * channel_count)1251 int audio_extn_usb_altset_for_service_interval(bool playback,
1252                                                unsigned long service_interval,
1253                                                uint32_t *bit_width,
1254                                                uint32_t *sample_rate,
1255                                                uint32_t *channel_count)
1256 {
1257     struct usb_card_config *card_info;
1258     struct usb_device_config *dev_info;
1259     struct listnode *node_i;
1260     struct listnode *node_j;
1261     uint32_t bw = 0;
1262     uint32_t ch = 0;
1263     uint32_t sr = 0;
1264     list_for_each(node_i, &usbmod->usb_card_conf_list) {
1265         /* Currently only apply the first playback sound card configuration */
1266         card_info = node_to_item(node_i, struct usb_card_config, list);
1267         list_for_each(node_j, &card_info->usb_device_conf_list) {
1268             dev_info = node_to_item(node_j, struct usb_device_config, list);
1269             if ((playback && dev_info->type == USB_PLAYBACK) ||
1270                 (!playback && dev_info->type == USB_CAPTURE)) {
1271                 if (dev_info->service_interval_us != service_interval)
1272                     continue;
1273                 if (dev_info->bit_width > bw) {
1274                     bw = dev_info->bit_width;
1275                     ch = dev_info->channel_count;
1276                 } else if (dev_info->bit_width == bw &&
1277                            dev_info->channel_count > ch) {
1278                     ch = dev_info->channel_count;
1279                 }
1280             }
1281         }
1282         break;
1283     }
1284     if (bw == 0 || ch == 0)
1285         return -1;
1286     list_for_each(node_i, &usbmod->usb_card_conf_list) {
1287         /* Currently only apply the first playback sound card configuration */
1288         card_info = node_to_item(node_i, struct usb_card_config, list);
1289         if ((playback && usb_output_device(card_info->usb_device_type)) ||
1290             (!playback && usb_input_device(card_info->usb_device_type))) {
1291             usb_get_best_match_for_sample_rate(&card_info->usb_device_conf_list,
1292                                                bw, ch, sr, &sr,
1293                                                service_interval,
1294                                                true);
1295         }
1296         break;
1297     }
1298     if (sr == 0)
1299         return -1;
1300     *bit_width = bw;
1301     *sample_rate = sr;
1302     *channel_count = ch;
1303     return 0;
1304 }
1305 
audio_extn_usb_usbid()1306 char *audio_extn_usb_usbid()
1307 {
1308     struct usb_card_config *card_info;
1309 
1310     if (usbmod == NULL)
1311         return NULL;
1312 
1313     if (list_empty(&usbmod->usb_card_conf_list))
1314         return NULL;
1315 
1316     card_info = node_to_item(list_head(&usbmod->usb_card_conf_list),\
1317                              struct usb_card_config, list);
1318 
1319     return strdup(card_info->usbid);
1320 }
1321 
audio_extn_usb_init(void * adev)1322 void audio_extn_usb_init(void *adev)
1323 {
1324     if (usbmod == NULL) {
1325         usbmod = calloc(1, sizeof(struct usb_module));
1326         if (usbmod == NULL) {
1327             ALOGE("%s: error unable to allocate memory", __func__);
1328             goto exit;
1329         }
1330     } else {
1331         memset(usbmod, 0, sizeof(*usbmod));
1332     }
1333 
1334     list_init(&usbmod->usb_card_conf_list);
1335     usbmod->adev = (struct audio_device*)adev;
1336     usbmod->sidetone_gain = usb_sidetone_gain;
1337     usbmod->is_capture_supported = false;
1338 exit:
1339     return;
1340 }
1341 
audio_extn_usb_deinit(void)1342 void audio_extn_usb_deinit(void)
1343 {
1344     if (NULL != usbmod){
1345         free(usbmod);
1346         usbmod = NULL;
1347     }
1348 }
1349 #endif /*USB_HEADSET_ENABLED end*/
1350