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 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 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 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 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 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 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 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=5; 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\n", path); 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 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 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 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 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 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 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 651 static bool usb_valid_device(audio_devices_t device) 652 { 653 return usb_output_device(device) || 654 usb_input_device(device); 655 } 656 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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