1 // SPDX-License-Identifier: GPL-2.0-only 2 /* 3 * Copyright (c) 2012-2016, The Linux Foundation. All rights reserved. 4 * Copyright (C) 2017 Linaro Ltd. 5 */ 6 #include <linux/slab.h> 7 #include <linux/mutex.h> 8 #include <linux/list.h> 9 #include <linux/completion.h> 10 #include <linux/platform_device.h> 11 #include <linux/videodev2.h> 12 13 #include "core.h" 14 #include "hfi.h" 15 #include "hfi_cmds.h" 16 #include "hfi_venus.h" 17 18 #define TIMEOUT msecs_to_jiffies(1000) 19 20 static u32 to_codec_type(u32 pixfmt) 21 { 22 switch (pixfmt) { 23 case V4L2_PIX_FMT_H264: 24 case V4L2_PIX_FMT_H264_NO_SC: 25 return HFI_VIDEO_CODEC_H264; 26 case V4L2_PIX_FMT_H263: 27 return HFI_VIDEO_CODEC_H263; 28 case V4L2_PIX_FMT_MPEG1: 29 return HFI_VIDEO_CODEC_MPEG1; 30 case V4L2_PIX_FMT_MPEG2: 31 return HFI_VIDEO_CODEC_MPEG2; 32 case V4L2_PIX_FMT_MPEG4: 33 return HFI_VIDEO_CODEC_MPEG4; 34 case V4L2_PIX_FMT_VC1_ANNEX_G: 35 case V4L2_PIX_FMT_VC1_ANNEX_L: 36 return HFI_VIDEO_CODEC_VC1; 37 case V4L2_PIX_FMT_VP8: 38 return HFI_VIDEO_CODEC_VP8; 39 case V4L2_PIX_FMT_VP9: 40 return HFI_VIDEO_CODEC_VP9; 41 case V4L2_PIX_FMT_XVID: 42 return HFI_VIDEO_CODEC_DIVX; 43 case V4L2_PIX_FMT_HEVC: 44 return HFI_VIDEO_CODEC_HEVC; 45 default: 46 return 0; 47 } 48 } 49 50 int hfi_core_init(struct venus_core *core) 51 { 52 int ret = 0; 53 54 mutex_lock(&core->lock); 55 56 if (core->state >= CORE_INIT) 57 goto unlock; 58 59 reinit_completion(&core->done); 60 61 ret = core->ops->core_init(core); 62 if (ret) 63 goto unlock; 64 65 ret = wait_for_completion_timeout(&core->done, TIMEOUT); 66 if (!ret) { 67 ret = -ETIMEDOUT; 68 goto unlock; 69 } 70 71 ret = 0; 72 73 if (core->error != HFI_ERR_NONE) { 74 ret = -EIO; 75 goto unlock; 76 } 77 78 core->state = CORE_INIT; 79 unlock: 80 mutex_unlock(&core->lock); 81 return ret; 82 } 83 84 int hfi_core_deinit(struct venus_core *core, bool blocking) 85 { 86 int ret = 0, empty; 87 88 mutex_lock(&core->lock); 89 90 if (core->state == CORE_UNINIT) 91 goto unlock; 92 93 empty = list_empty(&core->instances); 94 95 if (!empty && !blocking) { 96 ret = -EBUSY; 97 goto unlock; 98 } 99 100 if (!empty) { 101 mutex_unlock(&core->lock); 102 wait_var_event(&core->insts_count, 103 !atomic_read(&core->insts_count)); 104 mutex_lock(&core->lock); 105 } 106 107 if (!core->ops) 108 goto unlock; 109 110 ret = core->ops->core_deinit(core); 111 112 if (!ret) 113 core->state = CORE_UNINIT; 114 115 unlock: 116 mutex_unlock(&core->lock); 117 return ret; 118 } 119 120 int hfi_core_suspend(struct venus_core *core) 121 { 122 if (core->state != CORE_INIT) 123 return 0; 124 125 return core->ops->suspend(core); 126 } 127 128 int hfi_core_resume(struct venus_core *core, bool force) 129 { 130 if (!force && core->state != CORE_INIT) 131 return 0; 132 133 return core->ops->resume(core); 134 } 135 136 int hfi_core_trigger_ssr(struct venus_core *core, u32 type) 137 { 138 return core->ops->core_trigger_ssr(core, type); 139 } 140 141 int hfi_core_ping(struct venus_core *core) 142 { 143 int ret; 144 145 mutex_lock(&core->lock); 146 147 ret = core->ops->core_ping(core, 0xbeef); 148 if (ret) 149 goto unlock; 150 151 ret = wait_for_completion_timeout(&core->done, TIMEOUT); 152 if (!ret) { 153 ret = -ETIMEDOUT; 154 goto unlock; 155 } 156 ret = 0; 157 if (core->error != HFI_ERR_NONE) 158 ret = -ENODEV; 159 unlock: 160 mutex_unlock(&core->lock); 161 return ret; 162 } 163 164 static int wait_session_msg(struct venus_inst *inst) 165 { 166 int ret; 167 168 ret = wait_for_completion_timeout(&inst->done, TIMEOUT); 169 if (!ret) 170 return -ETIMEDOUT; 171 172 if (inst->error != HFI_ERR_NONE) 173 return -EIO; 174 175 return 0; 176 } 177 178 int hfi_session_create(struct venus_inst *inst, const struct hfi_inst_ops *ops) 179 { 180 struct venus_core *core = inst->core; 181 bool max; 182 int ret; 183 184 if (!ops) 185 return -EINVAL; 186 187 inst->state = INST_UNINIT; 188 init_completion(&inst->done); 189 inst->ops = ops; 190 191 mutex_lock(&core->lock); 192 193 if (test_bit(0, &inst->core->sys_error)) { 194 ret = -EIO; 195 goto unlock; 196 } 197 198 max = atomic_add_unless(&core->insts_count, 1, 199 core->max_sessions_supported); 200 if (!max) { 201 ret = -EAGAIN; 202 } else { 203 list_add_tail(&inst->list, &core->instances); 204 ret = 0; 205 } 206 207 unlock: 208 mutex_unlock(&core->lock); 209 210 return ret; 211 } 212 EXPORT_SYMBOL_GPL(hfi_session_create); 213 214 int hfi_session_init(struct venus_inst *inst, u32 pixfmt) 215 { 216 struct venus_core *core = inst->core; 217 const struct hfi_ops *ops = core->ops; 218 int ret; 219 220 /* 221 * If core shutdown is in progress or if we are in system 222 * recovery, return an error as during system error recovery 223 * session_init() can't pass successfully 224 */ 225 mutex_lock(&core->lock); 226 if (!core->ops || test_bit(0, &inst->core->sys_error)) { 227 mutex_unlock(&core->lock); 228 return -EIO; 229 } 230 mutex_unlock(&core->lock); 231 232 if (inst->state != INST_UNINIT) 233 return -EALREADY; 234 235 inst->hfi_codec = to_codec_type(pixfmt); 236 reinit_completion(&inst->done); 237 238 ret = ops->session_init(inst, inst->session_type, inst->hfi_codec); 239 if (ret) 240 return ret; 241 242 ret = wait_session_msg(inst); 243 if (ret) 244 return ret; 245 246 inst->state = INST_INIT; 247 248 return 0; 249 } 250 EXPORT_SYMBOL_GPL(hfi_session_init); 251 252 void hfi_session_destroy(struct venus_inst *inst) 253 { 254 struct venus_core *core = inst->core; 255 256 mutex_lock(&core->lock); 257 list_del_init(&inst->list); 258 if (atomic_dec_and_test(&core->insts_count)) 259 wake_up_var(&core->insts_count); 260 mutex_unlock(&core->lock); 261 } 262 EXPORT_SYMBOL_GPL(hfi_session_destroy); 263 264 int hfi_session_deinit(struct venus_inst *inst) 265 { 266 const struct hfi_ops *ops = inst->core->ops; 267 int ret; 268 269 if (inst->state == INST_UNINIT) 270 return 0; 271 272 if (inst->state < INST_INIT) 273 return -EINVAL; 274 275 if (test_bit(0, &inst->core->sys_error)) 276 goto done; 277 278 reinit_completion(&inst->done); 279 280 ret = ops->session_end(inst); 281 if (ret) 282 return ret; 283 284 ret = wait_session_msg(inst); 285 if (ret) 286 return ret; 287 288 done: 289 inst->state = INST_UNINIT; 290 291 return 0; 292 } 293 EXPORT_SYMBOL_GPL(hfi_session_deinit); 294 295 int hfi_session_start(struct venus_inst *inst) 296 { 297 const struct hfi_ops *ops = inst->core->ops; 298 int ret; 299 300 if (test_bit(0, &inst->core->sys_error)) 301 return -EIO; 302 303 if (inst->state != INST_LOAD_RESOURCES) 304 return -EINVAL; 305 306 reinit_completion(&inst->done); 307 308 ret = ops->session_start(inst); 309 if (ret) 310 return ret; 311 312 ret = wait_session_msg(inst); 313 if (ret) 314 return ret; 315 316 inst->state = INST_START; 317 318 return 0; 319 } 320 EXPORT_SYMBOL_GPL(hfi_session_start); 321 322 int hfi_session_stop(struct venus_inst *inst) 323 { 324 const struct hfi_ops *ops = inst->core->ops; 325 int ret; 326 327 if (test_bit(0, &inst->core->sys_error)) 328 return -EIO; 329 330 if (inst->state != INST_START) 331 return -EINVAL; 332 333 reinit_completion(&inst->done); 334 335 ret = ops->session_stop(inst); 336 if (ret) 337 return ret; 338 339 ret = wait_session_msg(inst); 340 if (ret) 341 return ret; 342 343 inst->state = INST_STOP; 344 345 return 0; 346 } 347 EXPORT_SYMBOL_GPL(hfi_session_stop); 348 349 int hfi_session_continue(struct venus_inst *inst) 350 { 351 struct venus_core *core = inst->core; 352 353 if (test_bit(0, &inst->core->sys_error)) 354 return -EIO; 355 356 if (core->res->hfi_version == HFI_VERSION_1XX) 357 return 0; 358 359 return core->ops->session_continue(inst); 360 } 361 EXPORT_SYMBOL_GPL(hfi_session_continue); 362 363 int hfi_session_abort(struct venus_inst *inst) 364 { 365 const struct hfi_ops *ops = inst->core->ops; 366 int ret; 367 368 if (test_bit(0, &inst->core->sys_error)) 369 return -EIO; 370 371 reinit_completion(&inst->done); 372 373 ret = ops->session_abort(inst); 374 if (ret) 375 return ret; 376 377 ret = wait_session_msg(inst); 378 if (ret) 379 return ret; 380 381 return 0; 382 } 383 EXPORT_SYMBOL_GPL(hfi_session_abort); 384 385 int hfi_session_load_res(struct venus_inst *inst) 386 { 387 const struct hfi_ops *ops = inst->core->ops; 388 int ret; 389 390 if (test_bit(0, &inst->core->sys_error)) 391 return -EIO; 392 393 if (inst->state != INST_INIT) 394 return -EINVAL; 395 396 reinit_completion(&inst->done); 397 398 ret = ops->session_load_res(inst); 399 if (ret) 400 return ret; 401 402 ret = wait_session_msg(inst); 403 if (ret) 404 return ret; 405 406 inst->state = INST_LOAD_RESOURCES; 407 408 return 0; 409 } 410 411 int hfi_session_unload_res(struct venus_inst *inst) 412 { 413 const struct hfi_ops *ops = inst->core->ops; 414 int ret; 415 416 if (test_bit(0, &inst->core->sys_error)) 417 return -EIO; 418 419 if (inst->state != INST_STOP) 420 return -EINVAL; 421 422 reinit_completion(&inst->done); 423 424 ret = ops->session_release_res(inst); 425 if (ret) 426 return ret; 427 428 ret = wait_session_msg(inst); 429 if (ret) 430 return ret; 431 432 inst->state = INST_RELEASE_RESOURCES; 433 434 return 0; 435 } 436 EXPORT_SYMBOL_GPL(hfi_session_unload_res); 437 438 int hfi_session_flush(struct venus_inst *inst, u32 type, bool block) 439 { 440 const struct hfi_ops *ops = inst->core->ops; 441 int ret; 442 443 if (test_bit(0, &inst->core->sys_error)) 444 return -EIO; 445 446 reinit_completion(&inst->done); 447 448 ret = ops->session_flush(inst, type); 449 if (ret) 450 return ret; 451 452 if (block) { 453 ret = wait_session_msg(inst); 454 if (ret) 455 return ret; 456 } 457 458 return 0; 459 } 460 EXPORT_SYMBOL_GPL(hfi_session_flush); 461 462 int hfi_session_set_buffers(struct venus_inst *inst, struct hfi_buffer_desc *bd) 463 { 464 const struct hfi_ops *ops = inst->core->ops; 465 466 if (test_bit(0, &inst->core->sys_error)) 467 return -EIO; 468 469 return ops->session_set_buffers(inst, bd); 470 } 471 472 int hfi_session_unset_buffers(struct venus_inst *inst, 473 struct hfi_buffer_desc *bd) 474 { 475 const struct hfi_ops *ops = inst->core->ops; 476 int ret; 477 478 if (test_bit(0, &inst->core->sys_error)) 479 return -EIO; 480 481 reinit_completion(&inst->done); 482 483 ret = ops->session_unset_buffers(inst, bd); 484 if (ret) 485 return ret; 486 487 if (!bd->response_required) 488 return 0; 489 490 ret = wait_session_msg(inst); 491 if (ret) 492 return ret; 493 494 return 0; 495 } 496 497 int hfi_session_get_property(struct venus_inst *inst, u32 ptype, 498 union hfi_get_property *hprop) 499 { 500 const struct hfi_ops *ops = inst->core->ops; 501 int ret; 502 503 if (test_bit(0, &inst->core->sys_error)) 504 return -EIO; 505 506 if (inst->state < INST_INIT || inst->state >= INST_STOP) 507 return -EINVAL; 508 509 reinit_completion(&inst->done); 510 511 ret = ops->session_get_property(inst, ptype); 512 if (ret) 513 return ret; 514 515 ret = wait_session_msg(inst); 516 if (ret) 517 return ret; 518 519 *hprop = inst->hprop; 520 521 return 0; 522 } 523 EXPORT_SYMBOL_GPL(hfi_session_get_property); 524 525 int hfi_session_set_property(struct venus_inst *inst, u32 ptype, void *pdata) 526 { 527 const struct hfi_ops *ops = inst->core->ops; 528 529 if (test_bit(0, &inst->core->sys_error)) 530 return -EIO; 531 532 if (inst->state < INST_INIT || inst->state >= INST_STOP) 533 return -EINVAL; 534 535 return ops->session_set_property(inst, ptype, pdata); 536 } 537 EXPORT_SYMBOL_GPL(hfi_session_set_property); 538 539 int hfi_session_process_buf(struct venus_inst *inst, struct hfi_frame_data *fd) 540 { 541 const struct hfi_ops *ops = inst->core->ops; 542 543 if (test_bit(0, &inst->core->sys_error)) 544 return -EIO; 545 546 if (fd->buffer_type == HFI_BUFFER_INPUT) 547 return ops->session_etb(inst, fd); 548 else if (fd->buffer_type == HFI_BUFFER_OUTPUT || 549 fd->buffer_type == HFI_BUFFER_OUTPUT2) 550 return ops->session_ftb(inst, fd); 551 552 return -EINVAL; 553 } 554 EXPORT_SYMBOL_GPL(hfi_session_process_buf); 555 556 irqreturn_t hfi_isr_thread(int irq, void *dev_id) 557 { 558 struct venus_core *core = dev_id; 559 560 return core->ops->isr_thread(core); 561 } 562 563 irqreturn_t hfi_isr(int irq, void *dev) 564 { 565 struct venus_core *core = dev; 566 567 return core->ops->isr(core); 568 } 569 570 int hfi_create(struct venus_core *core, const struct hfi_core_ops *ops) 571 { 572 if (!ops) 573 return -EINVAL; 574 575 atomic_set(&core->insts_count, 0); 576 core->core_ops = ops; 577 core->state = CORE_UNINIT; 578 init_completion(&core->done); 579 pkt_set_version(core->res->hfi_version); 580 581 return venus_hfi_create(core); 582 } 583 584 void hfi_destroy(struct venus_core *core) 585 { 586 venus_hfi_destroy(core); 587 } 588 589 void hfi_reinit(struct venus_core *core) 590 { 591 venus_hfi_queues_reinit(core); 592 } 593