kernel/sound/soc/intel/atom/sst/sst_stream.c

   1 /*
   2  *  sst_stream.c - Intel SST Driver for audio engine
   3  *
   4  *  Copyright (C) 2008-14 Intel Corp
   5  *  Authors:    Vinod Koul <vinod.koul@intel.com>
   6  *              Harsha Priya <priya.harsha@intel.com>
   7  *              Dharageswari R <dharageswari.r@intel.com>
   8  *              KP Jeeja <jeeja.kp@intel.com>
   9  *  ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  10  *
  11  *  This program is free software; you can redistribute it and/or modify
  12  *  it under the terms of the GNU General Public License as published by
  13  *  the Free Software Foundation; version 2 of the License.
  14  *
  15  *  This program is distributed in the hope that it will be useful, but
  16  *  WITHOUT ANY WARRANTY; without even the implied warranty of
  17  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  18  *  General Public License for more details.
  19  *
  20  * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  21  */
  22 #include <linux/pci.h>
  23 #include <linux/firmware.h>
  24 #include <linux/sched.h>
  25 #include <linux/delay.h>
  26 #include <linux/pm_runtime.h>
  27 #include <sound/core.h>
  28 #include <sound/pcm.h>
  29 #include <sound/soc.h>
  30 #include <sound/compress_driver.h>
  31 #include <asm/platform_sst_audio.h>
  32 #include "../sst-mfld-platform.h"
  33 #include "sst.h"
  34 #include "../../common/sst-dsp.h"
  35
  36 int sst_alloc_stream_mrfld(struct intel_sst_drv *sst_drv_ctx, void *params)
  37 {
  38         struct snd_sst_alloc_mrfld alloc_param;
  39         struct snd_sst_params *str_params;
  40         struct snd_sst_tstamp fw_tstamp;
  41         struct stream_info *str_info;
  42         struct snd_sst_alloc_response *response;
  43         unsigned int str_id, pipe_id, task_id;
  44         int i, num_ch, ret = 0;
  45         void *data = NULL;
  46
  47         dev_dbg(sst_drv_ctx->dev, "Enter\n");
  48         BUG_ON(!params);
  49
  50         str_params = (struct snd_sst_params *)params;
  51         memset(&alloc_param, 0, sizeof(alloc_param));
  52         alloc_param.operation = str_params->ops;
  53         alloc_param.codec_type = str_params->codec;
  54         alloc_param.sg_count = str_params->aparams.sg_count;
  55         alloc_param.ring_buf_info[0].addr =
  56                 str_params->aparams.ring_buf_info[0].addr;
  57         alloc_param.ring_buf_info[0].size =
  58                 str_params->aparams.ring_buf_info[0].size;
  59         alloc_param.frag_size = str_params->aparams.frag_size;
  60
  61         memcpy(&alloc_param.codec_params, &str_params->sparams,
  62                         sizeof(struct snd_sst_stream_params));
  63
  64         /*
  65          * fill channel map params for multichannel support.
  66          * Ideally channel map should be received from upper layers
  67          * for multichannel support.
  68          * Currently hardcoding as per FW reqm.
  69          */
  70         num_ch = sst_get_num_channel(str_params);
  71         for (i = 0; i < 8; i++) {
  72                 if (i < num_ch)
  73                         alloc_param.codec_params.uc.pcm_params.channel_map[i] = i;
  74                 else
  75                         alloc_param.codec_params.uc.pcm_params.channel_map[i] = 0xFF;
  76         }
  77
  78         str_id = str_params->stream_id;
  79         str_info = get_stream_info(sst_drv_ctx, str_id);
  80         if (str_info == NULL) {
  81                 dev_err(sst_drv_ctx->dev, "get stream info returned null\n");
  82                 return -EINVAL;
  83         }
  84
  85         pipe_id = str_params->device_type;
  86         task_id = str_params->task;
  87         sst_drv_ctx->streams[str_id].pipe_id = pipe_id;
  88         sst_drv_ctx->streams[str_id].task_id = task_id;
  89         sst_drv_ctx->streams[str_id].num_ch = num_ch;
  90
  91         if (sst_drv_ctx->info.lpe_viewpt_rqd)
  92                 alloc_param.ts = sst_drv_ctx->info.mailbox_start +
  93                         sst_drv_ctx->tstamp + (str_id * sizeof(fw_tstamp));
  94         else
  95                 alloc_param.ts = sst_drv_ctx->mailbox_add +
  96                         sst_drv_ctx->tstamp + (str_id * sizeof(fw_tstamp));
  97
  98         dev_dbg(sst_drv_ctx->dev, "alloc tstamp location = 0x%x\n",
  99                         alloc_param.ts);
 100         dev_dbg(sst_drv_ctx->dev, "assigned pipe id 0x%x to task %d\n",
 101                         pipe_id, task_id);
 102
 103         /* allocate device type context */
 104         sst_init_stream(&sst_drv_ctx->streams[str_id], alloc_param.codec_type,
 105                         str_id, alloc_param.operation, 0);
 106
 107         dev_info(sst_drv_ctx->dev, "Alloc for str %d pipe %#x\n",
 108                         str_id, pipe_id);
 109         ret = sst_prepare_and_post_msg(sst_drv_ctx, task_id, IPC_CMD,
 110                         IPC_IA_ALLOC_STREAM_MRFLD, pipe_id, sizeof(alloc_param),
 111                         &alloc_param, data, true, true, false, true);
 112
 113         if (ret < 0) {
 114                 dev_err(sst_drv_ctx->dev, "FW alloc failed ret %d\n", ret);
 115                 /* alloc failed, so reset the state to uninit */
 116                 str_info->status = STREAM_UN_INIT;
 117                 str_id = ret;
 118         } else if (data) {
 119                 response = (struct snd_sst_alloc_response *)data;
 120                 ret = response->str_type.result;
 121                 if (!ret)
 122                         goto out;
 123                 dev_err(sst_drv_ctx->dev, "FW alloc failed ret %d\n", ret);
 124                 if (ret == SST_ERR_STREAM_IN_USE) {
 125                         dev_err(sst_drv_ctx->dev,
 126                                 "FW not in clean state, send free for:%d\n", str_id);
 127                         sst_free_stream(sst_drv_ctx, str_id);
 128                 }
 129                 str_id = -ret;
 130         }
 131 out:
 132         kfree(data);
 133         return str_id;
 134 }
 135
 136 /**
 137 * sst_start_stream - Send msg for a starting stream
 138 * @str_id:       stream ID
 139 *
 140 * This function is called by any function which wants to start
 141 * a stream.
 142 */
 143 int sst_start_stream(struct intel_sst_drv *sst_drv_ctx, int str_id)
 144 {
 145         int retval = 0;
 146         struct stream_info *str_info;
 147         u16 data = 0;
 148
 149         dev_dbg(sst_drv_ctx->dev, "sst_start_stream for %d\n", str_id);
 150         str_info = get_stream_info(sst_drv_ctx, str_id);
 151         if (!str_info)
 152                 return -EINVAL;
 153         if (str_info->status != STREAM_RUNNING)
 154                 return -EBADRQC;
 155
 156         retval = sst_prepare_and_post_msg(sst_drv_ctx, str_info->task_id,
 157                         IPC_CMD, IPC_IA_START_STREAM_MRFLD, str_info->pipe_id,
 158                         sizeof(u16), &data, NULL, true, true, true, false);
 159
 160         return retval;
 161 }
 162
 163 int sst_send_byte_stream_mrfld(struct intel_sst_drv *sst_drv_ctx,
 164                 struct snd_sst_bytes_v2 *bytes)
 165 {       struct ipc_post *msg = NULL;
 166         u32 length;
 167         int pvt_id, ret = 0;
 168         struct sst_block *block = NULL;
 169
 170         dev_dbg(sst_drv_ctx->dev,
 171                 "type:%u ipc_msg:%u block:%u task_id:%u pipe: %#x length:%#x\n",
 172                 bytes->type, bytes->ipc_msg, bytes->block, bytes->task_id,
 173                 bytes->pipe_id, bytes->len);
 174
 175         if (sst_create_ipc_msg(&msg, true))
 176                 return -ENOMEM;
 177
 178         pvt_id = sst_assign_pvt_id(sst_drv_ctx);
 179         sst_fill_header_mrfld(&msg->mrfld_header, bytes->ipc_msg,
 180                         bytes->task_id, 1, pvt_id);
 181         msg->mrfld_header.p.header_high.part.res_rqd = bytes->block;
 182         length = bytes->len;
 183         msg->mrfld_header.p.header_low_payload = length;
 184         dev_dbg(sst_drv_ctx->dev, "length is %d\n", length);
 185         memcpy(msg->mailbox_data, &bytes->bytes, bytes->len);
 186         if (bytes->block) {
 187                 block = sst_create_block(sst_drv_ctx, bytes->ipc_msg, pvt_id);
 188                 if (block == NULL) {
 189                         kfree(msg);
 190                         ret = -ENOMEM;
 191                         goto out;
 192                 }
 193         }
 194
 195         sst_add_to_dispatch_list_and_post(sst_drv_ctx, msg);
 196         dev_dbg(sst_drv_ctx->dev, "msg->mrfld_header.p.header_low_payload:%d",
 197                         msg->mrfld_header.p.header_low_payload);
 198
 199         if (bytes->block) {
 200                 ret = sst_wait_timeout(sst_drv_ctx, block);
 201                 if (ret) {
 202                         dev_err(sst_drv_ctx->dev, "fw returned err %d\n", ret);
 203                         sst_free_block(sst_drv_ctx, block);
 204                         goto out;
 205                 }
 206         }
 207         if (bytes->type == SND_SST_BYTES_GET) {
 208                 /*
 209                  * copy the reply and send back
 210                  * we need to update only sz and payload
 211                  */
 212                 if (bytes->block) {
 213                         unsigned char *r = block->data;
 214
 215                         dev_dbg(sst_drv_ctx->dev, "read back %d bytes",
 216                                         bytes->len);
 217                         memcpy(bytes->bytes, r, bytes->len);
 218                 }
 219         }
 220         if (bytes->block)
 221                 sst_free_block(sst_drv_ctx, block);
 222 out:
 223         test_and_clear_bit(pvt_id, &sst_drv_ctx->pvt_id);
 224         return 0;
 225 }
 226
 227 /*
 228  * sst_pause_stream - Send msg for a pausing stream
 229  * @str_id:      stream ID
 230  *
 231  * This function is called by any function which wants to pause
 232  * an already running stream.
 233  */
 234 int sst_pause_stream(struct intel_sst_drv *sst_drv_ctx, int str_id)
 235 {
 236         int retval = 0;
 237         struct stream_info *str_info;
 238
 239         dev_dbg(sst_drv_ctx->dev, "SST DBG:sst_pause_stream for %d\n", str_id);
 240         str_info = get_stream_info(sst_drv_ctx, str_id);
 241         if (!str_info)
 242                 return -EINVAL;
 243         if (str_info->status == STREAM_PAUSED)
 244                 return 0;
 245         if (str_info->status == STREAM_RUNNING ||
 246                 str_info->status == STREAM_INIT) {
 247                 if (str_info->prev == STREAM_UN_INIT)
 248                         return -EBADRQC;
 249
 250                 retval = sst_prepare_and_post_msg(sst_drv_ctx, str_info->task_id, IPC_CMD,
 251                                 IPC_IA_PAUSE_STREAM_MRFLD, str_info->pipe_id,
 252                                 0, NULL, NULL, true, true, false, true);
 253
 254                 if (retval == 0) {
 255                         str_info->prev = str_info->status;
 256                         str_info->status = STREAM_PAUSED;
 257                 } else if (retval == SST_ERR_INVALID_STREAM_ID) {
 258                         retval = -EINVAL;
 259                         mutex_lock(&sst_drv_ctx->sst_lock);
 260                         sst_clean_stream(str_info);
 261                         mutex_unlock(&sst_drv_ctx->sst_lock);
 262                 }
 263         } else {
 264                 retval = -EBADRQC;
 265                 dev_dbg(sst_drv_ctx->dev, "SST DBG:BADRQC for stream\n ");
 266         }
 267
 268         return retval;
 269 }
 270
 271 /**
 272  * sst_resume_stream - Send msg for resuming stream
 273  * @str_id:             stream ID
 274  *
 275  * This function is called by any function which wants to resume
 276  * an already paused stream.
 277  */
 278 int sst_resume_stream(struct intel_sst_drv *sst_drv_ctx, int str_id)
 279 {
 280         int retval = 0;
 281         struct stream_info *str_info;
 282
 283         dev_dbg(sst_drv_ctx->dev, "SST DBG:sst_resume_stream for %d\n", str_id);
 284         str_info = get_stream_info(sst_drv_ctx, str_id);
 285         if (!str_info)
 286                 return -EINVAL;
 287         if (str_info->status == STREAM_RUNNING)
 288                         return 0;
 289         if (str_info->status == STREAM_PAUSED) {
 290                 retval = sst_prepare_and_post_msg(sst_drv_ctx, str_info->task_id,
 291                                 IPC_CMD, IPC_IA_RESUME_STREAM_MRFLD,
 292                                 str_info->pipe_id, 0, NULL, NULL,
 293                                 true, true, false, true);
 294
 295                 if (!retval) {
 296                         if (str_info->prev == STREAM_RUNNING)
 297                                 str_info->status = STREAM_RUNNING;
 298                         else
 299                                 str_info->status = STREAM_INIT;
 300                         str_info->prev = STREAM_PAUSED;
 301                 } else if (retval == -SST_ERR_INVALID_STREAM_ID) {
 302                         retval = -EINVAL;
 303                         mutex_lock(&sst_drv_ctx->sst_lock);
 304                         sst_clean_stream(str_info);
 305                         mutex_unlock(&sst_drv_ctx->sst_lock);
 306                 }
 307         } else {
 308                 retval = -EBADRQC;
 309                 dev_err(sst_drv_ctx->dev, "SST ERR: BADQRC for stream\n");
 310         }
 311
 312         return retval;
 313 }
 314
 315
 316 /**
 317  * sst_drop_stream - Send msg for stopping stream
 318  * @str_id:             stream ID
 319  *
 320  * This function is called by any function which wants to stop
 321  * a stream.
 322  */
 323 int sst_drop_stream(struct intel_sst_drv *sst_drv_ctx, int str_id)
 324 {
 325         int retval = 0;
 326         struct stream_info *str_info;
 327
 328         dev_dbg(sst_drv_ctx->dev, "SST DBG:sst_drop_stream for %d\n", str_id);
 329         str_info = get_stream_info(sst_drv_ctx, str_id);
 330         if (!str_info)
 331                 return -EINVAL;
 332
 333         if (str_info->status != STREAM_UN_INIT) {
 334                 str_info->prev = STREAM_UN_INIT;
 335                 str_info->status = STREAM_INIT;
 336                 str_info->cumm_bytes = 0;
 337                 retval = sst_prepare_and_post_msg(sst_drv_ctx, str_info->task_id,
 338                                 IPC_CMD, IPC_IA_DROP_STREAM_MRFLD,
 339                                 str_info->pipe_id, 0, NULL, NULL,
 340                                 true, true, true, false);
 341         } else {
 342                 retval = -EBADRQC;
 343                 dev_dbg(sst_drv_ctx->dev, "BADQRC for stream, state %x\n",
 344                                 str_info->status);
 345         }
 346         return retval;
 347 }
 348
 349 /**
 350 * sst_drain_stream - Send msg for draining stream
 351 * @str_id:              stream ID
 352 *
 353 * This function is called by any function which wants to drain
 354 * a stream.
 355 */
 356 int sst_drain_stream(struct intel_sst_drv *sst_drv_ctx,
 357                         int str_id, bool partial_drain)
 358 {
 359         int retval = 0;
 360         struct stream_info *str_info;
 361
 362         dev_dbg(sst_drv_ctx->dev, "SST DBG:sst_drain_stream for %d\n", str_id);
 363         str_info = get_stream_info(sst_drv_ctx, str_id);
 364         if (!str_info)
 365                 return -EINVAL;
 366         if (str_info->status != STREAM_RUNNING &&
 367                 str_info->status != STREAM_INIT &&
 368                 str_info->status != STREAM_PAUSED) {
 369                         dev_err(sst_drv_ctx->dev, "SST ERR: BADQRC for stream = %d\n",
 370                                        str_info->status);
 371                         return -EBADRQC;
 372         }
 373
 374         retval = sst_prepare_and_post_msg(sst_drv_ctx, str_info->task_id, IPC_CMD,
 375                         IPC_IA_DRAIN_STREAM_MRFLD, str_info->pipe_id,
 376                         sizeof(u8), &partial_drain, NULL, true, true, false, false);
 377         /*
 378          * with new non blocked drain implementation in core we dont need to
 379          * wait for respsonse, and need to only invoke callback for drain
 380          * complete
 381          */
 382
 383         return retval;
 384 }
 385
 386 /**
 387  * sst_free_stream - Frees a stream
 388  * @str_id:             stream ID
 389  *
 390  * This function is called by any function which wants to free
 391  * a stream.
 392  */
 393 int sst_free_stream(struct intel_sst_drv *sst_drv_ctx, int str_id)
 394 {
 395         int retval = 0;
 396         struct stream_info *str_info;
 397         struct intel_sst_ops *ops;
 398
 399         dev_dbg(sst_drv_ctx->dev, "SST DBG:sst_free_stream for %d\n", str_id);
 400
 401         mutex_lock(&sst_drv_ctx->sst_lock);
 402         if (sst_drv_ctx->sst_state == SST_RESET) {
 403                 mutex_unlock(&sst_drv_ctx->sst_lock);
 404                 return -ENODEV;
 405         }
 406         mutex_unlock(&sst_drv_ctx->sst_lock);
 407         str_info = get_stream_info(sst_drv_ctx, str_id);
 408         if (!str_info)
 409                 return -EINVAL;
 410         ops = sst_drv_ctx->ops;
 411
 412         mutex_lock(&str_info->lock);
 413         if (str_info->status != STREAM_UN_INIT) {
 414                 str_info->prev =  str_info->status;
 415                 str_info->status = STREAM_UN_INIT;
 416                 mutex_unlock(&str_info->lock);
 417
 418                 dev_info(sst_drv_ctx->dev, "Free for str %d pipe %#x\n",
 419                                 str_id, str_info->pipe_id);
 420                 retval = sst_prepare_and_post_msg(sst_drv_ctx, str_info->task_id, IPC_CMD,
 421                                 IPC_IA_FREE_STREAM_MRFLD, str_info->pipe_id, 0,
 422                                 NULL, NULL, true, true, false, true);
 423
 424                 dev_dbg(sst_drv_ctx->dev, "sst: wait for free returned %d\n",
 425                                 retval);
 426                 mutex_lock(&sst_drv_ctx->sst_lock);
 427                 sst_clean_stream(str_info);
 428                 mutex_unlock(&sst_drv_ctx->sst_lock);
 429                 dev_dbg(sst_drv_ctx->dev, "SST DBG:Stream freed\n");
 430         } else {
 431                 mutex_unlock(&str_info->lock);
 432                 retval = -EBADRQC;
 433                 dev_dbg(sst_drv_ctx->dev, "SST DBG:BADQRC for stream\n");
 434         }
 435
 436         return retval;
 437 }