1 // SPDX-License-Identifier: GPL-2.0+ 2 // Copyright 2017-2021 NXP 3 4 #include <linux/dma-mapping.h> 5 #include <linux/slab.h> 6 #include <linux/module.h> 7 #include <linux/delay.h> 8 #include <linux/rpmsg.h> 9 #include <sound/core.h> 10 #include <sound/pcm.h> 11 #include <sound/pcm_params.h> 12 #include <sound/dmaengine_pcm.h> 13 #include <sound/soc.h> 14 15 #include "imx-pcm.h" 16 #include "fsl_rpmsg.h" 17 #include "imx-pcm-rpmsg.h" 18 19 static struct snd_pcm_hardware imx_rpmsg_pcm_hardware = { 20 .info = SNDRV_PCM_INFO_INTERLEAVED | 21 SNDRV_PCM_INFO_BLOCK_TRANSFER | 22 SNDRV_PCM_INFO_MMAP | 23 SNDRV_PCM_INFO_MMAP_VALID | 24 SNDRV_PCM_INFO_NO_PERIOD_WAKEUP | 25 SNDRV_PCM_INFO_PAUSE | 26 SNDRV_PCM_INFO_RESUME, 27 .buffer_bytes_max = IMX_DEFAULT_DMABUF_SIZE, 28 .period_bytes_min = 512, 29 .period_bytes_max = 65536, 30 .periods_min = 2, 31 .periods_max = 6000, 32 .fifo_size = 0, 33 }; 34 35 static int imx_rpmsg_pcm_send_message(struct rpmsg_msg *msg, 36 struct rpmsg_info *info) 37 { 38 struct rpmsg_device *rpdev = info->rpdev; 39 int ret = 0; 40 41 mutex_lock(&info->msg_lock); 42 if (!rpdev) { 43 dev_err(info->dev, "rpmsg channel not ready\n"); 44 mutex_unlock(&info->msg_lock); 45 return -EINVAL; 46 } 47 48 dev_dbg(&rpdev->dev, "send cmd %d\n", msg->s_msg.header.cmd); 49 50 if (!(msg->s_msg.header.type == MSG_TYPE_C)) 51 reinit_completion(&info->cmd_complete); 52 53 ret = rpmsg_send(rpdev->ept, (void *)&msg->s_msg, 54 sizeof(struct rpmsg_s_msg)); 55 if (ret) { 56 dev_err(&rpdev->dev, "rpmsg_send failed: %d\n", ret); 57 mutex_unlock(&info->msg_lock); 58 return ret; 59 } 60 61 /* No receive msg for TYPE_C command */ 62 if (msg->s_msg.header.type == MSG_TYPE_C) { 63 mutex_unlock(&info->msg_lock); 64 return 0; 65 } 66 67 /* wait response from rpmsg */ 68 ret = wait_for_completion_timeout(&info->cmd_complete, 69 msecs_to_jiffies(RPMSG_TIMEOUT)); 70 if (!ret) { 71 dev_err(&rpdev->dev, "rpmsg_send cmd %d timeout!\n", 72 msg->s_msg.header.cmd); 73 mutex_unlock(&info->msg_lock); 74 return -ETIMEDOUT; 75 } 76 77 memcpy(&msg->r_msg, &info->r_msg, sizeof(struct rpmsg_r_msg)); 78 memcpy(&info->msg[msg->r_msg.header.cmd].r_msg, 79 &msg->r_msg, sizeof(struct rpmsg_r_msg)); 80 81 /* 82 * Reset the buffer pointer to be zero, actully we have 83 * set the buffer pointer to be zero in imx_rpmsg_terminate_all 84 * But if there is timer task queued in queue, after it is 85 * executed the buffer pointer will be changed, so need to 86 * reset it again with TERMINATE command. 87 */ 88 switch (msg->s_msg.header.cmd) { 89 case TX_TERMINATE: 90 info->msg[TX_POINTER].r_msg.param.buffer_offset = 0; 91 break; 92 case RX_TERMINATE: 93 info->msg[RX_POINTER].r_msg.param.buffer_offset = 0; 94 break; 95 default: 96 break; 97 } 98 99 dev_dbg(&rpdev->dev, "cmd:%d, resp %d\n", msg->s_msg.header.cmd, 100 info->r_msg.param.resp); 101 102 mutex_unlock(&info->msg_lock); 103 104 return 0; 105 } 106 107 static int imx_rpmsg_insert_workqueue(struct snd_pcm_substream *substream, 108 struct rpmsg_msg *msg, 109 struct rpmsg_info *info) 110 { 111 unsigned long flags; 112 int ret = 0; 113 114 /* 115 * Queue the work to workqueue. 116 * If the queue is full, drop the message. 117 */ 118 spin_lock_irqsave(&info->wq_lock, flags); 119 if (info->work_write_index != info->work_read_index) { 120 int index = info->work_write_index; 121 122 memcpy(&info->work_list[index].msg, msg, 123 sizeof(struct rpmsg_s_msg)); 124 125 queue_work(info->rpmsg_wq, &info->work_list[index].work); 126 info->work_write_index++; 127 info->work_write_index %= WORK_MAX_NUM; 128 } else { 129 info->msg_drop_count[substream->stream]++; 130 ret = -EPIPE; 131 } 132 spin_unlock_irqrestore(&info->wq_lock, flags); 133 134 return ret; 135 } 136 137 static int imx_rpmsg_pcm_hw_params(struct snd_soc_component *component, 138 struct snd_pcm_substream *substream, 139 struct snd_pcm_hw_params *params) 140 { 141 struct rpmsg_info *info = dev_get_drvdata(component->dev); 142 struct rpmsg_msg *msg; 143 144 if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) { 145 msg = &info->msg[TX_HW_PARAM]; 146 msg->s_msg.header.cmd = TX_HW_PARAM; 147 } else { 148 msg = &info->msg[RX_HW_PARAM]; 149 msg->s_msg.header.cmd = RX_HW_PARAM; 150 } 151 152 msg->s_msg.param.rate = params_rate(params); 153 154 switch (params_format(params)) { 155 case SNDRV_PCM_FORMAT_S16_LE: 156 msg->s_msg.param.format = RPMSG_S16_LE; 157 break; 158 case SNDRV_PCM_FORMAT_S24_LE: 159 msg->s_msg.param.format = RPMSG_S24_LE; 160 break; 161 case SNDRV_PCM_FORMAT_DSD_U16_LE: 162 msg->s_msg.param.format = RPMSG_DSD_U16_LE; 163 break; 164 case SNDRV_PCM_FORMAT_DSD_U32_LE: 165 msg->s_msg.param.format = RPMSG_DSD_U32_LE; 166 break; 167 default: 168 msg->s_msg.param.format = RPMSG_S32_LE; 169 break; 170 } 171 172 switch (params_channels(params)) { 173 case 1: 174 msg->s_msg.param.channels = RPMSG_CH_LEFT; 175 break; 176 case 2: 177 msg->s_msg.param.channels = RPMSG_CH_STEREO; 178 break; 179 default: 180 msg->s_msg.param.channels = params_channels(params); 181 break; 182 } 183 184 info->send_message(msg, info); 185 186 return 0; 187 } 188 189 static snd_pcm_uframes_t imx_rpmsg_pcm_pointer(struct snd_soc_component *component, 190 struct snd_pcm_substream *substream) 191 { 192 struct rpmsg_info *info = dev_get_drvdata(component->dev); 193 struct rpmsg_msg *msg; 194 unsigned int pos = 0; 195 int buffer_tail = 0; 196 197 if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) 198 msg = &info->msg[TX_PERIOD_DONE + MSG_TYPE_A_NUM]; 199 else 200 msg = &info->msg[RX_PERIOD_DONE + MSG_TYPE_A_NUM]; 201 202 buffer_tail = msg->r_msg.param.buffer_tail; 203 pos = buffer_tail * snd_pcm_lib_period_bytes(substream); 204 205 return bytes_to_frames(substream->runtime, pos); 206 } 207 208 static void imx_rpmsg_timer_callback(struct timer_list *t) 209 { 210 struct stream_timer *stream_timer = 211 from_timer(stream_timer, t, timer); 212 struct snd_pcm_substream *substream = stream_timer->substream; 213 struct rpmsg_info *info = stream_timer->info; 214 struct rpmsg_msg *msg; 215 216 if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) { 217 msg = &info->msg[TX_PERIOD_DONE + MSG_TYPE_A_NUM]; 218 msg->s_msg.header.cmd = TX_PERIOD_DONE; 219 } else { 220 msg = &info->msg[RX_PERIOD_DONE + MSG_TYPE_A_NUM]; 221 msg->s_msg.header.cmd = RX_PERIOD_DONE; 222 } 223 224 imx_rpmsg_insert_workqueue(substream, msg, info); 225 } 226 227 static int imx_rpmsg_pcm_open(struct snd_soc_component *component, 228 struct snd_pcm_substream *substream) 229 { 230 struct rpmsg_info *info = dev_get_drvdata(component->dev); 231 struct rpmsg_msg *msg; 232 int ret = 0; 233 int cmd; 234 235 if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) { 236 msg = &info->msg[TX_OPEN]; 237 msg->s_msg.header.cmd = TX_OPEN; 238 239 /* reinitialize buffer counter*/ 240 cmd = TX_PERIOD_DONE + MSG_TYPE_A_NUM; 241 info->msg[cmd].s_msg.param.buffer_tail = 0; 242 info->msg[cmd].r_msg.param.buffer_tail = 0; 243 info->msg[TX_POINTER].r_msg.param.buffer_offset = 0; 244 245 } else { 246 msg = &info->msg[RX_OPEN]; 247 msg->s_msg.header.cmd = RX_OPEN; 248 249 /* reinitialize buffer counter*/ 250 cmd = RX_PERIOD_DONE + MSG_TYPE_A_NUM; 251 info->msg[cmd].s_msg.param.buffer_tail = 0; 252 info->msg[cmd].r_msg.param.buffer_tail = 0; 253 info->msg[RX_POINTER].r_msg.param.buffer_offset = 0; 254 } 255 256 info->send_message(msg, info); 257 258 imx_rpmsg_pcm_hardware.period_bytes_max = 259 imx_rpmsg_pcm_hardware.buffer_bytes_max / 2; 260 261 snd_soc_set_runtime_hwparams(substream, &imx_rpmsg_pcm_hardware); 262 263 ret = snd_pcm_hw_constraint_integer(substream->runtime, 264 SNDRV_PCM_HW_PARAM_PERIODS); 265 if (ret < 0) 266 return ret; 267 268 info->msg_drop_count[substream->stream] = 0; 269 270 /* Create timer*/ 271 info->stream_timer[substream->stream].info = info; 272 info->stream_timer[substream->stream].substream = substream; 273 timer_setup(&info->stream_timer[substream->stream].timer, 274 imx_rpmsg_timer_callback, 0); 275 return ret; 276 } 277 278 static int imx_rpmsg_pcm_close(struct snd_soc_component *component, 279 struct snd_pcm_substream *substream) 280 { 281 struct snd_soc_pcm_runtime *rtd = asoc_substream_to_rtd(substream); 282 struct rpmsg_info *info = dev_get_drvdata(component->dev); 283 struct rpmsg_msg *msg; 284 285 /* Flush work in workqueue to make TX_CLOSE is the last message */ 286 flush_workqueue(info->rpmsg_wq); 287 288 if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) { 289 msg = &info->msg[TX_CLOSE]; 290 msg->s_msg.header.cmd = TX_CLOSE; 291 } else { 292 msg = &info->msg[RX_CLOSE]; 293 msg->s_msg.header.cmd = RX_CLOSE; 294 } 295 296 info->send_message(msg, info); 297 298 del_timer(&info->stream_timer[substream->stream].timer); 299 300 rtd->dai_link->ignore_suspend = 0; 301 302 if (info->msg_drop_count[substream->stream]) 303 dev_warn(rtd->dev, "Msg is dropped!, number is %d\n", 304 info->msg_drop_count[substream->stream]); 305 306 return 0; 307 } 308 309 static int imx_rpmsg_pcm_prepare(struct snd_soc_component *component, 310 struct snd_pcm_substream *substream) 311 { 312 struct snd_pcm_runtime *runtime = substream->runtime; 313 struct snd_soc_pcm_runtime *rtd = substream->private_data; 314 struct snd_soc_dai *cpu_dai = asoc_rtd_to_cpu(rtd, 0); 315 struct fsl_rpmsg *rpmsg = dev_get_drvdata(cpu_dai->dev); 316 317 /* 318 * NON-MMAP mode, NONBLOCK, Version 2, enable lpa in dts 319 * four conditions to determine the lpa is enabled. 320 */ 321 if ((runtime->access == SNDRV_PCM_ACCESS_RW_INTERLEAVED || 322 runtime->access == SNDRV_PCM_ACCESS_RW_NONINTERLEAVED) && 323 rpmsg->enable_lpa) { 324 /* 325 * Ignore suspend operation in low power mode 326 * M core will continue playback music on A core suspend. 327 */ 328 rtd->dai_link->ignore_suspend = 1; 329 rpmsg->force_lpa = 1; 330 } else { 331 rpmsg->force_lpa = 0; 332 } 333 334 return 0; 335 } 336 337 static void imx_rpmsg_pcm_dma_complete(void *arg) 338 { 339 struct snd_pcm_substream *substream = arg; 340 341 snd_pcm_period_elapsed(substream); 342 } 343 344 static int imx_rpmsg_prepare_and_submit(struct snd_soc_component *component, 345 struct snd_pcm_substream *substream) 346 { 347 struct rpmsg_info *info = dev_get_drvdata(component->dev); 348 struct rpmsg_msg *msg; 349 350 if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) { 351 msg = &info->msg[TX_BUFFER]; 352 msg->s_msg.header.cmd = TX_BUFFER; 353 } else { 354 msg = &info->msg[RX_BUFFER]; 355 msg->s_msg.header.cmd = RX_BUFFER; 356 } 357 358 /* Send buffer address and buffer size */ 359 msg->s_msg.param.buffer_addr = substream->runtime->dma_addr; 360 msg->s_msg.param.buffer_size = snd_pcm_lib_buffer_bytes(substream); 361 msg->s_msg.param.period_size = snd_pcm_lib_period_bytes(substream); 362 msg->s_msg.param.buffer_tail = 0; 363 364 info->num_period[substream->stream] = msg->s_msg.param.buffer_size / 365 msg->s_msg.param.period_size; 366 367 info->callback[substream->stream] = imx_rpmsg_pcm_dma_complete; 368 info->callback_param[substream->stream] = substream; 369 370 return imx_rpmsg_insert_workqueue(substream, msg, info); 371 } 372 373 static int imx_rpmsg_async_issue_pending(struct snd_soc_component *component, 374 struct snd_pcm_substream *substream) 375 { 376 struct rpmsg_info *info = dev_get_drvdata(component->dev); 377 struct rpmsg_msg *msg; 378 379 if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) { 380 msg = &info->msg[TX_START]; 381 msg->s_msg.header.cmd = TX_START; 382 } else { 383 msg = &info->msg[RX_START]; 384 msg->s_msg.header.cmd = RX_START; 385 } 386 387 return imx_rpmsg_insert_workqueue(substream, msg, info); 388 } 389 390 static int imx_rpmsg_restart(struct snd_soc_component *component, 391 struct snd_pcm_substream *substream) 392 { 393 struct rpmsg_info *info = dev_get_drvdata(component->dev); 394 struct rpmsg_msg *msg; 395 396 if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) { 397 msg = &info->msg[TX_RESTART]; 398 msg->s_msg.header.cmd = TX_RESTART; 399 } else { 400 msg = &info->msg[RX_RESTART]; 401 msg->s_msg.header.cmd = RX_RESTART; 402 } 403 404 return imx_rpmsg_insert_workqueue(substream, msg, info); 405 } 406 407 static int imx_rpmsg_pause(struct snd_soc_component *component, 408 struct snd_pcm_substream *substream) 409 { 410 struct rpmsg_info *info = dev_get_drvdata(component->dev); 411 struct rpmsg_msg *msg; 412 413 if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) { 414 msg = &info->msg[TX_PAUSE]; 415 msg->s_msg.header.cmd = TX_PAUSE; 416 } else { 417 msg = &info->msg[RX_PAUSE]; 418 msg->s_msg.header.cmd = RX_PAUSE; 419 } 420 421 return imx_rpmsg_insert_workqueue(substream, msg, info); 422 } 423 424 static int imx_rpmsg_terminate_all(struct snd_soc_component *component, 425 struct snd_pcm_substream *substream) 426 { 427 struct rpmsg_info *info = dev_get_drvdata(component->dev); 428 struct rpmsg_msg *msg; 429 int cmd; 430 431 if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) { 432 msg = &info->msg[TX_TERMINATE]; 433 msg->s_msg.header.cmd = TX_TERMINATE; 434 /* Clear buffer count*/ 435 cmd = TX_PERIOD_DONE + MSG_TYPE_A_NUM; 436 info->msg[cmd].s_msg.param.buffer_tail = 0; 437 info->msg[cmd].r_msg.param.buffer_tail = 0; 438 info->msg[TX_POINTER].r_msg.param.buffer_offset = 0; 439 } else { 440 msg = &info->msg[RX_TERMINATE]; 441 msg->s_msg.header.cmd = RX_TERMINATE; 442 /* Clear buffer count*/ 443 cmd = RX_PERIOD_DONE + MSG_TYPE_A_NUM; 444 info->msg[cmd].s_msg.param.buffer_tail = 0; 445 info->msg[cmd].r_msg.param.buffer_tail = 0; 446 info->msg[RX_POINTER].r_msg.param.buffer_offset = 0; 447 } 448 449 del_timer(&info->stream_timer[substream->stream].timer); 450 451 return imx_rpmsg_insert_workqueue(substream, msg, info); 452 } 453 454 static int imx_rpmsg_pcm_trigger(struct snd_soc_component *component, 455 struct snd_pcm_substream *substream, int cmd) 456 { 457 struct snd_pcm_runtime *runtime = substream->runtime; 458 struct snd_soc_pcm_runtime *rtd = substream->private_data; 459 struct snd_soc_dai *cpu_dai = asoc_rtd_to_cpu(rtd, 0); 460 struct fsl_rpmsg *rpmsg = dev_get_drvdata(cpu_dai->dev); 461 int ret = 0; 462 463 switch (cmd) { 464 case SNDRV_PCM_TRIGGER_START: 465 ret = imx_rpmsg_prepare_and_submit(component, substream); 466 if (ret) 467 return ret; 468 ret = imx_rpmsg_async_issue_pending(component, substream); 469 break; 470 case SNDRV_PCM_TRIGGER_RESUME: 471 if (rpmsg->force_lpa) 472 break; 473 fallthrough; 474 case SNDRV_PCM_TRIGGER_PAUSE_RELEASE: 475 ret = imx_rpmsg_restart(component, substream); 476 break; 477 case SNDRV_PCM_TRIGGER_SUSPEND: 478 if (!rpmsg->force_lpa) { 479 if (runtime->info & SNDRV_PCM_INFO_PAUSE) 480 ret = imx_rpmsg_pause(component, substream); 481 else 482 ret = imx_rpmsg_terminate_all(component, substream); 483 } 484 break; 485 case SNDRV_PCM_TRIGGER_PAUSE_PUSH: 486 ret = imx_rpmsg_pause(component, substream); 487 break; 488 case SNDRV_PCM_TRIGGER_STOP: 489 ret = imx_rpmsg_terminate_all(component, substream); 490 break; 491 default: 492 return -EINVAL; 493 } 494 495 if (ret) 496 return ret; 497 498 return 0; 499 } 500 501 /* 502 * imx_rpmsg_pcm_ack 503 * 504 * Send the period index to M core through rpmsg, but not send 505 * all the period index to M core, reduce some unnessesary msg 506 * to reduce the pressure of rpmsg bandwidth. 507 */ 508 static int imx_rpmsg_pcm_ack(struct snd_soc_component *component, 509 struct snd_pcm_substream *substream) 510 { 511 struct snd_pcm_runtime *runtime = substream->runtime; 512 struct snd_soc_pcm_runtime *rtd = substream->private_data; 513 struct snd_soc_dai *cpu_dai = asoc_rtd_to_cpu(rtd, 0); 514 struct fsl_rpmsg *rpmsg = dev_get_drvdata(cpu_dai->dev); 515 struct rpmsg_info *info = dev_get_drvdata(component->dev); 516 snd_pcm_uframes_t period_size = runtime->period_size; 517 snd_pcm_sframes_t avail; 518 struct timer_list *timer; 519 struct rpmsg_msg *msg; 520 unsigned long flags; 521 int buffer_tail = 0; 522 int written_num; 523 524 if (!rpmsg->force_lpa) 525 return 0; 526 527 if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) { 528 msg = &info->msg[TX_PERIOD_DONE + MSG_TYPE_A_NUM]; 529 msg->s_msg.header.cmd = TX_PERIOD_DONE; 530 } else { 531 msg = &info->msg[RX_PERIOD_DONE + MSG_TYPE_A_NUM]; 532 msg->s_msg.header.cmd = RX_PERIOD_DONE; 533 } 534 535 msg->s_msg.header.type = MSG_TYPE_C; 536 537 buffer_tail = (frames_to_bytes(runtime, runtime->control->appl_ptr) % 538 snd_pcm_lib_buffer_bytes(substream)); 539 buffer_tail = buffer_tail / snd_pcm_lib_period_bytes(substream); 540 541 /* There is update for period index */ 542 if (buffer_tail != msg->s_msg.param.buffer_tail) { 543 written_num = buffer_tail - msg->s_msg.param.buffer_tail; 544 if (written_num < 0) 545 written_num += runtime->periods; 546 547 msg->s_msg.param.buffer_tail = buffer_tail; 548 549 /* The notification message is updated to latest */ 550 spin_lock_irqsave(&info->lock[substream->stream], flags); 551 memcpy(&info->notify[substream->stream], msg, 552 sizeof(struct rpmsg_s_msg)); 553 info->notify_updated[substream->stream] = true; 554 spin_unlock_irqrestore(&info->lock[substream->stream], flags); 555 556 if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) 557 avail = snd_pcm_playback_hw_avail(runtime); 558 else 559 avail = snd_pcm_capture_hw_avail(runtime); 560 561 timer = &info->stream_timer[substream->stream].timer; 562 /* 563 * If the data in the buffer is less than one period before 564 * this fill, which means the data may not enough on M 565 * core side, we need to send message immediately to let 566 * M core know the pointer is updated. 567 * if there is more than one period data in the buffer before 568 * this fill, which means the data is enough on M core side, 569 * we can delay one period (using timer) to send the message 570 * for reduce the message number in workqueue, because the 571 * pointer may be updated by ack function later, we can 572 * send latest pointer to M core side. 573 */ 574 if ((avail - written_num * period_size) <= period_size) { 575 imx_rpmsg_insert_workqueue(substream, msg, info); 576 } else if (rpmsg->force_lpa && !timer_pending(timer)) { 577 int time_msec; 578 579 time_msec = (int)(runtime->period_size * 1000 / runtime->rate); 580 mod_timer(timer, jiffies + msecs_to_jiffies(time_msec)); 581 } 582 } 583 584 return 0; 585 } 586 587 static int imx_rpmsg_pcm_new(struct snd_soc_component *component, 588 struct snd_soc_pcm_runtime *rtd) 589 { 590 struct snd_card *card = rtd->card->snd_card; 591 struct snd_pcm *pcm = rtd->pcm; 592 struct snd_soc_dai *cpu_dai = asoc_rtd_to_cpu(rtd, 0); 593 struct fsl_rpmsg *rpmsg = dev_get_drvdata(cpu_dai->dev); 594 int ret; 595 596 ret = dma_coerce_mask_and_coherent(card->dev, DMA_BIT_MASK(32)); 597 if (ret) 598 return ret; 599 600 imx_rpmsg_pcm_hardware.buffer_bytes_max = rpmsg->buffer_size; 601 return snd_pcm_set_fixed_buffer_all(pcm, SNDRV_DMA_TYPE_DEV_WC, 602 pcm->card->dev, rpmsg->buffer_size); 603 } 604 605 static const struct snd_soc_component_driver imx_rpmsg_soc_component = { 606 .name = IMX_PCM_DRV_NAME, 607 .pcm_construct = imx_rpmsg_pcm_new, 608 .open = imx_rpmsg_pcm_open, 609 .close = imx_rpmsg_pcm_close, 610 .hw_params = imx_rpmsg_pcm_hw_params, 611 .trigger = imx_rpmsg_pcm_trigger, 612 .pointer = imx_rpmsg_pcm_pointer, 613 .ack = imx_rpmsg_pcm_ack, 614 .prepare = imx_rpmsg_pcm_prepare, 615 }; 616 617 static void imx_rpmsg_pcm_work(struct work_struct *work) 618 { 619 struct work_of_rpmsg *work_of_rpmsg; 620 bool is_notification = false; 621 struct rpmsg_info *info; 622 struct rpmsg_msg msg; 623 unsigned long flags; 624 625 work_of_rpmsg = container_of(work, struct work_of_rpmsg, work); 626 info = work_of_rpmsg->info; 627 628 /* 629 * Every work in the work queue, first we check if there 630 * is update for period is filled, because there may be not 631 * enough data in M core side, need to let M core know 632 * data is updated immediately. 633 */ 634 spin_lock_irqsave(&info->lock[TX], flags); 635 if (info->notify_updated[TX]) { 636 memcpy(&msg, &info->notify[TX], sizeof(struct rpmsg_s_msg)); 637 info->notify_updated[TX] = false; 638 spin_unlock_irqrestore(&info->lock[TX], flags); 639 info->send_message(&msg, info); 640 } else { 641 spin_unlock_irqrestore(&info->lock[TX], flags); 642 } 643 644 spin_lock_irqsave(&info->lock[RX], flags); 645 if (info->notify_updated[RX]) { 646 memcpy(&msg, &info->notify[RX], sizeof(struct rpmsg_s_msg)); 647 info->notify_updated[RX] = false; 648 spin_unlock_irqrestore(&info->lock[RX], flags); 649 info->send_message(&msg, info); 650 } else { 651 spin_unlock_irqrestore(&info->lock[RX], flags); 652 } 653 654 /* Skip the notification message for it has been processed above */ 655 if (work_of_rpmsg->msg.s_msg.header.type == MSG_TYPE_C && 656 (work_of_rpmsg->msg.s_msg.header.cmd == TX_PERIOD_DONE || 657 work_of_rpmsg->msg.s_msg.header.cmd == RX_PERIOD_DONE)) 658 is_notification = true; 659 660 if (!is_notification) 661 info->send_message(&work_of_rpmsg->msg, info); 662 663 /* update read index */ 664 spin_lock_irqsave(&info->wq_lock, flags); 665 info->work_read_index++; 666 info->work_read_index %= WORK_MAX_NUM; 667 spin_unlock_irqrestore(&info->wq_lock, flags); 668 } 669 670 static int imx_rpmsg_pcm_probe(struct platform_device *pdev) 671 { 672 struct snd_soc_component *component; 673 struct rpmsg_info *info; 674 int ret, i; 675 676 info = devm_kzalloc(&pdev->dev, sizeof(*info), GFP_KERNEL); 677 if (!info) 678 return -ENOMEM; 679 680 platform_set_drvdata(pdev, info); 681 682 info->rpdev = container_of(pdev->dev.parent, struct rpmsg_device, dev); 683 info->dev = &pdev->dev; 684 /* Setup work queue */ 685 info->rpmsg_wq = alloc_ordered_workqueue(info->rpdev->id.name, 686 WQ_HIGHPRI | 687 WQ_UNBOUND | 688 WQ_FREEZABLE); 689 if (!info->rpmsg_wq) { 690 dev_err(&pdev->dev, "workqueue create failed\n"); 691 return -ENOMEM; 692 } 693 694 /* Write index initialize 1, make it differ with the read index */ 695 info->work_write_index = 1; 696 info->send_message = imx_rpmsg_pcm_send_message; 697 698 for (i = 0; i < WORK_MAX_NUM; i++) { 699 INIT_WORK(&info->work_list[i].work, imx_rpmsg_pcm_work); 700 info->work_list[i].info = info; 701 } 702 703 /* Initialize msg */ 704 for (i = 0; i < MSG_MAX_NUM; i++) { 705 info->msg[i].s_msg.header.cate = IMX_RPMSG_AUDIO; 706 info->msg[i].s_msg.header.major = IMX_RMPSG_MAJOR; 707 info->msg[i].s_msg.header.minor = IMX_RMPSG_MINOR; 708 info->msg[i].s_msg.header.type = MSG_TYPE_A; 709 info->msg[i].s_msg.param.audioindex = 0; 710 } 711 712 init_completion(&info->cmd_complete); 713 mutex_init(&info->msg_lock); 714 spin_lock_init(&info->lock[TX]); 715 spin_lock_init(&info->lock[RX]); 716 spin_lock_init(&info->wq_lock); 717 718 ret = devm_snd_soc_register_component(&pdev->dev, 719 &imx_rpmsg_soc_component, 720 NULL, 0); 721 if (ret) 722 goto fail; 723 724 component = snd_soc_lookup_component(&pdev->dev, NULL); 725 if (!component) { 726 ret = -EINVAL; 727 goto fail; 728 } 729 730 /* platform component name is used by machine driver to link with */ 731 component->name = info->rpdev->id.name; 732 733 #ifdef CONFIG_DEBUG_FS 734 component->debugfs_prefix = "rpmsg"; 735 #endif 736 737 return 0; 738 739 fail: 740 if (info->rpmsg_wq) 741 destroy_workqueue(info->rpmsg_wq); 742 743 return ret; 744 } 745 746 static void imx_rpmsg_pcm_remove(struct platform_device *pdev) 747 { 748 struct rpmsg_info *info = platform_get_drvdata(pdev); 749 750 if (info->rpmsg_wq) 751 destroy_workqueue(info->rpmsg_wq); 752 } 753 754 #ifdef CONFIG_PM 755 static int imx_rpmsg_pcm_runtime_resume(struct device *dev) 756 { 757 struct rpmsg_info *info = dev_get_drvdata(dev); 758 759 cpu_latency_qos_add_request(&info->pm_qos_req, 0); 760 761 return 0; 762 } 763 764 static int imx_rpmsg_pcm_runtime_suspend(struct device *dev) 765 { 766 struct rpmsg_info *info = dev_get_drvdata(dev); 767 768 cpu_latency_qos_remove_request(&info->pm_qos_req); 769 770 return 0; 771 } 772 #endif 773 774 #ifdef CONFIG_PM_SLEEP 775 static int imx_rpmsg_pcm_suspend(struct device *dev) 776 { 777 struct rpmsg_info *info = dev_get_drvdata(dev); 778 struct rpmsg_msg *rpmsg_tx; 779 struct rpmsg_msg *rpmsg_rx; 780 781 rpmsg_tx = &info->msg[TX_SUSPEND]; 782 rpmsg_rx = &info->msg[RX_SUSPEND]; 783 784 rpmsg_tx->s_msg.header.cmd = TX_SUSPEND; 785 info->send_message(rpmsg_tx, info); 786 787 rpmsg_rx->s_msg.header.cmd = RX_SUSPEND; 788 info->send_message(rpmsg_rx, info); 789 790 return 0; 791 } 792 793 static int imx_rpmsg_pcm_resume(struct device *dev) 794 { 795 struct rpmsg_info *info = dev_get_drvdata(dev); 796 struct rpmsg_msg *rpmsg_tx; 797 struct rpmsg_msg *rpmsg_rx; 798 799 rpmsg_tx = &info->msg[TX_RESUME]; 800 rpmsg_rx = &info->msg[RX_RESUME]; 801 802 rpmsg_tx->s_msg.header.cmd = TX_RESUME; 803 info->send_message(rpmsg_tx, info); 804 805 rpmsg_rx->s_msg.header.cmd = RX_RESUME; 806 info->send_message(rpmsg_rx, info); 807 808 return 0; 809 } 810 #endif /* CONFIG_PM_SLEEP */ 811 812 static const struct dev_pm_ops imx_rpmsg_pcm_pm_ops = { 813 SET_RUNTIME_PM_OPS(imx_rpmsg_pcm_runtime_suspend, 814 imx_rpmsg_pcm_runtime_resume, 815 NULL) 816 SET_SYSTEM_SLEEP_PM_OPS(imx_rpmsg_pcm_suspend, 817 imx_rpmsg_pcm_resume) 818 }; 819 820 static struct platform_driver imx_pcm_rpmsg_driver = { 821 .probe = imx_rpmsg_pcm_probe, 822 .remove_new = imx_rpmsg_pcm_remove, 823 .driver = { 824 .name = IMX_PCM_DRV_NAME, 825 .pm = &imx_rpmsg_pcm_pm_ops, 826 }, 827 }; 828 module_platform_driver(imx_pcm_rpmsg_driver); 829 830 MODULE_DESCRIPTION("Freescale SoC Audio RPMSG PCM interface"); 831 MODULE_AUTHOR("Shengjiu Wang <shengjiu.wang@nxp.com>"); 832 MODULE_ALIAS("platform:" IMX_PCM_DRV_NAME); 833 MODULE_LICENSE("GPL v2"); 834