drivers/media/platform/qcom/venus/core.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/clk.h>
   7 #include <linux/init.h>
   8 #include <linux/interconnect.h>
   9 #include <linux/ioctl.h>
  10 #include <linux/list.h>
  11 #include <linux/module.h>
  12 #include <linux/of_device.h>
  13 #include <linux/platform_device.h>
  14 #include <linux/slab.h>
  15 #include <linux/types.h>
  16 #include <linux/pm_runtime.h>
  17 #include <media/videobuf2-v4l2.h>
  18 #include <media/v4l2-mem2mem.h>
  19 #include <media/v4l2-ioctl.h>
  20
  21 #include "core.h"
  22 #include "vdec.h"
  23 #include "venc.h"
  24 #include "firmware.h"
  25
  26 static void venus_event_notify(struct venus_core *core, u32 event)
  27 {
  28         struct venus_inst *inst;
  29
  30         switch (event) {
  31         case EVT_SYS_WATCHDOG_TIMEOUT:
  32         case EVT_SYS_ERROR:
  33                 break;
  34         default:
  35                 return;
  36         }
  37
  38         mutex_lock(&core->lock);
  39         core->sys_error = true;
  40         list_for_each_entry(inst, &core->instances, list)
  41                 inst->ops->event_notify(inst, EVT_SESSION_ERROR, NULL);
  42         mutex_unlock(&core->lock);
  43
  44         disable_irq_nosync(core->irq);
  45
  46         /*
  47          * Delay recovery to ensure venus has completed any pending cache
  48          * operations. Without this sleep, we see device reset when firmware is
  49          * unloaded after a system error.
  50          */
  51         schedule_delayed_work(&core->work, msecs_to_jiffies(100));
  52 }
  53
  54 static const struct hfi_core_ops venus_core_ops = {
  55         .event_notify = venus_event_notify,
  56 };
  57
  58 static void venus_sys_error_handler(struct work_struct *work)
  59 {
  60         struct venus_core *core =
  61                         container_of(work, struct venus_core, work.work);
  62         int ret = 0;
  63
  64         dev_warn(core->dev, "system error has occurred, starting recovery!\n");
  65
  66         pm_runtime_get_sync(core->dev);
  67
  68         hfi_core_deinit(core, true);
  69         hfi_destroy(core);
  70         mutex_lock(&core->lock);
  71         venus_shutdown(core);
  72
  73         pm_runtime_put_sync(core->dev);
  74
  75         ret |= hfi_create(core, &venus_core_ops);
  76
  77         pm_runtime_get_sync(core->dev);
  78
  79         ret |= venus_boot(core);
  80
  81         ret |= hfi_core_resume(core, true);
  82
  83         enable_irq(core->irq);
  84
  85         mutex_unlock(&core->lock);
  86
  87         ret |= hfi_core_init(core);
  88
  89         pm_runtime_put_sync(core->dev);
  90
  91         if (ret) {
  92                 disable_irq_nosync(core->irq);
  93                 dev_warn(core->dev, "recovery failed (%d)\n", ret);
  94                 schedule_delayed_work(&core->work, msecs_to_jiffies(10));
  95                 return;
  96         }
  97
  98         mutex_lock(&core->lock);
  99         core->sys_error = false;
 100         mutex_unlock(&core->lock);
 101 }
 102
 103 static int venus_clks_get(struct venus_core *core)
 104 {
 105         const struct venus_resources *res = core->res;
 106         struct device *dev = core->dev;
 107         unsigned int i;
 108
 109         for (i = 0; i < res->clks_num; i++) {
 110                 core->clks[i] = devm_clk_get(dev, res->clks[i]);
 111                 if (IS_ERR(core->clks[i]))
 112                         return PTR_ERR(core->clks[i]);
 113         }
 114
 115         return 0;
 116 }
 117
 118 static int venus_clks_enable(struct venus_core *core)
 119 {
 120         const struct venus_resources *res = core->res;
 121         unsigned int i;
 122         int ret;
 123
 124         for (i = 0; i < res->clks_num; i++) {
 125                 ret = clk_prepare_enable(core->clks[i]);
 126                 if (ret)
 127                         goto err;
 128         }
 129
 130         return 0;
 131 err:
 132         while (i--)
 133                 clk_disable_unprepare(core->clks[i]);
 134
 135         return ret;
 136 }
 137
 138 static void venus_clks_disable(struct venus_core *core)
 139 {
 140         const struct venus_resources *res = core->res;
 141         unsigned int i = res->clks_num;
 142
 143         while (i--)
 144                 clk_disable_unprepare(core->clks[i]);
 145 }
 146
 147 static u32 to_v4l2_codec_type(u32 codec)
 148 {
 149         switch (codec) {
 150         case HFI_VIDEO_CODEC_H264:
 151                 return V4L2_PIX_FMT_H264;
 152         case HFI_VIDEO_CODEC_H263:
 153                 return V4L2_PIX_FMT_H263;
 154         case HFI_VIDEO_CODEC_MPEG1:
 155                 return V4L2_PIX_FMT_MPEG1;
 156         case HFI_VIDEO_CODEC_MPEG2:
 157                 return V4L2_PIX_FMT_MPEG2;
 158         case HFI_VIDEO_CODEC_MPEG4:
 159                 return V4L2_PIX_FMT_MPEG4;
 160         case HFI_VIDEO_CODEC_VC1:
 161                 return V4L2_PIX_FMT_VC1_ANNEX_G;
 162         case HFI_VIDEO_CODEC_VP8:
 163                 return V4L2_PIX_FMT_VP8;
 164         case HFI_VIDEO_CODEC_VP9:
 165                 return V4L2_PIX_FMT_VP9;
 166         case HFI_VIDEO_CODEC_DIVX:
 167         case HFI_VIDEO_CODEC_DIVX_311:
 168                 return V4L2_PIX_FMT_XVID;
 169         default:
 170                 return 0;
 171         }
 172 }
 173
 174 static int venus_enumerate_codecs(struct venus_core *core, u32 type)
 175 {
 176         const struct hfi_inst_ops dummy_ops = {};
 177         struct venus_inst *inst;
 178         u32 codec, codecs;
 179         unsigned int i;
 180         int ret;
 181
 182         if (core->res->hfi_version != HFI_VERSION_1XX)
 183                 return 0;
 184
 185         inst = kzalloc(sizeof(*inst), GFP_KERNEL);
 186         if (!inst)
 187                 return -ENOMEM;
 188
 189         mutex_init(&inst->lock);
 190         inst->core = core;
 191         inst->session_type = type;
 192         if (type == VIDC_SESSION_TYPE_DEC)
 193                 codecs = core->dec_codecs;
 194         else
 195                 codecs = core->enc_codecs;
 196
 197         ret = hfi_session_create(inst, &dummy_ops);
 198         if (ret)
 199                 goto err;
 200
 201         for (i = 0; i < MAX_CODEC_NUM; i++) {
 202                 codec = (1UL << i) & codecs;
 203                 if (!codec)
 204                         continue;
 205
 206                 ret = hfi_session_init(inst, to_v4l2_codec_type(codec));
 207                 if (ret)
 208                         goto done;
 209
 210                 ret = hfi_session_deinit(inst);
 211                 if (ret)
 212                         goto done;
 213         }
 214
 215 done:
 216         hfi_session_destroy(inst);
 217 err:
 218         mutex_destroy(&inst->lock);
 219         kfree(inst);
 220
 221         return ret;
 222 }
 223
 224 static int venus_probe(struct platform_device *pdev)
 225 {
 226         struct device *dev = &pdev->dev;
 227         struct venus_core *core;
 228         struct resource *r;
 229         int ret;
 230
 231         core = devm_kzalloc(dev, sizeof(*core), GFP_KERNEL);
 232         if (!core)
 233                 return -ENOMEM;
 234
 235         core->dev = dev;
 236         platform_set_drvdata(pdev, core);
 237
 238         r = platform_get_resource(pdev, IORESOURCE_MEM, 0);
 239         core->base = devm_ioremap_resource(dev, r);
 240         if (IS_ERR(core->base))
 241                 return PTR_ERR(core->base);
 242
 243         core->video_path = of_icc_get(dev, "video-mem");
 244         if (IS_ERR(core->video_path))
 245                 return PTR_ERR(core->video_path);
 246
 247         core->cpucfg_path = of_icc_get(dev, "cpu-cfg");
 248         if (IS_ERR(core->cpucfg_path))
 249                 return PTR_ERR(core->cpucfg_path);
 250
 251         core->irq = platform_get_irq(pdev, 0);
 252         if (core->irq < 0)
 253                 return core->irq;
 254
 255         core->res = of_device_get_match_data(dev);
 256         if (!core->res)
 257                 return -ENODEV;
 258
 259         ret = venus_clks_get(core);
 260         if (ret)
 261                 return ret;
 262
 263         ret = dma_set_mask_and_coherent(dev, core->res->dma_mask);
 264         if (ret)
 265                 return ret;
 266
 267         if (!dev->dma_parms) {
 268                 dev->dma_parms = devm_kzalloc(dev, sizeof(*dev->dma_parms),
 269                                               GFP_KERNEL);
 270                 if (!dev->dma_parms)
 271                         return -ENOMEM;
 272         }
 273         dma_set_max_seg_size(dev, DMA_BIT_MASK(32));
 274
 275         INIT_LIST_HEAD(&core->instances);
 276         mutex_init(&core->lock);
 277         INIT_DELAYED_WORK(&core->work, venus_sys_error_handler);
 278
 279         ret = devm_request_threaded_irq(dev, core->irq, hfi_isr, hfi_isr_thread,
 280                                         IRQF_TRIGGER_HIGH | IRQF_ONESHOT,
 281                                         "venus", core);
 282         if (ret)
 283                 return ret;
 284
 285         ret = icc_set_bw(core->cpucfg_path, 0, kbps_to_icc(1000));
 286         if (ret)
 287                 return ret;
 288
 289         ret = hfi_create(core, &venus_core_ops);
 290         if (ret)
 291                 return ret;
 292
 293         pm_runtime_enable(dev);
 294
 295         ret = pm_runtime_get_sync(dev);
 296         if (ret < 0)
 297                 goto err_runtime_disable;
 298
 299         ret = of_platform_populate(dev->of_node, NULL, NULL, dev);
 300         if (ret)
 301                 goto err_runtime_disable;
 302
 303         ret = venus_firmware_init(core);
 304         if (ret)
 305                 goto err_runtime_disable;
 306
 307         ret = venus_boot(core);
 308         if (ret)
 309                 goto err_runtime_disable;
 310
 311         ret = hfi_core_resume(core, true);
 312         if (ret)
 313                 goto err_venus_shutdown;
 314
 315         ret = hfi_core_init(core);
 316         if (ret)
 317                 goto err_venus_shutdown;
 318
 319         ret = venus_enumerate_codecs(core, VIDC_SESSION_TYPE_DEC);
 320         if (ret)
 321                 goto err_venus_shutdown;
 322
 323         ret = venus_enumerate_codecs(core, VIDC_SESSION_TYPE_ENC);
 324         if (ret)
 325                 goto err_venus_shutdown;
 326
 327         ret = v4l2_device_register(dev, &core->v4l2_dev);
 328         if (ret)
 329                 goto err_core_deinit;
 330
 331         ret = pm_runtime_put_sync(dev);
 332         if (ret)
 333                 goto err_dev_unregister;
 334
 335         return 0;
 336
 337 err_dev_unregister:
 338         v4l2_device_unregister(&core->v4l2_dev);
 339 err_core_deinit:
 340         hfi_core_deinit(core, false);
 341 err_venus_shutdown:
 342         venus_shutdown(core);
 343 err_runtime_disable:
 344         pm_runtime_set_suspended(dev);
 345         pm_runtime_disable(dev);
 346         hfi_destroy(core);
 347         return ret;
 348 }
 349
 350 static int venus_remove(struct platform_device *pdev)
 351 {
 352         struct venus_core *core = platform_get_drvdata(pdev);
 353         struct device *dev = core->dev;
 354         int ret;
 355
 356         ret = pm_runtime_get_sync(dev);
 357         WARN_ON(ret < 0);
 358
 359         ret = hfi_core_deinit(core, true);
 360         WARN_ON(ret);
 361
 362         hfi_destroy(core);
 363         venus_shutdown(core);
 364         of_platform_depopulate(dev);
 365
 366         venus_firmware_deinit(core);
 367
 368         pm_runtime_put_sync(dev);
 369         pm_runtime_disable(dev);
 370
 371         icc_put(core->video_path);
 372         icc_put(core->cpucfg_path);
 373
 374         v4l2_device_unregister(&core->v4l2_dev);
 375
 376         return ret;
 377 }
 378
 379 static __maybe_unused int venus_runtime_suspend(struct device *dev)
 380 {
 381         struct venus_core *core = dev_get_drvdata(dev);
 382         int ret;
 383
 384         ret = hfi_core_suspend(core);
 385
 386         venus_clks_disable(core);
 387
 388         return ret;
 389 }
 390
 391 static __maybe_unused int venus_runtime_resume(struct device *dev)
 392 {
 393         struct venus_core *core = dev_get_drvdata(dev);
 394         int ret;
 395
 396         ret = venus_clks_enable(core);
 397         if (ret)
 398                 return ret;
 399
 400         ret = hfi_core_resume(core, false);
 401         if (ret)
 402                 goto err_clks_disable;
 403
 404         return 0;
 405
 406 err_clks_disable:
 407         venus_clks_disable(core);
 408         return ret;
 409 }
 410
 411 static const struct dev_pm_ops venus_pm_ops = {
 412         SET_SYSTEM_SLEEP_PM_OPS(pm_runtime_force_suspend,
 413                                 pm_runtime_force_resume)
 414         SET_RUNTIME_PM_OPS(venus_runtime_suspend, venus_runtime_resume, NULL)
 415 };
 416
 417 static const struct freq_tbl msm8916_freq_table[] = {
 418         { 352800, 228570000 },  /* 1920x1088 @ 30 + 1280x720 @ 30 */
 419         { 244800, 160000000 },  /* 1920x1088 @ 30 */
 420         { 108000, 100000000 },  /* 1280x720 @ 30 */
 421 };
 422
 423 static const struct reg_val msm8916_reg_preset[] = {
 424         { 0xe0020, 0x05555556 },
 425         { 0xe0024, 0x05555556 },
 426         { 0x80124, 0x00000003 },
 427 };
 428
 429 static const struct venus_resources msm8916_res = {
 430         .freq_tbl = msm8916_freq_table,
 431         .freq_tbl_size = ARRAY_SIZE(msm8916_freq_table),
 432         .reg_tbl = msm8916_reg_preset,
 433         .reg_tbl_size = ARRAY_SIZE(msm8916_reg_preset),
 434         .clks = { "core", "iface", "bus", },
 435         .clks_num = 3,
 436         .max_load = 352800, /* 720p@30 + 1080p@30 */
 437         .hfi_version = HFI_VERSION_1XX,
 438         .vmem_id = VIDC_RESOURCE_NONE,
 439         .vmem_size = 0,
 440         .vmem_addr = 0,
 441         .dma_mask = 0xddc00000 - 1,
 442         .fwname = "qcom/venus-1.8/venus.mdt",
 443 };
 444
 445 static const struct freq_tbl msm8996_freq_table[] = {
 446         { 1944000, 520000000 }, /* 4k UHD @ 60 (decode only) */
 447         {  972000, 520000000 }, /* 4k UHD @ 30 */
 448         {  489600, 346666667 }, /* 1080p @ 60 */
 449         {  244800, 150000000 }, /* 1080p @ 30 */
 450         {  108000,  75000000 }, /* 720p @ 30 */
 451 };
 452
 453 static const struct reg_val msm8996_reg_preset[] = {
 454         { 0x80010, 0xffffffff },
 455         { 0x80018, 0x00001556 },
 456         { 0x8001C, 0x00001556 },
 457 };
 458
 459 static const struct venus_resources msm8996_res = {
 460         .freq_tbl = msm8996_freq_table,
 461         .freq_tbl_size = ARRAY_SIZE(msm8996_freq_table),
 462         .reg_tbl = msm8996_reg_preset,
 463         .reg_tbl_size = ARRAY_SIZE(msm8996_reg_preset),
 464         .clks = {"core", "iface", "bus", "mbus" },
 465         .clks_num = 4,
 466         .max_load = 2563200,
 467         .hfi_version = HFI_VERSION_3XX,
 468         .vmem_id = VIDC_RESOURCE_NONE,
 469         .vmem_size = 0,
 470         .vmem_addr = 0,
 471         .dma_mask = 0xddc00000 - 1,
 472         .fwname = "qcom/venus-4.2/venus.mdt",
 473 };
 474
 475 static const struct freq_tbl sdm845_freq_table[] = {
 476         { 3110400, 533000000 }, /* 4096x2160@90 */
 477         { 2073600, 444000000 }, /* 4096x2160@60 */
 478         { 1944000, 404000000 }, /* 3840x2160@60 */
 479         {  972000, 330000000 }, /* 3840x2160@30 */
 480         {  489600, 200000000 }, /* 1920x1080@60 */
 481         {  244800, 100000000 }, /* 1920x1080@30 */
 482 };
 483
 484 static const struct bw_tbl sdm845_bw_table_enc[] = {
 485         { 1944000, 1612000, 0, 2416000, 0 },    /* 3840x2160@60 */
 486         {  972000,  951000, 0, 1434000, 0 },    /* 3840x2160@30 */
 487         {  489600,  723000, 0,  973000, 0 },    /* 1920x1080@60 */
 488         {  244800,  370000, 0,  495000, 0 },    /* 1920x1080@30 */
 489 };
 490
 491 static const struct bw_tbl sdm845_bw_table_dec[] = {
 492         { 2073600, 3929000, 0, 5551000, 0 },    /* 4096x2160@60 */
 493         { 1036800, 1987000, 0, 2797000, 0 },    /* 4096x2160@30 */
 494         {  489600, 1040000, 0, 1298000, 0 },    /* 1920x1080@60 */
 495         {  244800,  530000, 0,  659000, 0 },    /* 1920x1080@30 */
 496 };
 497
 498 static const struct venus_resources sdm845_res = {
 499         .freq_tbl = sdm845_freq_table,
 500         .freq_tbl_size = ARRAY_SIZE(sdm845_freq_table),
 501         .bw_tbl_enc = sdm845_bw_table_enc,
 502         .bw_tbl_enc_size = ARRAY_SIZE(sdm845_bw_table_enc),
 503         .bw_tbl_dec = sdm845_bw_table_dec,
 504         .bw_tbl_dec_size = ARRAY_SIZE(sdm845_bw_table_dec),
 505         .clks = {"core", "iface", "bus" },
 506         .clks_num = 3,
 507         .max_load = 3110400,    /* 4096x2160@90 */
 508         .hfi_version = HFI_VERSION_4XX,
 509         .vmem_id = VIDC_RESOURCE_NONE,
 510         .vmem_size = 0,
 511         .vmem_addr = 0,
 512         .dma_mask = 0xe0000000 - 1,
 513         .fwname = "qcom/venus-5.2/venus.mdt",
 514 };
 515
 516 static const struct of_device_id venus_dt_match[] = {
 517         { .compatible = "qcom,msm8916-venus", .data = &msm8916_res, },
 518         { .compatible = "qcom,msm8996-venus", .data = &msm8996_res, },
 519         { .compatible = "qcom,sdm845-venus", .data = &sdm845_res, },
 520         { }
 521 };
 522 MODULE_DEVICE_TABLE(of, venus_dt_match);
 523
 524 static struct platform_driver qcom_venus_driver = {
 525         .probe = venus_probe,
 526         .remove = venus_remove,
 527         .driver = {
 528                 .name = "qcom-venus",
 529                 .of_match_table = venus_dt_match,
 530                 .pm = &venus_pm_ops,
 531         },
 532 };
 533 module_platform_driver(qcom_venus_driver);
 534
 535 MODULE_ALIAS("platform:qcom-venus");
 536 MODULE_DESCRIPTION("Qualcomm Venus video encoder and decoder driver");
 537 MODULE_LICENSE("GPL v2");