1 /*
2 * Copyright (C) 2012 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 "modules.usbaudio.audio_hal"
18 /*#define LOG_NDEBUG 0*/
19
20 #include <errno.h>
21 #include <inttypes.h>
22 #include <pthread.h>
23 #include <stdint.h>
24 #include <stdlib.h>
25 #include <sys/time.h>
26 #include <unistd.h>
27
28 #include <log/log.h>
29 #include <cutils/list.h>
30 #include <cutils/str_parms.h>
31 #include <cutils/properties.h>
32
33 #include <hardware/audio.h>
34 #include <hardware/audio_alsaops.h>
35 #include <hardware/hardware.h>
36
37 #include <system/audio.h>
38
39 #include <tinyalsa/asoundlib.h>
40
41 #include <audio_utils/channels.h>
42
43 #include "alsa_device_profile.h"
44 #include "alsa_device_proxy.h"
45 #include "alsa_logging.h"
46
47 /* Lock play & record samples rates at or above this threshold */
48 #define RATELOCK_THRESHOLD 96000
49
50 struct audio_device {
51 struct audio_hw_device hw_device;
52
53 pthread_mutex_t lock; /* see note below on mutex acquisition order */
54
55 /* output */
56 alsa_device_profile out_profile;
57 struct listnode output_stream_list;
58
59 /* input */
60 alsa_device_profile in_profile;
61 struct listnode input_stream_list;
62
63 /* lock input & output sample rates */
64 /*FIXME - How do we address multiple output streams? */
65 uint32_t device_sample_rate;
66
67 bool mic_muted;
68
69 bool standby;
70
71 int32_t inputs_open; /* number of input streams currently open. */
72 };
73
74 struct stream_lock {
75 pthread_mutex_t lock; /* see note below on mutex acquisition order */
76 pthread_mutex_t pre_lock; /* acquire before lock to avoid DOS by playback thread */
77 };
78
79 struct stream_out {
80 struct audio_stream_out stream;
81
82 struct stream_lock lock;
83
84 bool standby;
85
86 struct audio_device *adev; /* hardware information - only using this for the lock */
87
88 const alsa_device_profile *profile; /* Points to the alsa_device_profile in the audio_device.
89 * Const, so modifications go through adev->out_profile
90 * and thus should have the hardware lock and ensure
91 * stream is not active and no other open output streams.
92 */
93
94 alsa_device_proxy proxy; /* state of the stream */
95
96 unsigned hal_channel_count; /* channel count exposed to AudioFlinger.
97 * This may differ from the device channel count when
98 * the device is not compatible with AudioFlinger
99 * capabilities, e.g. exposes too many channels or
100 * too few channels. */
101 audio_channel_mask_t hal_channel_mask; /* USB devices deal in channel counts, not masks
102 * so the proxy doesn't have a channel_mask, but
103 * audio HALs need to talk about channel masks
104 * so expose the one calculated by
105 * adev_open_output_stream */
106
107 struct listnode list_node;
108
109 void * conversion_buffer; /* any conversions are put into here
110 * they could come from here too if
111 * there was a previous conversion */
112 size_t conversion_buffer_size; /* in bytes */
113 };
114
115 struct stream_in {
116 struct audio_stream_in stream;
117
118 struct stream_lock lock;
119
120 bool standby;
121
122 struct audio_device *adev; /* hardware information - only using this for the lock */
123
124 const alsa_device_profile *profile; /* Points to the alsa_device_profile in the audio_device.
125 * Const, so modifications go through adev->out_profile
126 * and thus should have the hardware lock and ensure
127 * stream is not active and no other open input streams.
128 */
129
130 alsa_device_proxy proxy; /* state of the stream */
131
132 unsigned hal_channel_count; /* channel count exposed to AudioFlinger.
133 * This may differ from the device channel count when
134 * the device is not compatible with AudioFlinger
135 * capabilities, e.g. exposes too many channels or
136 * too few channels. */
137 audio_channel_mask_t hal_channel_mask; /* USB devices deal in channel counts, not masks
138 * so the proxy doesn't have a channel_mask, but
139 * audio HALs need to talk about channel masks
140 * so expose the one calculated by
141 * adev_open_input_stream */
142
143 struct listnode list_node;
144
145 /* We may need to read more data from the device in order to data reduce to 16bit, 4chan */
146 void * conversion_buffer; /* any conversions are put into here
147 * they could come from here too if
148 * there was a previous conversion */
149 size_t conversion_buffer_size; /* in bytes */
150 };
151
152 /*
153 * Locking Helpers
154 */
155 /*
156 * NOTE: when multiple mutexes have to be acquired, always take the
157 * stream_in or stream_out mutex first, followed by the audio_device mutex.
158 * stream pre_lock is always acquired before stream lock to prevent starvation of control thread by
159 * higher priority playback or capture thread.
160 */
161
stream_lock_init(struct stream_lock * lock)162 static void stream_lock_init(struct stream_lock *lock) {
163 pthread_mutex_init(&lock->lock, (const pthread_mutexattr_t *) NULL);
164 pthread_mutex_init(&lock->pre_lock, (const pthread_mutexattr_t *) NULL);
165 }
166
stream_lock(struct stream_lock * lock)167 static void stream_lock(struct stream_lock *lock) {
168 pthread_mutex_lock(&lock->pre_lock);
169 pthread_mutex_lock(&lock->lock);
170 pthread_mutex_unlock(&lock->pre_lock);
171 }
172
stream_unlock(struct stream_lock * lock)173 static void stream_unlock(struct stream_lock *lock) {
174 pthread_mutex_unlock(&lock->lock);
175 }
176
device_lock(struct audio_device * adev)177 static void device_lock(struct audio_device *adev) {
178 pthread_mutex_lock(&adev->lock);
179 }
180
device_try_lock(struct audio_device * adev)181 static int device_try_lock(struct audio_device *adev) {
182 return pthread_mutex_trylock(&adev->lock);
183 }
184
device_unlock(struct audio_device * adev)185 static void device_unlock(struct audio_device *adev) {
186 pthread_mutex_unlock(&adev->lock);
187 }
188
189 /*
190 * streams list management
191 */
adev_add_stream_to_list(struct audio_device * adev,struct listnode * list,struct listnode * stream_node)192 static void adev_add_stream_to_list(
193 struct audio_device* adev, struct listnode* list, struct listnode* stream_node) {
194 device_lock(adev);
195
196 list_add_tail(list, stream_node);
197
198 device_unlock(adev);
199 }
200
adev_remove_stream_from_list(struct audio_device * adev,struct listnode * stream_node)201 static void adev_remove_stream_from_list(
202 struct audio_device* adev, struct listnode* stream_node) {
203 device_lock(adev);
204
205 list_remove(stream_node);
206
207 device_unlock(adev);
208 }
209
210 /*
211 * Extract the card and device numbers from the supplied key/value pairs.
212 * kvpairs A null-terminated string containing the key/value pairs or card and device.
213 * i.e. "card=1;device=42"
214 * card A pointer to a variable to receive the parsed-out card number.
215 * device A pointer to a variable to receive the parsed-out device number.
216 * NOTE: The variables pointed to by card and device return -1 (undefined) if the
217 * associated key/value pair is not found in the provided string.
218 * Return true if the kvpairs string contain a card/device spec, false otherwise.
219 */
parse_card_device_params(const char * kvpairs,int * card,int * device)220 static bool parse_card_device_params(const char *kvpairs, int *card, int *device)
221 {
222 struct str_parms * parms = str_parms_create_str(kvpairs);
223 char value[32];
224 int param_val;
225
226 // initialize to "undefined" state.
227 *card = -1;
228 *device = -1;
229
230 param_val = str_parms_get_str(parms, "card", value, sizeof(value));
231 if (param_val >= 0) {
232 *card = atoi(value);
233 }
234
235 param_val = str_parms_get_str(parms, "device", value, sizeof(value));
236 if (param_val >= 0) {
237 *device = atoi(value);
238 }
239
240 str_parms_destroy(parms);
241
242 return *card >= 0 && *device >= 0;
243 }
244
device_get_parameters(const alsa_device_profile * profile,const char * keys)245 static char *device_get_parameters(const alsa_device_profile *profile, const char * keys)
246 {
247 if (profile->card < 0 || profile->device < 0) {
248 return strdup("");
249 }
250
251 struct str_parms *query = str_parms_create_str(keys);
252 struct str_parms *result = str_parms_create();
253
254 /* These keys are from hardware/libhardware/include/audio.h */
255 /* supported sample rates */
256 if (str_parms_has_key(query, AUDIO_PARAMETER_STREAM_SUP_SAMPLING_RATES)) {
257 char* rates_list = profile_get_sample_rate_strs(profile);
258 str_parms_add_str(result, AUDIO_PARAMETER_STREAM_SUP_SAMPLING_RATES,
259 rates_list);
260 free(rates_list);
261 }
262
263 /* supported channel counts */
264 if (str_parms_has_key(query, AUDIO_PARAMETER_STREAM_SUP_CHANNELS)) {
265 char* channels_list = profile_get_channel_count_strs(profile);
266 str_parms_add_str(result, AUDIO_PARAMETER_STREAM_SUP_CHANNELS,
267 channels_list);
268 free(channels_list);
269 }
270
271 /* supported sample formats */
272 if (str_parms_has_key(query, AUDIO_PARAMETER_STREAM_SUP_FORMATS)) {
273 char * format_params = profile_get_format_strs(profile);
274 str_parms_add_str(result, AUDIO_PARAMETER_STREAM_SUP_FORMATS,
275 format_params);
276 free(format_params);
277 }
278 str_parms_destroy(query);
279
280 char* result_str = str_parms_to_str(result);
281 str_parms_destroy(result);
282
283 ALOGV("device_get_parameters = %s", result_str);
284
285 return result_str;
286 }
287
288 /*
289 * HAl Functions
290 */
291 /**
292 * NOTE: when multiple mutexes have to be acquired, always respect the
293 * following order: hw device > out stream
294 */
295
296 /*
297 * OUT functions
298 */
out_get_sample_rate(const struct audio_stream * stream)299 static uint32_t out_get_sample_rate(const struct audio_stream *stream)
300 {
301 uint32_t rate = proxy_get_sample_rate(&((struct stream_out*)stream)->proxy);
302 ALOGV("out_get_sample_rate() = %d", rate);
303 return rate;
304 }
305
out_set_sample_rate(struct audio_stream * stream,uint32_t rate)306 static int out_set_sample_rate(struct audio_stream *stream, uint32_t rate)
307 {
308 return 0;
309 }
310
out_get_buffer_size(const struct audio_stream * stream)311 static size_t out_get_buffer_size(const struct audio_stream *stream)
312 {
313 const struct stream_out* out = (const struct stream_out*)stream;
314 size_t buffer_size =
315 proxy_get_period_size(&out->proxy) * audio_stream_out_frame_size(&(out->stream));
316 return buffer_size;
317 }
318
out_get_channels(const struct audio_stream * stream)319 static uint32_t out_get_channels(const struct audio_stream *stream)
320 {
321 const struct stream_out *out = (const struct stream_out*)stream;
322 return out->hal_channel_mask;
323 }
324
out_get_format(const struct audio_stream * stream)325 static audio_format_t out_get_format(const struct audio_stream *stream)
326 {
327 /* Note: The HAL doesn't do any FORMAT conversion at this time. It
328 * Relies on the framework to provide data in the specified format.
329 * This could change in the future.
330 */
331 alsa_device_proxy * proxy = &((struct stream_out*)stream)->proxy;
332 audio_format_t format = audio_format_from_pcm_format(proxy_get_format(proxy));
333 return format;
334 }
335
out_set_format(struct audio_stream * stream,audio_format_t format)336 static int out_set_format(struct audio_stream *stream, audio_format_t format)
337 {
338 return 0;
339 }
340
out_standby(struct audio_stream * stream)341 static int out_standby(struct audio_stream *stream)
342 {
343 struct stream_out *out = (struct stream_out *)stream;
344
345 stream_lock(&out->lock);
346 if (!out->standby) {
347 device_lock(out->adev);
348 proxy_close(&out->proxy);
349 device_unlock(out->adev);
350 out->standby = true;
351 }
352 stream_unlock(&out->lock);
353 return 0;
354 }
355
out_dump(const struct audio_stream * stream,int fd)356 static int out_dump(const struct audio_stream *stream, int fd) {
357 const struct stream_out* out_stream = (const struct stream_out*) stream;
358
359 if (out_stream != NULL) {
360 dprintf(fd, "Output Profile:\n");
361 profile_dump(out_stream->profile, fd);
362
363 dprintf(fd, "Output Proxy:\n");
364 proxy_dump(&out_stream->proxy, fd);
365 }
366
367 return 0;
368 }
369
out_set_parameters(struct audio_stream * stream,const char * kvpairs)370 static int out_set_parameters(struct audio_stream *stream, const char *kvpairs)
371 {
372 ALOGV("out_set_parameters() keys:%s", kvpairs);
373
374 struct stream_out *out = (struct stream_out *)stream;
375
376 int ret_value = 0;
377 int card = -1;
378 int device = -1;
379
380 if (!parse_card_device_params(kvpairs, &card, &device)) {
381 // nothing to do
382 return ret_value;
383 }
384
385 stream_lock(&out->lock);
386 /* Lock the device because that is where the profile lives */
387 device_lock(out->adev);
388
389 if (!profile_is_cached_for(out->profile, card, device)) {
390 /* cannot read pcm device info if playback is active */
391 if (!out->standby)
392 ret_value = -ENOSYS;
393 else {
394 int saved_card = out->profile->card;
395 int saved_device = out->profile->device;
396 out->adev->out_profile.card = card;
397 out->adev->out_profile.device = device;
398 ret_value = profile_read_device_info(&out->adev->out_profile) ? 0 : -EINVAL;
399 if (ret_value != 0) {
400 out->adev->out_profile.card = saved_card;
401 out->adev->out_profile.device = saved_device;
402 }
403 }
404 }
405
406 device_unlock(out->adev);
407 stream_unlock(&out->lock);
408
409 return ret_value;
410 }
411
out_get_parameters(const struct audio_stream * stream,const char * keys)412 static char * out_get_parameters(const struct audio_stream *stream, const char *keys)
413 {
414 struct stream_out *out = (struct stream_out *)stream;
415 stream_lock(&out->lock);
416 device_lock(out->adev);
417
418 char * params_str = device_get_parameters(out->profile, keys);
419
420 device_unlock(out->adev);
421 stream_unlock(&out->lock);
422 return params_str;
423 }
424
out_get_latency(const struct audio_stream_out * stream)425 static uint32_t out_get_latency(const struct audio_stream_out *stream)
426 {
427 alsa_device_proxy * proxy = &((struct stream_out*)stream)->proxy;
428 return proxy_get_latency(proxy);
429 }
430
out_set_volume(struct audio_stream_out * stream,float left,float right)431 static int out_set_volume(struct audio_stream_out *stream, float left, float right)
432 {
433 return -ENOSYS;
434 }
435
436 /* must be called with hw device and output stream mutexes locked */
start_output_stream(struct stream_out * out)437 static int start_output_stream(struct stream_out *out)
438 {
439 ALOGV("start_output_stream(card:%d device:%d)", out->profile->card, out->profile->device);
440
441 return proxy_open(&out->proxy);
442 }
443
out_write(struct audio_stream_out * stream,const void * buffer,size_t bytes)444 static ssize_t out_write(struct audio_stream_out *stream, const void* buffer, size_t bytes)
445 {
446 int ret;
447 struct stream_out *out = (struct stream_out *)stream;
448
449 stream_lock(&out->lock);
450 if (out->standby) {
451 device_lock(out->adev);
452 ret = start_output_stream(out);
453 device_unlock(out->adev);
454 if (ret != 0) {
455 goto err;
456 }
457 out->standby = false;
458 }
459
460 alsa_device_proxy* proxy = &out->proxy;
461 const void * write_buff = buffer;
462 int num_write_buff_bytes = bytes;
463 const int num_device_channels = proxy_get_channel_count(proxy); /* what we told alsa */
464 const int num_req_channels = out->hal_channel_count; /* what we told AudioFlinger */
465 if (num_device_channels != num_req_channels) {
466 /* allocate buffer */
467 const size_t required_conversion_buffer_size =
468 bytes * num_device_channels / num_req_channels;
469 if (required_conversion_buffer_size > out->conversion_buffer_size) {
470 out->conversion_buffer_size = required_conversion_buffer_size;
471 out->conversion_buffer = realloc(out->conversion_buffer,
472 out->conversion_buffer_size);
473 }
474 /* convert data */
475 const audio_format_t audio_format = out_get_format(&(out->stream.common));
476 const unsigned sample_size_in_bytes = audio_bytes_per_sample(audio_format);
477 num_write_buff_bytes =
478 adjust_channels(write_buff, num_req_channels,
479 out->conversion_buffer, num_device_channels,
480 sample_size_in_bytes, num_write_buff_bytes);
481 write_buff = out->conversion_buffer;
482 }
483
484 if (write_buff != NULL && num_write_buff_bytes != 0) {
485 proxy_write(&out->proxy, write_buff, num_write_buff_bytes);
486 }
487
488 stream_unlock(&out->lock);
489
490 return bytes;
491
492 err:
493 stream_unlock(&out->lock);
494 if (ret != 0) {
495 usleep(bytes * 1000000 / audio_stream_out_frame_size(stream) /
496 out_get_sample_rate(&stream->common));
497 }
498
499 return bytes;
500 }
501
out_get_render_position(const struct audio_stream_out * stream,uint32_t * dsp_frames)502 static int out_get_render_position(const struct audio_stream_out *stream, uint32_t *dsp_frames)
503 {
504 return -EINVAL;
505 }
506
out_get_presentation_position(const struct audio_stream_out * stream,uint64_t * frames,struct timespec * timestamp)507 static int out_get_presentation_position(const struct audio_stream_out *stream,
508 uint64_t *frames, struct timespec *timestamp)
509 {
510 struct stream_out *out = (struct stream_out *)stream; // discard const qualifier
511 stream_lock(&out->lock);
512
513 const alsa_device_proxy *proxy = &out->proxy;
514 const int ret = proxy_get_presentation_position(proxy, frames, timestamp);
515
516 stream_unlock(&out->lock);
517 return ret;
518 }
519
out_add_audio_effect(const struct audio_stream * stream,effect_handle_t effect)520 static int out_add_audio_effect(const struct audio_stream *stream, effect_handle_t effect)
521 {
522 return 0;
523 }
524
out_remove_audio_effect(const struct audio_stream * stream,effect_handle_t effect)525 static int out_remove_audio_effect(const struct audio_stream *stream, effect_handle_t effect)
526 {
527 return 0;
528 }
529
out_get_next_write_timestamp(const struct audio_stream_out * stream,int64_t * timestamp)530 static int out_get_next_write_timestamp(const struct audio_stream_out *stream, int64_t *timestamp)
531 {
532 return -EINVAL;
533 }
534
adev_open_output_stream(struct audio_hw_device * hw_dev,audio_io_handle_t handle,audio_devices_t devicesSpec __unused,audio_output_flags_t flags,struct audio_config * config,struct audio_stream_out ** stream_out,const char * address)535 static int adev_open_output_stream(struct audio_hw_device *hw_dev,
536 audio_io_handle_t handle,
537 audio_devices_t devicesSpec __unused,
538 audio_output_flags_t flags,
539 struct audio_config *config,
540 struct audio_stream_out **stream_out,
541 const char *address /*__unused*/)
542 {
543 ALOGV("adev_open_output_stream() handle:0x%X, devicesSpec:0x%X, flags:0x%X, addr:%s",
544 handle, devicesSpec, flags, address);
545
546 struct stream_out *out;
547
548 out = (struct stream_out *)calloc(1, sizeof(struct stream_out));
549 if (out == NULL) {
550 return -ENOMEM;
551 }
552
553 /* setup function pointers */
554 out->stream.common.get_sample_rate = out_get_sample_rate;
555 out->stream.common.set_sample_rate = out_set_sample_rate;
556 out->stream.common.get_buffer_size = out_get_buffer_size;
557 out->stream.common.get_channels = out_get_channels;
558 out->stream.common.get_format = out_get_format;
559 out->stream.common.set_format = out_set_format;
560 out->stream.common.standby = out_standby;
561 out->stream.common.dump = out_dump;
562 out->stream.common.set_parameters = out_set_parameters;
563 out->stream.common.get_parameters = out_get_parameters;
564 out->stream.common.add_audio_effect = out_add_audio_effect;
565 out->stream.common.remove_audio_effect = out_remove_audio_effect;
566 out->stream.get_latency = out_get_latency;
567 out->stream.set_volume = out_set_volume;
568 out->stream.write = out_write;
569 out->stream.get_render_position = out_get_render_position;
570 out->stream.get_presentation_position = out_get_presentation_position;
571 out->stream.get_next_write_timestamp = out_get_next_write_timestamp;
572
573 stream_lock_init(&out->lock);
574
575 out->adev = (struct audio_device *)hw_dev;
576 device_lock(out->adev);
577 out->profile = &out->adev->out_profile;
578
579 // build this to hand to the alsa_device_proxy
580 struct pcm_config proxy_config;
581 memset(&proxy_config, 0, sizeof(proxy_config));
582
583 /* Pull out the card/device pair */
584 parse_card_device_params(address, &out->adev->out_profile.card, &out->adev->out_profile.device);
585
586 profile_read_device_info(&out->adev->out_profile);
587
588 int ret = 0;
589
590 /* Rate */
591 if (config->sample_rate == 0) {
592 proxy_config.rate = config->sample_rate = profile_get_default_sample_rate(out->profile);
593 } else if (profile_is_sample_rate_valid(out->profile, config->sample_rate)) {
594 proxy_config.rate = config->sample_rate;
595 } else {
596 proxy_config.rate = config->sample_rate = profile_get_default_sample_rate(out->profile);
597 ret = -EINVAL;
598 }
599
600 out->adev->device_sample_rate = config->sample_rate;
601 device_unlock(out->adev);
602
603 /* Format */
604 if (config->format == AUDIO_FORMAT_DEFAULT) {
605 proxy_config.format = profile_get_default_format(out->profile);
606 config->format = audio_format_from_pcm_format(proxy_config.format);
607 } else {
608 enum pcm_format fmt = pcm_format_from_audio_format(config->format);
609 if (profile_is_format_valid(out->profile, fmt)) {
610 proxy_config.format = fmt;
611 } else {
612 proxy_config.format = profile_get_default_format(out->profile);
613 config->format = audio_format_from_pcm_format(proxy_config.format);
614 ret = -EINVAL;
615 }
616 }
617
618 /* Channels */
619 bool calc_mask = false;
620 if (config->channel_mask == AUDIO_CHANNEL_NONE) {
621 /* query case */
622 out->hal_channel_count = profile_get_default_channel_count(out->profile);
623 calc_mask = true;
624 } else {
625 /* explicit case */
626 out->hal_channel_count = audio_channel_count_from_out_mask(config->channel_mask);
627 }
628
629 /* The Framework is currently limited to no more than this number of channels */
630 if (out->hal_channel_count > FCC_8) {
631 out->hal_channel_count = FCC_8;
632 calc_mask = true;
633 }
634
635 if (calc_mask) {
636 /* need to calculate the mask from channel count either because this is the query case
637 * or the specified mask isn't valid for this device, or is more then the FW can handle */
638 config->channel_mask = out->hal_channel_count <= FCC_2
639 /* position mask for mono and stereo*/
640 ? audio_channel_out_mask_from_count(out->hal_channel_count)
641 /* otherwise indexed */
642 : audio_channel_mask_for_index_assignment_from_count(out->hal_channel_count);
643 }
644
645 out->hal_channel_mask = config->channel_mask;
646
647 // Validate the "logical" channel count against support in the "actual" profile.
648 // if they differ, choose the "actual" number of channels *closest* to the "logical".
649 // and store THAT in proxy_config.channels
650 proxy_config.channels = profile_get_closest_channel_count(out->profile, out->hal_channel_count);
651 proxy_prepare(&out->proxy, out->profile, &proxy_config);
652
653 /* TODO The retry mechanism isn't implemented in AudioPolicyManager/AudioFlinger
654 * So clear any errors that may have occurred above.
655 */
656 ret = 0;
657
658 out->conversion_buffer = NULL;
659 out->conversion_buffer_size = 0;
660
661 out->standby = true;
662
663 /* Save the stream for adev_dump() */
664 adev_add_stream_to_list(out->adev, &out->adev->output_stream_list, &out->list_node);
665
666 *stream_out = &out->stream;
667
668 return ret;
669 }
670
adev_close_output_stream(struct audio_hw_device * hw_dev,struct audio_stream_out * stream)671 static void adev_close_output_stream(struct audio_hw_device *hw_dev,
672 struct audio_stream_out *stream)
673 {
674 struct stream_out *out = (struct stream_out *)stream;
675 ALOGV("adev_close_output_stream(c:%d d:%d)", out->profile->card, out->profile->device);
676
677 adev_remove_stream_from_list(out->adev, &out->list_node);
678
679 /* Close the pcm device */
680 out_standby(&stream->common);
681
682 free(out->conversion_buffer);
683
684 out->conversion_buffer = NULL;
685 out->conversion_buffer_size = 0;
686
687 device_lock(out->adev);
688 out->adev->device_sample_rate = 0;
689 device_unlock(out->adev);
690
691 free(stream);
692 }
693
adev_get_input_buffer_size(const struct audio_hw_device * hw_dev,const struct audio_config * config)694 static size_t adev_get_input_buffer_size(const struct audio_hw_device *hw_dev,
695 const struct audio_config *config)
696 {
697 /* TODO This needs to be calculated based on format/channels/rate */
698 return 320;
699 }
700
701 /*
702 * IN functions
703 */
in_get_sample_rate(const struct audio_stream * stream)704 static uint32_t in_get_sample_rate(const struct audio_stream *stream)
705 {
706 uint32_t rate = proxy_get_sample_rate(&((const struct stream_in *)stream)->proxy);
707 ALOGV("in_get_sample_rate() = %d", rate);
708 return rate;
709 }
710
in_set_sample_rate(struct audio_stream * stream,uint32_t rate)711 static int in_set_sample_rate(struct audio_stream *stream, uint32_t rate)
712 {
713 ALOGV("in_set_sample_rate(%d) - NOPE", rate);
714 return -ENOSYS;
715 }
716
in_get_buffer_size(const struct audio_stream * stream)717 static size_t in_get_buffer_size(const struct audio_stream *stream)
718 {
719 const struct stream_in * in = ((const struct stream_in*)stream);
720 return proxy_get_period_size(&in->proxy) * audio_stream_in_frame_size(&(in->stream));
721 }
722
in_get_channels(const struct audio_stream * stream)723 static uint32_t in_get_channels(const struct audio_stream *stream)
724 {
725 const struct stream_in *in = (const struct stream_in*)stream;
726 return in->hal_channel_mask;
727 }
728
in_get_format(const struct audio_stream * stream)729 static audio_format_t in_get_format(const struct audio_stream *stream)
730 {
731 alsa_device_proxy *proxy = &((struct stream_in*)stream)->proxy;
732 audio_format_t format = audio_format_from_pcm_format(proxy_get_format(proxy));
733 return format;
734 }
735
in_set_format(struct audio_stream * stream,audio_format_t format)736 static int in_set_format(struct audio_stream *stream, audio_format_t format)
737 {
738 ALOGV("in_set_format(%d) - NOPE", format);
739
740 return -ENOSYS;
741 }
742
in_standby(struct audio_stream * stream)743 static int in_standby(struct audio_stream *stream)
744 {
745 struct stream_in *in = (struct stream_in *)stream;
746
747 stream_lock(&in->lock);
748 if (!in->standby) {
749 device_lock(in->adev);
750 proxy_close(&in->proxy);
751 device_unlock(in->adev);
752 in->standby = true;
753 }
754
755 stream_unlock(&in->lock);
756
757 return 0;
758 }
759
in_dump(const struct audio_stream * stream,int fd)760 static int in_dump(const struct audio_stream *stream, int fd)
761 {
762 const struct stream_in* in_stream = (const struct stream_in*)stream;
763 if (in_stream != NULL) {
764 dprintf(fd, "Input Profile:\n");
765 profile_dump(in_stream->profile, fd);
766
767 dprintf(fd, "Input Proxy:\n");
768 proxy_dump(&in_stream->proxy, fd);
769 }
770
771 return 0;
772 }
773
in_set_parameters(struct audio_stream * stream,const char * kvpairs)774 static int in_set_parameters(struct audio_stream *stream, const char *kvpairs)
775 {
776 ALOGV("in_set_parameters() keys:%s", kvpairs);
777
778 struct stream_in *in = (struct stream_in *)stream;
779
780 int ret_value = 0;
781 int card = -1;
782 int device = -1;
783
784 if (!parse_card_device_params(kvpairs, &card, &device)) {
785 // nothing to do
786 return ret_value;
787 }
788
789 stream_lock(&in->lock);
790 device_lock(in->adev);
791
792 if (card >= 0 && device >= 0 && !profile_is_cached_for(in->profile, card, device)) {
793 /* cannot read pcm device info if playback is active, or more than one open stream */
794 if (!in->standby || in->adev->inputs_open > 1)
795 ret_value = -ENOSYS;
796 else {
797 int saved_card = in->profile->card;
798 int saved_device = in->profile->device;
799 in->adev->in_profile.card = card;
800 in->adev->in_profile.device = device;
801 ret_value = profile_read_device_info(&in->adev->in_profile) ? 0 : -EINVAL;
802 if (ret_value != 0) {
803 in->adev->in_profile.card = saved_card;
804 in->adev->in_profile.device = saved_device;
805 }
806 }
807 }
808
809 device_unlock(in->adev);
810 stream_unlock(&in->lock);
811
812 return ret_value;
813 }
814
in_get_parameters(const struct audio_stream * stream,const char * keys)815 static char * in_get_parameters(const struct audio_stream *stream, const char *keys)
816 {
817 struct stream_in *in = (struct stream_in *)stream;
818
819 stream_lock(&in->lock);
820 device_lock(in->adev);
821
822 char * params_str = device_get_parameters(in->profile, keys);
823
824 device_unlock(in->adev);
825 stream_unlock(&in->lock);
826
827 return params_str;
828 }
829
in_add_audio_effect(const struct audio_stream * stream,effect_handle_t effect)830 static int in_add_audio_effect(const struct audio_stream *stream, effect_handle_t effect)
831 {
832 return 0;
833 }
834
in_remove_audio_effect(const struct audio_stream * stream,effect_handle_t effect)835 static int in_remove_audio_effect(const struct audio_stream *stream, effect_handle_t effect)
836 {
837 return 0;
838 }
839
in_set_gain(struct audio_stream_in * stream,float gain)840 static int in_set_gain(struct audio_stream_in *stream, float gain)
841 {
842 return 0;
843 }
844
845 /* must be called with hw device and output stream mutexes locked */
start_input_stream(struct stream_in * in)846 static int start_input_stream(struct stream_in *in)
847 {
848 ALOGV("start_input_stream(card:%d device:%d)", in->profile->card, in->profile->device);
849
850 return proxy_open(&in->proxy);
851 }
852
853 /* TODO mutex stuff here (see out_write) */
in_read(struct audio_stream_in * stream,void * buffer,size_t bytes)854 static ssize_t in_read(struct audio_stream_in *stream, void* buffer, size_t bytes)
855 {
856 size_t num_read_buff_bytes = 0;
857 void * read_buff = buffer;
858 void * out_buff = buffer;
859 int ret = 0;
860
861 struct stream_in * in = (struct stream_in *)stream;
862
863 stream_lock(&in->lock);
864 if (in->standby) {
865 device_lock(in->adev);
866 ret = start_input_stream(in);
867 device_unlock(in->adev);
868 if (ret != 0) {
869 goto err;
870 }
871 in->standby = false;
872 }
873
874 /*
875 * OK, we need to figure out how much data to read to be able to output the requested
876 * number of bytes in the HAL format (16-bit, stereo).
877 */
878 num_read_buff_bytes = bytes;
879 int num_device_channels = proxy_get_channel_count(&in->proxy); /* what we told Alsa */
880 int num_req_channels = in->hal_channel_count; /* what we told AudioFlinger */
881
882 if (num_device_channels != num_req_channels) {
883 num_read_buff_bytes = (num_device_channels * num_read_buff_bytes) / num_req_channels;
884 }
885
886 /* Setup/Realloc the conversion buffer (if necessary). */
887 if (num_read_buff_bytes != bytes) {
888 if (num_read_buff_bytes > in->conversion_buffer_size) {
889 /*TODO Remove this when AudioPolicyManger/AudioFlinger support arbitrary formats
890 (and do these conversions themselves) */
891 in->conversion_buffer_size = num_read_buff_bytes;
892 in->conversion_buffer = realloc(in->conversion_buffer, in->conversion_buffer_size);
893 }
894 read_buff = in->conversion_buffer;
895 }
896
897 ret = proxy_read(&in->proxy, read_buff, num_read_buff_bytes);
898 if (ret == 0) {
899 if (num_device_channels != num_req_channels) {
900 // ALOGV("chans dev:%d req:%d", num_device_channels, num_req_channels);
901
902 out_buff = buffer;
903 /* Num Channels conversion */
904 if (num_device_channels != num_req_channels) {
905 audio_format_t audio_format = in_get_format(&(in->stream.common));
906 unsigned sample_size_in_bytes = audio_bytes_per_sample(audio_format);
907
908 num_read_buff_bytes =
909 adjust_channels(read_buff, num_device_channels,
910 out_buff, num_req_channels,
911 sample_size_in_bytes, num_read_buff_bytes);
912 }
913 }
914
915 /* no need to acquire in->adev->lock to read mic_muted here as we don't change its state */
916 if (num_read_buff_bytes > 0 && in->adev->mic_muted)
917 memset(buffer, 0, num_read_buff_bytes);
918 } else {
919 num_read_buff_bytes = 0; // reset the value after USB headset is unplugged
920 }
921
922 err:
923 stream_unlock(&in->lock);
924 return num_read_buff_bytes;
925 }
926
in_get_input_frames_lost(struct audio_stream_in * stream)927 static uint32_t in_get_input_frames_lost(struct audio_stream_in *stream)
928 {
929 return 0;
930 }
931
adev_open_input_stream(struct audio_hw_device * hw_dev,audio_io_handle_t handle,audio_devices_t devicesSpec __unused,struct audio_config * config,struct audio_stream_in ** stream_in,audio_input_flags_t flags __unused,const char * address,audio_source_t source __unused)932 static int adev_open_input_stream(struct audio_hw_device *hw_dev,
933 audio_io_handle_t handle,
934 audio_devices_t devicesSpec __unused,
935 struct audio_config *config,
936 struct audio_stream_in **stream_in,
937 audio_input_flags_t flags __unused,
938 const char *address,
939 audio_source_t source __unused)
940 {
941 ALOGV("adev_open_input_stream() rate:%" PRIu32 ", chanMask:0x%" PRIX32 ", fmt:%" PRIu8,
942 config->sample_rate, config->channel_mask, config->format);
943
944 /* Pull out the card/device pair */
945 int32_t card, device;
946 if (!parse_card_device_params(address, &card, &device)) {
947 ALOGW("%s fail - invalid address %s", __func__, address);
948 *stream_in = NULL;
949 return -EINVAL;
950 }
951
952 struct stream_in * const in = (struct stream_in *)calloc(1, sizeof(struct stream_in));
953 if (in == NULL) {
954 *stream_in = NULL;
955 return -ENOMEM;
956 }
957
958 /* setup function pointers */
959 in->stream.common.get_sample_rate = in_get_sample_rate;
960 in->stream.common.set_sample_rate = in_set_sample_rate;
961 in->stream.common.get_buffer_size = in_get_buffer_size;
962 in->stream.common.get_channels = in_get_channels;
963 in->stream.common.get_format = in_get_format;
964 in->stream.common.set_format = in_set_format;
965 in->stream.common.standby = in_standby;
966 in->stream.common.dump = in_dump;
967 in->stream.common.set_parameters = in_set_parameters;
968 in->stream.common.get_parameters = in_get_parameters;
969 in->stream.common.add_audio_effect = in_add_audio_effect;
970 in->stream.common.remove_audio_effect = in_remove_audio_effect;
971
972 in->stream.set_gain = in_set_gain;
973 in->stream.read = in_read;
974 in->stream.get_input_frames_lost = in_get_input_frames_lost;
975
976 stream_lock_init(&in->lock);
977
978 in->adev = (struct audio_device *)hw_dev;
979 device_lock(in->adev);
980
981 in->profile = &in->adev->in_profile;
982
983 struct pcm_config proxy_config;
984 memset(&proxy_config, 0, sizeof(proxy_config));
985
986 int ret = 0;
987 /* Check if an input stream is already open */
988 if (in->adev->inputs_open > 0) {
989 if (!profile_is_cached_for(in->profile, card, device)) {
990 ALOGW("%s fail - address card:%d device:%d doesn't match existing profile",
991 __func__, card, device);
992 ret = -EINVAL;
993 }
994 } else {
995 /* Read input profile only if necessary */
996 in->adev->in_profile.card = card;
997 in->adev->in_profile.device = device;
998 if (!profile_read_device_info(&in->adev->in_profile)) {
999 ALOGW("%s fail - cannot read profile", __func__);
1000 ret = -EINVAL;
1001 }
1002 }
1003 if (ret != 0) {
1004 device_unlock(in->adev);
1005 free(in);
1006 *stream_in = NULL;
1007 return ret;
1008 }
1009
1010 /* Rate */
1011 if (config->sample_rate == 0) {
1012 config->sample_rate = profile_get_default_sample_rate(in->profile);
1013 }
1014
1015 if (in->adev->device_sample_rate != 0 && /* we are playing, so lock the rate */
1016 in->adev->device_sample_rate >= RATELOCK_THRESHOLD) {/* but only for high sample rates */
1017 ret = config->sample_rate != in->adev->device_sample_rate ? -EINVAL : 0;
1018 proxy_config.rate = config->sample_rate = in->adev->device_sample_rate;
1019 } else if (profile_is_sample_rate_valid(in->profile, config->sample_rate)) {
1020 proxy_config.rate = config->sample_rate;
1021 } else {
1022 proxy_config.rate = config->sample_rate = profile_get_default_sample_rate(in->profile);
1023 ret = -EINVAL;
1024 }
1025 device_unlock(in->adev);
1026
1027 /* Format */
1028 if (config->format == AUDIO_FORMAT_DEFAULT) {
1029 proxy_config.format = profile_get_default_format(in->profile);
1030 config->format = audio_format_from_pcm_format(proxy_config.format);
1031 } else {
1032 enum pcm_format fmt = pcm_format_from_audio_format(config->format);
1033 if (profile_is_format_valid(in->profile, fmt)) {
1034 proxy_config.format = fmt;
1035 } else {
1036 proxy_config.format = profile_get_default_format(in->profile);
1037 config->format = audio_format_from_pcm_format(proxy_config.format);
1038 ret = -EINVAL;
1039 }
1040 }
1041
1042 /* Channels */
1043 bool calc_mask = false;
1044 if (config->channel_mask == AUDIO_CHANNEL_NONE) {
1045 /* query case */
1046 in->hal_channel_count = profile_get_default_channel_count(in->profile);
1047 calc_mask = true;
1048 } else {
1049 /* explicit case */
1050 in->hal_channel_count = audio_channel_count_from_in_mask(config->channel_mask);
1051 }
1052
1053 /* The Framework is currently limited to no more than this number of channels */
1054 if (in->hal_channel_count > FCC_8) {
1055 in->hal_channel_count = FCC_8;
1056 calc_mask = true;
1057 }
1058
1059 if (calc_mask) {
1060 /* need to calculate the mask from channel count either because this is the query case
1061 * or the specified mask isn't valid for this device, or is more then the FW can handle */
1062 in->hal_channel_mask = in->hal_channel_count <= FCC_2
1063 /* position mask for mono & stereo */
1064 ? audio_channel_in_mask_from_count(in->hal_channel_count)
1065 /* otherwise indexed */
1066 : audio_channel_mask_for_index_assignment_from_count(in->hal_channel_count);
1067
1068 // if we change the mask...
1069 if (in->hal_channel_mask != config->channel_mask &&
1070 config->channel_mask != AUDIO_CHANNEL_NONE) {
1071 config->channel_mask = in->hal_channel_mask;
1072 ret = -EINVAL;
1073 }
1074 } else {
1075 in->hal_channel_mask = config->channel_mask;
1076 }
1077
1078 if (ret == 0) {
1079 // Validate the "logical" channel count against support in the "actual" profile.
1080 // if they differ, choose the "actual" number of channels *closest* to the "logical".
1081 // and store THAT in proxy_config.channels
1082 proxy_config.channels =
1083 profile_get_closest_channel_count(in->profile, in->hal_channel_count);
1084 ret = proxy_prepare(&in->proxy, in->profile, &proxy_config);
1085 if (ret == 0) {
1086 in->standby = true;
1087
1088 in->conversion_buffer = NULL;
1089 in->conversion_buffer_size = 0;
1090
1091 *stream_in = &in->stream;
1092
1093 /* Save this for adev_dump() */
1094 adev_add_stream_to_list(in->adev, &in->adev->input_stream_list, &in->list_node);
1095 } else {
1096 ALOGW("proxy_prepare error %d", ret);
1097 unsigned channel_count = proxy_get_channel_count(&in->proxy);
1098 config->channel_mask = channel_count <= FCC_2
1099 ? audio_channel_in_mask_from_count(channel_count)
1100 : audio_channel_mask_for_index_assignment_from_count(channel_count);
1101 config->format = audio_format_from_pcm_format(proxy_get_format(&in->proxy));
1102 config->sample_rate = proxy_get_sample_rate(&in->proxy);
1103 }
1104 }
1105
1106 if (ret != 0) {
1107 // Deallocate this stream on error, because AudioFlinger won't call
1108 // adev_close_input_stream() in this case.
1109 *stream_in = NULL;
1110 free(in);
1111 }
1112
1113 device_lock(in->adev);
1114 ++in->adev->inputs_open;
1115 device_unlock(in->adev);
1116
1117 return ret;
1118 }
1119
adev_close_input_stream(struct audio_hw_device * hw_dev,struct audio_stream_in * stream)1120 static void adev_close_input_stream(struct audio_hw_device *hw_dev,
1121 struct audio_stream_in *stream)
1122 {
1123 struct stream_in *in = (struct stream_in *)stream;
1124 ALOGV("adev_close_input_stream(c:%d d:%d)", in->profile->card, in->profile->device);
1125
1126 adev_remove_stream_from_list(in->adev, &in->list_node);
1127
1128 device_lock(in->adev);
1129 --in->adev->inputs_open;
1130 LOG_ALWAYS_FATAL_IF(in->adev->inputs_open < 0,
1131 "invalid inputs_open: %d", in->adev->inputs_open);
1132 device_unlock(in->adev);
1133
1134 /* Close the pcm device */
1135 in_standby(&stream->common);
1136
1137 free(in->conversion_buffer);
1138
1139 free(stream);
1140 }
1141
1142 /*
1143 * ADEV Functions
1144 */
adev_set_parameters(struct audio_hw_device * hw_dev,const char * kvpairs)1145 static int adev_set_parameters(struct audio_hw_device *hw_dev, const char *kvpairs)
1146 {
1147 return 0;
1148 }
1149
adev_get_parameters(const struct audio_hw_device * hw_dev,const char * keys)1150 static char * adev_get_parameters(const struct audio_hw_device *hw_dev, const char *keys)
1151 {
1152 return strdup("");
1153 }
1154
adev_init_check(const struct audio_hw_device * hw_dev)1155 static int adev_init_check(const struct audio_hw_device *hw_dev)
1156 {
1157 return 0;
1158 }
1159
adev_set_voice_volume(struct audio_hw_device * hw_dev,float volume)1160 static int adev_set_voice_volume(struct audio_hw_device *hw_dev, float volume)
1161 {
1162 return -ENOSYS;
1163 }
1164
adev_set_master_volume(struct audio_hw_device * hw_dev,float volume)1165 static int adev_set_master_volume(struct audio_hw_device *hw_dev, float volume)
1166 {
1167 return -ENOSYS;
1168 }
1169
adev_set_mode(struct audio_hw_device * hw_dev,audio_mode_t mode)1170 static int adev_set_mode(struct audio_hw_device *hw_dev, audio_mode_t mode)
1171 {
1172 return 0;
1173 }
1174
adev_set_mic_mute(struct audio_hw_device * hw_dev,bool state)1175 static int adev_set_mic_mute(struct audio_hw_device *hw_dev, bool state)
1176 {
1177 struct audio_device * adev = (struct audio_device *)hw_dev;
1178 device_lock(adev);
1179 adev->mic_muted = state;
1180 device_unlock(adev);
1181 return -ENOSYS;
1182 }
1183
adev_get_mic_mute(const struct audio_hw_device * hw_dev,bool * state)1184 static int adev_get_mic_mute(const struct audio_hw_device *hw_dev, bool *state)
1185 {
1186 return -ENOSYS;
1187 }
1188
adev_dump(const struct audio_hw_device * device,int fd)1189 static int adev_dump(const struct audio_hw_device *device, int fd)
1190 {
1191 dprintf(fd, "\nUSB audio module:\n");
1192
1193 struct audio_device* adev = (struct audio_device*)device;
1194 const int kNumRetries = 3;
1195 const int kSleepTimeMS = 500;
1196
1197 // use device_try_lock() in case we dumpsys during a deadlock
1198 int retry = kNumRetries;
1199 while (retry > 0 && device_try_lock(adev) != 0) {
1200 sleep(kSleepTimeMS);
1201 retry--;
1202 }
1203
1204 if (retry > 0) {
1205 if (list_empty(&adev->output_stream_list)) {
1206 dprintf(fd, " No output streams.\n");
1207 } else {
1208 struct listnode* node;
1209 list_for_each(node, &adev->output_stream_list) {
1210 struct audio_stream* stream =
1211 (struct audio_stream *)node_to_item(node, struct stream_out, list_node);
1212 out_dump(stream, fd);
1213 }
1214 }
1215
1216 if (list_empty(&adev->input_stream_list)) {
1217 dprintf(fd, "\n No input streams.\n");
1218 } else {
1219 struct listnode* node;
1220 list_for_each(node, &adev->input_stream_list) {
1221 struct audio_stream* stream =
1222 (struct audio_stream *)node_to_item(node, struct stream_in, list_node);
1223 in_dump(stream, fd);
1224 }
1225 }
1226
1227 device_unlock(adev);
1228 } else {
1229 // Couldn't lock
1230 dprintf(fd, " Could not obtain device lock.\n");
1231 }
1232
1233 return 0;
1234 }
1235
adev_close(hw_device_t * device)1236 static int adev_close(hw_device_t *device)
1237 {
1238 free(device);
1239
1240 return 0;
1241 }
1242
adev_open(const hw_module_t * module,const char * name,hw_device_t ** device)1243 static int adev_open(const hw_module_t* module, const char* name, hw_device_t** device)
1244 {
1245 if (strcmp(name, AUDIO_HARDWARE_INTERFACE) != 0)
1246 return -EINVAL;
1247
1248 struct audio_device *adev = calloc(1, sizeof(struct audio_device));
1249 if (!adev)
1250 return -ENOMEM;
1251
1252 profile_init(&adev->out_profile, PCM_OUT);
1253 profile_init(&adev->in_profile, PCM_IN);
1254
1255 list_init(&adev->output_stream_list);
1256 list_init(&adev->input_stream_list);
1257
1258 adev->hw_device.common.tag = HARDWARE_DEVICE_TAG;
1259 adev->hw_device.common.version = AUDIO_DEVICE_API_VERSION_2_0;
1260 adev->hw_device.common.module = (struct hw_module_t *)module;
1261 adev->hw_device.common.close = adev_close;
1262
1263 adev->hw_device.init_check = adev_init_check;
1264 adev->hw_device.set_voice_volume = adev_set_voice_volume;
1265 adev->hw_device.set_master_volume = adev_set_master_volume;
1266 adev->hw_device.set_mode = adev_set_mode;
1267 adev->hw_device.set_mic_mute = adev_set_mic_mute;
1268 adev->hw_device.get_mic_mute = adev_get_mic_mute;
1269 adev->hw_device.set_parameters = adev_set_parameters;
1270 adev->hw_device.get_parameters = adev_get_parameters;
1271 adev->hw_device.get_input_buffer_size = adev_get_input_buffer_size;
1272 adev->hw_device.open_output_stream = adev_open_output_stream;
1273 adev->hw_device.close_output_stream = adev_close_output_stream;
1274 adev->hw_device.open_input_stream = adev_open_input_stream;
1275 adev->hw_device.close_input_stream = adev_close_input_stream;
1276 adev->hw_device.dump = adev_dump;
1277
1278 *device = &adev->hw_device.common;
1279
1280 return 0;
1281 }
1282
1283 static struct hw_module_methods_t hal_module_methods = {
1284 .open = adev_open,
1285 };
1286
1287 struct audio_module HAL_MODULE_INFO_SYM = {
1288 .common = {
1289 .tag = HARDWARE_MODULE_TAG,
1290 .module_api_version = AUDIO_MODULE_API_VERSION_0_1,
1291 .hal_api_version = HARDWARE_HAL_API_VERSION,
1292 .id = AUDIO_HARDWARE_MODULE_ID,
1293 .name = "USB audio HW HAL",
1294 .author = "The Android Open Source Project",
1295 .methods = &hal_module_methods,
1296 },
1297 };
1298