2 * Copyright (c) 2016 MediaTek Inc.
3 * Author: PC Chen <pc.chen@mediatek.com>
4 * Tiffany Lin <tiffany.lin@mediatek.com>
6 * This program is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License version 2 as
8 * published by the Free Software Foundation.
10 * This program is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 * GNU General Public License for more details.
16 #include <linux/slab.h>
17 #include <linux/interrupt.h>
18 #include <linux/irq.h>
19 #include <linux/module.h>
20 #include <linux/of_device.h>
22 #include <media/v4l2-event.h>
23 #include <media/v4l2-mem2mem.h>
24 #include <media/videobuf2-dma-contig.h>
25 #include <linux/pm_runtime.h>
27 #include "mtk_vcodec_drv.h"
28 #include "mtk_vcodec_enc.h"
29 #include "mtk_vcodec_enc_pm.h"
30 #include "mtk_vcodec_intr.h"
31 #include "mtk_vcodec_util.h"
34 module_param(mtk_v4l2_dbg_level, int, S_IRUGO | S_IWUSR);
35 module_param(mtk_vcodec_dbg, bool, S_IRUGO | S_IWUSR);
37 /* Wake up context wait_queue */
38 static void wake_up_ctx(struct mtk_vcodec_ctx *ctx, unsigned int reason)
41 ctx->int_type = reason;
42 wake_up_interruptible(&ctx->queue);
45 static void clean_irq_status(unsigned int irq_status, void __iomem *addr)
47 if (irq_status & MTK_VENC_IRQ_STATUS_PAUSE)
48 writel(MTK_VENC_IRQ_STATUS_PAUSE, addr);
50 if (irq_status & MTK_VENC_IRQ_STATUS_SWITCH)
51 writel(MTK_VENC_IRQ_STATUS_SWITCH, addr);
53 if (irq_status & MTK_VENC_IRQ_STATUS_DRAM)
54 writel(MTK_VENC_IRQ_STATUS_DRAM, addr);
56 if (irq_status & MTK_VENC_IRQ_STATUS_SPS)
57 writel(MTK_VENC_IRQ_STATUS_SPS, addr);
59 if (irq_status & MTK_VENC_IRQ_STATUS_PPS)
60 writel(MTK_VENC_IRQ_STATUS_PPS, addr);
62 if (irq_status & MTK_VENC_IRQ_STATUS_FRM)
63 writel(MTK_VENC_IRQ_STATUS_FRM, addr);
66 static irqreturn_t mtk_vcodec_enc_irq_handler(int irq, void *priv)
68 struct mtk_vcodec_dev *dev = priv;
69 struct mtk_vcodec_ctx *ctx;
73 spin_lock_irqsave(&dev->irqlock, flags);
75 spin_unlock_irqrestore(&dev->irqlock, flags);
77 mtk_v4l2_debug(1, "id=%d", ctx->id);
78 addr = dev->reg_base[VENC_SYS] + MTK_VENC_IRQ_ACK_OFFSET;
80 ctx->irq_status = readl(dev->reg_base[VENC_SYS] +
81 (MTK_VENC_IRQ_STATUS_OFFSET));
83 clean_irq_status(ctx->irq_status, addr);
85 wake_up_ctx(ctx, MTK_INST_IRQ_RECEIVED);
89 static irqreturn_t mtk_vcodec_enc_lt_irq_handler(int irq, void *priv)
91 struct mtk_vcodec_dev *dev = priv;
92 struct mtk_vcodec_ctx *ctx;
96 spin_lock_irqsave(&dev->irqlock, flags);
98 spin_unlock_irqrestore(&dev->irqlock, flags);
100 mtk_v4l2_debug(1, "id=%d", ctx->id);
101 ctx->irq_status = readl(dev->reg_base[VENC_LT_SYS] +
102 (MTK_VENC_IRQ_STATUS_OFFSET));
104 addr = dev->reg_base[VENC_LT_SYS] + MTK_VENC_IRQ_ACK_OFFSET;
106 clean_irq_status(ctx->irq_status, addr);
108 wake_up_ctx(ctx, MTK_INST_IRQ_RECEIVED);
112 static void mtk_vcodec_enc_reset_handler(void *priv)
114 struct mtk_vcodec_dev *dev = priv;
115 struct mtk_vcodec_ctx *ctx;
117 mtk_v4l2_debug(0, "Watchdog timeout!!");
119 mutex_lock(&dev->dev_mutex);
120 list_for_each_entry(ctx, &dev->ctx_list, list) {
121 ctx->state = MTK_STATE_ABORT;
122 mtk_v4l2_debug(0, "[%d] Change to state MTK_STATE_ABORT",
125 mutex_unlock(&dev->dev_mutex);
128 static int fops_vcodec_open(struct file *file)
130 struct mtk_vcodec_dev *dev = video_drvdata(file);
131 struct mtk_vcodec_ctx *ctx = NULL;
134 ctx = kzalloc(sizeof(*ctx), GFP_KERNEL);
138 mutex_lock(&dev->dev_mutex);
140 * Use simple counter to uniquely identify this context. Only
143 ctx->id = dev->id_counter++;
144 v4l2_fh_init(&ctx->fh, video_devdata(file));
145 file->private_data = &ctx->fh;
146 v4l2_fh_add(&ctx->fh);
147 INIT_LIST_HEAD(&ctx->list);
149 init_waitqueue_head(&ctx->queue);
151 ctx->type = MTK_INST_ENCODER;
152 ret = mtk_vcodec_enc_ctrls_setup(ctx);
154 mtk_v4l2_err("Failed to setup controls() (%d)",
156 goto err_ctrls_setup;
158 ctx->m2m_ctx = v4l2_m2m_ctx_init(dev->m2m_dev_enc, ctx,
159 &mtk_vcodec_enc_queue_init);
160 if (IS_ERR((__force void *)ctx->m2m_ctx)) {
161 ret = PTR_ERR((__force void *)ctx->m2m_ctx);
162 mtk_v4l2_err("Failed to v4l2_m2m_ctx_init() (%d)",
164 goto err_m2m_ctx_init;
166 mtk_vcodec_enc_set_default_params(ctx);
168 if (v4l2_fh_is_singular(&ctx->fh)) {
170 * vpu_load_firmware checks if it was loaded already and
171 * does nothing in that case
173 ret = vpu_load_firmware(dev->vpu_plat_dev);
176 * Return 0 if downloading firmware successfully,
177 * otherwise it is failed
179 mtk_v4l2_err("vpu_load_firmware failed!");
183 dev->enc_capability =
184 vpu_get_venc_hw_capa(dev->vpu_plat_dev);
185 mtk_v4l2_debug(0, "encoder capability %x", dev->enc_capability);
188 mtk_v4l2_debug(2, "Create instance [%d]@%p m2m_ctx=%p ",
189 ctx->id, ctx, ctx->m2m_ctx);
191 dev->num_instances++;
192 list_add(&ctx->list, &dev->ctx_list);
194 mutex_unlock(&dev->dev_mutex);
195 mtk_v4l2_debug(0, "%s encoder [%d]", dev_name(&dev->plat_dev->dev),
199 /* Deinit when failure occurred */
201 v4l2_m2m_ctx_release(ctx->m2m_ctx);
203 v4l2_ctrl_handler_free(&ctx->ctrl_hdl);
205 v4l2_fh_del(&ctx->fh);
206 v4l2_fh_exit(&ctx->fh);
208 mutex_unlock(&dev->dev_mutex);
213 static int fops_vcodec_release(struct file *file)
215 struct mtk_vcodec_dev *dev = video_drvdata(file);
216 struct mtk_vcodec_ctx *ctx = fh_to_ctx(file->private_data);
218 mtk_v4l2_debug(1, "[%d] encoder", ctx->id);
219 mutex_lock(&dev->dev_mutex);
221 mtk_vcodec_enc_release(ctx);
222 v4l2_fh_del(&ctx->fh);
223 v4l2_fh_exit(&ctx->fh);
224 v4l2_ctrl_handler_free(&ctx->ctrl_hdl);
225 v4l2_m2m_ctx_release(ctx->m2m_ctx);
227 list_del_init(&ctx->list);
228 dev->num_instances--;
230 mutex_unlock(&dev->dev_mutex);
234 static const struct v4l2_file_operations mtk_vcodec_fops = {
235 .owner = THIS_MODULE,
236 .open = fops_vcodec_open,
237 .release = fops_vcodec_release,
238 .poll = v4l2_m2m_fop_poll,
239 .unlocked_ioctl = video_ioctl2,
240 .mmap = v4l2_m2m_fop_mmap,
243 static int mtk_vcodec_probe(struct platform_device *pdev)
245 struct mtk_vcodec_dev *dev;
246 struct video_device *vfd_enc;
247 struct resource *res;
249 DEFINE_DMA_ATTRS(attrs);
251 dev = devm_kzalloc(&pdev->dev, sizeof(*dev), GFP_KERNEL);
255 INIT_LIST_HEAD(&dev->ctx_list);
256 dev->plat_dev = pdev;
258 dev->vpu_plat_dev = vpu_get_plat_device(dev->plat_dev);
259 if (dev->vpu_plat_dev == NULL) {
260 mtk_v4l2_err("[VPU] vpu device in not ready");
261 return -EPROBE_DEFER;
264 vpu_wdt_reg_handler(dev->vpu_plat_dev, mtk_vcodec_enc_reset_handler,
267 ret = mtk_vcodec_init_enc_pm(dev);
269 dev_err(&pdev->dev, "Failed to get mt vcodec clock source!");
273 for (i = VENC_SYS, j = 0; i < NUM_MAX_VCODEC_REG_BASE; i++, j++) {
274 res = platform_get_resource(pdev, IORESOURCE_MEM, j);
276 dev_err(&pdev->dev, "get memory resource failed.");
280 dev->reg_base[i] = devm_ioremap_resource(&pdev->dev, res);
281 if (IS_ERR((__force void *)dev->reg_base[i])) {
282 ret = PTR_ERR((__force void *)dev->reg_base[i]);
285 mtk_v4l2_debug(2, "reg[%d] base=0x%p", i, dev->reg_base[i]);
288 res = platform_get_resource(pdev, IORESOURCE_IRQ, 0);
290 dev_err(&pdev->dev, "failed to get irq resource");
295 dev->enc_irq = platform_get_irq(pdev, 0);
296 ret = devm_request_irq(&pdev->dev, dev->enc_irq,
297 mtk_vcodec_enc_irq_handler,
300 dev_err(&pdev->dev, "Failed to install dev->enc_irq %d (%d)",
307 dev->enc_lt_irq = platform_get_irq(pdev, 1);
308 ret = devm_request_irq(&pdev->dev,
309 dev->enc_lt_irq, mtk_vcodec_enc_lt_irq_handler,
313 "Failed to install dev->enc_lt_irq %d (%d)",
314 dev->enc_lt_irq, ret);
319 disable_irq(dev->enc_irq);
320 disable_irq(dev->enc_lt_irq); /* VENC_LT */
321 mutex_init(&dev->enc_mutex);
322 mutex_init(&dev->dev_mutex);
323 spin_lock_init(&dev->irqlock);
325 snprintf(dev->v4l2_dev.name, sizeof(dev->v4l2_dev.name), "%s",
328 ret = v4l2_device_register(&pdev->dev, &dev->v4l2_dev);
330 mtk_v4l2_err("v4l2_device_register err=%d", ret);
334 init_waitqueue_head(&dev->queue);
336 /* allocate video device for encoder and register it */
337 vfd_enc = video_device_alloc();
339 mtk_v4l2_err("Failed to allocate video device");
343 vfd_enc->fops = &mtk_vcodec_fops;
344 vfd_enc->ioctl_ops = &mtk_venc_ioctl_ops;
345 vfd_enc->release = video_device_release;
346 vfd_enc->lock = &dev->dev_mutex;
347 vfd_enc->v4l2_dev = &dev->v4l2_dev;
348 vfd_enc->vfl_dir = VFL_DIR_M2M;
349 vfd_enc->device_caps = V4L2_CAP_VIDEO_M2M_MPLANE |
352 snprintf(vfd_enc->name, sizeof(vfd_enc->name), "%s",
353 MTK_VCODEC_ENC_NAME);
354 video_set_drvdata(vfd_enc, dev);
355 dev->vfd_enc = vfd_enc;
356 platform_set_drvdata(pdev, dev);
358 dev->m2m_dev_enc = v4l2_m2m_init(&mtk_venc_m2m_ops);
359 if (IS_ERR((__force void *)dev->m2m_dev_enc)) {
360 mtk_v4l2_err("Failed to init mem2mem enc device");
361 ret = PTR_ERR((__force void *)dev->m2m_dev_enc);
362 goto err_enc_mem_init;
365 dev->encode_workqueue =
366 alloc_ordered_workqueue(MTK_VCODEC_ENC_NAME,
369 if (!dev->encode_workqueue) {
370 mtk_v4l2_err("Failed to create encode workqueue");
372 goto err_event_workq;
375 ret = video_register_device(vfd_enc, VFL_TYPE_GRABBER, 1);
377 mtk_v4l2_err("Failed to register video device");
381 /* Avoid the iommu eat big hunks */
382 dma_set_attr(DMA_ATTR_ALLOC_SINGLE_PAGES, &attrs);
384 mtk_v4l2_debug(0, "encoder registered as /dev/video%d",
390 destroy_workqueue(dev->encode_workqueue);
392 v4l2_m2m_release(dev->m2m_dev_enc);
394 video_unregister_device(vfd_enc);
396 v4l2_device_unregister(&dev->v4l2_dev);
398 mtk_vcodec_release_enc_pm(dev);
402 static const struct of_device_id mtk_vcodec_enc_match[] = {
403 {.compatible = "mediatek,mt8173-vcodec-enc",},
406 MODULE_DEVICE_TABLE(of, mtk_vcodec_enc_match);
408 static int mtk_vcodec_enc_remove(struct platform_device *pdev)
410 struct mtk_vcodec_dev *dev = platform_get_drvdata(pdev);
412 mtk_v4l2_debug_enter();
413 flush_workqueue(dev->encode_workqueue);
414 destroy_workqueue(dev->encode_workqueue);
415 if (dev->m2m_dev_enc)
416 v4l2_m2m_release(dev->m2m_dev_enc);
419 video_unregister_device(dev->vfd_enc);
421 v4l2_device_unregister(&dev->v4l2_dev);
422 mtk_vcodec_release_enc_pm(dev);
426 static struct platform_driver mtk_vcodec_enc_driver = {
427 .probe = mtk_vcodec_probe,
428 .remove = mtk_vcodec_enc_remove,
430 .name = MTK_VCODEC_ENC_NAME,
431 .of_match_table = mtk_vcodec_enc_match,
435 module_platform_driver(mtk_vcodec_enc_driver);
438 MODULE_LICENSE("GPL v2");
439 MODULE_DESCRIPTION("Mediatek video codec V4L2 encoder driver");