1 // SPDX-License-Identifier: GPL-2.0 2 /* 3 * Cedrus VPU driver 4 * 5 * Copyright (C) 2016 Florent Revest <florent.revest@free-electrons.com> 6 * Copyright (C) 2018 Paul Kocialkowski <paul.kocialkowski@bootlin.com> 7 * Copyright (C) 2018 Bootlin 8 * 9 * Based on the vim2m driver, that is: 10 * 11 * Copyright (c) 2009-2010 Samsung Electronics Co., Ltd. 12 * Pawel Osciak, <pawel@osciak.com> 13 * Marek Szyprowski, <m.szyprowski@samsung.com> 14 */ 15 16 #include <linux/platform_device.h> 17 #include <linux/of_reserved_mem.h> 18 #include <linux/of_device.h> 19 #include <linux/dma-mapping.h> 20 #include <linux/interrupt.h> 21 #include <linux/clk.h> 22 #include <linux/regmap.h> 23 #include <linux/reset.h> 24 #include <linux/soc/sunxi/sunxi_sram.h> 25 26 #include <media/videobuf2-core.h> 27 #include <media/v4l2-mem2mem.h> 28 29 #include "cedrus.h" 30 #include "cedrus_hw.h" 31 #include "cedrus_regs.h" 32 33 int cedrus_engine_enable(struct cedrus_dev *dev, enum cedrus_codec codec) 34 { 35 u32 reg = 0; 36 37 /* 38 * FIXME: This is only valid on 32-bits DDR's, we should test 39 * it on the A13/A33. 40 */ 41 reg |= VE_MODE_REC_WR_MODE_2MB; 42 reg |= VE_MODE_DDR_MODE_BW_128; 43 44 switch (codec) { 45 case CEDRUS_CODEC_MPEG2: 46 reg |= VE_MODE_DEC_MPEG; 47 break; 48 49 default: 50 return -EINVAL; 51 } 52 53 cedrus_write(dev, VE_MODE, reg); 54 55 return 0; 56 } 57 58 void cedrus_engine_disable(struct cedrus_dev *dev) 59 { 60 cedrus_write(dev, VE_MODE, VE_MODE_DISABLED); 61 } 62 63 void cedrus_dst_format_set(struct cedrus_dev *dev, 64 struct v4l2_pix_format *fmt) 65 { 66 unsigned int width = fmt->width; 67 unsigned int height = fmt->height; 68 u32 chroma_size; 69 u32 reg; 70 71 switch (fmt->pixelformat) { 72 case V4L2_PIX_FMT_NV12: 73 chroma_size = ALIGN(width, 16) * ALIGN(height, 16) / 2; 74 75 reg = VE_PRIMARY_OUT_FMT_NV12; 76 cedrus_write(dev, VE_PRIMARY_OUT_FMT, reg); 77 78 reg = VE_CHROMA_BUF_LEN_SDRT(chroma_size / 2); 79 cedrus_write(dev, VE_CHROMA_BUF_LEN, reg); 80 81 reg = chroma_size / 2; 82 cedrus_write(dev, VE_PRIMARY_CHROMA_BUF_LEN, reg); 83 84 reg = VE_PRIMARY_FB_LINE_STRIDE_LUMA(ALIGN(width, 16)) | 85 VE_PRIMARY_FB_LINE_STRIDE_CHROMA(ALIGN(width, 16) / 2); 86 cedrus_write(dev, VE_PRIMARY_FB_LINE_STRIDE, reg); 87 88 break; 89 case V4L2_PIX_FMT_SUNXI_TILED_NV12: 90 default: 91 reg = VE_PRIMARY_OUT_FMT_TILED_32_NV12; 92 cedrus_write(dev, VE_PRIMARY_OUT_FMT, reg); 93 94 reg = VE_SECONDARY_OUT_FMT_TILED_32_NV12; 95 cedrus_write(dev, VE_CHROMA_BUF_LEN, reg); 96 97 break; 98 } 99 } 100 101 static irqreturn_t cedrus_irq(int irq, void *data) 102 { 103 struct cedrus_dev *dev = data; 104 struct cedrus_ctx *ctx; 105 struct vb2_v4l2_buffer *src_buf, *dst_buf; 106 enum vb2_buffer_state state; 107 enum cedrus_irq_status status; 108 109 ctx = v4l2_m2m_get_curr_priv(dev->m2m_dev); 110 if (!ctx) { 111 v4l2_err(&dev->v4l2_dev, 112 "Instance released before the end of transaction\n"); 113 return IRQ_NONE; 114 } 115 116 status = dev->dec_ops[ctx->current_codec]->irq_status(ctx); 117 if (status == CEDRUS_IRQ_NONE) 118 return IRQ_NONE; 119 120 dev->dec_ops[ctx->current_codec]->irq_disable(ctx); 121 dev->dec_ops[ctx->current_codec]->irq_clear(ctx); 122 123 src_buf = v4l2_m2m_src_buf_remove(ctx->fh.m2m_ctx); 124 dst_buf = v4l2_m2m_dst_buf_remove(ctx->fh.m2m_ctx); 125 126 if (!src_buf || !dst_buf) { 127 v4l2_err(&dev->v4l2_dev, 128 "Missing source and/or destination buffers\n"); 129 return IRQ_HANDLED; 130 } 131 132 if (status == CEDRUS_IRQ_ERROR) 133 state = VB2_BUF_STATE_ERROR; 134 else 135 state = VB2_BUF_STATE_DONE; 136 137 v4l2_m2m_buf_done(src_buf, state); 138 v4l2_m2m_buf_done(dst_buf, state); 139 140 v4l2_m2m_job_finish(ctx->dev->m2m_dev, ctx->fh.m2m_ctx); 141 142 return IRQ_HANDLED; 143 } 144 145 int cedrus_hw_probe(struct cedrus_dev *dev) 146 { 147 const struct cedrus_variant *variant; 148 struct resource *res; 149 int irq_dec; 150 int ret; 151 152 variant = of_device_get_match_data(dev->dev); 153 if (!variant) 154 return -EINVAL; 155 156 dev->capabilities = variant->capabilities; 157 158 irq_dec = platform_get_irq(dev->pdev, 0); 159 if (irq_dec <= 0) { 160 dev_err(dev->dev, "Failed to get IRQ\n"); 161 162 return irq_dec; 163 } 164 ret = devm_request_irq(dev->dev, irq_dec, cedrus_irq, 165 0, dev_name(dev->dev), dev); 166 if (ret) { 167 dev_err(dev->dev, "Failed to request IRQ\n"); 168 169 return ret; 170 } 171 172 /* 173 * The VPU is only able to handle bus addresses so we have to subtract 174 * the RAM offset to the physcal addresses. 175 * 176 * This information will eventually be obtained from device-tree. 177 */ 178 179 #ifdef PHYS_PFN_OFFSET 180 dev->dev->dma_pfn_offset = PHYS_PFN_OFFSET; 181 #endif 182 183 ret = of_reserved_mem_device_init(dev->dev); 184 if (ret && ret != -ENODEV) { 185 dev_err(dev->dev, "Failed to reserve memory\n"); 186 187 return ret; 188 } 189 190 ret = sunxi_sram_claim(dev->dev); 191 if (ret) { 192 dev_err(dev->dev, "Failed to claim SRAM\n"); 193 194 goto err_mem; 195 } 196 197 dev->ahb_clk = devm_clk_get(dev->dev, "ahb"); 198 if (IS_ERR(dev->ahb_clk)) { 199 dev_err(dev->dev, "Failed to get AHB clock\n"); 200 201 ret = PTR_ERR(dev->ahb_clk); 202 goto err_sram; 203 } 204 205 dev->mod_clk = devm_clk_get(dev->dev, "mod"); 206 if (IS_ERR(dev->mod_clk)) { 207 dev_err(dev->dev, "Failed to get MOD clock\n"); 208 209 ret = PTR_ERR(dev->mod_clk); 210 goto err_sram; 211 } 212 213 dev->ram_clk = devm_clk_get(dev->dev, "ram"); 214 if (IS_ERR(dev->ram_clk)) { 215 dev_err(dev->dev, "Failed to get RAM clock\n"); 216 217 ret = PTR_ERR(dev->ram_clk); 218 goto err_sram; 219 } 220 221 dev->rstc = devm_reset_control_get(dev->dev, NULL); 222 if (IS_ERR(dev->rstc)) { 223 dev_err(dev->dev, "Failed to get reset control\n"); 224 225 ret = PTR_ERR(dev->rstc); 226 goto err_sram; 227 } 228 229 res = platform_get_resource(dev->pdev, IORESOURCE_MEM, 0); 230 dev->base = devm_ioremap_resource(dev->dev, res); 231 if (IS_ERR(dev->base)) { 232 dev_err(dev->dev, "Failed to map registers\n"); 233 234 ret = PTR_ERR(dev->base); 235 goto err_sram; 236 } 237 238 ret = clk_set_rate(dev->mod_clk, CEDRUS_CLOCK_RATE_DEFAULT); 239 if (ret) { 240 dev_err(dev->dev, "Failed to set clock rate\n"); 241 242 goto err_sram; 243 } 244 245 ret = clk_prepare_enable(dev->ahb_clk); 246 if (ret) { 247 dev_err(dev->dev, "Failed to enable AHB clock\n"); 248 249 goto err_sram; 250 } 251 252 ret = clk_prepare_enable(dev->mod_clk); 253 if (ret) { 254 dev_err(dev->dev, "Failed to enable MOD clock\n"); 255 256 goto err_ahb_clk; 257 } 258 259 ret = clk_prepare_enable(dev->ram_clk); 260 if (ret) { 261 dev_err(dev->dev, "Failed to enable RAM clock\n"); 262 263 goto err_mod_clk; 264 } 265 266 ret = reset_control_reset(dev->rstc); 267 if (ret) { 268 dev_err(dev->dev, "Failed to apply reset\n"); 269 270 goto err_ram_clk; 271 } 272 273 return 0; 274 275 err_ram_clk: 276 clk_disable_unprepare(dev->ram_clk); 277 err_mod_clk: 278 clk_disable_unprepare(dev->mod_clk); 279 err_ahb_clk: 280 clk_disable_unprepare(dev->ahb_clk); 281 err_sram: 282 sunxi_sram_release(dev->dev); 283 err_mem: 284 of_reserved_mem_device_release(dev->dev); 285 286 return ret; 287 } 288 289 void cedrus_hw_remove(struct cedrus_dev *dev) 290 { 291 reset_control_assert(dev->rstc); 292 293 clk_disable_unprepare(dev->ram_clk); 294 clk_disable_unprepare(dev->mod_clk); 295 clk_disable_unprepare(dev->ahb_clk); 296 297 sunxi_sram_release(dev->dev); 298 299 of_reserved_mem_device_release(dev->dev); 300 } 301