Gitiles
Code Review Sign In
gerrit-public.fairphone.software / platform / vendor / opensource / audio-kernel / 605b42f92c7892864eb0a4ad42c043f656281d76 / . / asoc / msm-audio-effects-q6-v2.c
blob: 962d64e94ba3406786ee99058397887dacac7232 [file] [log] [blame]
Asish Bhattacharya8e2277f2017-07-20 18:31:55 +0530[diff] [blame]1/* Copyright (c) 2013-2017, The Linux Foundation. All rights reserved.
2 *
3 * This program is free software; you can redistribute it and/or modify
4 * it under the terms of the GNU General Public License version 2 and
5 * only version 2 as published by the Free Software Foundation.
6 *
7 * This program is distributed in the hope that it will be useful,
8 * but WITHOUT ANY WARRANTY; without even the implied warranty of
9 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
10 * GNU General Public License for more details.
11 */
12
13#include <linux/slab.h>
Asish Bhattacharya8e2277f2017-07-20 18:31:55 +0530[diff] [blame]14#include <sound/compress_params.h>
Asish Bhattacharya8e2277f2017-07-20 18:31:55 +0530[diff] [blame]15#include <sound/devdep_params.h>
Laxminath Kasam605b42f2017-08-01 22:02:15 +0530[diff] [blame^]16#include <dsp/apr_audio-v2.h>
17#include <dsp/q6asm-v2.h>
18#include <dsp/msm-audio-effects-q6-v2.h>
Asish Bhattacharya8e2277f2017-07-20 18:31:55 +0530[diff] [blame]19
20#define MAX_ENABLE_CMD_SIZE 32
21
22#define GET_NEXT(ptr, upper_limit, rc) \
23({ \
24 if (((ptr) + 1) > (upper_limit)) { \
25 pr_err("%s: param list out of boundary\n", __func__); \
26 (rc) = -EINVAL; \
27 } \
28 ((rc) == 0) ? *(ptr)++ : -EINVAL; \
29})
30
31#define CHECK_PARAM_LEN(len, max_len, tag, rc) \
32do { \
33 if ((len) > (max_len)) { \
34 pr_err("%s: params length overflows\n", (tag)); \
35 (rc) = -EINVAL; \
36 } \
37} while (0)
38
39
40bool msm_audio_effects_is_effmodule_supp_in_top(int effect_module,
41 int topology)
42{
43 switch (effect_module) {
44 case VIRTUALIZER_MODULE:
45 case REVERB_MODULE:
46 case BASS_BOOST_MODULE:
47 case PBE_MODULE:
48 case EQ_MODULE:
49 switch (topology) {
50 case ASM_STREAM_POSTPROC_TOPO_ID_SA_PLUS:
51 return true;
52 default:
53 return false;
54 }
55 default:
56 return false;
57 }
58}
59
60int msm_audio_effects_enable_extn(struct audio_client *ac,
61 struct msm_nt_eff_all_config *effects,
62 bool flag)
63{
64 uint32_t updt_params[MAX_ENABLE_CMD_SIZE] = {0};
65 uint32_t params_length;
66 int rc = 0;
67
68 pr_debug("%s\n", __func__);
69 if (!ac) {
70 pr_err("%s: cannot set audio effects\n", __func__);
71 return -EINVAL;
72 }
73 params_length = 0;
74 updt_params[0] = AUDPROC_MODULE_ID_VIRTUALIZER;
75 updt_params[1] = AUDPROC_PARAM_ID_ENABLE;
76 updt_params[2] = VIRTUALIZER_ENABLE_PARAM_SZ;
77 updt_params[3] = flag;
78 params_length += COMMAND_PAYLOAD_SZ + VIRTUALIZER_ENABLE_PARAM_SZ;
79 if (effects->virtualizer.enable_flag)
80 q6asm_send_audio_effects_params(ac, (char *)&updt_params[0],
81 params_length);
82 memset(updt_params, 0, MAX_ENABLE_CMD_SIZE);
83 params_length = 0;
84 updt_params[0] = AUDPROC_MODULE_ID_BASS_BOOST;
85 updt_params[1] = AUDPROC_PARAM_ID_ENABLE;
86 updt_params[2] = BASS_BOOST_ENABLE_PARAM_SZ;
87 updt_params[3] = flag;
88 params_length += COMMAND_PAYLOAD_SZ + BASS_BOOST_ENABLE_PARAM_SZ;
89 if (effects->bass_boost.enable_flag)
90 q6asm_send_audio_effects_params(ac, (char *)&updt_params[0],
91 params_length);
92 memset(updt_params, 0, MAX_ENABLE_CMD_SIZE);
93 params_length = 0;
94 updt_params[0] = AUDPROC_MODULE_ID_POPLESS_EQUALIZER;
95 updt_params[1] = AUDPROC_PARAM_ID_ENABLE;
96 updt_params[2] = EQ_ENABLE_PARAM_SZ;
97 updt_params[3] = flag;
98 params_length += COMMAND_PAYLOAD_SZ + EQ_ENABLE_PARAM_SZ;
99 if (effects->equalizer.enable_flag)
100 q6asm_send_audio_effects_params(ac, (char *)&updt_params[0],
101 params_length);
102 return rc;
103}
104
105int msm_audio_effects_virtualizer_handler(struct audio_client *ac,
106 struct virtualizer_params *virtualizer,
107 long *values)
108{
109 long *param_max_offset = values + MAX_PP_PARAMS_SZ - 1;
110 char *params = NULL;
111 int rc = 0;
112 int devices = GET_NEXT(values, param_max_offset, rc);
113 int num_commands = GET_NEXT(values, param_max_offset, rc);
114 int *updt_params, i, prev_enable_flag;
115 uint32_t params_length = (MAX_INBAND_PARAM_SZ);
116
117 pr_debug("%s\n", __func__);
118 if (!ac || (devices == -EINVAL) || (num_commands == -EINVAL)) {
119 pr_err("%s: cannot set audio effects\n", __func__);
120 return -EINVAL;
121 }
122 params = kzalloc(params_length, GFP_KERNEL);
123 if (!params)
124 return -ENOMEM;
125
126 pr_debug("%s: device: %d\n", __func__, devices);
127 updt_params = (int *)params;
128 params_length = 0;
129 for (i = 0; i < num_commands; i++) {
130 uint32_t command_id =
131 GET_NEXT(values, param_max_offset, rc);
132 uint32_t command_config_state =
133 GET_NEXT(values, param_max_offset, rc);
134 uint32_t index_offset =
135 GET_NEXT(values, param_max_offset, rc);
136 uint32_t length =
137 GET_NEXT(values, param_max_offset, rc);
138 switch (command_id) {
139 case VIRTUALIZER_ENABLE:
140 if (length != 1 || index_offset != 0) {
141 pr_err("VIRT ENABLE:invalid params\n");
142 rc = -EINVAL;
143 goto invalid_config;
144 }
145 prev_enable_flag = virtualizer->enable_flag;
146 virtualizer->enable_flag =
147 GET_NEXT(values, param_max_offset, rc);
148 pr_debug("%s:VIRT ENABLE prev:%d, new:%d\n", __func__,
149 prev_enable_flag, virtualizer->enable_flag);
150 if (prev_enable_flag != virtualizer->enable_flag) {
151 params_length += COMMAND_PAYLOAD_SZ +
152 VIRTUALIZER_ENABLE_PARAM_SZ;
153 CHECK_PARAM_LEN(params_length,
154 MAX_INBAND_PARAM_SZ,
155 "VIRT ENABLE", rc);
156 if (rc != 0)
157 break;
158 *updt_params++ =
159 AUDPROC_MODULE_ID_VIRTUALIZER;
160 *updt_params++ =
161 AUDPROC_PARAM_ID_VIRTUALIZER_ENABLE;
162 *updt_params++ =
163 VIRTUALIZER_ENABLE_PARAM_SZ;
164 *updt_params++ =
165 virtualizer->enable_flag;
166 }
167 break;
168 case VIRTUALIZER_STRENGTH:
169 if (length != 1 || index_offset != 0) {
170 pr_err("VIRT STRENGTH:invalid params\n");
171 rc = -EINVAL;
172 goto invalid_config;
173 }
174 virtualizer->strength =
175 GET_NEXT(values, param_max_offset, rc);
176 pr_debug("%s: VIRT STRENGTH val: %d\n",
177 __func__, virtualizer->strength);
178 if (command_config_state == CONFIG_SET) {
179 params_length += COMMAND_PAYLOAD_SZ +
180 VIRTUALIZER_STRENGTH_PARAM_SZ;
181 CHECK_PARAM_LEN(params_length,
182 MAX_INBAND_PARAM_SZ,
183 "VIRT STRENGTH", rc);
184 if (rc != 0)
185 break;
186 *updt_params++ =
187 AUDPROC_MODULE_ID_VIRTUALIZER;
188 *updt_params++ =
189 AUDPROC_PARAM_ID_VIRTUALIZER_STRENGTH;
190 *updt_params++ =
191 VIRTUALIZER_STRENGTH_PARAM_SZ;
192 *updt_params++ =
193 virtualizer->strength;
194 }
195 break;
196 case VIRTUALIZER_OUT_TYPE:
197 if (length != 1 || index_offset != 0) {
198 pr_err("VIRT OUT_TYPE:invalid params\n");
199 rc = -EINVAL;
200 goto invalid_config;
201 }
202 virtualizer->out_type =
203 GET_NEXT(values, param_max_offset, rc);
204 pr_debug("%s: VIRT OUT_TYPE val:%d\n",
205 __func__, virtualizer->out_type);
206 if (command_config_state == CONFIG_SET) {
207 params_length += COMMAND_PAYLOAD_SZ +
208 VIRTUALIZER_OUT_TYPE_PARAM_SZ;
209 CHECK_PARAM_LEN(params_length,
210 MAX_INBAND_PARAM_SZ,
211 "VIRT OUT_TYPE", rc);
212 if (rc != 0)
213 break;
214 *updt_params++ =
215 AUDPROC_MODULE_ID_VIRTUALIZER;
216 *updt_params++ =
217 AUDPROC_PARAM_ID_VIRTUALIZER_OUT_TYPE;
218 *updt_params++ =
219 VIRTUALIZER_OUT_TYPE_PARAM_SZ;
220 *updt_params++ =
221 virtualizer->out_type;
222 }
223 break;
224 case VIRTUALIZER_GAIN_ADJUST:
225 if (length != 1 || index_offset != 0) {
226 pr_err("VIRT GAIN_ADJUST: invalid params\n");
227 rc = -EINVAL;
228 goto invalid_config;
229 }
230 virtualizer->gain_adjust =
231 GET_NEXT(values, param_max_offset, rc);
232 pr_debug("%s: VIRT GAIN_ADJUST val:%d\n",
233 __func__, virtualizer->gain_adjust);
234 if (command_config_state == CONFIG_SET) {
235 params_length += COMMAND_PAYLOAD_SZ +
236 VIRTUALIZER_GAIN_ADJUST_PARAM_SZ;
237 CHECK_PARAM_LEN(params_length,
238 MAX_INBAND_PARAM_SZ,
239 "VIRT GAIN_ADJUST", rc);
240 if (rc != 0)
241 break;
242 *updt_params++ =
243 AUDPROC_MODULE_ID_VIRTUALIZER;
244 *updt_params++ =
245 AUDPROC_PARAM_ID_VIRTUALIZER_GAIN_ADJUST;
246 *updt_params++ =
247 VIRTUALIZER_GAIN_ADJUST_PARAM_SZ;
248 *updt_params++ =
249 virtualizer->gain_adjust;
250 }
251 break;
252 default:
253 pr_err("%s: Invalid command to set config\n", __func__);
254 break;
255 }
256 }
257 if (params_length && (rc == 0))
258 q6asm_send_audio_effects_params(ac, params,
259 params_length);
260 else
261 pr_debug("%s: did not send pp params\n", __func__);
262invalid_config:
263 kfree(params);
264 return rc;
265}
266
267int msm_audio_effects_reverb_handler(struct audio_client *ac,
268 struct reverb_params *reverb,
269 long *values)
270{
271 long *param_max_offset = values + MAX_PP_PARAMS_SZ - 1;
272 char *params = NULL;
273 int rc = 0;
274 int devices = GET_NEXT(values, param_max_offset, rc);
275 int num_commands = GET_NEXT(values, param_max_offset, rc);
276 int *updt_params, i, prev_enable_flag;
277 uint32_t params_length = (MAX_INBAND_PARAM_SZ);
278
279 pr_debug("%s\n", __func__);
280 if (!ac || (devices == -EINVAL) || (num_commands == -EINVAL)) {
281 pr_err("%s: cannot set audio effects\n", __func__);
282 return -EINVAL;
283 }
284 params = kzalloc(params_length, GFP_KERNEL);
285 if (!params)
286 return -ENOMEM;
287
288 pr_debug("%s: device: %d\n", __func__, devices);
289 updt_params = (int *)params;
290 params_length = 0;
291 for (i = 0; i < num_commands; i++) {
292 uint32_t command_id =
293 GET_NEXT(values, param_max_offset, rc);
294 uint32_t command_config_state =
295 GET_NEXT(values, param_max_offset, rc);
296 uint32_t index_offset =
297 GET_NEXT(values, param_max_offset, rc);
298 uint32_t length =
299 GET_NEXT(values, param_max_offset, rc);
300 switch (command_id) {
301 case REVERB_ENABLE:
302 if (length != 1 || index_offset != 0) {
303 pr_err("REVERB_ENABLE:invalid params\n");
304 rc = -EINVAL;
305 goto invalid_config;
306 }
307 prev_enable_flag = reverb->enable_flag;
308 reverb->enable_flag =
309 GET_NEXT(values, param_max_offset, rc);
310 pr_debug("%s:REVERB_ENABLE prev:%d,new:%d\n", __func__,
311 prev_enable_flag, reverb->enable_flag);
312 if (prev_enable_flag != reverb->enable_flag) {
313 params_length += COMMAND_PAYLOAD_SZ +
314 REVERB_ENABLE_PARAM_SZ;
315 CHECK_PARAM_LEN(params_length,
316 MAX_INBAND_PARAM_SZ,
317 "REVERB_ENABLE", rc);
318 if (rc != 0)
319 break;
320 *updt_params++ =
321 AUDPROC_MODULE_ID_REVERB;
322 *updt_params++ =
323 AUDPROC_PARAM_ID_REVERB_ENABLE;
324 *updt_params++ =
325 REVERB_ENABLE_PARAM_SZ;
326 *updt_params++ =
327 reverb->enable_flag;
328 }
329 break;
330 case REVERB_MODE:
331 if (length != 1 || index_offset != 0) {
332 pr_err("REVERB_MODE:invalid params\n");
333 rc = -EINVAL;
334 goto invalid_config;
335 }
336 reverb->mode =
337 GET_NEXT(values, param_max_offset, rc);
338 pr_debug("%s: REVERB_MODE val:%d\n",
339 __func__, reverb->mode);
340 if (command_config_state == CONFIG_SET) {
341 params_length += COMMAND_PAYLOAD_SZ +
342 REVERB_MODE_PARAM_SZ;
343 CHECK_PARAM_LEN(params_length,
344 MAX_INBAND_PARAM_SZ,
345 "REVERB_MODE", rc);
346 if (rc != 0)
347 break;
348 *updt_params++ =
349 AUDPROC_MODULE_ID_REVERB;
350 *updt_params++ =
351 AUDPROC_PARAM_ID_REVERB_MODE;
352 *updt_params++ =
353 REVERB_MODE_PARAM_SZ;
354 *updt_params++ =
355 reverb->mode;
356 }
357 break;
358 case REVERB_PRESET:
359 if (length != 1 || index_offset != 0) {
360 pr_err("REVERB_PRESET:invalid params\n");
361 rc = -EINVAL;
362 goto invalid_config;
363 }
364 reverb->preset =
365 GET_NEXT(values, param_max_offset, rc);
366 pr_debug("%s: REVERB_PRESET val:%d\n",
367 __func__, reverb->preset);
368 if (command_config_state == CONFIG_SET) {
369 params_length += COMMAND_PAYLOAD_SZ +
370 REVERB_PRESET_PARAM_SZ;
371 CHECK_PARAM_LEN(params_length,
372 MAX_INBAND_PARAM_SZ,
373 "REVERB_PRESET", rc);
374 if (rc != 0)
375 break;
376 *updt_params++ =
377 AUDPROC_MODULE_ID_REVERB;
378 *updt_params++ =
379 AUDPROC_PARAM_ID_REVERB_PRESET;
380 *updt_params++ =
381 REVERB_PRESET_PARAM_SZ;
382 *updt_params++ =
383 reverb->preset;
384 }
385 break;
386 case REVERB_WET_MIX:
387 if (length != 1 || index_offset != 0) {
388 pr_err("REVERB_WET_MIX:invalid params\n");
389 rc = -EINVAL;
390 goto invalid_config;
391 }
392 reverb->wet_mix =
393 GET_NEXT(values, param_max_offset, rc);
394 pr_debug("%s: REVERB_WET_MIX val:%d\n",
395 __func__, reverb->wet_mix);
396 if (command_config_state == CONFIG_SET) {
397 params_length += COMMAND_PAYLOAD_SZ +
398 REVERB_WET_MIX_PARAM_SZ;
399 CHECK_PARAM_LEN(params_length,
400 MAX_INBAND_PARAM_SZ,
401 "REVERB_WET_MIX", rc);
402 if (rc != 0)
403 break;
404 *updt_params++ =
405 AUDPROC_MODULE_ID_REVERB;
406 *updt_params++ =
407 AUDPROC_PARAM_ID_REVERB_WET_MIX;
408 *updt_params++ =
409 REVERB_WET_MIX_PARAM_SZ;
410 *updt_params++ =
411 reverb->wet_mix;
412 }
413 break;
414 case REVERB_GAIN_ADJUST:
415 if (length != 1 || index_offset != 0) {
416 pr_err("REVERB_GAIN_ADJUST:invalid params\n");
417 rc = -EINVAL;
418 goto invalid_config;
419 }
420 reverb->gain_adjust =
421 GET_NEXT(values, param_max_offset, rc);
422 pr_debug("%s: REVERB_GAIN_ADJUST val:%d\n",
423 __func__, reverb->gain_adjust);
424 if (command_config_state == CONFIG_SET) {
425 params_length += COMMAND_PAYLOAD_SZ +
426 REVERB_GAIN_ADJUST_PARAM_SZ;
427 CHECK_PARAM_LEN(params_length,
428 MAX_INBAND_PARAM_SZ,
429 "REVERB_GAIN_ADJUST", rc);
430 if (rc != 0)
431 break;
432 *updt_params++ =
433 AUDPROC_MODULE_ID_REVERB;
434 *updt_params++ =
435 AUDPROC_PARAM_ID_REVERB_GAIN_ADJUST;
436 *updt_params++ =
437 REVERB_GAIN_ADJUST_PARAM_SZ;
438 *updt_params++ =
439 reverb->gain_adjust;
440 }
441 break;
442 case REVERB_ROOM_LEVEL:
443 if (length != 1 || index_offset != 0) {
444 pr_err("REVERB_ROOM_LEVEL:invalid params\n");
445 rc = -EINVAL;
446 goto invalid_config;
447 }
448 reverb->room_level =
449 GET_NEXT(values, param_max_offset, rc);
450 pr_debug("%s: REVERB_ROOM_LEVEL val:%d\n",
451 __func__, reverb->room_level);
452 if (command_config_state == CONFIG_SET) {
453 params_length += COMMAND_PAYLOAD_SZ +
454 REVERB_ROOM_LEVEL_PARAM_SZ;
455 CHECK_PARAM_LEN(params_length,
456 MAX_INBAND_PARAM_SZ,
457 "REVERB_ROOM_LEVEL", rc);
458 if (rc != 0)
459 break;
460 *updt_params++ =
461 AUDPROC_MODULE_ID_REVERB;
462 *updt_params++ =
463 AUDPROC_PARAM_ID_REVERB_ROOM_LEVEL;
464 *updt_params++ =
465 REVERB_ROOM_LEVEL_PARAM_SZ;
466 *updt_params++ =
467 reverb->room_level;
468 }
469 break;
470 case REVERB_ROOM_HF_LEVEL:
471 if (length != 1 || index_offset != 0) {
472 pr_err("REVERB_ROOM_HF_LEVEL:invalid params\n");
473 rc = -EINVAL;
474 goto invalid_config;
475 }
476 reverb->room_hf_level =
477 GET_NEXT(values, param_max_offset, rc);
478 pr_debug("%s: REVERB_ROOM_HF_LEVEL val%d\n",
479 __func__, reverb->room_hf_level);
480 if (command_config_state == CONFIG_SET) {
481 params_length += COMMAND_PAYLOAD_SZ +
482 REVERB_ROOM_HF_LEVEL_PARAM_SZ;
483 CHECK_PARAM_LEN(params_length,
484 MAX_INBAND_PARAM_SZ,
485 "REVERB_ROOM_HF_LEVEL", rc);
486 if (rc != 0)
487 break;
488 *updt_params++ =
489 AUDPROC_MODULE_ID_REVERB;
490 *updt_params++ =
491 AUDPROC_PARAM_ID_REVERB_ROOM_HF_LEVEL;
492 *updt_params++ =
493 REVERB_ROOM_HF_LEVEL_PARAM_SZ;
494 *updt_params++ =
495 reverb->room_hf_level;
496 }
497 break;
498 case REVERB_DECAY_TIME:
499 if (length != 1 || index_offset != 0) {
500 pr_err("REVERB_DECAY_TIME:invalid params\n");
501 rc = -EINVAL;
502 goto invalid_config;
503 }
504 reverb->decay_time =
505 GET_NEXT(values, param_max_offset, rc);
506 pr_debug("%s: REVERB_DECAY_TIME val:%d\n",
507 __func__, reverb->decay_time);
508 if (command_config_state == CONFIG_SET) {
509 params_length += COMMAND_PAYLOAD_SZ +
510 REVERB_DECAY_TIME_PARAM_SZ;
511 CHECK_PARAM_LEN(params_length,
512 MAX_INBAND_PARAM_SZ,
513 "REVERB_DECAY_TIME", rc);
514 if (rc != 0)
515 break;
516 *updt_params++ =
517 AUDPROC_MODULE_ID_REVERB;
518 *updt_params++ =
519 AUDPROC_PARAM_ID_REVERB_DECAY_TIME;
520 *updt_params++ =
521 REVERB_DECAY_TIME_PARAM_SZ;
522 *updt_params++ =
523 reverb->decay_time;
524 }
525 break;
526 case REVERB_DECAY_HF_RATIO:
527 if (length != 1 || index_offset != 0) {
528 pr_err("REVERB_DECAY_HF_RATIOinvalid params\n");
529 rc = -EINVAL;
530 goto invalid_config;
531 }
532 reverb->decay_hf_ratio =
533 GET_NEXT(values, param_max_offset, rc);
534 pr_debug("%s: REVERB_DECAY_HF_RATIO val%d\n",
535 __func__, reverb->decay_hf_ratio);
536 if (command_config_state == CONFIG_SET) {
537 params_length += COMMAND_PAYLOAD_SZ +
538 REVERB_DECAY_HF_RATIO_PARAM_SZ;
539 CHECK_PARAM_LEN(params_length,
540 MAX_INBAND_PARAM_SZ,
541 "REVERB_DECAY_HF_RATIO", rc);
542 if (rc != 0)
543 break;
544 *updt_params++ =
545 AUDPROC_MODULE_ID_REVERB;
546 *updt_params++ =
547 AUDPROC_PARAM_ID_REVERB_DECAY_HF_RATIO;
548 *updt_params++ =
549 REVERB_DECAY_HF_RATIO_PARAM_SZ;
550 *updt_params++ =
551 reverb->decay_hf_ratio;
552 }
553 break;
554 case REVERB_REFLECTIONS_LEVEL:
555 if (length != 1 || index_offset != 0) {
556 pr_err("REVERB_REFLECTION_LVLinvalid params\n");
557 rc = -EINVAL;
558 goto invalid_config;
559 }
560 reverb->reflections_level =
561 GET_NEXT(values, param_max_offset, rc);
562 pr_debug("%s: REVERB_REFLECTIONS_LEVEL val:%d\n",
563 __func__, reverb->reflections_level);
564 if (command_config_state == CONFIG_SET) {
565 params_length += COMMAND_PAYLOAD_SZ +
566 REVERB_REFLECTIONS_LEVEL_PARAM_SZ;
567 CHECK_PARAM_LEN(params_length,
568 MAX_INBAND_PARAM_SZ,
569 "REVERB_REFLECTIONS_LEVEL", rc);
570 if (rc != 0)
571 break;
572 *updt_params++ =
573 AUDPROC_MODULE_ID_REVERB;
574 *updt_params++ =
575 AUDPROC_PARAM_ID_REVERB_REFLECTIONS_LEVEL;
576 *updt_params++ =
577 REVERB_REFLECTIONS_LEVEL_PARAM_SZ;
578 *updt_params++ =
579 reverb->reflections_level;
580 }
581 break;
582 case REVERB_REFLECTIONS_DELAY:
583 if (length != 1 || index_offset != 0) {
584 pr_err("REVERB_REFLECTION_DLYinvalid params\n");
585 rc = -EINVAL;
586 goto invalid_config;
587 }
588 reverb->reflections_delay =
589 GET_NEXT(values, param_max_offset, rc);
590 pr_debug("%s: REVERB_REFLECTIONS_DELAY val:%d\n",
591 __func__, reverb->reflections_delay);
592 if (command_config_state == CONFIG_SET) {
593 params_length += COMMAND_PAYLOAD_SZ +
594 REVERB_REFLECTIONS_DELAY_PARAM_SZ;
595 CHECK_PARAM_LEN(params_length,
596 MAX_INBAND_PARAM_SZ,
597 "REVERB_REFLECTIONS_DELAY", rc);
598 if (rc != 0)
599 break;
600 *updt_params++ =
601 AUDPROC_MODULE_ID_REVERB;
602 *updt_params++ =
603 AUDPROC_PARAM_ID_REVERB_REFLECTIONS_DELAY;
604 *updt_params++ =
605 REVERB_REFLECTIONS_DELAY_PARAM_SZ;
606 *updt_params++ =
607 reverb->reflections_delay;
608 }
609 break;
610 case REVERB_LEVEL:
611 if (length != 1 || index_offset != 0) {
612 pr_err("REVERB_LEVEL:invalid params\n");
613 rc = -EINVAL;
614 goto invalid_config;
615 }
616 reverb->level =
617 GET_NEXT(values, param_max_offset, rc);
618 pr_debug("%s: REVERB_LEVEL val:%d\n",
619 __func__, reverb->level);
620 if (command_config_state == CONFIG_SET) {
621 params_length += COMMAND_PAYLOAD_SZ +
622 REVERB_LEVEL_PARAM_SZ;
623 CHECK_PARAM_LEN(params_length,
624 MAX_INBAND_PARAM_SZ,
625 "REVERB_LEVEL", rc);
626 if (rc != 0)
627 break;
628 *updt_params++ =
629 AUDPROC_MODULE_ID_REVERB;
630 *updt_params++ =
631 AUDPROC_PARAM_ID_REVERB_LEVEL;
632 *updt_params++ =
633 REVERB_LEVEL_PARAM_SZ;
634 *updt_params++ =
635 reverb->level;
636 }
637 break;
638 case REVERB_DELAY:
639 if (length != 1 || index_offset != 0) {
640 pr_err("REVERB_DELAY:invalid params\n");
641 rc = -EINVAL;
642 goto invalid_config;
643 }
644 reverb->delay =
645 GET_NEXT(values, param_max_offset, rc);
646 pr_debug("%s:REVERB_DELAY val:%d\n",
647 __func__, reverb->delay);
648 if (command_config_state == CONFIG_SET) {
649 params_length += COMMAND_PAYLOAD_SZ +
650 REVERB_DELAY_PARAM_SZ;
651 CHECK_PARAM_LEN(params_length,
652 MAX_INBAND_PARAM_SZ,
653 "REVERB_DELAY", rc);
654 if (rc != 0)
655 break;
656 *updt_params++ =
657 AUDPROC_MODULE_ID_REVERB;
658 *updt_params++ =
659 AUDPROC_PARAM_ID_REVERB_DELAY;
660 *updt_params++ =
661 REVERB_DELAY_PARAM_SZ;
662 *updt_params++ =
663 reverb->delay;
664 }
665 break;
666 case REVERB_DIFFUSION:
667 if (length != 1 || index_offset != 0) {
668 pr_err("REVERB_DIFFUSION:invalid params\n");
669 rc = -EINVAL;
670 goto invalid_config;
671 }
672 reverb->diffusion =
673 GET_NEXT(values, param_max_offset, rc);
674 pr_debug("%s: REVERB_DIFFUSION val:%d\n",
675 __func__, reverb->diffusion);
676 if (command_config_state == CONFIG_SET) {
677 params_length += COMMAND_PAYLOAD_SZ +
678 REVERB_DIFFUSION_PARAM_SZ;
679 CHECK_PARAM_LEN(params_length,
680 MAX_INBAND_PARAM_SZ,
681 "REVERB_DIFFUSION", rc);
682 if (rc != 0)
683 break;
684 *updt_params++ =
685 AUDPROC_MODULE_ID_REVERB;
686 *updt_params++ =
687 AUDPROC_PARAM_ID_REVERB_DIFFUSION;
688 *updt_params++ =
689 REVERB_DIFFUSION_PARAM_SZ;
690 *updt_params++ =
691 reverb->diffusion;
692 }
693 break;
694 case REVERB_DENSITY:
695 if (length != 1 || index_offset != 0) {
696 pr_err("REVERB_DENSITY:invalid params\n");
697 rc = -EINVAL;
698 goto invalid_config;
699 }
700 reverb->density =
701 GET_NEXT(values, param_max_offset, rc);
702 pr_debug("%s: REVERB_DENSITY val:%d\n",
703 __func__, reverb->density);
704 if (command_config_state == CONFIG_SET) {
705 params_length += COMMAND_PAYLOAD_SZ +
706 REVERB_DENSITY_PARAM_SZ;
707 CHECK_PARAM_LEN(params_length,
708 MAX_INBAND_PARAM_SZ,
709 "REVERB_DENSITY", rc);
710 if (rc != 0)
711 break;
712 *updt_params++ =
713 AUDPROC_MODULE_ID_REVERB;
714 *updt_params++ =
715 AUDPROC_PARAM_ID_REVERB_DENSITY;
716 *updt_params++ =
717 REVERB_DENSITY_PARAM_SZ;
718 *updt_params++ =
719 reverb->density;
720 }
721 break;
722 default:
723 pr_err("%s: Invalid command to set config\n", __func__);
724 break;
725 }
726 }
727 if (params_length && (rc == 0))
728 q6asm_send_audio_effects_params(ac, params,
729 params_length);
730 else
731 pr_debug("%s: did not send pp params\n", __func__);
732invalid_config:
733 kfree(params);
734 return rc;
735}
736
737int msm_audio_effects_bass_boost_handler(struct audio_client *ac,
738 struct bass_boost_params *bass_boost,
739 long *values)
740{
741 long *param_max_offset = values + MAX_PP_PARAMS_SZ - 1;
742 char *params = NULL;
743 int rc = 0;
744 int devices = GET_NEXT(values, param_max_offset, rc);
745 int num_commands = GET_NEXT(values, param_max_offset, rc);
746 int *updt_params, i, prev_enable_flag;
747 uint32_t params_length = (MAX_INBAND_PARAM_SZ);
748
749 pr_debug("%s\n", __func__);
750 if (!ac || (devices == -EINVAL) || (num_commands == -EINVAL)) {
751 pr_err("%s: cannot set audio effects\n", __func__);
752 return -EINVAL;
753 }
754 params = kzalloc(params_length, GFP_KERNEL);
755 if (!params)
756 return -ENOMEM;
757
758 pr_debug("%s: device: %d\n", __func__, devices);
759 updt_params = (int *)params;
760 params_length = 0;
761 for (i = 0; i < num_commands; i++) {
762 uint32_t command_id =
763 GET_NEXT(values, param_max_offset, rc);
764 uint32_t command_config_state =
765 GET_NEXT(values, param_max_offset, rc);
766 uint32_t index_offset =
767 GET_NEXT(values, param_max_offset, rc);
768 uint32_t length =
769 GET_NEXT(values, param_max_offset, rc);
770 switch (command_id) {
771 case BASS_BOOST_ENABLE:
772 if (length != 1 || index_offset != 0) {
773 pr_err("BASS_BOOST_ENABLE:invalid params\n");
774 rc = -EINVAL;
775 goto invalid_config;
776 }
777 prev_enable_flag = bass_boost->enable_flag;
778 bass_boost->enable_flag =
779 GET_NEXT(values, param_max_offset, rc);
780 pr_debug("%s: BASS_BOOST_ENABLE prev:%d new:%d\n",
781 __func__, prev_enable_flag,
782 bass_boost->enable_flag);
783 if (prev_enable_flag != bass_boost->enable_flag) {
784 params_length += COMMAND_PAYLOAD_SZ +
785 BASS_BOOST_ENABLE_PARAM_SZ;
786 CHECK_PARAM_LEN(params_length,
787 MAX_INBAND_PARAM_SZ,
788 "BASS_BOOST_ENABLE", rc);
789 if (rc != 0)
790 break;
791 *updt_params++ =
792 AUDPROC_MODULE_ID_BASS_BOOST;
793 *updt_params++ =
794 AUDPROC_PARAM_ID_BASS_BOOST_ENABLE;
795 *updt_params++ =
796 BASS_BOOST_ENABLE_PARAM_SZ;
797 *updt_params++ =
798 bass_boost->enable_flag;
799 }
800 break;
801 case BASS_BOOST_MODE:
802 if (length != 1 || index_offset != 0) {
803 pr_err("BASS_BOOST_MODE:invalid params\n");
804 rc = -EINVAL;
805 goto invalid_config;
806 }
807 bass_boost->mode =
808 GET_NEXT(values, param_max_offset, rc);
809 pr_debug("%s: BASS_BOOST_MODE val:%d\n",
810 __func__, bass_boost->mode);
811 if (command_config_state == CONFIG_SET) {
812 params_length += COMMAND_PAYLOAD_SZ +
813 BASS_BOOST_MODE_PARAM_SZ;
814 CHECK_PARAM_LEN(params_length,
815 MAX_INBAND_PARAM_SZ,
816 "BASS_BOOST_MODE", rc);
817 if (rc != 0)
818 break;
819 *updt_params++ =
820 AUDPROC_MODULE_ID_BASS_BOOST;
821 *updt_params++ =
822 AUDPROC_PARAM_ID_BASS_BOOST_MODE;
823 *updt_params++ =
824 BASS_BOOST_MODE_PARAM_SZ;
825 *updt_params++ =
826 bass_boost->mode;
827 }
828 break;
829 case BASS_BOOST_STRENGTH:
830 if (length != 1 || index_offset != 0) {
831 pr_err("BASS_BOOST_STRENGTH:invalid params\n");
832 rc = -EINVAL;
833 goto invalid_config;
834 }
835 bass_boost->strength =
836 GET_NEXT(values, param_max_offset, rc);
837 pr_debug("%s: BASS_BOOST_STRENGTH val:%d\n",
838 __func__, bass_boost->strength);
839 if (command_config_state == CONFIG_SET) {
840 params_length += COMMAND_PAYLOAD_SZ +
841 BASS_BOOST_STRENGTH_PARAM_SZ;
842 CHECK_PARAM_LEN(params_length,
843 MAX_INBAND_PARAM_SZ,
844 "BASS_BOOST_STRENGTH", rc);
845 if (rc != 0)
846 break;
847 *updt_params++ =
848 AUDPROC_MODULE_ID_BASS_BOOST;
849 *updt_params++ =
850 AUDPROC_PARAM_ID_BASS_BOOST_STRENGTH;
851 *updt_params++ =
852 BASS_BOOST_STRENGTH_PARAM_SZ;
853 *updt_params++ =
854 bass_boost->strength;
855 }
856 break;
857 default:
858 pr_err("%s: Invalid command to set config\n", __func__);
859 break;
860 }
861 }
862 if (params_length && (rc == 0))
863 q6asm_send_audio_effects_params(ac, params,
864 params_length);
865 else
866 pr_debug("%s: did not send pp params\n", __func__);
867invalid_config:
868 kfree(params);
869 return rc;
870}
871
872int msm_audio_effects_pbe_handler(struct audio_client *ac,
873 struct pbe_params *pbe,
874 long *values)
875{
876 long *param_max_offset = values + MAX_PP_PARAMS_SZ - 1;
877 char *params = NULL;
878 int rc = 0;
879 int devices = GET_NEXT(values, param_max_offset, rc);
880 int num_commands = GET_NEXT(values, param_max_offset, rc);
881 int *updt_params, i, j, prev_enable_flag;
882 uint32_t params_length = (MAX_INBAND_PARAM_SZ);
883
884 pr_debug("%s\n", __func__);
885 if (!ac || (devices == -EINVAL) || (num_commands == -EINVAL)) {
886 pr_err("%s: cannot set audio effects\n", __func__);
887 return -EINVAL;
888 }
889 params = kzalloc(params_length, GFP_KERNEL);
890 if (!params)
891 return -ENOMEM;
892
893 pr_debug("%s: device: %d\n", __func__, devices);
894 updt_params = (int *)params;
895 params_length = 0;
896 for (i = 0; i < num_commands; i++) {
897 uint32_t command_id =
898 GET_NEXT(values, param_max_offset, rc);
899 uint32_t command_config_state =
900 GET_NEXT(values, param_max_offset, rc);
901 uint32_t index_offset =
902 GET_NEXT(values, param_max_offset, rc);
903 uint32_t length =
904 GET_NEXT(values, param_max_offset, rc);
905 switch (command_id) {
906 case PBE_ENABLE:
907 pr_debug("%s: PBE_ENABLE\n", __func__);
908 if (length != 1 || index_offset != 0) {
909 pr_err("no valid params\n");
910 rc = -EINVAL;
911 goto invalid_config;
912 }
913 prev_enable_flag = pbe->enable_flag;
914 pbe->enable_flag =
915 GET_NEXT(values, param_max_offset, rc);
916 if (prev_enable_flag != pbe->enable_flag) {
917 params_length += COMMAND_PAYLOAD_SZ +
918 PBE_ENABLE_PARAM_SZ;
919 CHECK_PARAM_LEN(params_length,
920 MAX_INBAND_PARAM_SZ,
921 "PBE_ENABLE", rc);
922 if (rc != 0)
923 break;
924 *updt_params++ =
925 AUDPROC_MODULE_ID_PBE;
926 *updt_params++ =
927 AUDPROC_PARAM_ID_PBE_ENABLE;
928 *updt_params++ =
929 PBE_ENABLE_PARAM_SZ;
930 *updt_params++ =
931 pbe->enable_flag;
932 }
933 break;
934 case PBE_CONFIG:
935 pr_debug("%s: PBE_PARAM length %u\n", __func__, length);
936 if (length > sizeof(struct pbe_config_t) ||
937 length < PBE_CONFIG_PARAM_LEN ||
938 index_offset != 0) {
939 pr_err("no valid params, len %d\n", length);
940 rc = -EINVAL;
941 goto invalid_config;
942 }
943 if (command_config_state == CONFIG_SET) {
944 params_length += COMMAND_PAYLOAD_SZ + length;
945 CHECK_PARAM_LEN(params_length,
946 MAX_INBAND_PARAM_SZ,
947 "PBE_PARAM", rc);
948 if (rc != 0)
949 break;
950 *updt_params++ =
951 AUDPROC_MODULE_ID_PBE;
952 *updt_params++ =
953 AUDPROC_PARAM_ID_PBE_PARAM_CONFIG;
954 *updt_params++ =
955 length;
956 for (j = 0; j < length; ) {
957 j += sizeof(*updt_params);
958 *updt_params++ =
959 GET_NEXT(
960 values,
961 param_max_offset,
962 rc);
963 }
964 }
965 break;
966 default:
967 pr_err("%s: Invalid command to set config\n", __func__);
968 break;
969 }
970 }
971 if (params_length && (rc == 0))
972 q6asm_send_audio_effects_params(ac, params,
973 params_length);
974invalid_config:
975 kfree(params);
976 return rc;
977}
978
979int msm_audio_effects_popless_eq_handler(struct audio_client *ac,
980 struct eq_params *eq,
981 long *values)
982{
983 long *param_max_offset = values + MAX_PP_PARAMS_SZ - 1;
984 char *params = NULL;
985 int rc = 0;
986 int devices = GET_NEXT(values, param_max_offset, rc);
987 int num_commands = GET_NEXT(values, param_max_offset, rc);
988 int *updt_params, i, prev_enable_flag;
989 uint32_t params_length = (MAX_INBAND_PARAM_SZ);
990
991 pr_debug("%s\n", __func__);
992 if (!ac || (devices == -EINVAL) || (num_commands == -EINVAL)) {
993 pr_err("%s: cannot set audio effects\n", __func__);
994 return -EINVAL;
995 }
996 params = kzalloc(params_length, GFP_KERNEL);
997 if (!params)
998 return -ENOMEM;
999
1000 pr_debug("%s: device: %d\n", __func__, devices);
1001 updt_params = (int *)params;
1002 params_length = 0;
1003 for (i = 0; i < num_commands; i++) {
1004 uint32_t command_id =
1005 GET_NEXT(values, param_max_offset, rc);
1006 uint32_t command_config_state =
1007 GET_NEXT(values, param_max_offset, rc);
1008 uint32_t index_offset =
1009 GET_NEXT(values, param_max_offset, rc);
1010 uint32_t length =
1011 GET_NEXT(values, param_max_offset, rc);
1012 uint32_t idx;
1013 int j;
1014
1015 switch (command_id) {
1016 case EQ_ENABLE:
1017 if (length != 1 || index_offset != 0) {
1018 pr_err("EQ_ENABLE:invalid params\n");
1019 rc = -EINVAL;
1020 goto invalid_config;
1021 }
1022 prev_enable_flag = eq->enable_flag;
1023 eq->enable_flag =
1024 GET_NEXT(values, param_max_offset, rc);
1025 pr_debug("%s: EQ_ENABLE prev:%d new:%d\n", __func__,
1026 prev_enable_flag, eq->enable_flag);
1027 if (prev_enable_flag != eq->enable_flag) {
1028 params_length += COMMAND_PAYLOAD_SZ +
1029 EQ_ENABLE_PARAM_SZ;
1030 CHECK_PARAM_LEN(params_length,
1031 MAX_INBAND_PARAM_SZ,
1032 "EQ_ENABLE", rc);
1033 if (rc != 0)
1034 break;
1035 *updt_params++ =
1036 AUDPROC_MODULE_ID_POPLESS_EQUALIZER;
1037 *updt_params++ =
1038 AUDPROC_PARAM_ID_EQ_ENABLE;
1039 *updt_params++ =
1040 EQ_ENABLE_PARAM_SZ;
1041 *updt_params++ =
1042 eq->enable_flag;
1043 }
1044 break;
1045 case EQ_CONFIG:
1046 if (length < EQ_CONFIG_PARAM_LEN || index_offset != 0) {
1047 pr_err("EQ_CONFIG:invalid params\n");
1048 rc = -EINVAL;
1049 goto invalid_config;
1050 }
1051 pr_debug("%s: EQ_CONFIG bands:%d, pgain:%d, pset:%d\n",
1052 __func__, eq->config.num_bands,
1053 eq->config.eq_pregain, eq->config.preset_id);
1054 for (idx = 0; idx < MAX_EQ_BANDS; idx++)
1055 eq->per_band_cfg[idx].band_idx = -1;
1056 eq->config.eq_pregain =
1057 GET_NEXT(values, param_max_offset, rc);
1058 eq->config.preset_id =
1059 GET_NEXT(values, param_max_offset, rc);
1060 eq->config.num_bands =
1061 GET_NEXT(values, param_max_offset, rc);
1062 if (eq->config.num_bands > MAX_EQ_BANDS) {
1063 pr_err("EQ_CONFIG:invalid num of bands\n");
1064 rc = -EINVAL;
1065 goto invalid_config;
1066 }
1067 if (eq->config.num_bands &&
1068 (((length - EQ_CONFIG_PARAM_LEN)/
1069 EQ_CONFIG_PER_BAND_PARAM_LEN)
1070 != eq->config.num_bands)) {
1071 pr_err("EQ_CONFIG:invalid length per band\n");
1072 rc = -EINVAL;
1073 goto invalid_config;
1074 }
1075 for (j = 0; j < eq->config.num_bands; j++) {
1076 idx = GET_NEXT(values, param_max_offset, rc);
1077 if (idx >= MAX_EQ_BANDS) {
1078 pr_err("EQ_CONFIG:invalid band index\n");
1079 rc = -EINVAL;
1080 goto invalid_config;
1081 }
1082 eq->per_band_cfg[idx].band_idx = idx;
1083 eq->per_band_cfg[idx].filter_type =
1084 GET_NEXT(values, param_max_offset, rc);
1085 eq->per_band_cfg[idx].freq_millihertz =
1086 GET_NEXT(values, param_max_offset, rc);
1087 eq->per_band_cfg[idx].gain_millibels =
1088 GET_NEXT(values, param_max_offset, rc);
1089 eq->per_band_cfg[idx].quality_factor =
1090 GET_NEXT(values, param_max_offset, rc);
1091 }
1092 if (command_config_state == CONFIG_SET) {
1093 int config_param_length = EQ_CONFIG_PARAM_SZ +
1094 (EQ_CONFIG_PER_BAND_PARAM_SZ*
1095 eq->config.num_bands);
1096 params_length += COMMAND_PAYLOAD_SZ +
1097 config_param_length;
1098 CHECK_PARAM_LEN(params_length,
1099 MAX_INBAND_PARAM_SZ,
1100 "EQ_CONFIG", rc);
1101 if (rc != 0)
1102 break;
1103 *updt_params++ =
1104 AUDPROC_MODULE_ID_POPLESS_EQUALIZER;
1105 *updt_params++ =
1106 AUDPROC_PARAM_ID_EQ_CONFIG;
1107 *updt_params++ =
1108 config_param_length;
1109 *updt_params++ =
1110 eq->config.eq_pregain;
1111 *updt_params++ =
1112 eq->config.preset_id;
1113 *updt_params++ =
1114 eq->config.num_bands;
1115 for (idx = 0; idx < MAX_EQ_BANDS; idx++) {
1116 if (eq->per_band_cfg[idx].band_idx < 0)
1117 continue;
1118 *updt_params++ =
1119 eq->per_band_cfg[idx].filter_type;
1120 *updt_params++ =
1121 eq->per_band_cfg[idx].freq_millihertz;
1122 *updt_params++ =
1123 eq->per_band_cfg[idx].gain_millibels;
1124 *updt_params++ =
1125 eq->per_band_cfg[idx].quality_factor;
1126 *updt_params++ =
1127 eq->per_band_cfg[idx].band_idx;
1128 }
1129 }
1130 break;
1131 case EQ_BAND_INDEX:
1132 if (length != 1 || index_offset != 0) {
1133 pr_err("EQ_BAND_INDEX:invalid params\n");
1134 rc = -EINVAL;
1135 goto invalid_config;
1136 }
1137 idx = GET_NEXT(values, param_max_offset, rc);
1138 if (idx > MAX_EQ_BANDS) {
1139 pr_err("EQ_BAND_INDEX:invalid band index\n");
1140 rc = -EINVAL;
1141 goto invalid_config;
1142 }
1143 eq->band_index = idx;
1144 pr_debug("%s: EQ_BAND_INDEX val:%d\n",
1145 __func__, eq->band_index);
1146 if (command_config_state == CONFIG_SET) {
1147 params_length += COMMAND_PAYLOAD_SZ +
1148 EQ_BAND_INDEX_PARAM_SZ;
1149 CHECK_PARAM_LEN(params_length,
1150 MAX_INBAND_PARAM_SZ,
1151 "EQ_BAND_INDEX", rc);
1152 if (rc != 0)
1153 break;
1154 *updt_params++ =
1155 AUDPROC_MODULE_ID_POPLESS_EQUALIZER;
1156 *updt_params++ =
1157 AUDPROC_PARAM_ID_EQ_BAND_INDEX;
1158 *updt_params++ =
1159 EQ_BAND_INDEX_PARAM_SZ;
1160 *updt_params++ =
1161 eq->band_index;
1162 }
1163 break;
1164 case EQ_SINGLE_BAND_FREQ:
1165 if (length != 1 || index_offset != 0) {
1166 pr_err("EQ_SINGLE_BAND_FREQ:invalid params\n");
1167 rc = -EINVAL;
1168 goto invalid_config;
1169 }
1170 if (eq->band_index > MAX_EQ_BANDS) {
1171 pr_err("EQ_SINGLE_BAND_FREQ:invalid index\n");
1172 break;
1173 }
1174 eq->freq_millihertz =
1175 GET_NEXT(values, param_max_offset, rc);
1176 pr_debug("%s: EQ_SINGLE_BAND_FREQ idx:%d, val:%d\n",
1177 __func__, eq->band_index, eq->freq_millihertz);
1178 if (command_config_state == CONFIG_SET) {
1179 params_length += COMMAND_PAYLOAD_SZ +
1180 EQ_SINGLE_BAND_FREQ_PARAM_SZ;
1181 CHECK_PARAM_LEN(params_length,
1182 MAX_INBAND_PARAM_SZ,
1183 "EQ_SINGLE_BAND_FREQ", rc);
1184 if (rc != 0)
1185 break;
1186 *updt_params++ =
1187 AUDPROC_MODULE_ID_POPLESS_EQUALIZER;
1188 *updt_params++ =
1189 AUDPROC_PARAM_ID_EQ_SINGLE_BAND_FREQ;
1190 *updt_params++ =
1191 EQ_SINGLE_BAND_FREQ_PARAM_SZ;
1192 *updt_params++ =
1193 eq->freq_millihertz;
1194 }
1195 break;
1196 default:
1197 pr_err("%s: Invalid command to set config\n", __func__);
1198 break;
1199 }
1200 }
1201 if (params_length && (rc == 0))
1202 q6asm_send_audio_effects_params(ac, params,
1203 params_length);
1204 else
1205 pr_debug("%s: did not send pp params\n", __func__);
1206invalid_config:
1207 kfree(params);
1208 return rc;
1209}
1210
1211static int __msm_audio_effects_volume_handler(struct audio_client *ac,
1212 struct soft_volume_params *vol,
1213 long *values,
1214 int instance)
1215{
1216 int devices;
1217 int num_commands;
1218 char *params = NULL;
1219 int *updt_params, i;
1220 uint32_t params_length = (MAX_INBAND_PARAM_SZ);
1221 long *param_max_offset;
1222 int rc = 0;
1223
1224 pr_debug("%s: instance: %d\n", __func__, instance);
1225 if (!values) {
1226 pr_err("%s: set audio effects failed, no valid data\n",
1227 __func__);
1228 return -EINVAL;
1229 }
1230 param_max_offset = values + MAX_PP_PARAMS_SZ - 1;
1231 devices = GET_NEXT(values, param_max_offset, rc);
1232 num_commands = GET_NEXT(values, param_max_offset, rc);
1233 if (!ac || (devices == -EINVAL) || (num_commands == -EINVAL)) {
1234 pr_err("%s: cannot set audio effects\n", __func__);
1235 return -EINVAL;
1236 }
1237 params = kzalloc(params_length, GFP_KERNEL);
1238 if (!params)
1239 return -ENOMEM;
1240
1241 updt_params = (int *)params;
1242 params_length = 0;
1243 for (i = 0; i < num_commands; i++) {
1244 uint32_t command_id =
1245 GET_NEXT(values, param_max_offset, rc);
1246 uint32_t command_config_state =
1247 GET_NEXT(values, param_max_offset, rc);
1248 uint32_t index_offset =
1249 GET_NEXT(values, param_max_offset, rc);
1250 uint32_t length =
1251 GET_NEXT(values, param_max_offset, rc);
1252 switch (command_id) {
1253 case SOFT_VOLUME_GAIN_2CH:
1254 case SOFT_VOLUME2_GAIN_2CH:
1255 if (length != 2 || index_offset != 0) {
1256 pr_err("VOLUME_GAIN_2CH: invalid params\n");
1257 rc = -EINVAL;
1258 goto invalid_config;
1259 }
1260 vol->left_gain = GET_NEXT(values, param_max_offset, rc);
1261 vol->right_gain =
1262 GET_NEXT(values, param_max_offset, rc);
1263 vol->master_gain = 0x2000;
1264 if (command_config_state == CONFIG_SET) {
1265 params_length += COMMAND_PAYLOAD_SZ +
1266 SOFT_VOLUME_GAIN_2CH_PARAM_SZ;
1267 params_length += COMMAND_PAYLOAD_SZ +
1268 SOFT_VOLUME_GAIN_MASTER_PARAM_SZ;
1269 CHECK_PARAM_LEN(params_length,
1270 MAX_INBAND_PARAM_SZ,
1271 "VOLUME/VOLUME2_GAIN_2CH",
1272 rc);
1273 if (rc != 0)
1274 break;
1275 if (instance == SOFT_VOLUME_INSTANCE_2)
1276 *updt_params++ =
1277 ASM_MODULE_ID_VOL_CTRL2;
1278 else
1279 *updt_params++ =
1280 ASM_MODULE_ID_VOL_CTRL;
1281 *updt_params++ =
1282 ASM_PARAM_ID_VOL_CTRL_LR_CHANNEL_GAIN;
1283 *updt_params++ =
1284 SOFT_VOLUME_GAIN_2CH_PARAM_SZ;
1285 *updt_params++ =
1286 (vol->left_gain << 16) |
1287 vol->right_gain;
1288 if (instance == SOFT_VOLUME_INSTANCE_2)
1289 *updt_params++ =
1290 ASM_MODULE_ID_VOL_CTRL2;
1291 else
1292 *updt_params++ =
1293 ASM_MODULE_ID_VOL_CTRL;
1294 *updt_params++ =
1295 ASM_PARAM_ID_VOL_CTRL_MASTER_GAIN;
1296 *updt_params++ =
1297 SOFT_VOLUME_GAIN_MASTER_PARAM_SZ;
1298 *updt_params++ =
1299 vol->master_gain;
1300 }
1301 break;
1302 case SOFT_VOLUME_GAIN_MASTER:
1303 case SOFT_VOLUME2_GAIN_MASTER:
1304 if (length != 1 || index_offset != 0) {
1305 pr_err("VOLUME_GAIN_MASTER: invalid params\n");
1306 rc = -EINVAL;
1307 goto invalid_config;
1308 }
1309 vol->left_gain = 0x2000;
1310 vol->right_gain = 0x2000;
1311 vol->master_gain =
1312 GET_NEXT(values, param_max_offset, rc);
1313 if (command_config_state == CONFIG_SET) {
1314 params_length += COMMAND_PAYLOAD_SZ +
1315 SOFT_VOLUME_GAIN_2CH_PARAM_SZ;
1316 params_length += COMMAND_PAYLOAD_SZ +
1317 SOFT_VOLUME_GAIN_MASTER_PARAM_SZ;
1318 CHECK_PARAM_LEN(params_length,
1319 MAX_INBAND_PARAM_SZ,
1320 "VOLUME/VOLUME2_GAIN_MASTER",
1321 rc);
1322 if (rc != 0)
1323 break;
1324 if (instance == SOFT_VOLUME_INSTANCE_2)
1325 *updt_params++ =
1326 ASM_MODULE_ID_VOL_CTRL2;
1327 else
1328 *updt_params++ =
1329 ASM_MODULE_ID_VOL_CTRL;
1330 *updt_params++ =
1331 ASM_PARAM_ID_VOL_CTRL_LR_CHANNEL_GAIN;
1332 *updt_params++ =
1333 SOFT_VOLUME_GAIN_2CH_PARAM_SZ;
1334 *updt_params++ =
1335 (vol->left_gain << 16) |
1336 vol->right_gain;
1337 if (instance == SOFT_VOLUME_INSTANCE_2)
1338 *updt_params++ =
1339 ASM_MODULE_ID_VOL_CTRL2;
1340 else
1341 *updt_params++ =
1342 ASM_MODULE_ID_VOL_CTRL;
1343 *updt_params++ =
1344 ASM_PARAM_ID_VOL_CTRL_MASTER_GAIN;
1345 *updt_params++ =
1346 SOFT_VOLUME_GAIN_MASTER_PARAM_SZ;
1347 *updt_params++ =
1348 vol->master_gain;
1349 }
1350 break;
1351 default:
1352 pr_err("%s: Invalid command id: %d to set config\n",
1353 __func__, command_id);
1354 break;
1355 }
1356 }
1357 if (params_length && (rc == 0))
1358 q6asm_send_audio_effects_params(ac, params,
1359 params_length);
1360invalid_config:
1361 kfree(params);
1362 return rc;
1363}
1364
1365int msm_audio_effects_volume_handler(struct audio_client *ac,
1366 struct soft_volume_params *vol,
1367 long *values)
1368{
1369 return __msm_audio_effects_volume_handler(ac, vol, values,
1370 SOFT_VOLUME_INSTANCE_1);
1371}
1372
1373int msm_audio_effects_volume_handler_v2(struct audio_client *ac,
1374 struct soft_volume_params *vol,
1375 long *values, int instance)
1376{
1377 return __msm_audio_effects_volume_handler(ac, vol, values, instance);
1378}