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