drivers/media/platform/qcom/venus/hfi.c

   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         ret = core->ops->core_deinit(core);
 108
 109         if (!ret)
 110                 core->state = CORE_UNINIT;
 111
 112 unlock:
 113         mutex_unlock(&core->lock);
 114         return ret;
 115 }
 116
 117 int hfi_core_suspend(struct venus_core *core)
 118 {
 119         if (core->state != CORE_INIT)
 120                 return 0;
 121
 122         return core->ops->suspend(core);
 123 }
 124
 125 int hfi_core_resume(struct venus_core *core, bool force)
 126 {
 127         if (!force && core->state != CORE_INIT)
 128                 return 0;
 129
 130         return core->ops->resume(core);
 131 }
 132
 133 int hfi_core_trigger_ssr(struct venus_core *core, u32 type)
 134 {
 135         return core->ops->core_trigger_ssr(core, type);
 136 }
 137
 138 int hfi_core_ping(struct venus_core *core)
 139 {
 140         int ret;
 141
 142         mutex_lock(&core->lock);
 143
 144         ret = core->ops->core_ping(core, 0xbeef);
 145         if (ret)
 146                 goto unlock;
 147
 148         ret = wait_for_completion_timeout(&core->done, TIMEOUT);
 149         if (!ret) {
 150                 ret = -ETIMEDOUT;
 151                 goto unlock;
 152         }
 153         ret = 0;
 154         if (core->error != HFI_ERR_NONE)
 155                 ret = -ENODEV;
 156 unlock:
 157         mutex_unlock(&core->lock);
 158         return ret;
 159 }
 160
 161 static int wait_session_msg(struct venus_inst *inst)
 162 {
 163         int ret;
 164
 165         ret = wait_for_completion_timeout(&inst->done, TIMEOUT);
 166         if (!ret)
 167                 return -ETIMEDOUT;
 168
 169         if (inst->error != HFI_ERR_NONE)
 170                 return -EIO;
 171
 172         return 0;
 173 }
 174
 175 int hfi_session_create(struct venus_inst *inst, const struct hfi_inst_ops *ops)
 176 {
 177         struct venus_core *core = inst->core;
 178
 179         if (!ops)
 180                 return -EINVAL;
 181
 182         inst->state = INST_UNINIT;
 183         init_completion(&inst->done);
 184         inst->ops = ops;
 185
 186         mutex_lock(&core->lock);
 187         list_add_tail(&inst->list, &core->instances);
 188         atomic_inc(&core->insts_count);
 189         mutex_unlock(&core->lock);
 190
 191         return 0;
 192 }
 193 EXPORT_SYMBOL_GPL(hfi_session_create);
 194
 195 int hfi_session_init(struct venus_inst *inst, u32 pixfmt)
 196 {
 197         struct venus_core *core = inst->core;
 198         const struct hfi_ops *ops = core->ops;
 199         int ret;
 200
 201         if (inst->state != INST_UNINIT)
 202                 return -EINVAL;
 203
 204         inst->hfi_codec = to_codec_type(pixfmt);
 205         reinit_completion(&inst->done);
 206
 207         ret = ops->session_init(inst, inst->session_type, inst->hfi_codec);
 208         if (ret)
 209                 return ret;
 210
 211         ret = wait_session_msg(inst);
 212         if (ret)
 213                 return ret;
 214
 215         inst->state = INST_INIT;
 216
 217         return 0;
 218 }
 219 EXPORT_SYMBOL_GPL(hfi_session_init);
 220
 221 void hfi_session_destroy(struct venus_inst *inst)
 222 {
 223         struct venus_core *core = inst->core;
 224
 225         mutex_lock(&core->lock);
 226         list_del_init(&inst->list);
 227         if (atomic_dec_and_test(&core->insts_count))
 228                 wake_up_var(&core->insts_count);
 229         mutex_unlock(&core->lock);
 230 }
 231 EXPORT_SYMBOL_GPL(hfi_session_destroy);
 232
 233 int hfi_session_deinit(struct venus_inst *inst)
 234 {
 235         const struct hfi_ops *ops = inst->core->ops;
 236         int ret;
 237
 238         if (inst->state == INST_UNINIT)
 239                 return 0;
 240
 241         if (inst->state < INST_INIT)
 242                 return -EINVAL;
 243
 244         reinit_completion(&inst->done);
 245
 246         ret = ops->session_end(inst);
 247         if (ret)
 248                 return ret;
 249
 250         ret = wait_session_msg(inst);
 251         if (ret)
 252                 return ret;
 253
 254         inst->state = INST_UNINIT;
 255
 256         return 0;
 257 }
 258 EXPORT_SYMBOL_GPL(hfi_session_deinit);
 259
 260 int hfi_session_start(struct venus_inst *inst)
 261 {
 262         const struct hfi_ops *ops = inst->core->ops;
 263         int ret;
 264
 265         if (inst->state != INST_LOAD_RESOURCES)
 266                 return -EINVAL;
 267
 268         reinit_completion(&inst->done);
 269
 270         ret = ops->session_start(inst);
 271         if (ret)
 272                 return ret;
 273
 274         ret = wait_session_msg(inst);
 275         if (ret)
 276                 return ret;
 277
 278         inst->state = INST_START;
 279
 280         return 0;
 281 }
 282 EXPORT_SYMBOL_GPL(hfi_session_start);
 283
 284 int hfi_session_stop(struct venus_inst *inst)
 285 {
 286         const struct hfi_ops *ops = inst->core->ops;
 287         int ret;
 288
 289         if (inst->state != INST_START)
 290                 return -EINVAL;
 291
 292         reinit_completion(&inst->done);
 293
 294         ret = ops->session_stop(inst);
 295         if (ret)
 296                 return ret;
 297
 298         ret = wait_session_msg(inst);
 299         if (ret)
 300                 return ret;
 301
 302         inst->state = INST_STOP;
 303
 304         return 0;
 305 }
 306 EXPORT_SYMBOL_GPL(hfi_session_stop);
 307
 308 int hfi_session_continue(struct venus_inst *inst)
 309 {
 310         struct venus_core *core = inst->core;
 311
 312         if (core->res->hfi_version == HFI_VERSION_1XX)
 313                 return 0;
 314
 315         return core->ops->session_continue(inst);
 316 }
 317 EXPORT_SYMBOL_GPL(hfi_session_continue);
 318
 319 int hfi_session_abort(struct venus_inst *inst)
 320 {
 321         const struct hfi_ops *ops = inst->core->ops;
 322         int ret;
 323
 324         reinit_completion(&inst->done);
 325
 326         ret = ops->session_abort(inst);
 327         if (ret)
 328                 return ret;
 329
 330         ret = wait_session_msg(inst);
 331         if (ret)
 332                 return ret;
 333
 334         return 0;
 335 }
 336 EXPORT_SYMBOL_GPL(hfi_session_abort);
 337
 338 int hfi_session_load_res(struct venus_inst *inst)
 339 {
 340         const struct hfi_ops *ops = inst->core->ops;
 341         int ret;
 342
 343         if (inst->state != INST_INIT)
 344                 return -EINVAL;
 345
 346         reinit_completion(&inst->done);
 347
 348         ret = ops->session_load_res(inst);
 349         if (ret)
 350                 return ret;
 351
 352         ret = wait_session_msg(inst);
 353         if (ret)
 354                 return ret;
 355
 356         inst->state = INST_LOAD_RESOURCES;
 357
 358         return 0;
 359 }
 360
 361 int hfi_session_unload_res(struct venus_inst *inst)
 362 {
 363         const struct hfi_ops *ops = inst->core->ops;
 364         int ret;
 365
 366         if (inst->state != INST_STOP)
 367                 return -EINVAL;
 368
 369         reinit_completion(&inst->done);
 370
 371         ret = ops->session_release_res(inst);
 372         if (ret)
 373                 return ret;
 374
 375         ret = wait_session_msg(inst);
 376         if (ret)
 377                 return ret;
 378
 379         inst->state = INST_RELEASE_RESOURCES;
 380
 381         return 0;
 382 }
 383 EXPORT_SYMBOL_GPL(hfi_session_unload_res);
 384
 385 int hfi_session_flush(struct venus_inst *inst, u32 type, bool block)
 386 {
 387         const struct hfi_ops *ops = inst->core->ops;
 388         int ret;
 389
 390         reinit_completion(&inst->done);
 391
 392         ret = ops->session_flush(inst, type);
 393         if (ret)
 394                 return ret;
 395
 396         if (block) {
 397                 ret = wait_session_msg(inst);
 398                 if (ret)
 399                         return ret;
 400         }
 401
 402         return 0;
 403 }
 404 EXPORT_SYMBOL_GPL(hfi_session_flush);
 405
 406 int hfi_session_set_buffers(struct venus_inst *inst, struct hfi_buffer_desc *bd)
 407 {
 408         const struct hfi_ops *ops = inst->core->ops;
 409
 410         return ops->session_set_buffers(inst, bd);
 411 }
 412
 413 int hfi_session_unset_buffers(struct venus_inst *inst,
 414                               struct hfi_buffer_desc *bd)
 415 {
 416         const struct hfi_ops *ops = inst->core->ops;
 417         int ret;
 418
 419         reinit_completion(&inst->done);
 420
 421         ret = ops->session_unset_buffers(inst, bd);
 422         if (ret)
 423                 return ret;
 424
 425         if (!bd->response_required)
 426                 return 0;
 427
 428         ret = wait_session_msg(inst);
 429         if (ret)
 430                 return ret;
 431
 432         return 0;
 433 }
 434
 435 int hfi_session_get_property(struct venus_inst *inst, u32 ptype,
 436                              union hfi_get_property *hprop)
 437 {
 438         const struct hfi_ops *ops = inst->core->ops;
 439         int ret;
 440
 441         if (inst->state < INST_INIT || inst->state >= INST_STOP)
 442                 return -EINVAL;
 443
 444         reinit_completion(&inst->done);
 445
 446         ret = ops->session_get_property(inst, ptype);
 447         if (ret)
 448                 return ret;
 449
 450         ret = wait_session_msg(inst);
 451         if (ret)
 452                 return ret;
 453
 454         *hprop = inst->hprop;
 455
 456         return 0;
 457 }
 458 EXPORT_SYMBOL_GPL(hfi_session_get_property);
 459
 460 int hfi_session_set_property(struct venus_inst *inst, u32 ptype, void *pdata)
 461 {
 462         const struct hfi_ops *ops = inst->core->ops;
 463
 464         if (inst->state < INST_INIT || inst->state >= INST_STOP)
 465                 return -EINVAL;
 466
 467         return ops->session_set_property(inst, ptype, pdata);
 468 }
 469 EXPORT_SYMBOL_GPL(hfi_session_set_property);
 470
 471 int hfi_session_process_buf(struct venus_inst *inst, struct hfi_frame_data *fd)
 472 {
 473         const struct hfi_ops *ops = inst->core->ops;
 474
 475         if (fd->buffer_type == HFI_BUFFER_INPUT)
 476                 return ops->session_etb(inst, fd);
 477         else if (fd->buffer_type == HFI_BUFFER_OUTPUT ||
 478                  fd->buffer_type == HFI_BUFFER_OUTPUT2)
 479                 return ops->session_ftb(inst, fd);
 480
 481         return -EINVAL;
 482 }
 483 EXPORT_SYMBOL_GPL(hfi_session_process_buf);
 484
 485 irqreturn_t hfi_isr_thread(int irq, void *dev_id)
 486 {
 487         struct venus_core *core = dev_id;
 488
 489         return core->ops->isr_thread(core);
 490 }
 491
 492 irqreturn_t hfi_isr(int irq, void *dev)
 493 {
 494         struct venus_core *core = dev;
 495
 496         return core->ops->isr(core);
 497 }
 498
 499 int hfi_create(struct venus_core *core, const struct hfi_core_ops *ops)
 500 {
 501         int ret;
 502
 503         if (!ops)
 504                 return -EINVAL;
 505
 506         atomic_set(&core->insts_count, 0);
 507         core->core_ops = ops;
 508         core->state = CORE_UNINIT;
 509         init_completion(&core->done);
 510         pkt_set_version(core->res->hfi_version);
 511         ret = venus_hfi_create(core);
 512
 513         return ret;
 514 }
 515
 516 void hfi_destroy(struct venus_core *core)
 517 {
 518         venus_hfi_destroy(core);
 519 }