1 // SPDX-License-Identifier: GPL-2.0 2 // Copyright (c) 2011-2017, The Linux Foundation. All rights reserved. 3 // Copyright (c) 2018, Linaro Limited 4 5 #include <linux/device.h> 6 #include <linux/jiffies.h> 7 #include <linux/kernel.h> 8 #include <linux/kref.h> 9 #include <linux/module.h> 10 #include <linux/of.h> 11 #include <linux/of_platform.h> 12 #include <linux/platform_device.h> 13 #include <linux/sched.h> 14 #include <linux/slab.h> 15 #include <linux/soc/qcom/apr.h> 16 #include <linux/wait.h> 17 #include <sound/asound.h> 18 #include "q6adm.h" 19 #include "q6afe.h" 20 #include "q6core.h" 21 #include "q6dsp-common.h" 22 #include "q6dsp-errno.h" 23 24 #define ADM_CMD_DEVICE_OPEN_V5 0x00010326 25 #define ADM_CMDRSP_DEVICE_OPEN_V5 0x00010329 26 #define ADM_CMD_DEVICE_CLOSE_V5 0x00010327 27 #define ADM_CMD_MATRIX_MAP_ROUTINGS_V5 0x00010325 28 29 #define TIMEOUT_MS 1000 30 #define RESET_COPP_ID 99 31 #define INVALID_COPP_ID 0xFF 32 /* Definition for a legacy device session. */ 33 #define ADM_LEGACY_DEVICE_SESSION 0 34 #define ADM_MATRIX_ID_AUDIO_RX 0 35 #define ADM_MATRIX_ID_AUDIO_TX 1 36 37 struct q6copp { 38 int afe_port; 39 int copp_idx; 40 int id; 41 int topology; 42 int mode; 43 int rate; 44 int bit_width; 45 int channels; 46 int app_type; 47 int acdb_id; 48 49 struct aprv2_ibasic_rsp_result_t result; 50 struct kref refcount; 51 wait_queue_head_t wait; 52 struct list_head node; 53 struct q6adm *adm; 54 }; 55 56 struct q6adm { 57 struct apr_device *apr; 58 struct device *dev; 59 struct q6core_svc_api_info ainfo; 60 unsigned long copp_bitmap[AFE_MAX_PORTS]; 61 struct list_head copps_list; 62 spinlock_t copps_list_lock; 63 struct aprv2_ibasic_rsp_result_t result; 64 struct mutex lock; 65 wait_queue_head_t matrix_map_wait; 66 }; 67 68 struct q6adm_cmd_device_open_v5 { 69 u16 flags; 70 u16 mode_of_operation; 71 u16 endpoint_id_1; 72 u16 endpoint_id_2; 73 u32 topology_id; 74 u16 dev_num_channel; 75 u16 bit_width; 76 u32 sample_rate; 77 u8 dev_channel_mapping[8]; 78 } __packed; 79 80 struct q6adm_cmd_matrix_map_routings_v5 { 81 u32 matrix_id; 82 u32 num_sessions; 83 } __packed; 84 85 struct q6adm_session_map_node_v5 { 86 u16 session_id; 87 u16 num_copps; 88 } __packed; 89 90 static struct q6copp *q6adm_find_copp(struct q6adm *adm, int port_idx, 91 int copp_idx) 92 { 93 struct q6copp *c = NULL; 94 struct q6copp *ret = NULL; 95 unsigned long flags; 96 97 spin_lock_irqsave(&adm->copps_list_lock, flags); 98 list_for_each_entry(c, &adm->copps_list, node) { 99 if ((port_idx == c->afe_port) && (copp_idx == c->copp_idx)) { 100 ret = c; 101 kref_get(&c->refcount); 102 break; 103 } 104 } 105 106 spin_unlock_irqrestore(&adm->copps_list_lock, flags); 107 108 return ret; 109 110 } 111 112 static void q6adm_free_copp(struct kref *ref) 113 { 114 struct q6copp *c = container_of(ref, struct q6copp, refcount); 115 struct q6adm *adm = c->adm; 116 unsigned long flags; 117 118 spin_lock_irqsave(&adm->copps_list_lock, flags); 119 clear_bit(c->copp_idx, &adm->copp_bitmap[c->afe_port]); 120 list_del(&c->node); 121 spin_unlock_irqrestore(&adm->copps_list_lock, flags); 122 kfree(c); 123 } 124 125 static int q6adm_callback(struct apr_device *adev, struct apr_resp_pkt *data) 126 { 127 struct aprv2_ibasic_rsp_result_t *result = data->payload; 128 int port_idx, copp_idx; 129 struct apr_hdr *hdr = &data->hdr; 130 struct q6copp *copp; 131 struct q6adm *adm = dev_get_drvdata(&adev->dev); 132 133 if (!data->payload_size) 134 return 0; 135 136 copp_idx = (hdr->token) & 0XFF; 137 port_idx = ((hdr->token) >> 16) & 0xFF; 138 if (port_idx < 0 || port_idx >= AFE_MAX_PORTS) { 139 dev_err(&adev->dev, "Invalid port idx %d token %d\n", 140 port_idx, hdr->token); 141 return 0; 142 } 143 if (copp_idx < 0 || copp_idx >= MAX_COPPS_PER_PORT) { 144 dev_err(&adev->dev, "Invalid copp idx %d token %d\n", 145 copp_idx, hdr->token); 146 return 0; 147 } 148 149 switch (hdr->opcode) { 150 case APR_BASIC_RSP_RESULT: { 151 if (result->status != 0) { 152 dev_err(&adev->dev, "cmd = 0x%x return error = 0x%x\n", 153 result->opcode, result->status); 154 } 155 switch (result->opcode) { 156 case ADM_CMD_DEVICE_OPEN_V5: 157 case ADM_CMD_DEVICE_CLOSE_V5: 158 copp = q6adm_find_copp(adm, port_idx, copp_idx); 159 if (!copp) 160 return 0; 161 162 copp->result = *result; 163 wake_up(&copp->wait); 164 kref_put(&copp->refcount, q6adm_free_copp); 165 break; 166 case ADM_CMD_MATRIX_MAP_ROUTINGS_V5: 167 adm->result = *result; 168 wake_up(&adm->matrix_map_wait); 169 break; 170 171 default: 172 dev_err(&adev->dev, "Unknown Cmd: 0x%x\n", 173 result->opcode); 174 break; 175 } 176 return 0; 177 } 178 case ADM_CMDRSP_DEVICE_OPEN_V5: { 179 struct adm_cmd_rsp_device_open_v5 { 180 u32 status; 181 u16 copp_id; 182 u16 reserved; 183 } __packed * open = data->payload; 184 185 copp = q6adm_find_copp(adm, port_idx, copp_idx); 186 if (!copp) 187 return 0; 188 189 if (open->copp_id == INVALID_COPP_ID) { 190 dev_err(&adev->dev, "Invalid coppid rxed %d\n", 191 open->copp_id); 192 copp->result.status = ADSP_EBADPARAM; 193 wake_up(&copp->wait); 194 kref_put(&copp->refcount, q6adm_free_copp); 195 break; 196 } 197 copp->result.opcode = hdr->opcode; 198 copp->id = open->copp_id; 199 wake_up(&copp->wait); 200 kref_put(&copp->refcount, q6adm_free_copp); 201 } 202 break; 203 default: 204 dev_err(&adev->dev, "Unknown cmd:0x%x\n", 205 hdr->opcode); 206 break; 207 } 208 209 return 0; 210 } 211 212 static struct q6copp *q6adm_alloc_copp(struct q6adm *adm, int port_idx) 213 { 214 struct q6copp *c; 215 int idx; 216 217 idx = find_first_zero_bit(&adm->copp_bitmap[port_idx], 218 MAX_COPPS_PER_PORT); 219 220 if (idx > MAX_COPPS_PER_PORT) 221 return ERR_PTR(-EBUSY); 222 223 c = kzalloc(sizeof(*c), GFP_ATOMIC); 224 if (!c) 225 return ERR_PTR(-ENOMEM); 226 227 set_bit(idx, &adm->copp_bitmap[port_idx]); 228 c->copp_idx = idx; 229 c->afe_port = port_idx; 230 c->adm = adm; 231 232 init_waitqueue_head(&c->wait); 233 234 return c; 235 } 236 237 static int q6adm_apr_send_copp_pkt(struct q6adm *adm, struct q6copp *copp, 238 struct apr_pkt *pkt, uint32_t rsp_opcode) 239 { 240 struct device *dev = adm->dev; 241 uint32_t opcode = pkt->hdr.opcode; 242 int ret; 243 244 mutex_lock(&adm->lock); 245 copp->result.opcode = 0; 246 copp->result.status = 0; 247 ret = apr_send_pkt(adm->apr, pkt); 248 if (ret < 0) { 249 dev_err(dev, "Failed to send APR packet\n"); 250 ret = -EINVAL; 251 goto err; 252 } 253 254 /* Wait for the callback with copp id */ 255 if (rsp_opcode) 256 ret = wait_event_timeout(copp->wait, 257 (copp->result.opcode == opcode) || 258 (copp->result.opcode == rsp_opcode), 259 msecs_to_jiffies(TIMEOUT_MS)); 260 else 261 ret = wait_event_timeout(copp->wait, 262 (copp->result.opcode == opcode), 263 msecs_to_jiffies(TIMEOUT_MS)); 264 265 if (!ret) { 266 dev_err(dev, "ADM copp cmd timedout\n"); 267 ret = -ETIMEDOUT; 268 } else if (copp->result.status > 0) { 269 dev_err(dev, "DSP returned error[%d]\n", 270 copp->result.status); 271 ret = -EINVAL; 272 } 273 274 err: 275 mutex_unlock(&adm->lock); 276 return ret; 277 } 278 279 static int q6adm_device_close(struct q6adm *adm, struct q6copp *copp, 280 int port_id, int copp_idx) 281 { 282 struct apr_pkt close; 283 284 close.hdr.hdr_field = APR_HDR_FIELD(APR_MSG_TYPE_SEQ_CMD, 285 APR_HDR_LEN(APR_HDR_SIZE), 286 APR_PKT_VER); 287 close.hdr.pkt_size = sizeof(close); 288 close.hdr.src_port = port_id; 289 close.hdr.dest_port = copp->id; 290 close.hdr.token = port_id << 16 | copp_idx; 291 close.hdr.opcode = ADM_CMD_DEVICE_CLOSE_V5; 292 293 return q6adm_apr_send_copp_pkt(adm, copp, &close, 0); 294 } 295 296 static struct q6copp *q6adm_find_matching_copp(struct q6adm *adm, 297 int port_id, int topology, 298 int mode, int rate, 299 int channel_mode, int bit_width, 300 int app_type) 301 { 302 struct q6copp *c = NULL; 303 struct q6copp *ret = NULL; 304 unsigned long flags; 305 306 spin_lock_irqsave(&adm->copps_list_lock, flags); 307 308 list_for_each_entry(c, &adm->copps_list, node) { 309 if ((port_id == c->afe_port) && (topology == c->topology) && 310 (mode == c->mode) && (rate == c->rate) && 311 (bit_width == c->bit_width) && (app_type == c->app_type)) { 312 ret = c; 313 kref_get(&c->refcount); 314 } 315 } 316 spin_unlock_irqrestore(&adm->copps_list_lock, flags); 317 318 return ret; 319 } 320 321 static int q6adm_device_open(struct q6adm *adm, struct q6copp *copp, 322 int port_id, int path, int topology, 323 int channel_mode, int bit_width, int rate) 324 { 325 struct q6adm_cmd_device_open_v5 *open; 326 int afe_port = q6afe_get_port_id(port_id); 327 struct apr_pkt *pkt; 328 void *p; 329 int ret, pkt_size; 330 331 pkt_size = APR_HDR_SIZE + sizeof(*open); 332 p = kzalloc(pkt_size, GFP_KERNEL); 333 if (!p) 334 return -ENOMEM; 335 336 pkt = p; 337 open = p + APR_HDR_SIZE; 338 pkt->hdr.hdr_field = APR_HDR_FIELD(APR_MSG_TYPE_SEQ_CMD, 339 APR_HDR_LEN(APR_HDR_SIZE), 340 APR_PKT_VER); 341 pkt->hdr.pkt_size = pkt_size; 342 pkt->hdr.src_port = afe_port; 343 pkt->hdr.dest_port = afe_port; 344 pkt->hdr.token = port_id << 16 | copp->copp_idx; 345 pkt->hdr.opcode = ADM_CMD_DEVICE_OPEN_V5; 346 open->flags = ADM_LEGACY_DEVICE_SESSION; 347 open->mode_of_operation = path; 348 open->endpoint_id_1 = afe_port; 349 open->topology_id = topology; 350 open->dev_num_channel = channel_mode & 0x00FF; 351 open->bit_width = bit_width; 352 open->sample_rate = rate; 353 354 ret = q6dsp_map_channels(&open->dev_channel_mapping[0], 355 channel_mode); 356 if (ret) 357 goto err; 358 359 ret = q6adm_apr_send_copp_pkt(adm, copp, pkt, 360 ADM_CMDRSP_DEVICE_OPEN_V5); 361 362 err: 363 kfree(pkt); 364 return ret; 365 } 366 367 /** 368 * q6adm_open() - open adm and grab a free copp 369 * 370 * @dev: Pointer to adm child device. 371 * @port_id: port id 372 * @path: playback or capture path. 373 * @rate: rate at which copp is required. 374 * @channel_mode: channel mode 375 * @topology: adm topology id 376 * @perf_mode: performace mode. 377 * @bit_width: audio sample bit width 378 * @app_type: Application type. 379 * @acdb_id: ACDB id 380 * 381 * Return: Will be an negative on error or a valid copp pointer on success. 382 */ 383 struct q6copp *q6adm_open(struct device *dev, int port_id, int path, int rate, 384 int channel_mode, int topology, int perf_mode, 385 uint16_t bit_width, int app_type, int acdb_id) 386 { 387 struct q6adm *adm = dev_get_drvdata(dev->parent); 388 struct q6copp *copp; 389 unsigned long flags; 390 int ret = 0; 391 392 if (port_id < 0) { 393 dev_err(dev, "Invalid port_id 0x%x\n", port_id); 394 return ERR_PTR(-EINVAL); 395 } 396 397 copp = q6adm_find_matching_copp(adm, port_id, topology, perf_mode, 398 rate, channel_mode, bit_width, app_type); 399 if (copp) { 400 dev_err(dev, "Found Matching Copp 0x%x\n", copp->copp_idx); 401 return copp; 402 } 403 404 spin_lock_irqsave(&adm->copps_list_lock, flags); 405 copp = q6adm_alloc_copp(adm, port_id); 406 if (IS_ERR(copp)) { 407 spin_unlock_irqrestore(&adm->copps_list_lock, flags); 408 return ERR_CAST(copp); 409 } 410 411 list_add_tail(&copp->node, &adm->copps_list); 412 spin_unlock_irqrestore(&adm->copps_list_lock, flags); 413 414 kref_init(&copp->refcount); 415 copp->topology = topology; 416 copp->mode = perf_mode; 417 copp->rate = rate; 418 copp->channels = channel_mode; 419 copp->bit_width = bit_width; 420 copp->app_type = app_type; 421 422 ret = q6adm_device_open(adm, copp, port_id, path, topology, 423 channel_mode, bit_width, rate); 424 if (ret < 0) { 425 kref_put(&copp->refcount, q6adm_free_copp); 426 return ERR_PTR(ret); 427 } 428 429 return copp; 430 } 431 EXPORT_SYMBOL_GPL(q6adm_open); 432 433 /** 434 * q6adm_get_copp_id() - get copp index 435 * 436 * @copp: Pointer to valid copp 437 * 438 * Return: Will be an negative on error or a valid copp index on success. 439 **/ 440 int q6adm_get_copp_id(struct q6copp *copp) 441 { 442 if (!copp) 443 return -EINVAL; 444 445 return copp->copp_idx; 446 } 447 EXPORT_SYMBOL_GPL(q6adm_get_copp_id); 448 449 /** 450 * q6adm_matrix_map() - Map asm streams and afe ports using payload 451 * 452 * @dev: Pointer to adm child device. 453 * @path: playback or capture path. 454 * @payload_map: map between session id and afe ports. 455 * @perf_mode: Performace mode. 456 * 457 * Return: Will be an negative on error or a zero on success. 458 */ 459 int q6adm_matrix_map(struct device *dev, int path, 460 struct route_payload payload_map, int perf_mode) 461 { 462 struct q6adm *adm = dev_get_drvdata(dev->parent); 463 struct q6adm_cmd_matrix_map_routings_v5 *route; 464 struct q6adm_session_map_node_v5 *node; 465 struct apr_pkt *pkt; 466 uint16_t *copps_list; 467 int pkt_size, ret, i, copp_idx; 468 void *matrix_map; 469 struct q6copp *copp; 470 471 /* Assumes port_ids have already been validated during adm_open */ 472 pkt_size = (APR_HDR_SIZE + sizeof(*route) + sizeof(*node) + 473 (sizeof(uint32_t) * payload_map.num_copps)); 474 475 matrix_map = kzalloc(pkt_size, GFP_KERNEL); 476 if (!matrix_map) 477 return -ENOMEM; 478 479 pkt = matrix_map; 480 route = matrix_map + APR_HDR_SIZE; 481 node = matrix_map + APR_HDR_SIZE + sizeof(*route); 482 copps_list = matrix_map + APR_HDR_SIZE + sizeof(*route) + sizeof(*node); 483 484 pkt->hdr.hdr_field = APR_HDR_FIELD(APR_MSG_TYPE_SEQ_CMD, 485 APR_HDR_LEN(APR_HDR_SIZE), 486 APR_PKT_VER); 487 pkt->hdr.pkt_size = pkt_size; 488 pkt->hdr.token = 0; 489 pkt->hdr.opcode = ADM_CMD_MATRIX_MAP_ROUTINGS_V5; 490 route->num_sessions = 1; 491 492 switch (path) { 493 case ADM_PATH_PLAYBACK: 494 route->matrix_id = ADM_MATRIX_ID_AUDIO_RX; 495 break; 496 case ADM_PATH_LIVE_REC: 497 route->matrix_id = ADM_MATRIX_ID_AUDIO_TX; 498 break; 499 default: 500 dev_err(dev, "Wrong path set[%d]\n", path); 501 break; 502 } 503 504 node->session_id = payload_map.session_id; 505 node->num_copps = payload_map.num_copps; 506 507 for (i = 0; i < payload_map.num_copps; i++) { 508 int port_idx = payload_map.port_id[i]; 509 510 if (port_idx < 0) { 511 dev_err(dev, "Invalid port_id 0x%x\n", 512 payload_map.port_id[i]); 513 kfree(pkt); 514 return -EINVAL; 515 } 516 copp_idx = payload_map.copp_idx[i]; 517 518 copp = q6adm_find_copp(adm, port_idx, copp_idx); 519 if (!copp) { 520 kfree(pkt); 521 return -EINVAL; 522 } 523 524 copps_list[i] = copp->id; 525 kref_put(&copp->refcount, q6adm_free_copp); 526 } 527 528 mutex_lock(&adm->lock); 529 adm->result.status = 0; 530 adm->result.opcode = 0; 531 532 ret = apr_send_pkt(adm->apr, pkt); 533 if (ret < 0) { 534 dev_err(dev, "routing for stream %d failed ret %d\n", 535 payload_map.session_id, ret); 536 goto fail_cmd; 537 } 538 ret = wait_event_timeout(adm->matrix_map_wait, 539 adm->result.opcode == pkt->hdr.opcode, 540 msecs_to_jiffies(TIMEOUT_MS)); 541 if (!ret) { 542 dev_err(dev, "routing for stream %d failed\n", 543 payload_map.session_id); 544 ret = -ETIMEDOUT; 545 goto fail_cmd; 546 } else if (adm->result.status > 0) { 547 dev_err(dev, "DSP returned error[%d]\n", 548 adm->result.status); 549 ret = -EINVAL; 550 goto fail_cmd; 551 } 552 553 fail_cmd: 554 mutex_unlock(&adm->lock); 555 kfree(pkt); 556 return ret; 557 } 558 EXPORT_SYMBOL_GPL(q6adm_matrix_map); 559 560 /** 561 * q6adm_close() - Close adm copp 562 * 563 * @dev: Pointer to adm child device. 564 * @copp: pointer to previously opened copp 565 * 566 * Return: Will be an negative on error or a zero on success. 567 */ 568 int q6adm_close(struct device *dev, struct q6copp *copp) 569 { 570 struct q6adm *adm = dev_get_drvdata(dev->parent); 571 int ret = 0; 572 573 ret = q6adm_device_close(adm, copp, copp->afe_port, copp->copp_idx); 574 if (ret < 0) { 575 dev_err(adm->dev, "Failed to close copp %d\n", ret); 576 return ret; 577 } 578 579 kref_put(&copp->refcount, q6adm_free_copp); 580 581 return 0; 582 } 583 EXPORT_SYMBOL_GPL(q6adm_close); 584 585 static int q6adm_probe(struct apr_device *adev) 586 { 587 struct device *dev = &adev->dev; 588 struct q6adm *adm; 589 590 adm = devm_kzalloc(dev, sizeof(*adm), GFP_KERNEL); 591 if (!adm) 592 return -ENOMEM; 593 594 adm->apr = adev; 595 dev_set_drvdata(dev, adm); 596 adm->dev = dev; 597 q6core_get_svc_api_info(adev->svc_id, &adm->ainfo); 598 mutex_init(&adm->lock); 599 init_waitqueue_head(&adm->matrix_map_wait); 600 601 INIT_LIST_HEAD(&adm->copps_list); 602 spin_lock_init(&adm->copps_list_lock); 603 604 return devm_of_platform_populate(dev); 605 } 606 607 #ifdef CONFIG_OF 608 static const struct of_device_id q6adm_device_id[] = { 609 { .compatible = "qcom,q6adm" }, 610 {}, 611 }; 612 MODULE_DEVICE_TABLE(of, q6adm_device_id); 613 #endif 614 615 static struct apr_driver qcom_q6adm_driver = { 616 .probe = q6adm_probe, 617 .callback = q6adm_callback, 618 .driver = { 619 .name = "qcom-q6adm", 620 .of_match_table = of_match_ptr(q6adm_device_id), 621 }, 622 }; 623 624 module_apr_driver(qcom_q6adm_driver); 625 MODULE_DESCRIPTION("Q6 Audio Device Manager"); 626 MODULE_LICENSE("GPL v2"); 627