sound/soc/msm/qdsp6v2/rtac.c

   1 /* Copyright (c) 2012-2018, 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
  14 #include <linux/fs.h>
  15 #include <linux/module.h>
  16 #include <linux/miscdevice.h>
  17 #include <linux/slab.h>
  18 #include <linux/uaccess.h>
  19 #include <linux/mutex.h>
  20 #include <linux/sched.h>
  21 #include <linux/msm_audio_calibration.h>
  22 #include <linux/atomic.h>
  23 #include <linux/msm_audio_ion.h>
  24 #include <linux/qdsp6v2/rtac.h>
  25 #include <linux/compat.h>
  26 #include <sound/q6asm-v2.h>
  27 #include <sound/q6afe-v2.h>
  28 #include <sound/q6adm-v2.h>
  29 #include <sound/apr_audio-v2.h>
  30 #include <sound/q6common.h>
  31 #include "q6voice.h"
  32 #include "msm-pcm-routing-v2.h"
  33 #include <sound/adsp_err.h>
  34
  35
  36 /* Max size of payload (buf size - apr header) */
  37 #define MAX_PAYLOAD_SIZE                4076
  38 #define RTAC_MAX_ACTIVE_VOICE_COMBOS    2
  39 #define RTAC_MAX_ACTIVE_POPP            8
  40 #define RTAC_BUF_SIZE                   163840
  41
  42 #define TIMEOUT_MS      1000
  43
  44 struct rtac_cal_block_data      rtac_cal[MAX_RTAC_BLOCKS] = {
  45 /* ADM_RTAC_CAL */
  46         {{RTAC_BUF_SIZE, 0, 0, 0}, {0, 0, 0} },
  47 /* ASM_RTAC_CAL */
  48         {{RTAC_BUF_SIZE, 0, 0, 0}, {0, 0, 0} },
  49 /* VOICE_RTAC_CAL */
  50         {{RTAC_BUF_SIZE, 0, 0, 0}, {0, 0, 0} },
  51 /* AFE_RTAC_CAL */
  52         {{RTAC_BUF_SIZE, 0, 0, 0}, {0, 0, 0} }
  53 };
  54
  55 struct rtac_common_data {
  56         atomic_t                        usage_count;
  57         atomic_t                        apr_err_code;
  58         struct mutex                    rtac_fops_mutex;
  59 };
  60
  61 static struct rtac_common_data          rtac_common;
  62
  63 /* APR data */
  64 struct rtac_apr_data {
  65         void                    *apr_handle;
  66         atomic_t                cmd_state;
  67         wait_queue_head_t       cmd_wait;
  68 };
  69
  70 static struct rtac_apr_data rtac_adm_apr_data;
  71 static struct rtac_apr_data rtac_asm_apr_data[ASM_ACTIVE_STREAMS_ALLOWED + 1];
  72 static struct rtac_apr_data     rtac_afe_apr_data;
  73 static struct rtac_apr_data     rtac_voice_apr_data[RTAC_VOICE_MODES];
  74
  75 /* ADM info & APR */
  76 static struct rtac_adm          rtac_adm_data;
  77 static u32                      *rtac_adm_buffer;
  78
  79
  80 /* ASM APR */
  81 static u32                      *rtac_asm_buffer;
  82
  83 static u32                      *rtac_afe_buffer;
  84
  85 /* Voice info & APR */
  86 struct rtac_voice_data_t {
  87         uint32_t        tx_topology_id;
  88         uint32_t        rx_topology_id;
  89         uint32_t        tx_afe_topology;
  90         uint32_t        rx_afe_topology;
  91         uint32_t        tx_afe_port;
  92         uint32_t        rx_afe_port;
  93         uint16_t        cvs_handle;
  94         uint16_t        cvp_handle;
  95         uint32_t        tx_acdb_id;
  96         uint32_t        rx_acdb_id;
  97 };
  98
  99 struct rtac_voice {
 100         uint32_t                        num_of_voice_combos;
 101         struct rtac_voice_data_t        voice[RTAC_MAX_ACTIVE_VOICE_COMBOS];
 102 };
 103
 104 struct rtac_afe_user_data {
 105         uint32_t        buf_size;
 106         uint32_t        cmd_size;
 107         uint32_t        port_id;
 108         union {
 109                 struct afe_rtac_user_data_set_v2 v2_set;
 110                 struct afe_rtac_user_data_set_v3 v3_set;
 111                 struct afe_rtac_user_data_get_v2 v2_get;
 112                 struct afe_rtac_user_data_get_v3 v3_get;
 113         };
 114 }  __packed;
 115
 116 static struct rtac_voice        rtac_voice_data;
 117 static u32                      *rtac_voice_buffer;
 118 static u32                      voice_session_id[RTAC_MAX_ACTIVE_VOICE_COMBOS];
 119
 120
 121 struct mutex                    rtac_adm_mutex;
 122 struct mutex                    rtac_adm_apr_mutex;
 123 struct mutex                    rtac_asm_apr_mutex;
 124 struct mutex                    rtac_voice_mutex;
 125 struct mutex                    rtac_voice_apr_mutex;
 126 struct mutex                    rtac_afe_apr_mutex;
 127
 128 int rtac_clear_mapping(uint32_t cal_type)
 129 {
 130         int result = 0;
 131         pr_debug("%s\n", __func__);
 132
 133         if (cal_type >= MAX_RTAC_BLOCKS) {
 134                 pr_debug("%s: invalid cal type %d\n", __func__, cal_type);
 135                 result = -EINVAL;
 136                 goto done;
 137         }
 138
 139         rtac_cal[cal_type].map_data.map_handle = 0;
 140 done:
 141         return result;
 142 }
 143
 144 int rtac_allocate_cal_buffer(uint32_t cal_type)
 145 {
 146         int result = 0;
 147         size_t len;
 148         pr_debug("%s\n", __func__);
 149
 150         if (cal_type >= MAX_RTAC_BLOCKS) {
 151                 pr_err("%s: cal_type %d is invalid!\n",
 152                        __func__, cal_type);
 153                 result =  -EINVAL;
 154                 goto done;
 155         }
 156
 157         if (rtac_cal[cal_type].cal_data.paddr != 0) {
 158                 pr_err("%s: memory already allocated! cal_type %d, paddr 0x%pK\n",
 159                        __func__, cal_type, &rtac_cal[cal_type].cal_data.paddr);
 160                 result = -EPERM;
 161                 goto done;
 162         }
 163
 164         result = msm_audio_ion_alloc("rtac_client",
 165                 &rtac_cal[cal_type].map_data.ion_client,
 166                 &rtac_cal[cal_type].map_data.ion_handle,
 167                 rtac_cal[cal_type].map_data.map_size,
 168                 &rtac_cal[cal_type].cal_data.paddr,
 169                 &len,
 170                 &rtac_cal[cal_type].cal_data.kvaddr);
 171         if (result < 0) {
 172                 pr_err("%s: ION create client for RTAC failed\n",
 173                        __func__);
 174                 goto done;
 175         }
 176
 177         pr_debug("%s: cal_type %d, paddr 0x%pK, kvaddr 0x%pK, map_size 0x%x\n",
 178                 __func__, cal_type,
 179                 &rtac_cal[cal_type].cal_data.paddr,
 180                 rtac_cal[cal_type].cal_data.kvaddr,
 181                 rtac_cal[cal_type].map_data.map_size);
 182 done:
 183         return result;
 184 }
 185
 186 int rtac_free_cal_buffer(uint32_t cal_type)
 187 {
 188         int result = 0;
 189         pr_debug("%s\n", __func__);
 190
 191         if (cal_type >= MAX_RTAC_BLOCKS) {
 192                 pr_err("%s: cal_type %d is invalid!\n",
 193                        __func__, cal_type);
 194                 result =  -EINVAL;
 195                 goto done;
 196         }
 197
 198         if (rtac_cal[cal_type].map_data.ion_client == NULL) {
 199                 pr_debug("%s: cal_type %d not allocated!\n",
 200                        __func__, cal_type);
 201                 goto done;
 202         }
 203
 204         result = msm_audio_ion_free(rtac_cal[cal_type].map_data.ion_client,
 205                                 rtac_cal[cal_type].map_data.ion_handle);
 206         if (result < 0) {
 207                 pr_err("%s: ION free for RTAC failed! cal_type %d, paddr 0x%pK\n",
 208                        __func__, cal_type, &rtac_cal[cal_type].cal_data.paddr);
 209                 goto done;
 210         }
 211
 212         rtac_cal[cal_type].map_data.map_handle = 0;
 213         rtac_cal[cal_type].map_data.ion_client = NULL;
 214         rtac_cal[cal_type].map_data.ion_handle = NULL;
 215         rtac_cal[cal_type].cal_data.size = 0;
 216         rtac_cal[cal_type].cal_data.kvaddr = 0;
 217         rtac_cal[cal_type].cal_data.paddr = 0;
 218 done:
 219         return result;
 220 }
 221
 222 int rtac_map_cal_buffer(uint32_t cal_type)
 223 {
 224         int result = 0;
 225         pr_debug("%s\n", __func__);
 226
 227         if (cal_type >= MAX_RTAC_BLOCKS) {
 228                 pr_err("%s: cal_type %d is invalid!\n",
 229                        __func__, cal_type);
 230                 result =  -EINVAL;
 231                 goto done;
 232         }
 233
 234         if (rtac_cal[cal_type].map_data.map_handle != 0) {
 235                 pr_err("%s: already mapped cal_type %d\n",
 236                         __func__, cal_type);
 237                 result =  -EPERM;
 238                 goto done;
 239         }
 240
 241         if (rtac_cal[cal_type].cal_data.paddr == 0) {
 242                 pr_err("%s: physical address is NULL cal_type %d\n",
 243                         __func__, cal_type);
 244                 result =  -EPERM;
 245                 goto done;
 246         }
 247
 248         switch (cal_type) {
 249         case ADM_RTAC_CAL:
 250                 result = adm_map_rtac_block(&rtac_cal[cal_type]);
 251                 break;
 252         case ASM_RTAC_CAL:
 253                 result = q6asm_map_rtac_block(&rtac_cal[cal_type]);
 254                 break;
 255         case VOICE_RTAC_CAL:
 256                 result = voc_map_rtac_block(&rtac_cal[cal_type]);
 257                 break;
 258         case AFE_RTAC_CAL:
 259                 result = afe_map_rtac_block(&rtac_cal[cal_type]);
 260                 break;
 261         }
 262         if (result < 0) {
 263                 pr_err("%s: map RTAC failed! cal_type %d\n",
 264                        __func__, cal_type);
 265                 goto done;
 266         }
 267 done:
 268         return result;
 269 }
 270
 271 int rtac_unmap_cal_buffer(uint32_t cal_type)
 272 {
 273         int result = 0;
 274         pr_debug("%s\n", __func__);
 275
 276         if (cal_type >= MAX_RTAC_BLOCKS) {
 277                 pr_err("%s: cal_type %d is invalid!\n",
 278                        __func__, cal_type);
 279                 result =  -EINVAL;
 280                 goto done;
 281         }
 282
 283         if (rtac_cal[cal_type].map_data.map_handle == 0) {
 284                 pr_debug("%s: nothing to unmap cal_type %d\n",
 285                         __func__, cal_type);
 286                 goto done;
 287         }
 288
 289         switch (cal_type) {
 290         case ADM_RTAC_CAL:
 291                 result = adm_unmap_rtac_block(
 292                         &rtac_cal[cal_type].map_data.map_handle);
 293                 break;
 294         case ASM_RTAC_CAL:
 295                 result = q6asm_unmap_rtac_block(
 296                         &rtac_cal[cal_type].map_data.map_handle);
 297                 break;
 298         case VOICE_RTAC_CAL:
 299                 result = voc_unmap_rtac_block(
 300                         &rtac_cal[cal_type].map_data.map_handle);
 301                 break;
 302         case AFE_RTAC_CAL:
 303                 result = afe_unmap_rtac_block(
 304                         &rtac_cal[cal_type].map_data.map_handle);
 305                 break;
 306         }
 307         if (result < 0) {
 308                 pr_err("%s: unmap RTAC failed! cal_type %d\n",
 309                        __func__, cal_type);
 310                 goto done;
 311         }
 312 done:
 313         return result;
 314 }
 315
 316 static int rtac_open(struct inode *inode, struct file *f)
 317 {
 318         int     result = 0;
 319         pr_debug("%s\n", __func__);
 320
 321         mutex_lock(&rtac_common.rtac_fops_mutex);
 322         atomic_inc(&rtac_common.usage_count);
 323         mutex_unlock(&rtac_common.rtac_fops_mutex);
 324         return result;
 325 }
 326
 327 static int rtac_release(struct inode *inode, struct file *f)
 328 {
 329         int     result = 0;
 330         int     result2 = 0;
 331         int     i;
 332         pr_debug("%s\n", __func__);
 333
 334         mutex_lock(&rtac_common.rtac_fops_mutex);
 335         atomic_dec(&rtac_common.usage_count);
 336         pr_debug("%s: ref count %d!\n", __func__,
 337                 atomic_read(&rtac_common.usage_count));
 338
 339         if (atomic_read(&rtac_common.usage_count) > 0) {
 340                 mutex_unlock(&rtac_common.rtac_fops_mutex);
 341                 goto done;
 342         }
 343
 344         for (i = 0; i < MAX_RTAC_BLOCKS; i++) {
 345                 result2 = rtac_unmap_cal_buffer(i);
 346                 if (result2 < 0) {
 347                         pr_err("%s: unmap buffer failed! error %d!\n",
 348                                 __func__, result2);
 349                         result = result2;
 350                 }
 351
 352                 result2 = rtac_free_cal_buffer(i);
 353                 if (result2 < 0) {
 354                         pr_err("%s: free buffer failed! error %d!\n",
 355                                 __func__, result2);
 356                         result = result2;
 357                 }
 358         }
 359         mutex_unlock(&rtac_common.rtac_fops_mutex);
 360 done:
 361         return result;
 362 }
 363
 364
 365 /* ADM Info */
 366 void add_popp(u32 dev_idx, u32 port_id, u32 popp_id)
 367 {
 368         u32 i = 0;
 369
 370         for (; i < rtac_adm_data.device[dev_idx].num_of_popp; i++)
 371                 if (rtac_adm_data.device[dev_idx].popp[i].popp == popp_id)
 372                         goto done;
 373
 374         if (rtac_adm_data.device[dev_idx].num_of_popp ==
 375                         RTAC_MAX_ACTIVE_POPP) {
 376                 pr_err("%s, Max POPP!\n", __func__);
 377                 goto done;
 378         }
 379         rtac_adm_data.device[dev_idx].popp[
 380                 rtac_adm_data.device[dev_idx].num_of_popp].popp = popp_id;
 381         rtac_adm_data.device[dev_idx].popp[
 382                 rtac_adm_data.device[dev_idx].num_of_popp].popp_topology =
 383                 q6asm_get_asm_topology(popp_id);
 384         rtac_adm_data.device[dev_idx].popp[
 385                 rtac_adm_data.device[dev_idx].num_of_popp++].app_type =
 386                 q6asm_get_asm_app_type(popp_id);
 387
 388         pr_debug("%s: popp_id = %d, popp topology = 0x%x, popp app type = 0x%x\n",
 389                 __func__,
 390                 rtac_adm_data.device[dev_idx].popp[
 391                         rtac_adm_data.device[dev_idx].num_of_popp - 1].popp,
 392                 rtac_adm_data.device[dev_idx].popp[
 393                 rtac_adm_data.device[dev_idx].num_of_popp - 1].popp_topology,
 394                 rtac_adm_data.device[dev_idx].popp[
 395                 rtac_adm_data.device[dev_idx].num_of_popp - 1].app_type);
 396 done:
 397         return;
 398 }
 399
 400 void rtac_update_afe_topology(u32 port_id)
 401 {
 402         u32 i = 0;
 403
 404         mutex_lock(&rtac_adm_mutex);
 405         for (i = 0; i < rtac_adm_data.num_of_dev; i++) {
 406                 if (rtac_adm_data.device[i].afe_port == port_id) {
 407                         rtac_adm_data.device[i].afe_topology =
 408                                                 afe_get_topology(port_id);
 409                         pr_debug("%s: port_id = 0x%x topology_id = 0x%x copp_id = %d\n",
 410                                  __func__, port_id,
 411                                  rtac_adm_data.device[i].afe_topology,
 412                                  rtac_adm_data.device[i].copp);
 413                 }
 414         }
 415         mutex_unlock(&rtac_adm_mutex);
 416 }
 417
 418 void rtac_add_adm_device(u32 port_id, u32 copp_id, u32 path_id, u32 popp_id,
 419                          u32 app_type, u32 acdb_id)
 420 {
 421         u32 i = 0;
 422         pr_debug("%s: num rtac devices %d port_id = %d, copp_id = %d\n",
 423                 __func__, rtac_adm_data.num_of_dev, port_id, copp_id);
 424
 425         mutex_lock(&rtac_adm_mutex);
 426         if (rtac_adm_data.num_of_dev == RTAC_MAX_ACTIVE_DEVICES) {
 427                 pr_err("%s, Can't add anymore RTAC devices!\n", __func__);
 428                 goto done;
 429         }
 430
 431         /* Check if device already added */
 432         if (rtac_adm_data.num_of_dev != 0) {
 433                 for (; i < rtac_adm_data.num_of_dev; i++) {
 434                         if (rtac_adm_data.device[i].afe_port == port_id &&
 435                             rtac_adm_data.device[i].copp == copp_id) {
 436                                 add_popp(i, port_id, popp_id);
 437                                 goto done;
 438                         }
 439                         if (rtac_adm_data.device[i].num_of_popp ==
 440                                                 RTAC_MAX_ACTIVE_POPP) {
 441                                 pr_err("%s, Max POPP!\n", __func__);
 442                                 goto done;
 443                         }
 444                 }
 445         }
 446
 447         /* Add device */
 448         rtac_adm_data.num_of_dev++;
 449
 450         rtac_adm_data.device[i].topology_id =
 451                 adm_get_topology_for_port_from_copp_id(port_id, copp_id);
 452         rtac_adm_data.device[i].afe_topology =
 453                 afe_get_topology(port_id);
 454         rtac_adm_data.device[i].afe_port = port_id;
 455         rtac_adm_data.device[i].copp = copp_id;
 456         rtac_adm_data.device[i].app_type = app_type;
 457         rtac_adm_data.device[i].acdb_dev_id = acdb_id;
 458         rtac_adm_data.device[i].popp[
 459                 rtac_adm_data.device[i].num_of_popp].popp = popp_id;
 460         rtac_adm_data.device[i].popp[
 461                 rtac_adm_data.device[i].num_of_popp].popp_topology =
 462                 q6asm_get_asm_topology(popp_id);
 463         rtac_adm_data.device[i].popp[
 464                 rtac_adm_data.device[i].num_of_popp++].app_type =
 465                 q6asm_get_asm_app_type(popp_id);
 466
 467         pr_debug("%s: topology = 0x%x, afe_topology = 0x%x, port_id = %d, copp_id = %d, app id = 0x%x, acdb id = %d, popp_id = %d, popp topology = 0x%x, popp app type = 0x%x\n",
 468                 __func__,
 469                 rtac_adm_data.device[i].topology_id,
 470                 rtac_adm_data.device[i].afe_topology,
 471                 rtac_adm_data.device[i].afe_port,
 472                 rtac_adm_data.device[i].copp,
 473                 rtac_adm_data.device[i].app_type,
 474                 rtac_adm_data.device[i].acdb_dev_id,
 475                 rtac_adm_data.device[i].popp[
 476                         rtac_adm_data.device[i].num_of_popp - 1].popp,
 477                 rtac_adm_data.device[i].popp[
 478                 rtac_adm_data.device[i].num_of_popp - 1].popp_topology,
 479                 rtac_adm_data.device[i].popp[
 480                 rtac_adm_data.device[i].num_of_popp - 1].app_type);
 481 done:
 482         mutex_unlock(&rtac_adm_mutex);
 483         return;
 484 }
 485
 486 static void shift_adm_devices(u32 dev_idx)
 487 {
 488         for (; dev_idx < rtac_adm_data.num_of_dev; dev_idx++) {
 489                 memcpy(&rtac_adm_data.device[dev_idx],
 490                         &rtac_adm_data.device[dev_idx + 1],
 491                         sizeof(rtac_adm_data.device[dev_idx]));
 492                 memset(&rtac_adm_data.device[dev_idx + 1], 0,
 493                            sizeof(rtac_adm_data.device[dev_idx]));
 494         }
 495 }
 496
 497 static void shift_popp(u32 copp_idx, u32 popp_idx)
 498 {
 499         for (; popp_idx < rtac_adm_data.device[copp_idx].num_of_popp;
 500                                                         popp_idx++) {
 501                 memcpy(&rtac_adm_data.device[copp_idx].popp[popp_idx].popp,
 502                         &rtac_adm_data.device[copp_idx].popp[popp_idx + 1].
 503                         popp, sizeof(uint32_t));
 504                 memcpy(&rtac_adm_data.device[copp_idx].popp[popp_idx].
 505                         popp_topology,
 506                         &rtac_adm_data.device[copp_idx].popp[popp_idx + 1].
 507                         popp_topology,
 508                         sizeof(uint32_t));
 509                 memset(&rtac_adm_data.device[copp_idx].popp[popp_idx + 1].
 510                         popp, 0, sizeof(uint32_t));
 511                 memset(&rtac_adm_data.device[copp_idx].popp[popp_idx + 1].
 512                         popp_topology, 0, sizeof(uint32_t));
 513         }
 514 }
 515
 516 void rtac_remove_adm_device(u32 port_id, u32 copp_id)
 517 {
 518         s32 i;
 519         pr_debug("%s: num rtac devices %d port_id = %d, copp_id = %d\n",
 520                 __func__, rtac_adm_data.num_of_dev, port_id, copp_id);
 521
 522         mutex_lock(&rtac_adm_mutex);
 523         /* look for device */
 524         for (i = 0; i < rtac_adm_data.num_of_dev; i++) {
 525                 if (rtac_adm_data.device[i].afe_port == port_id &&
 526                     rtac_adm_data.device[i].copp == copp_id) {
 527                         memset(&rtac_adm_data.device[i], 0,
 528                                    sizeof(rtac_adm_data.device[i]));
 529                         rtac_adm_data.num_of_dev--;
 530
 531                         if (rtac_adm_data.num_of_dev >= 1) {
 532                                 shift_adm_devices(i);
 533                                 break;
 534                         }
 535                 }
 536         }
 537
 538         mutex_unlock(&rtac_adm_mutex);
 539         return;
 540 }
 541
 542 void rtac_remove_popp_from_adm_devices(u32 popp_id)
 543 {
 544         s32 i, j;
 545         pr_debug("%s: popp_id = %d\n", __func__, popp_id);
 546
 547         mutex_lock(&rtac_adm_mutex);
 548         for (i = 0; i < rtac_adm_data.num_of_dev; i++) {
 549                 for (j = 0; j < rtac_adm_data.device[i].num_of_popp; j++) {
 550                         if (rtac_adm_data.device[i].popp[j].popp ==
 551                                                                 popp_id) {
 552                                 rtac_adm_data.device[i].popp[j].popp = 0;
 553                                 rtac_adm_data.device[i].popp[j].
 554                                         popp_topology = 0;
 555                                 rtac_adm_data.device[i].num_of_popp--;
 556                                 shift_popp(i, j);
 557                         }
 558                 }
 559         }
 560         mutex_unlock(&rtac_adm_mutex);
 561 }
 562
 563
 564 /* Voice Info */
 565 static void set_rtac_voice_data(int idx, u32 cvs_handle, u32 cvp_handle,
 566                                         u32 rx_afe_port, u32 tx_afe_port,
 567                                         u32 rx_acdb_id, u32 tx_acdb_id,
 568                                         u32 session_id)
 569 {
 570         rtac_voice_data.voice[idx].tx_topology_id =
 571                 voice_get_topology(CVP_VOC_TX_TOPOLOGY_CAL);
 572         rtac_voice_data.voice[idx].rx_topology_id =
 573                 voice_get_topology(CVP_VOC_RX_TOPOLOGY_CAL);
 574         rtac_voice_data.voice[idx].tx_afe_topology =
 575                 afe_get_topology(tx_afe_port);
 576         rtac_voice_data.voice[idx].rx_afe_topology =
 577                 afe_get_topology(rx_afe_port);
 578         rtac_voice_data.voice[idx].tx_afe_port = tx_afe_port;
 579         rtac_voice_data.voice[idx].rx_afe_port = rx_afe_port;
 580         rtac_voice_data.voice[idx].tx_acdb_id = tx_acdb_id;
 581         rtac_voice_data.voice[idx].rx_acdb_id = rx_acdb_id;
 582         rtac_voice_data.voice[idx].cvs_handle = cvs_handle;
 583         rtac_voice_data.voice[idx].cvp_handle = cvp_handle;
 584         pr_debug("%s\n%s: %x\n%s: %d %s: %d\n%s: %d %s: %d\n %s: %d\n %s: %d\n%s: %d %s: %d\n%s",
 585                  "<---- Voice Data Info ---->", "Session id", session_id,
 586                  "cvs_handle", cvs_handle, "cvp_handle", cvp_handle,
 587                  "rx_afe_topology", rtac_voice_data.voice[idx].rx_afe_topology,
 588                  "tx_afe_topology", rtac_voice_data.voice[idx].tx_afe_topology,
 589                  "rx_afe_port", rx_afe_port, "tx_afe_port", tx_afe_port,
 590                  "rx_acdb_id", rx_acdb_id, "tx_acdb_id", tx_acdb_id,
 591                  "<-----------End----------->");
 592
 593         /* Store session ID for voice RTAC */
 594         voice_session_id[idx] = session_id;
 595 }
 596
 597 void rtac_add_voice(u32 cvs_handle, u32 cvp_handle, u32 rx_afe_port,
 598                         u32 tx_afe_port, u32 rx_acdb_id, u32 tx_acdb_id,
 599                         u32 session_id)
 600 {
 601         u32 i = 0;
 602         pr_debug("%s\n", __func__);
 603         mutex_lock(&rtac_voice_mutex);
 604
 605         if (rtac_voice_data.num_of_voice_combos ==
 606                         RTAC_MAX_ACTIVE_VOICE_COMBOS) {
 607                 pr_err("%s, Can't add anymore RTAC devices!\n", __func__);
 608                 goto done;
 609         }
 610
 611         /* Check if device already added */
 612         if (rtac_voice_data.num_of_voice_combos != 0) {
 613                 for (; i < rtac_voice_data.num_of_voice_combos; i++) {
 614                         if (rtac_voice_data.voice[i].cvs_handle ==
 615                                                         cvs_handle) {
 616                                 set_rtac_voice_data(i, cvs_handle, cvp_handle,
 617                                         rx_afe_port, tx_afe_port, rx_acdb_id,
 618                                         tx_acdb_id, session_id);
 619                                 goto done;
 620                         }
 621                 }
 622         }
 623
 624         /* Add device */
 625         rtac_voice_data.num_of_voice_combos++;
 626         set_rtac_voice_data(i, cvs_handle, cvp_handle,
 627                                 rx_afe_port, tx_afe_port,
 628                                 rx_acdb_id, tx_acdb_id,
 629                                 session_id);
 630 done:
 631         mutex_unlock(&rtac_voice_mutex);
 632         return;
 633 }
 634
 635 static void shift_voice_devices(u32 idx)
 636 {
 637         for (; idx < rtac_voice_data.num_of_voice_combos - 1; idx++) {
 638                 memcpy(&rtac_voice_data.voice[idx],
 639                         &rtac_voice_data.voice[idx + 1],
 640                         sizeof(rtac_voice_data.voice[idx]));
 641                 voice_session_id[idx] = voice_session_id[idx + 1];
 642         }
 643 }
 644
 645 void rtac_remove_voice(u32 cvs_handle)
 646 {
 647         u32 i = 0;
 648         pr_debug("%s\n", __func__);
 649
 650         mutex_lock(&rtac_voice_mutex);
 651         /* look for device */
 652         for (i = 0; i < rtac_voice_data.num_of_voice_combos; i++) {
 653                 if (rtac_voice_data.voice[i].cvs_handle == cvs_handle) {
 654                         shift_voice_devices(i);
 655                         rtac_voice_data.num_of_voice_combos--;
 656                         memset(&rtac_voice_data.voice[
 657                                 rtac_voice_data.num_of_voice_combos], 0,
 658                                 sizeof(rtac_voice_data.voice
 659                                 [rtac_voice_data.num_of_voice_combos]));
 660                         voice_session_id[rtac_voice_data.num_of_voice_combos]
 661                                 = 0;
 662                         break;
 663                 }
 664         }
 665         mutex_unlock(&rtac_voice_mutex);
 666         return;
 667 }
 668
 669 static u32 get_voice_session_id_cvs(u32 cvs_handle)
 670 {
 671         u32 i;
 672
 673         for (i = 0; i < rtac_voice_data.num_of_voice_combos; i++) {
 674                 if (rtac_voice_data.voice[i].cvs_handle == cvs_handle)
 675                         return voice_session_id[i];
 676         }
 677
 678         pr_err("%s: No voice index for CVS handle %d found returning 0\n",
 679                __func__, cvs_handle);
 680         return 0;
 681 }
 682
 683 static u32 get_voice_session_id_cvp(u32 cvp_handle)
 684 {
 685         u32 i;
 686
 687         for (i = 0; i < rtac_voice_data.num_of_voice_combos; i++) {
 688                 if (rtac_voice_data.voice[i].cvp_handle == cvp_handle)
 689                         return voice_session_id[i];
 690         }
 691
 692         pr_err("%s: No voice index for CVP handle %d found returning 0\n",
 693                __func__, cvp_handle);
 694         return 0;
 695 }
 696
 697 static int get_voice_index(u32 mode, u32 handle)
 698 {
 699         if (mode == RTAC_CVP)
 700                 return voice_get_idx_for_session(
 701                         get_voice_session_id_cvp(handle));
 702         if (mode == RTAC_CVS)
 703                 return voice_get_idx_for_session(
 704                         get_voice_session_id_cvs(handle));
 705
 706         pr_err("%s: Invalid mode %d, returning 0\n",
 707                __func__, mode);
 708         return 0;
 709 }
 710
 711
 712 /* ADM APR */
 713 void rtac_set_adm_handle(void *handle)
 714 {
 715         pr_debug("%s: handle = %pK\n", __func__, handle);
 716
 717         mutex_lock(&rtac_adm_apr_mutex);
 718         rtac_adm_apr_data.apr_handle = handle;
 719         mutex_unlock(&rtac_adm_apr_mutex);
 720 }
 721
 722 bool rtac_make_adm_callback(uint32_t *payload, u32 payload_size)
 723 {
 724         pr_debug("%s:cmd_state = %d\n", __func__,
 725                         atomic_read(&rtac_adm_apr_data.cmd_state));
 726         if (atomic_read(&rtac_adm_apr_data.cmd_state) != 1)
 727                 return false;
 728
 729         pr_debug("%s\n", __func__);
 730         if (payload_size == sizeof(uint32_t))
 731                 atomic_set(&rtac_common.apr_err_code, payload[0]);
 732         else if (payload_size == (2*sizeof(uint32_t)))
 733                 atomic_set(&rtac_common.apr_err_code, payload[1]);
 734
 735         atomic_set(&rtac_adm_apr_data.cmd_state, 0);
 736         wake_up(&rtac_adm_apr_data.cmd_wait);
 737         return true;
 738 }
 739
 740 int send_adm_apr(void *buf, u32 opcode)
 741 {
 742         s32     result;
 743         u32     user_buf_size = 0;
 744         u32     bytes_returned = 0;
 745         u32     copp_id;
 746         u32     payload_size;
 747         u32     data_size = 0;
 748         int     copp_idx;
 749         int     port_idx;
 750         struct apr_hdr  adm_params;
 751         pr_debug("%s\n", __func__);
 752
 753         if (rtac_cal[ADM_RTAC_CAL].map_data.ion_handle == NULL) {
 754                 result = rtac_allocate_cal_buffer(ADM_RTAC_CAL);
 755                 if (result < 0) {
 756                         pr_err("%s: allocate buffer failed!",
 757                                 __func__);
 758                         goto done;
 759                 }
 760         }
 761
 762         if (rtac_cal[ADM_RTAC_CAL].map_data.map_handle == 0) {
 763                 result = rtac_map_cal_buffer(ADM_RTAC_CAL);
 764                 if (result < 0) {
 765                         pr_err("%s: map buffer failed!",
 766                                 __func__);
 767                         goto done;
 768                 }
 769         }
 770
 771         if (copy_from_user(&user_buf_size, (void *)buf,
 772                                                 sizeof(user_buf_size))) {
 773                 pr_err("%s: Copy from user failed! buf = 0x%pK\n",
 774                        __func__, buf);
 775                 goto done;
 776         }
 777         if (user_buf_size <= 0) {
 778                 pr_err("%s: Invalid buffer size = %d\n",
 779                         __func__, user_buf_size);
 780                 goto done;
 781         }
 782
 783         if (copy_from_user(&payload_size, buf + sizeof(u32), sizeof(u32))) {
 784                 pr_err("%s: Could not copy payload size from user buffer\n",
 785                         __func__);
 786                 goto done;
 787         }
 788
 789         if (copy_from_user(&copp_id, buf + 2 * sizeof(u32), sizeof(u32))) {
 790                 pr_err("%s: Could not copy port id from user buffer\n",
 791                         __func__);
 792                 goto done;
 793         }
 794
 795         if (adm_get_indexes_from_copp_id(copp_id, &copp_idx, &port_idx) != 0) {
 796                 pr_err("%s: Copp Id-%d is not active\n", __func__, copp_id);
 797                 goto done;
 798         }
 799
 800         mutex_lock(&rtac_adm_apr_mutex);
 801         if (rtac_adm_apr_data.apr_handle == NULL) {
 802                 pr_err("%s: APR not initialized\n", __func__);
 803                 result = -EINVAL;
 804                 goto err;
 805         }
 806
 807         switch (opcode) {
 808         case ADM_CMD_SET_PP_PARAMS_V5:
 809         case ADM_CMD_SET_PP_PARAMS_V6:
 810                 /* set payload size to in-band payload */
 811                 /* set data size to actual out of band payload size */
 812                 data_size = payload_size - 4 * sizeof(u32);
 813                 if (data_size > rtac_cal[ADM_RTAC_CAL].map_data.map_size) {
 814                         pr_err("%s: Invalid data size = %d\n",
 815                                 __func__, data_size);
 816                         result = -EINVAL;
 817                         goto err;
 818                 }
 819                 payload_size = 4 * sizeof(u32);
 820
 821                 /* Copy buffer to out-of-band payload */
 822                 if (copy_from_user((void *)
 823                                 rtac_cal[ADM_RTAC_CAL].cal_data.kvaddr,
 824                                 buf + 7 * sizeof(u32), data_size)) {
 825                         pr_err("%s: Could not copy payload from user buffer\n",
 826                                 __func__);
 827                         result = -EFAULT;
 828                         goto err;
 829                 }
 830
 831                 /* set payload size in packet */
 832                 rtac_adm_buffer[8] = data_size;
 833                 break;
 834         case ADM_CMD_GET_PP_PARAMS_V5:
 835         case ADM_CMD_GET_PP_PARAMS_V6:
 836                 if (payload_size > MAX_PAYLOAD_SIZE) {
 837                         pr_err("%s: Invalid payload size = %d\n",
 838                                 __func__, payload_size);
 839                         result = -EINVAL;
 840                         goto err;
 841                 }
 842
 843                 /* Copy buffer to in-band payload */
 844                 if (copy_from_user(rtac_adm_buffer +
 845                                 sizeof(adm_params)/sizeof(u32),
 846                                 buf + 3 * sizeof(u32), payload_size)) {
 847                         pr_err("%s: Could not copy payload from user buffer\n",
 848                                 __func__);
 849                         result = -EFAULT;
 850                         goto err;
 851                 }
 852                 break;
 853         default:
 854                 pr_err("%s: Invalid opcode %d\n", __func__, opcode);
 855                 result = -EINVAL;
 856                 goto err;
 857         }
 858
 859         /* Pack header */
 860         adm_params.hdr_field = APR_HDR_FIELD(APR_MSG_TYPE_SEQ_CMD,
 861                 APR_HDR_LEN(20), APR_PKT_VER);
 862         adm_params.pkt_size = APR_PKT_SIZE(APR_HDR_SIZE,
 863                 payload_size);
 864         adm_params.src_svc = APR_SVC_ADM;
 865         adm_params.src_domain = APR_DOMAIN_APPS;
 866         adm_params.src_port = copp_id;
 867         adm_params.dest_svc = APR_SVC_ADM;
 868         adm_params.dest_domain = APR_DOMAIN_ADSP;
 869         adm_params.dest_port = copp_id;
 870         adm_params.token = port_idx << 16 | copp_idx;
 871         adm_params.opcode = opcode;
 872
 873         /* fill for out-of-band */
 874         rtac_adm_buffer[5] =
 875                 lower_32_bits(rtac_cal[ADM_RTAC_CAL].cal_data.paddr);
 876         rtac_adm_buffer[6] =
 877                 msm_audio_populate_upper_32_bits(
 878                                 rtac_cal[ADM_RTAC_CAL].cal_data.paddr);
 879         rtac_adm_buffer[7] = rtac_cal[ADM_RTAC_CAL].map_data.map_handle;
 880
 881         memcpy(rtac_adm_buffer, &adm_params, sizeof(adm_params));
 882         atomic_set(&rtac_adm_apr_data.cmd_state, 1);
 883
 884         pr_debug("%s: Sending RTAC command ioctl 0x%x, paddr 0x%pK\n",
 885                 __func__, opcode,
 886                 &rtac_cal[ADM_RTAC_CAL].cal_data.paddr);
 887
 888         result = apr_send_pkt(rtac_adm_apr_data.apr_handle,
 889                                         (uint32_t *)rtac_adm_buffer);
 890         if (result < 0) {
 891                 pr_err("%s: Set params failed copp = %d\n", __func__, copp_id);
 892                 goto err;
 893         }
 894         /* Wait for the callback */
 895         result = wait_event_timeout(rtac_adm_apr_data.cmd_wait,
 896                 (atomic_read(&rtac_adm_apr_data.cmd_state) == 0),
 897                 msecs_to_jiffies(TIMEOUT_MS));
 898         if (!result) {
 899                 pr_err("%s: Set params timed out copp = %d\n", __func__,
 900                         copp_id);
 901                 goto err;
 902         }
 903         if (atomic_read(&rtac_common.apr_err_code)) {
 904                 pr_err("%s: DSP returned error code = [%s], opcode = 0x%x\n",
 905                         __func__, adsp_err_get_err_str(atomic_read(
 906                         &rtac_common.apr_err_code)),
 907                         opcode);
 908                 result = adsp_err_get_lnx_err_code(
 909                                         atomic_read(
 910                                         &rtac_common.apr_err_code));
 911                 goto err;
 912         }
 913
 914         if (opcode == ADM_CMD_GET_PP_PARAMS_V5) {
 915                 bytes_returned = ((u32 *)rtac_cal[ADM_RTAC_CAL].cal_data.
 916                         kvaddr)[2] + 3 * sizeof(u32);
 917         } else if (opcode == ADM_CMD_GET_PP_PARAMS_V6) {
 918                 bytes_returned =
 919                         ((u32 *) rtac_cal[ADM_RTAC_CAL].cal_data.kvaddr)[3] +
 920                         4 * sizeof(u32);
 921         } else {
 922                 bytes_returned = data_size;
 923                 goto unlock;
 924         }
 925
 926         if (bytes_returned > rtac_cal[ADM_RTAC_CAL].map_data.map_size) {
 927                 pr_err("%s: Invalid data size = %d\n", __func__,
 928                        bytes_returned);
 929                 result = -EINVAL;
 930                 goto err;
 931         }
 932
 933         if (bytes_returned > user_buf_size) {
 934                 pr_err("%s: User buf not big enough, size = 0x%x, returned size = 0x%x\n",
 935                        __func__, user_buf_size, bytes_returned);
 936                 result = -EINVAL;
 937                 goto err;
 938         }
 939
 940         if (copy_to_user((void __user *) buf,
 941                          rtac_cal[ADM_RTAC_CAL].cal_data.kvaddr,
 942                          bytes_returned)) {
 943                 pr_err("%s: Could not copy buffer to user,size = %d\n",
 944                        __func__, bytes_returned);
 945                 result = -EFAULT;
 946                 goto err;
 947         }
 948
 949 unlock:
 950         mutex_unlock(&rtac_adm_apr_mutex);
 951 done:
 952         return bytes_returned;
 953 err:
 954         mutex_unlock(&rtac_adm_apr_mutex);
 955         return result;
 956 }
 957
 958
 959 /* ASM APR */
 960 void rtac_set_asm_handle(u32 session_id, void *handle)
 961 {
 962         pr_debug("%s\n", __func__);
 963
 964         mutex_lock(&rtac_asm_apr_mutex);
 965         rtac_asm_apr_data[session_id].apr_handle = handle;
 966         mutex_unlock(&rtac_asm_apr_mutex);
 967 }
 968
 969 bool rtac_make_asm_callback(u32 session_id, uint32_t *payload,
 970         u32 payload_size)
 971 {
 972         if (atomic_read(&rtac_asm_apr_data[session_id].cmd_state) != 1)
 973                 return false;
 974
 975         pr_debug("%s\n", __func__);
 976         if (payload_size == sizeof(uint32_t))
 977                 atomic_set(&rtac_common.apr_err_code, payload[0]);
 978         else if (payload_size == (2*sizeof(uint32_t)))
 979                 atomic_set(&rtac_common.apr_err_code, payload[1]);
 980
 981         atomic_set(&rtac_asm_apr_data[session_id].cmd_state, 0);
 982         wake_up(&rtac_asm_apr_data[session_id].cmd_wait);
 983         return true;
 984 }
 985
 986 int send_rtac_asm_apr(void *buf, u32 opcode)
 987 {
 988         s32     result;
 989         u32     user_buf_size = 0;
 990         u32     bytes_returned = 0;
 991         u32     session_id = 0;
 992         u32     payload_size;
 993         u32     data_size = 0;
 994         struct apr_hdr          asm_params;
 995         pr_debug("%s\n", __func__);
 996
 997         if (rtac_cal[ASM_RTAC_CAL].map_data.ion_handle == NULL) {
 998                 result = rtac_allocate_cal_buffer(ASM_RTAC_CAL);
 999                 if (result < 0) {
1000                         pr_err("%s: allocate buffer failed!",
1001                                 __func__);
1002                         goto done;
1003                 }
1004         }
1005
1006         if (rtac_cal[ASM_RTAC_CAL].map_data.map_handle == 0) {
1007                 result = rtac_map_cal_buffer(ASM_RTAC_CAL);
1008                 if (result < 0) {
1009                         pr_err("%s: map buffer failed!",
1010                                 __func__);
1011                         goto done;
1012                 }
1013         }
1014
1015         if (copy_from_user(&user_buf_size, (void *)buf,
1016                                                 sizeof(user_buf_size))) {
1017                 pr_err("%s: Copy from user failed! buf = 0x%pK\n",
1018                        __func__, buf);
1019                 goto done;
1020         }
1021         if (user_buf_size <= 0) {
1022                 pr_err("%s: Invalid buffer size = %d\n",
1023                         __func__, user_buf_size);
1024                 goto done;
1025         }
1026
1027         if (copy_from_user(&payload_size, buf + sizeof(u32), sizeof(u32))) {
1028                 pr_err("%s: Could not copy payload size from user buffer\n",
1029                         __func__);
1030                 goto done;
1031         }
1032
1033         if (copy_from_user(&session_id, buf + 2 * sizeof(u32), sizeof(u32))) {
1034                 pr_err("%s: Could not copy session id from user buffer\n",
1035                         __func__);
1036                 goto done;
1037         }
1038         if (session_id >= (ASM_ACTIVE_STREAMS_ALLOWED + 1)) {
1039                 pr_err("%s: Invalid Session = %d\n", __func__, session_id);
1040                 goto done;
1041         }
1042
1043         mutex_lock(&rtac_asm_apr_mutex);
1044         if (rtac_asm_apr_data[session_id].apr_handle == NULL) {
1045                 pr_err("%s: APR not initialized\n", __func__);
1046                 result = -EINVAL;
1047                 goto err;
1048         }
1049
1050         switch (opcode) {
1051         case ASM_STREAM_CMD_SET_PP_PARAMS_V2:
1052         case ASM_STREAM_CMD_SET_PP_PARAMS_V3:
1053                 /* set payload size to in-band payload */
1054                 /* set data size to actual out of band payload size */
1055                 data_size = payload_size - 4 * sizeof(u32);
1056                 if (data_size > rtac_cal[ASM_RTAC_CAL].map_data.map_size) {
1057                         pr_err("%s: Invalid data size = %d\n",
1058                                 __func__, data_size);
1059                         result = -EINVAL;
1060                         goto err;
1061                 }
1062                 payload_size = 4 * sizeof(u32);
1063
1064                 /* Copy buffer to out-of-band payload */
1065                 if (copy_from_user((void *)
1066                                 rtac_cal[ASM_RTAC_CAL].cal_data.kvaddr,
1067                                 buf + 7 * sizeof(u32), data_size)) {
1068                         pr_err("%s: Could not copy payload from user buffer\n",
1069                                 __func__);
1070                         result = -EFAULT;
1071                         goto err;
1072                 }
1073                 /* set payload size in packet */
1074                 rtac_asm_buffer[8] = data_size;
1075                 break;
1076         case ASM_STREAM_CMD_GET_PP_PARAMS_V2:
1077         case ASM_STREAM_CMD_GET_PP_PARAMS_V3:
1078                 if (payload_size > MAX_PAYLOAD_SIZE) {
1079                         pr_err("%s: Invalid payload size = %d\n",
1080                                 __func__, payload_size);
1081                         result = -EINVAL;
1082                         goto err;
1083                 }
1084
1085                 /* Copy buffer to in-band payload */
1086                 if (copy_from_user(rtac_asm_buffer +
1087                                 sizeof(asm_params)/sizeof(u32),
1088                                 buf + 3 * sizeof(u32), payload_size)) {
1089                         pr_err("%s: Could not copy payload from user buffer\n",
1090                                 __func__);
1091                         result = -EFAULT;
1092                         goto err;
1093                 }
1094
1095                 break;
1096         default:
1097                 pr_err("%s: Invalid opcode %d\n", __func__, opcode);
1098                 result = -EINVAL;
1099                 goto err;
1100         }
1101
1102         /* Pack header */
1103         asm_params.hdr_field = APR_HDR_FIELD(APR_MSG_TYPE_SEQ_CMD,
1104                 APR_HDR_LEN(20), APR_PKT_VER);
1105         asm_params.pkt_size = APR_PKT_SIZE(APR_HDR_SIZE,
1106                 payload_size);
1107         asm_params.src_svc = q6asm_get_apr_service_id(session_id);
1108         asm_params.src_domain = APR_DOMAIN_APPS;
1109         asm_params.src_port = (session_id << 8) | 0x0001;
1110         asm_params.dest_svc = APR_SVC_ASM;
1111         asm_params.dest_domain = APR_DOMAIN_ADSP;
1112         asm_params.dest_port = (session_id << 8) | 0x0001;
1113         asm_params.token = session_id;
1114         asm_params.opcode = opcode;
1115
1116         /* fill for out-of-band */
1117         rtac_asm_buffer[5] =
1118                 lower_32_bits(rtac_cal[ASM_RTAC_CAL].cal_data.paddr);
1119         rtac_asm_buffer[6] =
1120                 msm_audio_populate_upper_32_bits(
1121                                 rtac_cal[ASM_RTAC_CAL].cal_data.paddr);
1122         rtac_asm_buffer[7] = rtac_cal[ASM_RTAC_CAL].map_data.map_handle;
1123
1124         memcpy(rtac_asm_buffer, &asm_params, sizeof(asm_params));
1125         atomic_set(&rtac_asm_apr_data[session_id].cmd_state, 1);
1126
1127         pr_debug("%s: Sending RTAC command ioctl 0x%x, paddr 0x%pK\n",
1128                 __func__, opcode,
1129                 &rtac_cal[ASM_RTAC_CAL].cal_data.paddr);
1130
1131         result = apr_send_pkt(rtac_asm_apr_data[session_id].apr_handle,
1132                                 (uint32_t *)rtac_asm_buffer);
1133         if (result < 0) {
1134                 pr_err("%s: Set params failed session = %d\n",
1135                         __func__, session_id);
1136                 goto err;
1137         }
1138
1139         /* Wait for the callback */
1140         result = wait_event_timeout(rtac_asm_apr_data[session_id].cmd_wait,
1141                 (atomic_read(&rtac_asm_apr_data[session_id].cmd_state) == 0),
1142                 5 * HZ);
1143         if (!result) {
1144                 pr_err("%s: Set params timed out session = %d\n",
1145                         __func__, session_id);
1146                 goto err;
1147         }
1148         if (atomic_read(&rtac_common.apr_err_code)) {
1149                 pr_err("%s: DSP returned error code = [%s], opcode = 0x%x\n",
1150                         __func__, adsp_err_get_err_str(atomic_read(
1151                         &rtac_common.apr_err_code)),
1152                         opcode);
1153                 result = adsp_err_get_lnx_err_code(
1154                                         atomic_read(
1155                                         &rtac_common.apr_err_code));
1156                 goto err;
1157         }
1158
1159         if (opcode == ASM_STREAM_CMD_GET_PP_PARAMS_V2) {
1160                 bytes_returned = ((u32 *)rtac_cal[ASM_RTAC_CAL].cal_data.
1161                         kvaddr)[2] + 3 * sizeof(u32);
1162         } else if (opcode == ASM_STREAM_CMD_GET_PP_PARAMS_V3) {
1163                 bytes_returned =
1164                         ((u32 *) rtac_cal[ASM_RTAC_CAL].cal_data.kvaddr)[3] +
1165                         4 * sizeof(u32);
1166         } else {
1167                 bytes_returned = data_size;
1168                 goto unlock;
1169         }
1170
1171         if (bytes_returned > rtac_cal[ASM_RTAC_CAL].map_data.map_size) {
1172                 pr_err("%s: Invalid data size = %d\n", __func__,
1173                        bytes_returned);
1174                 result = -EINVAL;
1175                 goto err;
1176         }
1177
1178         if (bytes_returned > user_buf_size) {
1179                 pr_err("%s: User buf not big enough, size = 0x%x, returned size = 0x%x\n",
1180                        __func__, user_buf_size, bytes_returned);
1181                 result = -EINVAL;
1182                 goto err;
1183         }
1184
1185         if (copy_to_user((void __user *) buf,
1186                          rtac_cal[ASM_RTAC_CAL].cal_data.kvaddr,
1187                          bytes_returned)) {
1188                 pr_err("%s: Could not copy buffer to user,size = %d\n",
1189                        __func__, bytes_returned);
1190                 result = -EFAULT;
1191                 goto err;
1192         }
1193
1194 unlock:
1195         mutex_unlock(&rtac_asm_apr_mutex);
1196 done:
1197         return bytes_returned;
1198 err:
1199         mutex_unlock(&rtac_asm_apr_mutex);
1200         return result;
1201 }
1202
1203 /* AFE APR */
1204 void rtac_set_afe_handle(void *handle)
1205 {
1206         mutex_lock(&rtac_afe_apr_mutex);
1207         rtac_afe_apr_data.apr_handle = handle;
1208         mutex_unlock(&rtac_afe_apr_mutex);
1209 }
1210
1211 bool rtac_make_afe_callback(uint32_t *payload, uint32_t payload_size)
1212 {
1213         pr_debug("%s:cmd_state = %d\n", __func__,
1214                         atomic_read(&rtac_afe_apr_data.cmd_state));
1215         if (atomic_read(&rtac_afe_apr_data.cmd_state) != 1)
1216                 return false;
1217
1218         if (payload_size == sizeof(uint32_t))
1219                 atomic_set(&rtac_common.apr_err_code, payload[0]);
1220         else if (payload_size == (2*sizeof(uint32_t)))
1221                 atomic_set(&rtac_common.apr_err_code, payload[1]);
1222
1223         atomic_set(&rtac_afe_apr_data.cmd_state, 0);
1224         wake_up(&rtac_afe_apr_data.cmd_wait);
1225         return true;
1226 }
1227
1228 static int fill_afe_apr_hdr(struct apr_hdr *apr_hdr, uint32_t port,
1229                          uint32_t opcode, uint32_t apr_msg_size)
1230 {
1231         if (apr_hdr == NULL) {
1232                 pr_err("%s: invalid APR pointer", __func__);
1233                 return -EINVAL;
1234         }
1235
1236         apr_hdr->hdr_field = APR_HDR_FIELD(APR_MSG_TYPE_SEQ_CMD,
1237                 APR_HDR_LEN(APR_HDR_SIZE), APR_PKT_VER);
1238         apr_hdr->pkt_size = apr_msg_size;
1239         apr_hdr->src_svc = APR_SVC_AFE;
1240         apr_hdr->src_domain = APR_DOMAIN_APPS;
1241         apr_hdr->src_port = 0;
1242         apr_hdr->dest_svc = APR_SVC_AFE;
1243         apr_hdr->dest_domain = APR_DOMAIN_ADSP;
1244         apr_hdr->dest_port = 0;
1245         apr_hdr->token = port;
1246         apr_hdr->opcode = opcode;
1247
1248         return 0;
1249
1250 }
1251 static int send_rtac_afe_apr(void __user *buf, uint32_t opcode)
1252 {
1253         int32_t result;
1254         uint32_t bytes_returned = 0;
1255         uint32_t payload_size = 0;
1256         uint32_t port_index = 0;
1257         uint32_t *afe_cmd = NULL;
1258         uint32_t apr_msg_size = 0;
1259         struct rtac_afe_user_data user_afe_buf;
1260         struct mem_mapping_hdr *mem_hdr = NULL;
1261         struct param_hdr_v1 *get_resp_v2;
1262         struct param_hdr_v3 *get_resp_v3;
1263
1264         pr_debug("%s\n", __func__);
1265
1266         if (rtac_cal[AFE_RTAC_CAL].map_data.ion_handle == NULL) {
1267                 result = rtac_allocate_cal_buffer(AFE_RTAC_CAL);
1268                 if (result < 0) {
1269                         pr_err("%s: allocate buffer failed! ret = %d\n",
1270                                 __func__, result);
1271                         goto done;
1272                 }
1273         }
1274
1275         if (rtac_cal[AFE_RTAC_CAL].map_data.map_handle == 0) {
1276                 result = rtac_map_cal_buffer(AFE_RTAC_CAL);
1277                 if (result < 0) {
1278                         pr_err("%s: map buffer failed! ret = %d\n",
1279                                 __func__, result);
1280                         goto done;
1281                 }
1282         }
1283
1284         if (copy_from_user(&user_afe_buf, (void *)buf,
1285                 sizeof(struct rtac_afe_user_data))) {
1286                 pr_err("%s: Copy from user failed! buf = 0x%pK\n",
1287                        __func__, buf);
1288                 goto done;
1289         }
1290
1291         if (user_afe_buf.buf_size <= 0) {
1292                 pr_err("%s: Invalid buffer size = %d\n",
1293                         __func__, user_afe_buf.buf_size);
1294                 goto done;
1295         }
1296
1297         port_index = q6audio_get_port_index(user_afe_buf.port_id);
1298         if (port_index >= AFE_MAX_PORTS) {
1299                 pr_err("%s: Invalid AFE port = 0x%x\n",
1300                        __func__, user_afe_buf.port_id);
1301                 goto done;
1302         }
1303
1304         mutex_lock(&rtac_afe_apr_mutex);
1305         if (rtac_afe_apr_data.apr_handle == NULL) {
1306                 pr_err("%s: APR not initialized\n", __func__);
1307                 result = -EINVAL;
1308                 goto err;
1309         }
1310
1311         afe_cmd =
1312                 (u32 *) rtac_afe_buffer + sizeof(struct apr_hdr) / sizeof(u32);
1313
1314         switch (opcode) {
1315         case AFE_PORT_CMD_SET_PARAM_V2:
1316                 apr_msg_size = sizeof(struct afe_port_cmd_set_param_v2);
1317                 payload_size = user_afe_buf.v2_set.payload_size;
1318                 if (payload_size > rtac_cal[AFE_RTAC_CAL].map_data.map_size) {
1319                         pr_err("%s: Invalid payload size = %d\n", __func__,
1320                                payload_size);
1321                         result = -EINVAL;
1322                         goto err;
1323                 }
1324
1325                 /* Copy the command to the rtac buffer */
1326                 memcpy(afe_cmd, &user_afe_buf.v2_set,
1327                        sizeof(user_afe_buf.v2_set));
1328
1329                 /* Copy the param data to the out-of-band location */
1330                 if (copy_from_user(rtac_cal[AFE_RTAC_CAL].cal_data.kvaddr,
1331                                    (void __user *) buf +
1332                                            offsetof(struct rtac_afe_user_data,
1333                                                     v2_set.param_hdr),
1334                                    payload_size)) {
1335                         pr_err("%s: Could not copy payload from user buffer\n",
1336                                 __func__);
1337                         result = -EFAULT;
1338                         goto err;
1339                 }
1340                 break;
1341         case AFE_PORT_CMD_SET_PARAM_V3:
1342                 apr_msg_size = sizeof(struct afe_port_cmd_set_param_v3);
1343                 payload_size = user_afe_buf.v3_set.payload_size;
1344                 if (payload_size > rtac_cal[AFE_RTAC_CAL].map_data.map_size) {
1345                         pr_err("%s: Invalid payload size = %d\n", __func__,
1346                                payload_size);
1347                         result = -EINVAL;
1348                         goto err;
1349                 }
1350
1351                 /* Copy the command to the rtac buffer */
1352                 memcpy(afe_cmd, &user_afe_buf.v3_set,
1353                        sizeof(user_afe_buf.v3_set));
1354
1355                 /* Copy the param data to the out-of-band location */
1356                 if (copy_from_user(rtac_cal[AFE_RTAC_CAL].cal_data.kvaddr,
1357                                    (void __user *) buf +
1358                                            offsetof(struct rtac_afe_user_data,
1359                                                     v3_set.param_hdr),
1360                                    payload_size)) {
1361                         pr_err("%s: Could not copy payload from user buffer\n",
1362                                 __func__);
1363                         result = -EFAULT;
1364                         goto err;
1365                 }
1366                 break;
1367         case AFE_PORT_CMD_GET_PARAM_V2:
1368                 apr_msg_size = sizeof(struct afe_port_cmd_get_param_v2);
1369
1370                 if (user_afe_buf.cmd_size > MAX_PAYLOAD_SIZE) {
1371                         pr_err("%s: Invalid payload size = %d\n", __func__,
1372                                user_afe_buf.cmd_size);
1373                         result = -EINVAL;
1374                         goto err;
1375                 }
1376
1377                 /* Copy the command and param data in-band */
1378                 if (copy_from_user(afe_cmd,
1379                                    (void __user *) buf +
1380                                            offsetof(struct rtac_afe_user_data,
1381                                                     v2_get),
1382                                    user_afe_buf.cmd_size)) {
1383                         pr_err("%s: Could not copy payload from user buffer\n",
1384                                __func__);
1385                         result = -EFAULT;
1386                         goto err;
1387                 }
1388                 break;
1389         case AFE_PORT_CMD_GET_PARAM_V3:
1390                 apr_msg_size = sizeof(struct afe_port_cmd_get_param_v3);
1391
1392                 if (user_afe_buf.cmd_size > MAX_PAYLOAD_SIZE) {
1393                         pr_err("%s: Invalid payload size = %d\n", __func__,
1394                                user_afe_buf.cmd_size);
1395                         result = -EINVAL;
1396                         goto err;
1397                 }
1398
1399                 /* Copy the command and param data in-band */
1400                 if (copy_from_user(afe_cmd,
1401                                    (void __user *) buf +
1402                                            offsetof(struct rtac_afe_user_data,
1403                                                     v3_get),
1404                                    user_afe_buf.cmd_size)) {
1405                         pr_err("%s: Could not copy payload from user buffer\n",
1406                                 __func__);
1407                         result = -EFAULT;
1408                         goto err;
1409                 }
1410                 break;
1411         default:
1412                 pr_err("%s: Invalid opcode %d\n", __func__, opcode);
1413                 result = -EINVAL;
1414                 goto err;
1415         }
1416
1417         /*
1418          * The memory header is in the same location in all commands. Therefore,
1419          * it doesn't matter what command the buffer is cast into.
1420          */
1421         mem_hdr = &((struct afe_port_cmd_set_param_v3 *) rtac_afe_buffer)
1422                            ->mem_hdr;
1423         mem_hdr->data_payload_addr_lsw =
1424                 lower_32_bits(rtac_cal[AFE_RTAC_CAL].cal_data.paddr);
1425         mem_hdr->data_payload_addr_msw = msm_audio_populate_upper_32_bits(
1426                 rtac_cal[AFE_RTAC_CAL].cal_data.paddr);
1427         mem_hdr->mem_map_handle = rtac_cal[AFE_RTAC_CAL].map_data.map_handle;
1428
1429         /* Fill the APR header at the end so we have the correct message size */
1430         fill_afe_apr_hdr((struct apr_hdr *) rtac_afe_buffer,
1431                         port_index, opcode, apr_msg_size);
1432
1433         atomic_set(&rtac_afe_apr_data.cmd_state, 1);
1434
1435         pr_debug("%s: Sending RTAC command ioctl 0x%x, paddr 0x%pK\n",
1436                 __func__, opcode,
1437                 &rtac_cal[AFE_RTAC_CAL].cal_data.paddr);
1438
1439         result = apr_send_pkt(rtac_afe_apr_data.apr_handle,
1440                                         (uint32_t *)rtac_afe_buffer);
1441         if (result < 0) {
1442                 pr_err("%s: Set params failed port = 0x%x, ret = %d\n",
1443                         __func__, user_afe_buf.port_id, result);
1444                 goto err;
1445         }
1446         /* Wait for the callback */
1447         result = wait_event_timeout(rtac_afe_apr_data.cmd_wait,
1448                 (atomic_read(&rtac_afe_apr_data.cmd_state) == 0),
1449                 msecs_to_jiffies(TIMEOUT_MS));
1450         if (!result) {
1451                 pr_err("%s: Set params timed out port = 0x%x, ret = %d\n",
1452                         __func__, user_afe_buf.port_id, result);
1453                 goto err;
1454         }
1455         if (atomic_read(&rtac_common.apr_err_code)) {
1456                 pr_err("%s: DSP returned error code = [%s], opcode = 0x%x\n",
1457                         __func__, adsp_err_get_err_str(atomic_read(
1458                         &rtac_common.apr_err_code)),
1459                         opcode);
1460                 result = adsp_err_get_lnx_err_code(
1461                                         atomic_read(
1462                                         &rtac_common.apr_err_code));
1463                 goto err;
1464         }
1465
1466         if (opcode == AFE_PORT_CMD_GET_PARAM_V2) {
1467                 get_resp_v2 = (struct param_hdr_v1 *) rtac_cal[AFE_RTAC_CAL]
1468                                       .cal_data.kvaddr;
1469                 bytes_returned =
1470                         get_resp_v2->param_size + sizeof(struct param_hdr_v1);
1471         } else if (opcode == AFE_PORT_CMD_GET_PARAM_V3) {
1472                 get_resp_v3 = (struct param_hdr_v3 *) rtac_cal[AFE_RTAC_CAL]
1473                                       .cal_data.kvaddr;
1474                 bytes_returned =
1475                         get_resp_v3->param_size + sizeof(struct param_hdr_v3);
1476         } else {
1477                 bytes_returned = payload_size;
1478                 goto unlock;
1479         }
1480
1481         if (bytes_returned > rtac_cal[AFE_RTAC_CAL].map_data.map_size) {
1482                 pr_err("%s: Invalid data size = %d\n", __func__,
1483                        bytes_returned);
1484                 result = -EINVAL;
1485                 goto err;
1486         }
1487
1488         if (bytes_returned > user_afe_buf.buf_size) {
1489                 pr_err("%s: user size = 0x%x, returned size = 0x%x\n", __func__,
1490                        user_afe_buf.buf_size, bytes_returned);
1491                 result = -EINVAL;
1492                 goto err;
1493         }
1494
1495         if (copy_to_user((void __user *) buf,
1496                          rtac_cal[AFE_RTAC_CAL].cal_data.kvaddr,
1497                          bytes_returned)) {
1498                 pr_err("%s: Could not copy buffer to user,size = %d\n",
1499                        __func__, bytes_returned);
1500                 result = -EFAULT;
1501                 goto err;
1502         }
1503
1504 unlock:
1505         mutex_unlock(&rtac_afe_apr_mutex);
1506 done:
1507         return bytes_returned;
1508 err:
1509         mutex_unlock(&rtac_afe_apr_mutex);
1510         return result;
1511 }
1512
1513 /* Voice APR */
1514 void rtac_set_voice_handle(u32 mode, void *handle)
1515 {
1516         pr_debug("%s\n", __func__);
1517
1518         mutex_lock(&rtac_voice_apr_mutex);
1519         rtac_voice_apr_data[mode].apr_handle = handle;
1520         mutex_unlock(&rtac_voice_apr_mutex);
1521 }
1522
1523 bool rtac_make_voice_callback(u32 mode, uint32_t *payload, u32 payload_size)
1524 {
1525         if ((atomic_read(&rtac_voice_apr_data[mode].cmd_state) != 1) ||
1526                 (mode >= RTAC_VOICE_MODES))
1527                 return false;
1528
1529         pr_debug("%s\n", __func__);
1530         if (payload_size == sizeof(uint32_t))
1531                 atomic_set(&rtac_common.apr_err_code, payload[0]);
1532         else if (payload_size == (2*sizeof(uint32_t)))
1533                 atomic_set(&rtac_common.apr_err_code, payload[1]);
1534
1535         atomic_set(&rtac_voice_apr_data[mode].cmd_state, 0);
1536         wake_up(&rtac_voice_apr_data[mode].cmd_wait);
1537         return true;
1538 }
1539
1540 int send_voice_apr(u32 mode, void *buf, u32 opcode)
1541 {
1542         s32     result;
1543         u32     user_buf_size = 0;
1544         u32     bytes_returned = 0;
1545         u32     payload_size;
1546         u32     dest_port;
1547         u32     data_size = 0;
1548         struct apr_hdr          voice_params;
1549         pr_debug("%s\n", __func__);
1550
1551         if (rtac_cal[VOICE_RTAC_CAL].map_data.ion_handle == NULL) {
1552                 result = rtac_allocate_cal_buffer(VOICE_RTAC_CAL);
1553                 if (result < 0) {
1554                         pr_err("%s: allocate buffer failed!",
1555                                 __func__);
1556                         goto done;
1557                 }
1558         }
1559
1560         if (rtac_cal[VOICE_RTAC_CAL].map_data.map_handle == 0) {
1561                 result = rtac_map_cal_buffer(VOICE_RTAC_CAL);
1562                 if (result < 0) {
1563                         pr_err("%s: map buffer failed!",
1564                                 __func__);
1565                         goto done;
1566                 }
1567         }
1568
1569         if (copy_from_user(&user_buf_size, (void *)buf,
1570                                                 sizeof(user_buf_size))) {
1571                 pr_err("%s: Copy from user failed! buf = 0x%pK\n",
1572                        __func__, buf);
1573                 goto done;
1574         }
1575         if (user_buf_size <= 0) {
1576                 pr_err("%s: Invalid buffer size = %d\n",
1577                         __func__, user_buf_size);
1578                 goto done;
1579         }
1580
1581         if (copy_from_user(&payload_size, buf + sizeof(u32), sizeof(u32))) {
1582                 pr_err("%s: Could not copy payload size from user buffer\n",
1583                         __func__);
1584                 goto done;
1585         }
1586
1587         if (copy_from_user(&dest_port, buf + 2 * sizeof(u32), sizeof(u32))) {
1588                 pr_err("%s: Could not copy port id from user buffer\n",
1589                         __func__);
1590                 goto done;
1591         }
1592
1593         if ((mode != RTAC_CVP) && (mode != RTAC_CVS)) {
1594                 pr_err("%s: Invalid Mode for APR, mode = %d\n",
1595                         __func__, mode);
1596                 goto done;
1597         }
1598
1599         mutex_lock(&rtac_voice_apr_mutex);
1600         if (rtac_voice_apr_data[mode].apr_handle == NULL) {
1601                 pr_err("%s: APR not initialized\n", __func__);
1602                 result = -EINVAL;
1603                 goto err;
1604         }
1605
1606         switch (opcode) {
1607         case VSS_ICOMMON_CMD_SET_PARAM_V2:
1608         case VSS_ICOMMON_CMD_SET_PARAM_V3:
1609                 /* set payload size to in-band payload */
1610                 /* set data size to actual out of band payload size */
1611                 data_size = payload_size - 4 * sizeof(u32);
1612                 if (data_size > rtac_cal[VOICE_RTAC_CAL].map_data.map_size) {
1613                         pr_err("%s: Invalid data size = %d\n",
1614                                 __func__, data_size);
1615                         result = -EINVAL;
1616                         goto err;
1617                 }
1618                 payload_size = 4 * sizeof(u32);
1619
1620                 /* Copy buffer to out-of-band payload */
1621                 if (copy_from_user((void *)
1622                                 rtac_cal[VOICE_RTAC_CAL].cal_data.kvaddr,
1623                                 buf + 7 * sizeof(u32), data_size)) {
1624                         pr_err("%s: Could not copy payload from user buffer\n",
1625                                 __func__);
1626                         result = -EFAULT;
1627                         goto err;
1628                 }
1629                 /* set payload size in packet */
1630                 rtac_voice_buffer[8] = data_size;
1631                 /* set token for set param case */
1632                 voice_params.token = VOC_RTAC_SET_PARAM_TOKEN;
1633                 break;
1634         case VSS_ICOMMON_CMD_GET_PARAM_V2:
1635         case VSS_ICOMMON_CMD_GET_PARAM_V3:
1636                 if (payload_size > MAX_PAYLOAD_SIZE) {
1637                         pr_err("%s: Invalid payload size = %d\n",
1638                                         __func__, payload_size);
1639                         result = -EINVAL;
1640                         goto err;
1641                 }
1642
1643                 /* Copy buffer to in-band payload */
1644                 if (copy_from_user(rtac_voice_buffer +
1645                                 sizeof(voice_params)/sizeof(u32),
1646                                 buf + 3 * sizeof(u32), payload_size)) {
1647                         pr_err("%s: Could not copy payload from user buffer\n",
1648                                 __func__);
1649                         result = -EFAULT;
1650                         goto err;
1651                 }
1652                 /* set token for get param case */
1653                 voice_params.token = 0;
1654                 break;
1655         default:
1656                 pr_err("%s: Invalid opcode %d\n", __func__, opcode);
1657                 result = -EINVAL;
1658                 goto err;
1659         }
1660
1661         /* Pack header */
1662         voice_params.hdr_field = APR_HDR_FIELD(APR_MSG_TYPE_SEQ_CMD,
1663                 APR_HDR_LEN(20), APR_PKT_VER);
1664         voice_params.pkt_size = APR_PKT_SIZE(APR_HDR_SIZE,
1665                 payload_size);
1666         voice_params.src_svc = 0;
1667         voice_params.src_domain = APR_DOMAIN_APPS;
1668         voice_params.src_port = get_voice_index(mode, dest_port);
1669         voice_params.dest_svc = 0;
1670         voice_params.dest_domain = APR_DOMAIN_MODEM;
1671         voice_params.dest_port = (u16)dest_port;
1672         voice_params.opcode = opcode;
1673
1674         /* fill for out-of-band */
1675         rtac_voice_buffer[5] = rtac_cal[VOICE_RTAC_CAL].map_data.map_handle;
1676         rtac_voice_buffer[6] =
1677                 lower_32_bits(rtac_cal[VOICE_RTAC_CAL].cal_data.paddr);
1678         rtac_voice_buffer[7] = msm_audio_populate_upper_32_bits(
1679                 rtac_cal[VOICE_RTAC_CAL].cal_data.paddr);
1680
1681         memcpy(rtac_voice_buffer, &voice_params, sizeof(voice_params));
1682         atomic_set(&rtac_voice_apr_data[mode].cmd_state, 1);
1683
1684         pr_debug("%s: Sending RTAC command ioctl 0x%x, paddr 0x%pK\n",
1685                 __func__, opcode,
1686                 &rtac_cal[VOICE_RTAC_CAL].cal_data.paddr);
1687
1688         result = apr_send_pkt(rtac_voice_apr_data[mode].apr_handle,
1689                                         (uint32_t *)rtac_voice_buffer);
1690         if (result < 0) {
1691                 pr_err("%s: apr_send_pkt failed opcode = %x\n",
1692                         __func__, opcode);
1693                 goto err;
1694         }
1695         /* Wait for the callback */
1696         result = wait_event_timeout(rtac_voice_apr_data[mode].cmd_wait,
1697                 (atomic_read(&rtac_voice_apr_data[mode].cmd_state) == 0),
1698                 msecs_to_jiffies(TIMEOUT_MS));
1699         if (!result) {
1700                 pr_err("%s: apr_send_pkt timed out opcode = %x\n",
1701                         __func__, opcode);
1702                 goto err;
1703         }
1704         if (atomic_read(&rtac_common.apr_err_code)) {
1705                 pr_err("%s: DSP returned error code = [%s], opcode = 0x%x\n",
1706                         __func__, adsp_err_get_err_str(atomic_read(
1707                         &rtac_common.apr_err_code)),
1708                         opcode);
1709                 result = adsp_err_get_lnx_err_code(
1710                                         atomic_read(
1711                                         &rtac_common.apr_err_code));
1712                 goto err;
1713         }
1714
1715         if (opcode == VSS_ICOMMON_CMD_GET_PARAM_V2) {
1716                 bytes_returned = ((u32 *)rtac_cal[VOICE_RTAC_CAL].cal_data.
1717                         kvaddr)[2] + 3 * sizeof(u32);
1718         } else if (opcode == VSS_ICOMMON_CMD_GET_PARAM_V3) {
1719                 bytes_returned =
1720                         ((u32 *) rtac_cal[VOICE_RTAC_CAL].cal_data.kvaddr)[3] +
1721                         4 * sizeof(u32);
1722         } else {
1723                 bytes_returned = data_size;
1724                 goto unlock;
1725         }
1726
1727         if (bytes_returned > rtac_cal[VOICE_RTAC_CAL].map_data.map_size) {
1728                 pr_err("%s: Invalid data size = %d\n", __func__,
1729                        bytes_returned);
1730                 result = -EINVAL;
1731                 goto err;
1732         }
1733
1734         if (bytes_returned > user_buf_size) {
1735                 pr_err("%s: User buf not big enough, size = 0x%x, returned size = 0x%x\n",
1736                        __func__, user_buf_size, bytes_returned);
1737                 result = -EINVAL;
1738                 goto err;
1739         }
1740
1741         if (copy_to_user((void __user *) buf,
1742                          rtac_cal[VOICE_RTAC_CAL].cal_data.kvaddr,
1743                          bytes_returned)) {
1744                 pr_err("%s: Could not copy buffer to user, size = %d\n",
1745                        __func__, bytes_returned);
1746                 result = -EFAULT;
1747                 goto err;
1748         }
1749
1750 unlock:
1751         mutex_unlock(&rtac_voice_apr_mutex);
1752 done:
1753         return bytes_returned;
1754 err:
1755         mutex_unlock(&rtac_voice_apr_mutex);
1756         return result;
1757 }
1758
1759 void get_rtac_adm_data(struct rtac_adm *adm_data)
1760 {
1761         mutex_lock(&rtac_adm_mutex);
1762         memcpy(adm_data, &rtac_adm_data, sizeof(struct rtac_adm));
1763         mutex_unlock(&rtac_adm_mutex);
1764 }
1765
1766
1767 static long rtac_ioctl_shared(struct file *f,
1768                 unsigned int cmd, void *arg)
1769 {
1770         u32 opcode;
1771         int result = 0;
1772         if (!arg) {
1773                 pr_err("%s: No data sent to driver!\n", __func__);
1774                 result = -EFAULT;
1775                 goto done;
1776         }
1777
1778         switch (cmd) {
1779         case AUDIO_GET_RTAC_ADM_INFO: {
1780                 mutex_lock(&rtac_adm_mutex);
1781                 if (copy_to_user((void *)arg, &rtac_adm_data,
1782                                                 sizeof(rtac_adm_data))) {
1783                         pr_err("%s: copy_to_user failed for AUDIO_GET_RTAC_ADM_INFO\n",
1784                                         __func__);
1785                         mutex_unlock(&rtac_adm_mutex);
1786                         return -EFAULT;
1787                 } else {
1788                         result = sizeof(rtac_adm_data);
1789                 }
1790                 mutex_unlock(&rtac_adm_mutex);
1791                 break;
1792         }
1793         case AUDIO_GET_RTAC_VOICE_INFO: {
1794                 mutex_lock(&rtac_voice_mutex);
1795                 if (copy_to_user((void *)arg, &rtac_voice_data,
1796                                                 sizeof(rtac_voice_data))) {
1797                         pr_err("%s: copy_to_user failed for AUDIO_GET_RTAC_VOICE_INFO\n",
1798                                         __func__);
1799                         mutex_unlock(&rtac_voice_mutex);
1800                         return -EFAULT;
1801                 } else {
1802                         result = sizeof(rtac_voice_data);
1803                 }
1804                 mutex_unlock(&rtac_voice_mutex);
1805                 break;
1806         }
1807
1808         case AUDIO_GET_RTAC_ADM_CAL:
1809                 opcode = q6common_is_instance_id_supported() ?
1810                                  ADM_CMD_GET_PP_PARAMS_V6 :
1811                                  ADM_CMD_GET_PP_PARAMS_V5;
1812                 result = send_adm_apr((void *) arg, opcode);
1813                 break;
1814         case AUDIO_SET_RTAC_ADM_CAL:
1815                 opcode = q6common_is_instance_id_supported() ?
1816                                  ADM_CMD_SET_PP_PARAMS_V6 :
1817                                  ADM_CMD_SET_PP_PARAMS_V5;
1818                 result = send_adm_apr((void *) arg, opcode);
1819                 break;
1820         case AUDIO_GET_RTAC_ASM_CAL:
1821                 opcode = q6common_is_instance_id_supported() ?
1822                                  ASM_STREAM_CMD_GET_PP_PARAMS_V3 :
1823                                  ASM_STREAM_CMD_GET_PP_PARAMS_V2;
1824                 result = send_rtac_asm_apr((void *) arg, opcode);
1825                 break;
1826         case AUDIO_SET_RTAC_ASM_CAL:
1827                 opcode = q6common_is_instance_id_supported() ?
1828                                  ASM_STREAM_CMD_SET_PP_PARAMS_V3 :
1829                                  ASM_STREAM_CMD_SET_PP_PARAMS_V2;
1830                 result = send_rtac_asm_apr((void *) arg, opcode);
1831                 break;
1832         case AUDIO_GET_RTAC_CVS_CAL:
1833                 opcode = q6common_is_instance_id_supported() ?
1834                                  VSS_ICOMMON_CMD_GET_PARAM_V3 :
1835                                  VSS_ICOMMON_CMD_GET_PARAM_V2;
1836                 result = send_voice_apr(RTAC_CVS, (void *) arg, opcode);
1837                 break;
1838         case AUDIO_SET_RTAC_CVS_CAL:
1839                 opcode = q6common_is_instance_id_supported() ?
1840                                  VSS_ICOMMON_CMD_SET_PARAM_V3 :
1841                                  VSS_ICOMMON_CMD_SET_PARAM_V2;
1842                 result = send_voice_apr(RTAC_CVS, (void *) arg, opcode);
1843                 break;
1844         case AUDIO_GET_RTAC_CVP_CAL:
1845                 opcode = q6common_is_instance_id_supported() ?
1846                                  VSS_ICOMMON_CMD_GET_PARAM_V3 :
1847                                  VSS_ICOMMON_CMD_GET_PARAM_V2;
1848                 result = send_voice_apr(RTAC_CVP, (void *) arg, opcode);
1849                 break;
1850         case AUDIO_SET_RTAC_CVP_CAL:
1851                 opcode = q6common_is_instance_id_supported() ?
1852                                  VSS_ICOMMON_CMD_SET_PARAM_V3 :
1853                                  VSS_ICOMMON_CMD_SET_PARAM_V2;
1854                 result = send_voice_apr(RTAC_CVP, (void *) arg, opcode);
1855                 break;
1856         case AUDIO_GET_RTAC_AFE_CAL:
1857                 opcode = q6common_is_instance_id_supported() ?
1858                                  AFE_PORT_CMD_GET_PARAM_V3 :
1859                                  AFE_PORT_CMD_GET_PARAM_V2;
1860                 result = send_rtac_afe_apr((void __user *) arg, opcode);
1861                 break;
1862         case AUDIO_SET_RTAC_AFE_CAL:
1863                 opcode = q6common_is_instance_id_supported() ?
1864                                  AFE_PORT_CMD_SET_PARAM_V3 :
1865                                  AFE_PORT_CMD_SET_PARAM_V2;
1866                 result = send_rtac_afe_apr((void __user *) arg, opcode);
1867                 break;
1868         default:
1869                 pr_err("%s: Invalid IOCTL, command = %d!\n",
1870                        __func__, cmd);
1871                 result = -EINVAL;
1872         }
1873 done:
1874         return result;
1875 }
1876
1877 static long rtac_ioctl(struct file *f,
1878                 unsigned int cmd, unsigned long arg)
1879 {
1880         int result = 0;
1881
1882         mutex_lock(&rtac_common.rtac_fops_mutex);
1883         if (!arg) {
1884                 pr_err("%s: No data sent to driver!\n", __func__);
1885                 result = -EFAULT;
1886         } else {
1887                 result = rtac_ioctl_shared(f, cmd, (void __user *)arg);
1888         }
1889
1890         mutex_unlock(&rtac_common.rtac_fops_mutex);
1891         return result;
1892 }
1893
1894 #ifdef CONFIG_COMPAT
1895 #define AUDIO_GET_RTAC_ADM_INFO_32   _IOR(CAL_IOCTL_MAGIC, 207, compat_uptr_t)
1896 #define AUDIO_GET_RTAC_VOICE_INFO_32 _IOR(CAL_IOCTL_MAGIC, 208, compat_uptr_t)
1897 #define AUDIO_GET_RTAC_ADM_CAL_32 _IOWR(CAL_IOCTL_MAGIC, 209, compat_uptr_t)
1898 #define AUDIO_SET_RTAC_ADM_CAL_32 _IOWR(CAL_IOCTL_MAGIC, 210, compat_uptr_t)
1899 #define AUDIO_GET_RTAC_ASM_CAL_32 _IOWR(CAL_IOCTL_MAGIC, 211, compat_uptr_t)
1900 #define AUDIO_SET_RTAC_ASM_CAL_32 _IOWR(CAL_IOCTL_MAGIC, 212, compat_uptr_t)
1901 #define AUDIO_GET_RTAC_CVS_CAL_32 _IOWR(CAL_IOCTL_MAGIC, 213, compat_uptr_t)
1902 #define AUDIO_SET_RTAC_CVS_CAL_32 _IOWR(CAL_IOCTL_MAGIC, 214, compat_uptr_t)
1903 #define AUDIO_GET_RTAC_CVP_CAL_32 _IOWR(CAL_IOCTL_MAGIC, 215, compat_uptr_t)
1904 #define AUDIO_SET_RTAC_CVP_CAL_32 _IOWR(CAL_IOCTL_MAGIC, 216, compat_uptr_t)
1905 #define AUDIO_GET_RTAC_AFE_CAL_32 _IOWR(CAL_IOCTL_MAGIC, 217, compat_uptr_t)
1906 #define AUDIO_SET_RTAC_AFE_CAL_32 _IOWR(CAL_IOCTL_MAGIC, 218, compat_uptr_t)
1907
1908 static long rtac_compat_ioctl(struct file *f,
1909                 unsigned int cmd, unsigned long arg)
1910 {
1911         int result = 0;
1912
1913         mutex_lock(&rtac_common.rtac_fops_mutex);
1914         if (!arg) {
1915                 pr_err("%s: No data sent to driver!\n", __func__);
1916                 result = -EINVAL;
1917                 goto done;
1918         }
1919
1920         switch (cmd) {
1921         case AUDIO_GET_RTAC_ADM_INFO_32:
1922                 cmd = AUDIO_GET_RTAC_ADM_INFO;
1923                 goto process;
1924         case AUDIO_GET_RTAC_VOICE_INFO_32:
1925                 cmd = AUDIO_GET_RTAC_VOICE_INFO;
1926                 goto process;
1927         case AUDIO_GET_RTAC_AFE_CAL_32:
1928                 cmd = AUDIO_GET_RTAC_AFE_CAL;
1929                 goto process;
1930         case AUDIO_SET_RTAC_AFE_CAL_32:
1931                 cmd = AUDIO_SET_RTAC_AFE_CAL;
1932                 goto process;
1933         case AUDIO_GET_RTAC_ADM_CAL_32:
1934                 cmd = AUDIO_GET_RTAC_ADM_CAL;
1935                 goto process;
1936         case AUDIO_SET_RTAC_ADM_CAL_32:
1937                 cmd = AUDIO_SET_RTAC_ADM_CAL;
1938                 goto process;
1939         case AUDIO_GET_RTAC_ASM_CAL_32:
1940                 cmd = AUDIO_GET_RTAC_ASM_CAL;
1941                 goto process;
1942         case AUDIO_SET_RTAC_ASM_CAL_32:
1943                 cmd =  AUDIO_SET_RTAC_ASM_CAL;
1944                 goto process;
1945         case AUDIO_GET_RTAC_CVS_CAL_32:
1946                 cmd = AUDIO_GET_RTAC_CVS_CAL;
1947                 goto process;
1948         case AUDIO_SET_RTAC_CVS_CAL_32:
1949                 cmd = AUDIO_SET_RTAC_CVS_CAL;
1950                 goto process;
1951         case AUDIO_GET_RTAC_CVP_CAL_32:
1952                 cmd =  AUDIO_GET_RTAC_CVP_CAL;
1953                 goto process;
1954         case AUDIO_SET_RTAC_CVP_CAL_32:
1955                 cmd = AUDIO_SET_RTAC_CVP_CAL;
1956 process:
1957                 result = rtac_ioctl_shared(f, cmd, compat_ptr(arg));
1958                 break;
1959         default:
1960                 result = -EINVAL;
1961                 pr_err("%s: Invalid IOCTL, command = %d!\n",
1962                        __func__, cmd);
1963                 break;
1964         }
1965 done:
1966         mutex_unlock(&rtac_common.rtac_fops_mutex);
1967         return result;
1968 }
1969 #else
1970 #define rtac_compat_ioctl NULL
1971 #endif
1972
1973 static const struct file_operations rtac_fops = {
1974         .owner = THIS_MODULE,
1975         .open = rtac_open,
1976         .release = rtac_release,
1977         .unlocked_ioctl = rtac_ioctl,
1978         .compat_ioctl = rtac_compat_ioctl,
1979 };
1980
1981 struct miscdevice rtac_misc = {
1982         .minor  = MISC_DYNAMIC_MINOR,
1983         .name   = "msm_rtac",
1984         .fops   = &rtac_fops,
1985 };
1986
1987 static int __init rtac_init(void)
1988 {
1989         int i = 0;
1990
1991         /* Driver */
1992         atomic_set(&rtac_common.usage_count, 0);
1993         atomic_set(&rtac_common.apr_err_code, 0);
1994         mutex_init(&rtac_common.rtac_fops_mutex);
1995
1996         /* ADM */
1997         memset(&rtac_adm_data, 0, sizeof(rtac_adm_data));
1998         rtac_adm_apr_data.apr_handle = NULL;
1999         atomic_set(&rtac_adm_apr_data.cmd_state, 0);
2000         init_waitqueue_head(&rtac_adm_apr_data.cmd_wait);
2001         mutex_init(&rtac_adm_mutex);
2002         mutex_init(&rtac_adm_apr_mutex);
2003
2004         rtac_adm_buffer = kzalloc(
2005                 rtac_cal[ADM_RTAC_CAL].map_data.map_size, GFP_KERNEL);
2006         if (rtac_adm_buffer == NULL) {
2007                 pr_err("%s: Could not allocate payload of size = %d\n",
2008                         __func__, rtac_cal[ADM_RTAC_CAL].map_data.map_size);
2009                 goto nomem;
2010         }
2011
2012         /* ASM */
2013         for (i = 0; i < ASM_ACTIVE_STREAMS_ALLOWED+1; i++) {
2014                 rtac_asm_apr_data[i].apr_handle = NULL;
2015                 atomic_set(&rtac_asm_apr_data[i].cmd_state, 0);
2016                 init_waitqueue_head(&rtac_asm_apr_data[i].cmd_wait);
2017         }
2018         mutex_init(&rtac_asm_apr_mutex);
2019
2020         rtac_asm_buffer = kzalloc(
2021                 rtac_cal[ASM_RTAC_CAL].map_data.map_size, GFP_KERNEL);
2022         if (rtac_asm_buffer == NULL) {
2023                 pr_err("%s: Could not allocate payload of size = %d\n",
2024                         __func__, rtac_cal[ASM_RTAC_CAL].map_data.map_size);
2025                 kzfree(rtac_adm_buffer);
2026                 goto nomem;
2027         }
2028
2029         /* AFE */
2030         rtac_afe_apr_data.apr_handle = NULL;
2031         atomic_set(&rtac_afe_apr_data.cmd_state, 0);
2032         init_waitqueue_head(&rtac_afe_apr_data.cmd_wait);
2033         mutex_init(&rtac_afe_apr_mutex);
2034
2035         rtac_afe_buffer = kzalloc(
2036                 rtac_cal[AFE_RTAC_CAL].map_data.map_size, GFP_KERNEL);
2037         if (rtac_afe_buffer == NULL) {
2038                 pr_err("%s: Could not allocate payload of size = %d\n",
2039                         __func__, rtac_cal[AFE_RTAC_CAL].map_data.map_size);
2040                 kzfree(rtac_adm_buffer);
2041                 kzfree(rtac_asm_buffer);
2042                 goto nomem;
2043         }
2044
2045         /* Voice */
2046         memset(&rtac_voice_data, 0, sizeof(rtac_voice_data));
2047         for (i = 0; i < RTAC_VOICE_MODES; i++) {
2048                 rtac_voice_apr_data[i].apr_handle = NULL;
2049                 atomic_set(&rtac_voice_apr_data[i].cmd_state, 0);
2050                 init_waitqueue_head(&rtac_voice_apr_data[i].cmd_wait);
2051         }
2052         mutex_init(&rtac_voice_mutex);
2053         mutex_init(&rtac_voice_apr_mutex);
2054
2055         rtac_voice_buffer = kzalloc(
2056                 rtac_cal[VOICE_RTAC_CAL].map_data.map_size, GFP_KERNEL);
2057         if (rtac_voice_buffer == NULL) {
2058                 pr_err("%s: Could not allocate payload of size = %d\n",
2059                         __func__, rtac_cal[VOICE_RTAC_CAL].map_data.map_size);
2060                 kzfree(rtac_adm_buffer);
2061                 kzfree(rtac_asm_buffer);
2062                 kzfree(rtac_afe_buffer);
2063                 goto nomem;
2064         }
2065
2066         return misc_register(&rtac_misc);
2067 nomem:
2068         return -ENOMEM;
2069 }
2070
2071 module_init(rtac_init);
2072
2073 MODULE_DESCRIPTION("SoC QDSP6v2 Real-Time Audio Calibration driver");
2074 MODULE_LICENSE("GPL v2");