source: mainline/uspace/lib/drv/generic/remote_audio_pcm.c@ 2e01b3f

lfn serial ticket/834-toolchain-update topic/msim-upgrade topic/simplify-dev-export
Last change on this file since 2e01b3f was 2e01b3f, checked in by Jan Vesely <jano.vesely@…>, 14 years ago

libdrv: Add method to query audio capabilities.
  • Property mode set to 100644
File size: 18.7 KB
Line 
1/*
2 * Copyright (c) 2012 Jan Vesely
3 * All rights reserved.
4 *
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
7 * are met:
8 *
9 * - Redistributions of source code must retain the above copyright
10 * notice, this list of conditions and the following disclaimer.
11 * - Redistributions in binary form must reproduce the above copyright
12 * notice, this list of conditions and the following disclaimer in the
13 * documentation and/or other materials provided with the distribution.
14 * - The name of the author may not be used to endorse or promote products
15 * derived from this software without specific prior written permission.
16 *
17 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
18 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
19 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
20 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
21 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
22 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
23 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
24 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
25 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
26 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
27 */
28/** @addtogroup libdrv
29 * @{
30 */
31/** @file
32 */
33
34#include <async.h>
35#include <devman.h>
36#include <ddf/log.h>
37#include <errno.h>
38#include <str.h>
39#include <as.h>
40#include <sys/mman.h>
41
42#include "audio_pcm_iface.h"
43#include "ddf/driver.h"
44
45typedef enum {
46 IPC_M_AUDIO_PCM_GET_INFO_STR,
47 IPC_M_AUDIO_PCM_QUERY_CAPS,
48 IPC_M_AUDIO_PCM_TEST_FORMAT,
49 IPC_M_AUDIO_PCM_GET_BUFFER,
50 IPC_M_AUDIO_PCM_RELEASE_BUFFER,
51 IPC_M_AUDIO_PCM_START_PLAYBACK,
52 IPC_M_AUDIO_PCM_STOP_PLAYBACK,
53 IPC_M_AUDIO_PCM_START_RECORD,
54 IPC_M_AUDIO_PCM_STOP_RECORD,
55} audio_pcm_iface_funcs_t;
56
57/*
58 * CLIENT SIDE
59 */
60audio_pcm_sess_t *audio_pcm_open(const char *name)
61{
62 devman_handle_t device_handle = 0;
63 const int ret = devman_fun_get_handle(name, &device_handle, 0);
64 if (ret != EOK)
65 return NULL;
66 return devman_device_connect(EXCHANGE_SERIALIZE, device_handle,
67 IPC_FLAG_BLOCKING);
68}
69
70audio_pcm_sess_t *audio_pcm_open_service(service_id_t id)
71{
72 return loc_service_connect(EXCHANGE_SERIALIZE, id, IPC_FLAG_BLOCKING);
73}
74
75void audio_pcm_close(audio_pcm_sess_t *sess)
76{
77 if (sess)
78 async_hangup(sess);
79}
80
81int audio_pcm_get_info_str(audio_pcm_sess_t *sess, const char **name)
82{
83 async_exch_t *exch = async_exchange_begin(sess);
84 sysarg_t name_size;
85 const int ret = async_req_1_1(exch,
86 DEV_IFACE_ID(AUDIO_PCM_BUFFER_IFACE),
87 IPC_M_AUDIO_PCM_GET_INFO_STR, &name_size);
88 if (ret == EOK && name) {
89 char *name_place = calloc(1, name_size);
90 if (!name_place) {
91 /* Make the other side fail
92 * as it waits for read request */
93 async_data_read_start(exch, (void*)-1, 0);
94 async_exchange_end(exch);
95 return ENOMEM;
96 }
97 const int ret =
98 async_data_read_start(exch, name_place, name_size);
99 if (ret != EOK) {
100 free(name_place);
101 async_exchange_end(exch);
102 return ret;
103 }
104 *name = name_place;
105 }
106 async_exchange_end(exch);
107 return ret;
108}
109
110int audio_pcm_query_cap(audio_pcm_sess_t *sess, audio_cap_t cap, unsigned *val)
111{
112 if (!val)
113 return EINVAL;
114 async_exch_t *exch = async_exchange_begin(sess);
115 sysarg_t value = *val;
116 const int ret = async_req_2_1(exch,
117 DEV_IFACE_ID(AUDIO_PCM_BUFFER_IFACE), IPC_M_AUDIO_PCM_QUERY_CAPS,
118 value, &value);
119 if (ret == EOK)
120 *val = value;
121 return ret;
122}
123
124int audio_pcm_test_format(audio_pcm_sess_t *sess, unsigned *channels,
125 unsigned *rate, pcm_sample_format_t *format)
126{
127 async_exch_t *exch = async_exchange_begin(sess);
128 sysarg_t channels_arg = channels ? *channels : 0;
129 sysarg_t rate_arg = rate ? *rate : 0;
130 sysarg_t format_arg = format ? *format : 0;
131 const int ret = async_req_4_3(exch,
132 DEV_IFACE_ID(AUDIO_PCM_BUFFER_IFACE),
133 IPC_M_AUDIO_PCM_TEST_FORMAT, channels_arg, rate_arg, format_arg,
134 &channels_arg, &rate_arg, &format_arg);
135 async_exchange_end(exch);
136
137 /* All OK or something has changed. Verify that it was not one of the
138 * params we care about */
139 if ((ret == EOK || ret == ELIMIT)
140 && (!channels || *channels == channels_arg)
141 && (!rate || *rate == rate_arg)
142 && (!format || *format == format_arg))
143 return EOK;
144 if (channels)
145 *channels = channels_arg;
146 if (rate)
147 *rate = rate_arg;
148 if (format)
149 *format = format_arg;
150 return ret;
151}
152
153int audio_pcm_get_buffer(audio_pcm_sess_t *sess, void **buffer, size_t *size,
154 async_client_conn_t event_rec, void* arg)
155{
156 if (!buffer || !size)
157 return EINVAL;
158
159 async_exch_t *exch = async_exchange_begin(sess);
160
161 sysarg_t buffer_size = *size;
162 const int ret = async_req_2_1(exch,
163 DEV_IFACE_ID(AUDIO_PCM_BUFFER_IFACE), IPC_M_AUDIO_PCM_GET_BUFFER,
164 (sysarg_t)buffer_size, &buffer_size);
165 if (ret == EOK) {
166 void *dst = NULL;
167 int ret = async_share_in_start_0_0(exch, buffer_size, &dst);
168 if (ret != EOK) {
169 async_exchange_end(exch);
170 return ret;
171 }
172 ret = async_connect_to_me(exch, 0, 0, 0, event_rec, arg);
173 if (ret != EOK) {
174 async_exchange_end(exch);
175 return ret;
176 }
177
178 *buffer = dst;
179 *size = buffer_size;
180 }
181 async_exchange_end(exch);
182 return ret;
183}
184
185int audio_pcm_release_buffer(audio_pcm_sess_t *sess)
186{
187 async_exch_t *exch = async_exchange_begin(sess);
188 const int ret = async_req_1_0(exch,
189 DEV_IFACE_ID(AUDIO_PCM_BUFFER_IFACE),
190 IPC_M_AUDIO_PCM_RELEASE_BUFFER);
191 async_exchange_end(exch);
192 return ret;
193}
194
195int audio_pcm_start_playback(audio_pcm_sess_t *sess, unsigned frames,
196 unsigned channels, unsigned sample_rate, pcm_sample_format_t format)
197{
198 if (channels > UINT16_MAX)
199 return EINVAL;
200 assert((format & UINT16_MAX) == format);
201 const sysarg_t packed = (channels << 16) | (format & UINT16_MAX);
202 async_exch_t *exch = async_exchange_begin(sess);
203 const int ret = async_req_4_0(exch,
204 DEV_IFACE_ID(AUDIO_PCM_BUFFER_IFACE),
205 IPC_M_AUDIO_PCM_START_PLAYBACK,
206 frames, sample_rate, packed);
207 async_exchange_end(exch);
208 return ret;
209}
210
211int audio_pcm_stop_playback(audio_pcm_sess_t *sess)
212{
213 async_exch_t *exch = async_exchange_begin(sess);
214 const int ret = async_req_1_0(exch,
215 DEV_IFACE_ID(AUDIO_PCM_BUFFER_IFACE),
216 IPC_M_AUDIO_PCM_STOP_PLAYBACK);
217 async_exchange_end(exch);
218 return ret;
219}
220
221int audio_pcm_start_record(audio_pcm_sess_t *sess, unsigned frames,
222 unsigned channels, unsigned sample_rate, pcm_sample_format_t format)
223{
224 if (channels > UINT16_MAX)
225 return EINVAL;
226 assert((format & UINT16_MAX) == format);
227 const sysarg_t packed = (channels << 16) | (format & UINT16_MAX);
228 async_exch_t *exch = async_exchange_begin(sess);
229 const int ret = async_req_4_0(exch,
230 DEV_IFACE_ID(AUDIO_PCM_BUFFER_IFACE), IPC_M_AUDIO_PCM_START_RECORD,
231 frames, sample_rate, packed);
232 async_exchange_end(exch);
233 return ret;
234}
235
236int audio_pcm_stop_record(audio_pcm_sess_t *sess)
237{
238 async_exch_t *exch = async_exchange_begin(sess);
239 const int ret = async_req_1_0(exch,
240 DEV_IFACE_ID(AUDIO_PCM_BUFFER_IFACE), IPC_M_AUDIO_PCM_STOP_RECORD);
241 async_exchange_end(exch);
242 return ret;
243}
244
245/*
246 * SERVER SIDE
247 */
248static void remote_audio_pcm_get_info_str(ddf_fun_t *, void *, ipc_callid_t, ipc_call_t *);
249static void remote_audio_pcm_query_caps(ddf_fun_t *, void *, ipc_callid_t, ipc_call_t *);
250static void remote_audio_pcm_test_format(ddf_fun_t *, void *, ipc_callid_t, ipc_call_t *);
251static void remote_audio_pcm_get_buffer(ddf_fun_t *, void *, ipc_callid_t, ipc_call_t *);
252static void remote_audio_pcm_release_buffer(ddf_fun_t *, void *, ipc_callid_t, ipc_call_t *);
253static void remote_audio_pcm_start_playback(ddf_fun_t *, void *, ipc_callid_t, ipc_call_t *);
254static void remote_audio_pcm_stop_playback(ddf_fun_t *, void *, ipc_callid_t, ipc_call_t *);
255static void remote_audio_pcm_start_record(ddf_fun_t *, void *, ipc_callid_t, ipc_call_t *);
256static void remote_audio_pcm_stop_record(ddf_fun_t *, void *, ipc_callid_t, ipc_call_t *);
257
258/** Remote audio pcm buffer interface operations. */
259static remote_iface_func_ptr_t remote_audio_pcm_iface_ops[] = {
260 [IPC_M_AUDIO_PCM_GET_INFO_STR] = remote_audio_pcm_get_info_str,
261 [IPC_M_AUDIO_PCM_QUERY_CAPS] = remote_audio_pcm_query_caps,
262 [IPC_M_AUDIO_PCM_TEST_FORMAT] = remote_audio_pcm_test_format,
263 [IPC_M_AUDIO_PCM_GET_BUFFER] = remote_audio_pcm_get_buffer,
264 [IPC_M_AUDIO_PCM_RELEASE_BUFFER] = remote_audio_pcm_release_buffer,
265 [IPC_M_AUDIO_PCM_START_PLAYBACK] = remote_audio_pcm_start_playback,
266 [IPC_M_AUDIO_PCM_STOP_PLAYBACK] = remote_audio_pcm_stop_playback,
267 [IPC_M_AUDIO_PCM_START_RECORD] = remote_audio_pcm_start_record,
268 [IPC_M_AUDIO_PCM_STOP_RECORD] = remote_audio_pcm_stop_record,
269};
270
271/** Remote audio mixer interface structure. */
272remote_iface_t remote_audio_pcm_iface = {
273 .method_count = sizeof(remote_audio_pcm_iface_ops) /
274 sizeof(remote_audio_pcm_iface_ops[0]),
275 .methods = remote_audio_pcm_iface_ops
276};
277
278void remote_audio_pcm_get_info_str(ddf_fun_t *fun, void *iface,
279 ipc_callid_t callid, ipc_call_t *call)
280{
281 const audio_pcm_iface_t *pcm_iface = iface;
282
283 if (!pcm_iface->get_info_str) {
284 async_answer_0(callid, ENOTSUP);
285 return;
286 }
287 const char *name = NULL;
288 const int ret = pcm_iface->get_info_str(fun, &name);
289 const size_t name_size = name ? str_size(name) + 1 : 0;
290 async_answer_1(callid, ret, name_size);
291 /* Send the string. */
292 if (ret == EOK && name_size > 0) {
293 size_t size;
294 ipc_callid_t name_id;
295 if (!async_data_read_receive(&name_id, &size)) {
296 async_answer_0(name_id, EPARTY);
297 return;
298 }
299 if (size != name_size) {
300 async_answer_0(name_id, ELIMIT);
301 return;
302 }
303 async_data_read_finalize(name_id, name, name_size);
304 }
305}
306
307void remote_audio_pcm_query_caps(ddf_fun_t *fun, void *iface, ipc_callid_t callid, ipc_call_t *call)
308{
309 const audio_pcm_iface_t *pcm_iface = iface;
310 const audio_cap_t cap = DEV_IPC_GET_ARG1(*call);
311 if (pcm_iface->query_cap) {
312 const unsigned value = pcm_iface->query_cap(fun, cap);
313 async_answer_1(callid, EOK, value);
314 } else {
315 async_answer_0(callid, ENOTSUP);
316 }
317}
318
319void remote_audio_pcm_test_format(ddf_fun_t *fun, void *iface, ipc_callid_t callid, ipc_call_t *call)
320{
321 const audio_pcm_iface_t *pcm_iface = iface;
322 unsigned channels = DEV_IPC_GET_ARG1(*call);
323 unsigned rate = DEV_IPC_GET_ARG2(*call);
324 pcm_sample_format_t format = DEV_IPC_GET_ARG3(*call);
325 const int ret = pcm_iface->test_format ?
326 pcm_iface->test_format(fun, &channels, &rate, &format) : ENOTSUP;
327 async_answer_3(callid, ret, channels, rate, format);
328}
329
330void remote_audio_pcm_get_buffer(ddf_fun_t *fun, void *iface,
331 ipc_callid_t callid, ipc_call_t *call)
332{
333 const audio_pcm_iface_t *pcm_iface = iface;
334
335 if (!pcm_iface->get_buffer ||
336 !pcm_iface->release_buffer ||
337 !pcm_iface->set_event_session) {
338 async_answer_0(callid, ENOTSUP);
339 return;
340 }
341 void *buffer = NULL;
342 size_t size = DEV_IPC_GET_ARG1(*call);
343 int ret = pcm_iface->get_buffer(fun, &buffer, &size);
344 async_answer_1(callid, ret, size);
345 if (ret != EOK || size == 0)
346 return;
347
348 /* Share the buffer. */
349 size_t share_size = 0;
350 ipc_callid_t share_id = 0;
351
352 ddf_msg(LVL_DEBUG2, "Receiving share request.");
353 if (!async_share_in_receive(&share_id, &share_size)) {
354 ddf_msg(LVL_DEBUG, "Failed to share pcm buffer.");
355 pcm_iface->release_buffer(fun);
356 async_answer_0(share_id, EPARTY);
357 return;
358 }
359
360 ddf_msg(LVL_DEBUG2, "Checking requested share size.");
361 if (share_size != size) {
362 ddf_msg(LVL_DEBUG, "Incorrect pcm buffer size requested.");
363 pcm_iface->release_buffer(fun);
364 async_answer_0(share_id, ELIMIT);
365 return;
366 }
367
368 ddf_msg(LVL_DEBUG2, "Calling share finalize.");
369 ret = async_share_in_finalize(share_id, buffer, AS_AREA_WRITE
370 | AS_AREA_READ);
371 if (ret != EOK) {
372 ddf_msg(LVL_DEBUG, "Failed to share buffer.");
373 pcm_iface->release_buffer(fun);
374 return;
375 }
376
377 ddf_msg(LVL_DEBUG2, "Buffer shared with size %zu, creating callback.",
378 share_size);
379 {
380 ipc_call_t call;
381 ipc_callid_t callid = async_get_call(&call);
382 async_sess_t *sess =
383 async_callback_receive_start(EXCHANGE_ATOMIC, &call);
384 if (sess == NULL) {
385 ddf_msg(LVL_DEBUG, "Failed to create event callback");
386 pcm_iface->release_buffer(fun);
387 async_answer_0(callid, EAGAIN);
388 return;
389 }
390 ret = pcm_iface->set_event_session(fun, sess);
391 if (ret != EOK) {
392 ddf_msg(LVL_DEBUG, "Failed to set event callback.");
393 pcm_iface->release_buffer(fun);
394 async_answer_0(callid, ret);
395 return;
396 }
397 ddf_msg(LVL_DEBUG2, "Buffer and event session setup OK.");
398 async_answer_0(callid, EOK);
399 }
400}
401
402void remote_audio_pcm_release_buffer(ddf_fun_t *fun, void *iface,
403 ipc_callid_t callid, ipc_call_t *call)
404{
405 const audio_pcm_iface_t *pcm_iface = iface;
406
407 const int ret = pcm_iface->release_buffer ?
408 pcm_iface->release_buffer(fun) : ENOTSUP;
409 async_answer_0(callid, ret);
410}
411
412void remote_audio_pcm_start_playback(ddf_fun_t *fun, void *iface,
413 ipc_callid_t callid, ipc_call_t *call)
414{
415 const audio_pcm_iface_t *pcm_iface = iface;
416
417 const unsigned frames = DEV_IPC_GET_ARG1(*call);
418 const unsigned rate = DEV_IPC_GET_ARG2(*call);
419 const unsigned channels = (DEV_IPC_GET_ARG3(*call) >> 16) & UINT8_MAX;
420 const pcm_sample_format_t format = DEV_IPC_GET_ARG3(*call) & UINT16_MAX;
421
422 const int ret = pcm_iface->start_playback
423 ? pcm_iface->start_playback(fun, frames, channels, rate, format)
424 : ENOTSUP;
425 async_answer_0(callid, ret);
426}
427
428void remote_audio_pcm_stop_playback(ddf_fun_t *fun, void *iface,
429 ipc_callid_t callid, ipc_call_t *call)
430{
431 const audio_pcm_iface_t *pcm_iface = iface;
432
433 const int ret = pcm_iface->stop_playback ?
434 pcm_iface->stop_playback(fun) : ENOTSUP;
435 async_answer_0(callid, ret);
436}
437
438void remote_audio_pcm_start_record(ddf_fun_t *fun, void *iface,
439 ipc_callid_t callid, ipc_call_t *call)
440{
441 const audio_pcm_iface_t *pcm_iface = iface;
442
443 const unsigned frames = DEV_IPC_GET_ARG1(*call);
444 const unsigned rate = DEV_IPC_GET_ARG2(*call);
445 const unsigned channels = (DEV_IPC_GET_ARG3(*call) >> 16) & UINT16_MAX;
446 const pcm_sample_format_t format = DEV_IPC_GET_ARG3(*call) & UINT16_MAX;
447
448 const int ret = pcm_iface->start_record
449 ? pcm_iface->start_record(fun, frames, channels, rate, format)
450 : ENOTSUP;
451 async_answer_0(callid, ret);
452}
453
454void remote_audio_pcm_stop_record(ddf_fun_t *fun, void *iface,
455 ipc_callid_t callid, ipc_call_t *call)
456{
457 const audio_pcm_iface_t *pcm_iface = iface;
458
459 const int ret = pcm_iface->stop_record ?
460 pcm_iface->stop_record(fun) : ENOTSUP;
461 async_answer_0(callid, ret);
462}
463
464#if 0
465
466void remote_audio_mixer_get_info(
467 ddf_fun_t *fun, void *iface, ipc_callid_t callid, ipc_call_t *call)
468{
469 audio_mixer_iface_t *mixer_iface = iface;
470
471 if (!mixer_iface->get_info) {
472 async_answer_0(callid, ENOTSUP);
473 return;
474 }
475 const char *name = NULL;
476 unsigned items = 0;
477 const int ret = mixer_iface->get_info(fun, &name, &items);
478 const size_t name_size = name ? str_size(name) + 1 : 0;
479 async_answer_2(callid, ret, name_size, items);
480 /* Send the name. */
481 if (ret == EOK && name_size > 0) {
482 size_t size;
483 ipc_callid_t name_id;
484 if (!async_data_read_receive(&name_id, &size)) {
485 async_answer_0(name_id, EPARTY);
486 return;
487 }
488 if (size != name_size) {
489 async_answer_0(name_id, ELIMIT);
490 return;
491 }
492 async_data_read_finalize(name_id, name, name_size);
493 }
494}
495
496void remote_audio_mixer_get_item_info(
497 ddf_fun_t *fun, void *iface, ipc_callid_t callid, ipc_call_t *call)
498{
499 audio_mixer_iface_t *mixer_iface = iface;
500
501 if (!mixer_iface->get_item_info) {
502 async_answer_0(callid, ENOTSUP);
503 return;
504 }
505
506 const unsigned item = DEV_IPC_GET_ARG1(*call);
507 const char *name = NULL;
508 unsigned channels = 0;
509 const int ret = mixer_iface->get_item_info(fun, item, &name, &channels);
510 const size_t name_size = name ? str_size(name) + 1 : 0;
511 async_answer_2(callid, ret, name_size, channels);
512 /* Send the name. */
513 if (ret == EOK && name_size > 0) {
514 size_t size;
515 ipc_callid_t name_id;
516 if (!async_data_read_receive(&name_id, &size)) {
517 async_answer_0(name_id, EPARTY);
518 return;
519 }
520 if (size != name_size) {
521 async_answer_0(name_id, ELIMIT);
522 return;
523 }
524 async_data_read_finalize(name_id, name, name_size);
525 }
526}
527
528void remote_audio_mixer_get_channel_info(
529 ddf_fun_t *fun, void *iface, ipc_callid_t callid, ipc_call_t *call)
530{
531 audio_mixer_iface_t *mixer_iface = iface;
532
533 if (!mixer_iface->get_channel_info) {
534 async_answer_0(callid, ENOTSUP);
535 return;
536 }
537
538 const unsigned item = DEV_IPC_GET_ARG1(*call);
539 const unsigned channel = DEV_IPC_GET_ARG2(*call);
540 const char *name = NULL;
541 unsigned levels = 0;
542 const int ret =
543 mixer_iface->get_channel_info(fun, item, channel, &name, &levels);
544 const size_t name_size = name ? str_size(name) + 1 : 0;
545 async_answer_2(callid, ret, name_size, levels);
546 /* Send the name. */
547 if (ret == EOK && name_size > 0) {
548 size_t size;
549 ipc_callid_t name_id;
550 if (!async_data_read_receive(&name_id, &size)) {
551 async_answer_0(name_id, EPARTY);
552 return;
553 }
554 if (size != name_size) {
555 async_answer_0(name_id, ELIMIT);
556 return;
557 }
558 async_data_read_finalize(name_id, name, name_size);
559 }
560}
561
562void remote_audio_mixer_channel_mute_set(
563 ddf_fun_t *fun, void *iface, ipc_callid_t callid, ipc_call_t *call)
564{
565 audio_mixer_iface_t *mixer_iface = iface;
566
567 if (!mixer_iface->channel_mute_set) {
568 async_answer_0(callid, ENOTSUP);
569 return;
570 }
571 const unsigned item = DEV_IPC_GET_ARG1(*call);
572 const unsigned channel = DEV_IPC_GET_ARG2(*call);
573 const bool mute = DEV_IPC_GET_ARG3(*call);
574 const int ret = mixer_iface->channel_mute_set(fun, item, channel, mute);
575 async_answer_0(callid, ret);
576}
577
578void remote_audio_mixer_channel_mute_get(
579 ddf_fun_t *fun, void *iface, ipc_callid_t callid, ipc_call_t *call)
580{
581 audio_mixer_iface_t *mixer_iface = iface;
582
583 if (!mixer_iface->channel_mute_get) {
584 async_answer_0(callid, ENOTSUP);
585 return;
586 }
587 const unsigned item = DEV_IPC_GET_ARG1(*call);
588 const unsigned channel = DEV_IPC_GET_ARG2(*call);
589 bool mute = false;
590 const int ret =
591 mixer_iface->channel_mute_get(fun, item, channel, &mute);
592 async_answer_1(callid, ret, mute);
593}
594
595void remote_audio_mixer_channel_volume_set(
596 ddf_fun_t *fun, void *iface, ipc_callid_t callid, ipc_call_t *call)
597{
598 audio_mixer_iface_t *mixer_iface = iface;
599
600 if (!mixer_iface->channel_volume_set) {
601 async_answer_0(callid, ENOTSUP);
602 return;
603 }
604 const unsigned item = DEV_IPC_GET_ARG1(*call);
605 const unsigned channel = DEV_IPC_GET_ARG2(*call);
606 const unsigned level = DEV_IPC_GET_ARG3(*call);
607 const int ret =
608 mixer_iface->channel_volume_set(fun, item, channel, level);
609 async_answer_0(callid, ret);
610}
611
612void remote_audio_mixer_channel_volume_get(
613 ddf_fun_t *fun, void *iface, ipc_callid_t callid, ipc_call_t *call)
614{
615 audio_mixer_iface_t *mixer_iface = iface;
616
617 if (!mixer_iface->channel_volume_get) {
618 async_answer_0(callid, ENOTSUP);
619 return;
620 }
621 const unsigned item = DEV_IPC_GET_ARG1(*call);
622 const unsigned channel = DEV_IPC_GET_ARG2(*call);
623 unsigned current = 0, max = 0;
624 const int ret =
625 mixer_iface->channel_volume_get(fun, item, channel, &current, &max);
626 async_answer_2(callid, ret, current, max);
627}
628#endif
629
630/**
631 * @}
632 */
633
Note: See TracBrowser for help on using the repository browser.