1// SPDX-License-Identifier: GPL-2.0 2/* 3 * V4L2 driver for the JPEG encoder/decoder from i.MX8QXP/i.MX8QM application 4 * processors. 5 * 6 * The multi-planar buffers API is used. 7 * 8 * Baseline and extended sequential jpeg decoding is supported. 9 * Progressive jpeg decoding is not supported by the IP. 10 * Supports encode and decode of various formats: 11 * YUV444, YUV422, YUV420, BGR, ABGR, Gray 12 * YUV420 is the only multi-planar format supported. 13 * Minimum resolution is 64 x 64, maximum 8192 x 8192. 14 * To achieve 8192 x 8192, modify in defconfig: CONFIG_CMA_SIZE_MBYTES=320 15 * The alignment requirements for the resolution depend on the format, 16 * multiple of 16 resolutions should work for all formats. 17 * Special workarounds are made in the driver to support NV12 1080p. 18 * When decoding, the driver detects image resolution and pixel format 19 * from the jpeg stream, by parsing the jpeg markers. 20 * 21 * The IP has 4 slots available for context switching, but only slot 0 22 * was fully tested to work. Context switching is not used by the driver. 23 * Each driver instance (context) allocates a slot for itself, but this 24 * is postponed until device_run, to allow unlimited opens. 25 * 26 * The driver submits jobs to the IP by setting up a descriptor for the 27 * used slot, and then validating it. The encoder has an additional descriptor 28 * for the configuration phase. The driver expects FRM_DONE interrupt from 29 * IP to mark the job as finished. 30 * 31 * The decoder IP has some limitations regarding the component ID's, 32 * but the driver works around this by replacing them in the jpeg stream. 33 * 34 * A module parameter is available for debug purpose (jpeg_tracing), to enable 35 * it, enable dynamic debug for this module and: 36 * echo 1 > /sys/module/mxc_jpeg_encdec/parameters/jpeg_tracing 37 * 38 * This is inspired by the drivers/media/platform/samsung/s5p-jpeg driver 39 * 40 * Copyright 2018-2019 NXP 41 */ 42 43#include <linux/kernel.h> 44#include <linux/module.h> 45#include <linux/io.h> 46#include <linux/clk.h> 47#include <linux/of_platform.h> 48#include <linux/platform_device.h> 49#include <linux/slab.h> 50#include <linux/irqreturn.h> 51#include <linux/interrupt.h> 52#include <linux/pm_runtime.h> 53#include <linux/pm_domain.h> 54#include <linux/string.h> 55 56#include <media/v4l2-jpeg.h> 57#include <media/v4l2-mem2mem.h> 58#include <media/v4l2-ioctl.h> 59#include <media/v4l2-common.h> 60#include <media/v4l2-event.h> 61#include <media/videobuf2-dma-contig.h> 62 63#include "mxc-jpeg-hw.h" 64#include "mxc-jpeg.h" 65 66static const struct mxc_jpeg_fmt mxc_formats[] = { 67 { 68 .name = "JPEG", 69 .fourcc = V4L2_PIX_FMT_JPEG, 70 .subsampling = -1, 71 .nc = -1, 72 .mem_planes = 1, 73 .comp_planes = 1, 74 .flags = MXC_JPEG_FMT_TYPE_ENC, 75 }, 76 { 77 .name = "BGR", /*BGR packed format*/ 78 .fourcc = V4L2_PIX_FMT_BGR24, 79 .subsampling = V4L2_JPEG_CHROMA_SUBSAMPLING_444, 80 .nc = 3, 81 .depth = 24, 82 .mem_planes = 1, 83 .comp_planes = 1, 84 .h_align = 3, 85 .v_align = 3, 86 .flags = MXC_JPEG_FMT_TYPE_RAW, 87 .precision = 8, 88 .is_rgb = 1, 89 }, 90 { 91 .name = "BGR 12bit", /*12-bit BGR packed format*/ 92 .fourcc = V4L2_PIX_FMT_BGR48_12, 93 .subsampling = V4L2_JPEG_CHROMA_SUBSAMPLING_444, 94 .nc = 3, 95 .depth = 36, 96 .mem_planes = 1, 97 .comp_planes = 1, 98 .h_align = 3, 99 .v_align = 3, 100 .flags = MXC_JPEG_FMT_TYPE_RAW, 101 .precision = 12, 102 .is_rgb = 1, 103 }, 104 { 105 .name = "ABGR", /* ABGR packed format */ 106 .fourcc = V4L2_PIX_FMT_ABGR32, 107 .subsampling = V4L2_JPEG_CHROMA_SUBSAMPLING_444, 108 .nc = 4, 109 .depth = 32, 110 .mem_planes = 1, 111 .comp_planes = 1, 112 .h_align = 3, 113 .v_align = 3, 114 .flags = MXC_JPEG_FMT_TYPE_RAW, 115 .precision = 8, 116 .is_rgb = 1, 117 }, 118 { 119 .name = "ABGR 12bit", /* 12-bit ABGR packed format */ 120 .fourcc = V4L2_PIX_FMT_ABGR64_12, 121 .subsampling = V4L2_JPEG_CHROMA_SUBSAMPLING_444, 122 .nc = 4, 123 .depth = 48, 124 .mem_planes = 1, 125 .comp_planes = 1, 126 .h_align = 3, 127 .v_align = 3, 128 .flags = MXC_JPEG_FMT_TYPE_RAW, 129 .precision = 12, 130 .is_rgb = 1, 131 }, 132 { 133 .name = "YUV420", /* 1st plane = Y, 2nd plane = UV */ 134 .fourcc = V4L2_PIX_FMT_NV12M, 135 .subsampling = V4L2_JPEG_CHROMA_SUBSAMPLING_420, 136 .nc = 3, 137 .depth = 12, /* 6 bytes (4Y + UV) for 4 pixels */ 138 .mem_planes = 2, 139 .comp_planes = 2, /* 1 plane Y, 1 plane UV interleaved */ 140 .h_align = 4, 141 .v_align = 4, 142 .flags = MXC_JPEG_FMT_TYPE_RAW, 143 .precision = 8, 144 }, 145 { 146 .name = "YUV420", /* 1st plane = Y, 2nd plane = UV */ 147 .fourcc = V4L2_PIX_FMT_NV12, 148 .subsampling = V4L2_JPEG_CHROMA_SUBSAMPLING_420, 149 .nc = 3, 150 .depth = 12, /* 6 bytes (4Y + UV) for 4 pixels */ 151 .mem_planes = 1, 152 .comp_planes = 2, /* 1 plane Y, 1 plane UV interleaved */ 153 .h_align = 4, 154 .v_align = 4, 155 .flags = MXC_JPEG_FMT_TYPE_RAW, 156 .precision = 8, 157 }, 158 { 159 .name = "YUV420 12bit", /* 1st plane = Y, 2nd plane = UV */ 160 .fourcc = V4L2_PIX_FMT_P012M, 161 .subsampling = V4L2_JPEG_CHROMA_SUBSAMPLING_420, 162 .nc = 3, 163 .depth = 18, /* 6 x 12 bits (4Y + UV) for 4 pixels */ 164 .mem_planes = 2, 165 .comp_planes = 2, /* 1 plane Y, 1 plane UV interleaved */ 166 .h_align = 4, 167 .v_align = 4, 168 .flags = MXC_JPEG_FMT_TYPE_RAW, 169 .precision = 12, 170 }, 171 { 172 .name = "YUV420 12bit", /* 1st plane = Y, 2nd plane = UV */ 173 .fourcc = V4L2_PIX_FMT_P012, 174 .subsampling = V4L2_JPEG_CHROMA_SUBSAMPLING_420, 175 .nc = 3, 176 .depth = 18, /* 6 x 12 bits (4Y + UV) for 4 pixels */ 177 .mem_planes = 1, 178 .comp_planes = 2, /* 1 plane Y, 1 plane UV interleaved */ 179 .h_align = 4, 180 .v_align = 4, 181 .flags = MXC_JPEG_FMT_TYPE_RAW, 182 .precision = 12, 183 }, 184 { 185 .name = "YUV422", /* YUYV */ 186 .fourcc = V4L2_PIX_FMT_YUYV, 187 .subsampling = V4L2_JPEG_CHROMA_SUBSAMPLING_422, 188 .nc = 3, 189 .depth = 16, 190 .mem_planes = 1, 191 .comp_planes = 1, 192 .h_align = 4, 193 .v_align = 3, 194 .flags = MXC_JPEG_FMT_TYPE_RAW, 195 .precision = 8, 196 }, 197 { 198 .name = "YUV422 12bit", /* YUYV */ 199 .fourcc = V4L2_PIX_FMT_Y212, 200 .subsampling = V4L2_JPEG_CHROMA_SUBSAMPLING_422, 201 .nc = 3, 202 .depth = 24, 203 .mem_planes = 1, 204 .comp_planes = 1, 205 .h_align = 4, 206 .v_align = 3, 207 .flags = MXC_JPEG_FMT_TYPE_RAW, 208 .precision = 12, 209 }, 210 { 211 .name = "YUV444", /* YUVYUV */ 212 .fourcc = V4L2_PIX_FMT_YUV24, 213 .subsampling = V4L2_JPEG_CHROMA_SUBSAMPLING_444, 214 .nc = 3, 215 .depth = 24, 216 .mem_planes = 1, 217 .comp_planes = 1, 218 .h_align = 3, 219 .v_align = 3, 220 .flags = MXC_JPEG_FMT_TYPE_RAW, 221 .precision = 8, 222 }, 223 { 224 .name = "YUV444 12bit", /* YUVYUV */ 225 .fourcc = V4L2_PIX_FMT_YUV48_12, 226 .subsampling = V4L2_JPEG_CHROMA_SUBSAMPLING_444, 227 .nc = 3, 228 .depth = 36, 229 .mem_planes = 1, 230 .comp_planes = 1, 231 .h_align = 3, 232 .v_align = 3, 233 .flags = MXC_JPEG_FMT_TYPE_RAW, 234 .precision = 12, 235 }, 236 { 237 .name = "Gray", /* Gray (Y8/Y12) or Single Comp */ 238 .fourcc = V4L2_PIX_FMT_GREY, 239 .subsampling = V4L2_JPEG_CHROMA_SUBSAMPLING_GRAY, 240 .nc = 1, 241 .depth = 8, 242 .mem_planes = 1, 243 .comp_planes = 1, 244 .h_align = 3, 245 .v_align = 3, 246 .flags = MXC_JPEG_FMT_TYPE_RAW, 247 .precision = 8, 248 }, 249 { 250 .name = "Gray 12bit", /* Gray (Y8/Y12) or Single Comp */ 251 .fourcc = V4L2_PIX_FMT_Y012, 252 .subsampling = V4L2_JPEG_CHROMA_SUBSAMPLING_GRAY, 253 .nc = 1, 254 .depth = 12, 255 .mem_planes = 1, 256 .comp_planes = 1, 257 .h_align = 3, 258 .v_align = 3, 259 .flags = MXC_JPEG_FMT_TYPE_RAW, 260 .precision = 12, 261 }, 262}; 263 264#define MXC_JPEG_NUM_FORMATS ARRAY_SIZE(mxc_formats) 265 266static const int mxc_decode_mode = MXC_JPEG_DECODE; 267static const int mxc_encode_mode = MXC_JPEG_ENCODE; 268 269static const struct of_device_id mxc_jpeg_match[] = { 270 { 271 .compatible = "nxp,imx8qxp-jpgdec", 272 .data = &mxc_decode_mode, 273 }, 274 { 275 .compatible = "nxp,imx8qxp-jpgenc", 276 .data = &mxc_encode_mode, 277 }, 278 { }, 279}; 280 281/* 282 * default configuration stream, 64x64 yuv422 283 * split by JPEG marker, so it's easier to modify & use 284 */ 285static const unsigned char jpeg_soi[] = { 286 0xFF, 0xD8 287}; 288 289static const unsigned char jpeg_app0[] = { 290 0xFF, 0xE0, 291 0x00, 0x10, 0x4A, 0x46, 0x49, 0x46, 0x00, 292 0x01, 0x01, 0x00, 0x00, 0x01, 0x00, 0x01, 293 0x00, 0x00 294}; 295 296static const unsigned char jpeg_app14[] = { 297 0xFF, 0xEE, 298 0x00, 0x0E, 0x41, 0x64, 0x6F, 0x62, 0x65, 299 0x00, 0x64, 0x00, 0x00, 0x00, 0x00, 0x00 300}; 301 302static const unsigned char jpeg_dqt[] = { 303 0xFF, 0xDB, 304 0x00, 0x84, 0x00, 0x10, 0x0B, 0x0C, 0x0E, 305 0x0C, 0x0A, 0x10, 0x0E, 0x0D, 0x0E, 0x12, 306 0x11, 0x10, 0x13, 0x18, 0x28, 0x1A, 0x18, 307 0x16, 0x16, 0x18, 0x31, 0x23, 0x25, 0x1D, 308 0x28, 0x3A, 0x33, 0x3D, 0x3C, 0x39, 0x33, 309 0x38, 0x37, 0x40, 0x48, 0x5C, 0x4E, 0x40, 310 0x44, 0x57, 0x45, 0x37, 0x38, 0x50, 0x6D, 311 0x51, 0x57, 0x5F, 0x62, 0x67, 0x68, 0x67, 312 0x3E, 0x4D, 0x71, 0x79, 0x70, 0x64, 0x78, 313 0x5C, 0x65, 0x67, 0x63, 0x01, 0x11, 0x12, 314 0x12, 0x18, 0x15, 0x18, 0x2F, 0x1A, 0x1A, 315 0x2F, 0x63, 0x42, 0x38, 0x42, 0x63, 0x63, 316 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 317 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 318 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 319 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 320 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 321 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 322 0x63, 0x63, 0x63, 0x63, 0x63, 0x63 323}; 324 325static const unsigned char jpeg_dqt_extseq[] = { 326 0xFF, 0xDB, 327 0x01, 0x04, 328 0x10, 329 0x00, 0x80, 0x00, 0x58, 0x00, 0x60, 0x00, 0x70, 330 0x00, 0x60, 0x00, 0x50, 0x00, 0x80, 0x00, 0x70, 331 0x00, 0x68, 0x00, 0x70, 0x00, 0x90, 0x00, 0x88, 332 0x00, 0x80, 0x00, 0x98, 0x00, 0xC0, 0x01, 0x40, 333 0x00, 0xD0, 0x00, 0xC0, 0x00, 0xB0, 0x00, 0xB0, 334 0x00, 0xC0, 0x01, 0x88, 0x01, 0x18, 0x01, 0x28, 335 0x00, 0xE8, 0x01, 0x40, 0x01, 0xD0, 0x01, 0x98, 336 0x01, 0xE8, 0x01, 0xE0, 0x01, 0xC8, 0x01, 0x98, 337 0x01, 0xC0, 0x01, 0xB8, 0x02, 0x00, 0x02, 0x40, 338 0x02, 0xE0, 0x02, 0x70, 0x02, 0x00, 0x02, 0x20, 339 0x02, 0xB8, 0x02, 0x28, 0x01, 0xB8, 0x01, 0xC0, 340 0x02, 0x80, 0x03, 0x68, 0x02, 0x88, 0x02, 0xB8, 341 0x02, 0xF8, 0x03, 0x10, 0x03, 0x38, 0x03, 0x40, 342 0x03, 0x38, 0x01, 0xF0, 0x02, 0x68, 0x03, 0x88, 343 0x03, 0xC8, 0x03, 0x80, 0x03, 0x20, 0x03, 0xC0, 344 0x02, 0xE0, 0x03, 0x28, 0x03, 0x38, 0x03, 0x18, 345 0x11, 346 0x00, 0x88, 0x00, 0x90, 0x00, 0x90, 0x00, 0xC0, 347 0x00, 0xA8, 0x00, 0xC0, 0x01, 0x78, 0x00, 0xD0, 348 0x00, 0xD0, 0x01, 0x78, 0x03, 0x18, 0x02, 0x10, 349 0x01, 0xC0, 0x02, 0x10, 0x03, 0x18, 0x03, 0x18, 350 0x03, 0x18, 0x03, 0x18, 0x03, 0x18, 0x03, 0x18, 351 0x03, 0x18, 0x03, 0x18, 0x03, 0x18, 0x03, 0x18, 352 0x03, 0x18, 0x03, 0x18, 0x03, 0x18, 0x03, 0x18, 353 0x03, 0x18, 0x03, 0x18, 0x03, 0x18, 0x03, 0x18, 354 0x03, 0x18, 0x03, 0x18, 0x03, 0x18, 0x03, 0x18, 355 0x03, 0x18, 0x03, 0x18, 0x03, 0x18, 0x03, 0x18, 356 0x03, 0x18, 0x03, 0x18, 0x03, 0x18, 0x03, 0x18, 357 0x03, 0x18, 0x03, 0x18, 0x03, 0x18, 0x03, 0x18, 358 0x03, 0x18, 0x03, 0x18, 0x03, 0x18, 0x03, 0x18, 359 0x03, 0x18, 0x03, 0x18, 0x03, 0x18, 0x03, 0x18, 360 0x03, 0x18, 0x03, 0x18, 0x03, 0x18, 0x03, 0x18, 361 0x03, 0x18, 0x03, 0x18, 0x03, 0x18, 0x03, 0x18, 362}; 363 364static const unsigned char jpeg_sof_maximal[] = { 365 0xFF, 0xC0, 366 0x00, 0x14, 0x08, 0x00, 0x40, 0x00, 0x40, 367 0x04, 0x01, 0x11, 0x00, 0x02, 0x11, 0x01, 368 0x03, 0x11, 0x01, 0x04, 0x11, 0x01 369}; 370 371static const unsigned char jpeg_sof_extseq[] = { 372 0xFF, 0xC1, 373 0x00, 0x14, 0x08, 0x00, 0x40, 0x00, 0x40, 374 0x04, 0x01, 0x11, 0x00, 0x02, 0x11, 0x01, 375 0x03, 0x11, 0x01, 0x04, 0x11, 0x01 376}; 377 378static const unsigned char jpeg_dht[] = { 379 0xFF, 0xC4, 380 0x01, 0xA2, 0x00, 0x00, 0x01, 0x05, 0x01, 381 0x01, 0x01, 0x01, 0x01, 0x01, 0x00, 0x00, 382 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 383 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 384 0x09, 0x0A, 0x0B, 0x10, 0x00, 0x02, 0x01, 385 0x03, 0x03, 0x02, 0x04, 0x03, 0x05, 0x05, 386 0x04, 0x04, 0x00, 0x00, 0x01, 0x7D, 0x01, 387 0x02, 0x03, 0x00, 0x04, 0x11, 0x05, 0x12, 388 0x21, 0x31, 0x41, 0x06, 0x13, 0x51, 0x61, 389 0x07, 0x22, 0x71, 0x14, 0x32, 0x81, 0x91, 390 0xA1, 0x08, 0x23, 0x42, 0xB1, 0xC1, 0x15, 391 0x52, 0xD1, 0xF0, 0x24, 0x33, 0x62, 0x72, 392 0x82, 0x09, 0x0A, 0x16, 0x17, 0x18, 0x19, 393 0x1A, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2A, 394 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3A, 395 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 396 0x4A, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 397 0x59, 0x5A, 0x63, 0x64, 0x65, 0x66, 0x67, 398 0x68, 0x69, 0x6A, 0x73, 0x74, 0x75, 0x76, 399 0x77, 0x78, 0x79, 0x7A, 0x83, 0x84, 0x85, 400 0x86, 0x87, 0x88, 0x89, 0x8A, 0x92, 0x93, 401 0x94, 0x95, 0x96, 0x97, 0x98, 0x99, 0x9A, 402 0xA2, 0xA3, 0xA4, 0xA5, 0xA6, 0xA7, 0xA8, 403 0xA9, 0xAA, 0xB2, 0xB3, 0xB4, 0xB5, 0xB6, 404 0xB7, 0xB8, 0xB9, 0xBA, 0xC2, 0xC3, 0xC4, 405 0xC5, 0xC6, 0xC7, 0xC8, 0xC9, 0xCA, 0xD2, 406 0xD3, 0xD4, 0xD5, 0xD6, 0xD7, 0xD8, 0xD9, 407 0xDA, 0xE1, 0xE2, 0xE3, 0xE4, 0xE5, 0xE6, 408 0xE7, 0xE8, 0xE9, 0xEA, 0xF1, 0xF2, 0xF3, 409 0xF4, 0xF5, 0xF6, 0xF7, 0xF8, 0xF9, 0xFA, 410 0x01, 0x00, 0x03, 0x01, 0x01, 0x01, 0x01, 411 0x01, 0x01, 0x01, 0x01, 0x01, 0x00, 0x00, 412 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x03, 413 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, 414 0x0B, 0x11, 0x00, 0x02, 0x01, 0x02, 0x04, 415 0x04, 0x03, 0x04, 0x07, 0x05, 0x04, 0x04, 416 0x00, 0x01, 0x02, 0x77, 0x00, 0x01, 0x02, 417 0x03, 0x11, 0x04, 0x05, 0x21, 0x31, 0x06, 418 0x12, 0x41, 0x51, 0x07, 0x61, 0x71, 0x13, 419 0x22, 0x32, 0x81, 0x08, 0x14, 0x42, 0x91, 420 0xA1, 0xB1, 0xC1, 0x09, 0x23, 0x33, 0x52, 421 0xF0, 0x15, 0x62, 0x72, 0xD1, 0x0A, 0x16, 422 0x24, 0x34, 0xE1, 0x25, 0xF1, 0x17, 0x18, 423 0x19, 0x1A, 0x26, 0x27, 0x28, 0x29, 0x2A, 424 0x35, 0x36, 0x37, 0x38, 0x39, 0x3A, 0x43, 425 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4A, 426 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 427 0x5A, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 428 0x69, 0x6A, 0x73, 0x74, 0x75, 0x76, 0x77, 429 0x78, 0x79, 0x7A, 0x82, 0x83, 0x84, 0x85, 430 0x86, 0x87, 0x88, 0x89, 0x8A, 0x92, 0x93, 431 0x94, 0x95, 0x96, 0x97, 0x98, 0x99, 0x9A, 432 0xA2, 0xA3, 0xA4, 0xA5, 0xA6, 0xA7, 0xA8, 433 0xA9, 0xAA, 0xB2, 0xB3, 0xB4, 0xB5, 0xB6, 434 0xB7, 0xB8, 0xB9, 0xBA, 0xC2, 0xC3, 0xC4, 435 0xC5, 0xC6, 0xC7, 0xC8, 0xC9, 0xCA, 0xD2, 436 0xD3, 0xD4, 0xD5, 0xD6, 0xD7, 0xD8, 0xD9, 437 0xDA, 0xE2, 0xE3, 0xE4, 0xE5, 0xE6, 0xE7, 438 0xE8, 0xE9, 0xEA, 0xF2, 0xF3, 0xF4, 0xF5, 439 0xF6, 0xF7, 0xF8, 0xF9, 0xFA 440}; 441 442static const unsigned char jpeg_dht_extseq[] = { 443 0xFF, 0xC4, 444 0x02, 0x2a, 0x00, 0x00, 0x01, 0x05, 0x01, 445 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 446 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x01, 447 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 448 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 449 0x10, 0x00, 0x02, 0x01, 0x03, 0x03, 0x02, 450 0x04, 0x03, 0x05, 0x05, 0x02, 0x03, 0x02, 451 0x00, 0x00, 0xbf, 0x01, 0x02, 0x03, 0x00, 452 0x04, 0x11, 0x05, 0x12, 0x21, 0x31, 0x41, 453 0x06, 0x13, 0x51, 0x61, 0x07, 0x22, 0x71, 454 0x14, 0x32, 0x81, 0x91, 0xa1, 0x08, 0x23, 455 0x42, 0xb1, 0xc1, 0x15, 0x52, 0xd1, 0xf0, 456 0x24, 0x33, 0x62, 0x72, 0x82, 0x09, 0x0a, 457 0x16, 0x17, 0x18, 0x19, 0x1a, 0x25, 0x26, 458 0x27, 0x28, 0x29, 0x2a, 0x34, 0x35, 0x36, 459 0x37, 0x38, 0x39, 0x3a, 0x43, 0x44, 0x45, 460 0x46, 0x47, 0x48, 0x49, 0x4a, 0x53, 0x54, 461 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a, 0x63, 462 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x6a, 463 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79, 464 0x7a, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 465 0x89, 0x8a, 0x92, 0x93, 0x94, 0x95, 0x96, 466 0x97, 0x98, 0x99, 0x9a, 0xa2, 0xa3, 0xa4, 467 0xa5, 0xa6, 0xa7, 0xa8, 0xa9, 0xaa, 0xb2, 468 0xb3, 0xb4, 0xb5, 0xb6, 0xb7, 0xb8, 0xb9, 469 0xba, 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc7, 470 0xc8, 0xc9, 0xca, 0xd2, 0xd3, 0xd4, 0xd5, 471 0xd6, 0xd7, 0xd8, 0xd9, 0xda, 0xe1, 0xe2, 472 0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9, 473 0xea, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 474 0xf7, 0xf8, 0xf9, 0xfa, 0x0b, 0x0c, 0x0d, 475 0x0e, 0x1b, 0x1c, 0x1d, 0x1e, 0x2b, 0x2c, 476 0x2d, 0x2e, 0x3b, 0x3c, 0x3d, 0x3e, 0x4b, 477 0x4c, 0x4d, 0x4e, 0x5b, 0x5c, 0x5d, 0x5e, 478 0x6b, 0x6c, 0x6d, 0x6e, 0x7b, 0x7c, 0x7d, 479 0x7e, 0x8b, 0x8c, 0x8d, 0x8e, 0x9b, 0x9c, 480 0x9d, 0x9e, 0xab, 0xac, 0xad, 0xae, 0xbb, 481 0xbc, 0xbd, 0xbe, 0xcb, 0xcc, 0xcd, 0xce, 482 0xdb, 0xdc, 0xdd, 0xde, 0xeb, 0xec, 0xed, 483 0xee, 0xfb, 0xfc, 0xfd, 0xfe, 0x01, 0x00, 484 0x01, 0x05, 0x01, 0x01, 0x01, 0x01, 0x01, 485 0x01, 0x01, 0x01, 0x01, 0x01, 0x00, 0x00, 486 0x00, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 487 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 488 0x0d, 0x0e, 0x0f, 0x11, 0x00, 0x02, 0x01, 489 0x03, 0x03, 0x02, 0x04, 0x03, 0x05, 0x05, 490 0x02, 0x03, 0x02, 0x00, 0x00, 0xbf, 0x01, 491 0x02, 0x03, 0x00, 0x04, 0x11, 0x05, 0x12, 492 0x21, 0x31, 0x41, 0x06, 0x13, 0x51, 0x61, 493 0x07, 0x22, 0x71, 0x14, 0x32, 0x81, 0x91, 494 0xa1, 0x08, 0x23, 0x42, 0xb1, 0xc1, 0x15, 495 0x52, 0xd1, 0xf0, 0x24, 0x33, 0x62, 0x72, 496 0x82, 0x09, 0x0a, 0x16, 0x17, 0x18, 0x19, 497 0x1a, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a, 498 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 499 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 500 0x4a, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 501 0x59, 0x5a, 0x63, 0x64, 0x65, 0x66, 0x67, 502 0x68, 0x69, 0x6a, 0x73, 0x74, 0x75, 0x76, 503 0x77, 0x78, 0x79, 0x7a, 0x83, 0x84, 0x85, 504 0x86, 0x87, 0x88, 0x89, 0x8a, 0x92, 0x93, 505 0x94, 0x95, 0x96, 0x97, 0x98, 0x99, 0x9a, 506 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7, 0xa8, 507 0xa9, 0xaa, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6, 508 0xb7, 0xb8, 0xb9, 0xba, 0xc2, 0xc3, 0xc4, 509 0xc5, 0xc6, 0xc7, 0xc8, 0xc9, 0xca, 0xd2, 510 0xd3, 0xd4, 0xd5, 0xd6, 0xd7, 0xd8, 0xd9, 511 0xda, 0xe1, 0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 512 0xe7, 0xe8, 0xe9, 0xea, 0xf1, 0xf2, 0xf3, 513 0xf4, 0xf5, 0xf6, 0xf7, 0xf8, 0xf9, 0xfa, 514 0x0b, 0x0c, 0x0d, 0x0e, 0x1b, 0x1c, 0x1d, 515 0x1e, 0x2b, 0x2c, 0x2d, 0x2e, 0x3b, 0x3c, 516 0x3d, 0x3e, 0x4b, 0x4c, 0x4d, 0x4e, 0x5b, 517 0x5c, 0x5d, 0x5e, 0x6b, 0x6c, 0x6d, 0x6e, 518 0x7b, 0x7c, 0x7d, 0x7e, 0x8b, 0x8c, 0x8d, 519 0x8e, 0x9b, 0x9c, 0x9d, 0x9e, 0xab, 0xac, 520 0xad, 0xae, 0xbb, 0xbc, 0xbd, 0xbe, 0xcb, 521 0xcc, 0xcd, 0xce, 0xdb, 0xdc, 0xdd, 0xde, 522 0xeb, 0xec, 0xed, 0xee, 0xfb, 0xfc, 0xfd, 523 0xfe, 524}; 525 526static const unsigned char jpeg_dri[] = { 527 0xFF, 0xDD, 528 0x00, 0x04, 0x00, 0x20 529}; 530 531static const unsigned char jpeg_sos_maximal[] = { 532 0xFF, 0xDA, 533 0x00, 0x0C, 0x04, 0x01, 0x00, 0x02, 0x11, 0x03, 534 0x11, 0x04, 0x11, 0x00, 0x3F, 0x00 535}; 536 537static const unsigned char jpeg_image_red[] = { 538 0xFC, 0x5F, 0xA2, 0xBF, 0xCA, 0x73, 0xFE, 0xFE, 539 0x02, 0x8A, 0x00, 0x28, 0xA0, 0x02, 0x8A, 0x00, 540 0x28, 0xA0, 0x02, 0x8A, 0x00, 0x28, 0xA0, 0x02, 541 0x8A, 0x00, 0x28, 0xA0, 0x02, 0x8A, 0x00, 0x28, 542 0xA0, 0x02, 0x8A, 0x00, 0x28, 0xA0, 0x02, 0x8A, 543 0x00, 0x28, 0xA0, 0x02, 0x8A, 0x00, 0x28, 0xA0, 544 0x02, 0x8A, 0x00, 0x28, 0xA0, 0x02, 0x8A, 0x00, 545 0x28, 0xA0, 0x02, 0x8A, 0x00, 0x28, 0xA0, 0x02, 546 0x8A, 0x00, 0x28, 0xA0, 0x02, 0x8A, 0x00, 0x28, 547 0xA0, 0x02, 0x8A, 0x00, 0x28, 0xA0, 0x02, 0x8A, 548 0x00, 0x28, 0xA0, 0x02, 0x8A, 0x00 549}; 550 551static const unsigned char jpeg_eoi[] = { 552 0xFF, 0xD9 553}; 554 555struct mxc_jpeg_src_buf { 556 /* common v4l buffer stuff -- must be first */ 557 struct vb2_v4l2_buffer b; 558 struct list_head list; 559 560 /* mxc-jpeg specific */ 561 bool dht_needed; 562 bool jpeg_parse_error; 563 const struct mxc_jpeg_fmt *fmt; 564 int w; 565 int h; 566}; 567 568static inline struct mxc_jpeg_src_buf *vb2_to_mxc_buf(struct vb2_buffer *vb) 569{ 570 return container_of(to_vb2_v4l2_buffer(vb), 571 struct mxc_jpeg_src_buf, b); 572} 573 574static unsigned int debug; 575module_param(debug, int, 0644); 576MODULE_PARM_DESC(debug, "Debug level (0-3)"); 577 578static unsigned int hw_timeout = 2000; 579module_param(hw_timeout, int, 0644); 580MODULE_PARM_DESC(hw_timeout, "MXC JPEG hw timeout, the number of milliseconds"); 581 582static void mxc_jpeg_bytesperline(struct mxc_jpeg_q_data *q, u32 precision); 583static void mxc_jpeg_sizeimage(struct mxc_jpeg_q_data *q); 584 585static void _bswap16(u16 *a) 586{ 587 *a = ((*a & 0x00FF) << 8) | ((*a & 0xFF00) >> 8); 588} 589 590static void print_mxc_buf(struct mxc_jpeg_dev *jpeg, struct vb2_buffer *buf, 591 unsigned long len) 592{ 593 unsigned int plane_no; 594 u32 dma_addr; 595 void *vaddr; 596 unsigned long payload; 597 598 if (debug < 3) 599 return; 600 601 for (plane_no = 0; plane_no < buf->num_planes; plane_no++) { 602 payload = vb2_get_plane_payload(buf, plane_no); 603 if (len == 0) 604 len = payload; 605 dma_addr = vb2_dma_contig_plane_dma_addr(buf, plane_no); 606 vaddr = vb2_plane_vaddr(buf, plane_no); 607 v4l2_dbg(3, debug, &jpeg->v4l2_dev, 608 "plane %d (vaddr=%p dma_addr=%x payload=%ld):", 609 plane_no, vaddr, dma_addr, payload); 610 print_hex_dump(KERN_DEBUG, "", DUMP_PREFIX_OFFSET, 32, 1, 611 vaddr, len, false); 612 } 613} 614 615static inline struct mxc_jpeg_ctx *mxc_jpeg_fh_to_ctx(struct v4l2_fh *fh) 616{ 617 return container_of(fh, struct mxc_jpeg_ctx, fh); 618} 619 620static int enum_fmt(const struct mxc_jpeg_fmt *mxc_formats, int n, 621 struct v4l2_fmtdesc *f, u32 type) 622{ 623 int i, num = 0; 624 625 for (i = 0; i < n; ++i) { 626 if (mxc_formats[i].flags == type) { 627 /* index-th format of searched type found ? */ 628 if (num == f->index) 629 break; 630 /* Correct type but haven't reached our index yet, 631 * just increment per-type index 632 */ 633 ++num; 634 } 635 } 636 637 /* Format not found */ 638 if (i >= n) 639 return -EINVAL; 640 641 f->pixelformat = mxc_formats[i].fourcc; 642 643 return 0; 644} 645 646static const struct mxc_jpeg_fmt *mxc_jpeg_find_format(u32 pixelformat) 647{ 648 unsigned int k; 649 650 for (k = 0; k < MXC_JPEG_NUM_FORMATS; k++) { 651 const struct mxc_jpeg_fmt *fmt = &mxc_formats[k]; 652 653 if (fmt->fourcc == pixelformat) 654 return fmt; 655 } 656 return NULL; 657} 658 659static enum mxc_jpeg_image_format mxc_jpeg_fourcc_to_imgfmt(u32 fourcc) 660{ 661 switch (fourcc) { 662 case V4L2_PIX_FMT_GREY: 663 case V4L2_PIX_FMT_Y012: 664 return MXC_JPEG_GRAY; 665 case V4L2_PIX_FMT_YUYV: 666 case V4L2_PIX_FMT_Y212: 667 return MXC_JPEG_YUV422; 668 case V4L2_PIX_FMT_NV12: 669 case V4L2_PIX_FMT_NV12M: 670 case V4L2_PIX_FMT_P012: 671 case V4L2_PIX_FMT_P012M: 672 return MXC_JPEG_YUV420; 673 case V4L2_PIX_FMT_YUV24: 674 case V4L2_PIX_FMT_YUV48_12: 675 return MXC_JPEG_YUV444; 676 case V4L2_PIX_FMT_BGR24: 677 case V4L2_PIX_FMT_BGR48_12: 678 return MXC_JPEG_BGR; 679 case V4L2_PIX_FMT_ABGR32: 680 case V4L2_PIX_FMT_ABGR64_12: 681 return MXC_JPEG_ABGR; 682 default: 683 return MXC_JPEG_INVALID; 684 } 685} 686 687static struct mxc_jpeg_q_data *mxc_jpeg_get_q_data(struct mxc_jpeg_ctx *ctx, 688 enum v4l2_buf_type type) 689{ 690 if (V4L2_TYPE_IS_OUTPUT(type)) 691 return &ctx->out_q; 692 return &ctx->cap_q; 693} 694 695static void mxc_jpeg_addrs(struct mxc_jpeg_desc *desc, 696 struct vb2_buffer *raw_buf, 697 struct vb2_buffer *jpeg_buf, int offset) 698{ 699 int img_fmt = desc->stm_ctrl & STM_CTRL_IMAGE_FORMAT_MASK; 700 struct mxc_jpeg_ctx *ctx = vb2_get_drv_priv(raw_buf->vb2_queue); 701 struct mxc_jpeg_q_data *q_data; 702 703 q_data = mxc_jpeg_get_q_data(ctx, raw_buf->type); 704 desc->buf_base0 = vb2_dma_contig_plane_dma_addr(raw_buf, 0); 705 desc->buf_base1 = 0; 706 if (img_fmt == STM_CTRL_IMAGE_FORMAT(MXC_JPEG_YUV420)) { 707 if (raw_buf->num_planes == 2) 708 desc->buf_base1 = vb2_dma_contig_plane_dma_addr(raw_buf, 1); 709 else 710 desc->buf_base1 = desc->buf_base0 + q_data->sizeimage[0]; 711 } 712 desc->stm_bufbase = vb2_dma_contig_plane_dma_addr(jpeg_buf, 0) + 713 offset; 714} 715 716static bool mxc_jpeg_is_extended_sequential(const struct mxc_jpeg_fmt *fmt) 717{ 718 if (!fmt || !(fmt->flags & MXC_JPEG_FMT_TYPE_RAW)) 719 return false; 720 721 if (fmt->precision > 8) 722 return true; 723 724 return false; 725} 726 727static void notify_eos(struct mxc_jpeg_ctx *ctx) 728{ 729 const struct v4l2_event ev = { 730 .type = V4L2_EVENT_EOS 731 }; 732 733 dev_dbg(ctx->mxc_jpeg->dev, "Notify app event EOS reached"); 734 v4l2_event_queue_fh(&ctx->fh, &ev); 735} 736 737static void notify_src_chg(struct mxc_jpeg_ctx *ctx) 738{ 739 const struct v4l2_event ev = { 740 .type = V4L2_EVENT_SOURCE_CHANGE, 741 .u.src_change.changes = V4L2_EVENT_SRC_CH_RESOLUTION, 742 }; 743 744 dev_dbg(ctx->mxc_jpeg->dev, "Notify app event SRC_CH_RESOLUTION"); 745 v4l2_event_queue_fh(&ctx->fh, &ev); 746} 747 748static int mxc_get_free_slot(struct mxc_jpeg_slot_data *slot_data) 749{ 750 if (!slot_data->used) 751 return slot_data->slot; 752 return -1; 753} 754 755static bool mxc_jpeg_alloc_slot_data(struct mxc_jpeg_dev *jpeg) 756{ 757 struct mxc_jpeg_desc *desc; 758 struct mxc_jpeg_desc *cfg_desc; 759 void *cfg_stm; 760 761 if (jpeg->slot_data.desc) 762 goto skip_alloc; /* already allocated, reuse it */ 763 764 /* allocate descriptor for decoding/encoding phase */ 765 desc = dma_alloc_coherent(jpeg->dev, 766 sizeof(struct mxc_jpeg_desc), 767 &jpeg->slot_data.desc_handle, 768 GFP_ATOMIC); 769 if (!desc) 770 goto err; 771 jpeg->slot_data.desc = desc; 772 773 /* allocate descriptor for configuration phase (encoder only) */ 774 cfg_desc = dma_alloc_coherent(jpeg->dev, 775 sizeof(struct mxc_jpeg_desc), 776 &jpeg->slot_data.cfg_desc_handle, 777 GFP_ATOMIC); 778 if (!cfg_desc) 779 goto err; 780 jpeg->slot_data.cfg_desc = cfg_desc; 781 782 /* allocate configuration stream */ 783 cfg_stm = dma_alloc_coherent(jpeg->dev, 784 MXC_JPEG_MAX_CFG_STREAM, 785 &jpeg->slot_data.cfg_stream_handle, 786 GFP_ATOMIC); 787 if (!cfg_stm) 788 goto err; 789 jpeg->slot_data.cfg_stream_vaddr = cfg_stm; 790 791skip_alloc: 792 jpeg->slot_data.used = true; 793 794 return true; 795err: 796 dev_err(jpeg->dev, "Could not allocate descriptors for slot %d", jpeg->slot_data.slot); 797 798 return false; 799} 800 801static void mxc_jpeg_free_slot_data(struct mxc_jpeg_dev *jpeg) 802{ 803 /* free descriptor for decoding/encoding phase */ 804 dma_free_coherent(jpeg->dev, sizeof(struct mxc_jpeg_desc), 805 jpeg->slot_data.desc, 806 jpeg->slot_data.desc_handle); 807 808 /* free descriptor for encoder configuration phase / decoder DHT */ 809 dma_free_coherent(jpeg->dev, sizeof(struct mxc_jpeg_desc), 810 jpeg->slot_data.cfg_desc, 811 jpeg->slot_data.cfg_desc_handle); 812 813 /* free configuration stream */ 814 dma_free_coherent(jpeg->dev, MXC_JPEG_MAX_CFG_STREAM, 815 jpeg->slot_data.cfg_stream_vaddr, 816 jpeg->slot_data.cfg_stream_handle); 817 818 jpeg->slot_data.used = false; 819} 820 821static void mxc_jpeg_check_and_set_last_buffer(struct mxc_jpeg_ctx *ctx, 822 struct vb2_v4l2_buffer *src_buf, 823 struct vb2_v4l2_buffer *dst_buf) 824{ 825 if (v4l2_m2m_is_last_draining_src_buf(ctx->fh.m2m_ctx, src_buf)) { 826 dst_buf->flags |= V4L2_BUF_FLAG_LAST; 827 v4l2_m2m_mark_stopped(ctx->fh.m2m_ctx); 828 notify_eos(ctx); 829 ctx->header_parsed = false; 830 } 831} 832 833static void mxc_jpeg_job_finish(struct mxc_jpeg_ctx *ctx, enum vb2_buffer_state state, bool reset) 834{ 835 struct mxc_jpeg_dev *jpeg = ctx->mxc_jpeg; 836 void __iomem *reg = jpeg->base_reg; 837 struct vb2_v4l2_buffer *src_buf, *dst_buf; 838 839 dst_buf = v4l2_m2m_next_dst_buf(ctx->fh.m2m_ctx); 840 src_buf = v4l2_m2m_next_src_buf(ctx->fh.m2m_ctx); 841 mxc_jpeg_check_and_set_last_buffer(ctx, src_buf, dst_buf); 842 v4l2_m2m_src_buf_remove(ctx->fh.m2m_ctx); 843 v4l2_m2m_dst_buf_remove(ctx->fh.m2m_ctx); 844 v4l2_m2m_buf_done(src_buf, state); 845 v4l2_m2m_buf_done(dst_buf, state); 846 847 mxc_jpeg_disable_irq(reg, ctx->slot); 848 jpeg->slot_data.used = false; 849 if (reset) 850 mxc_jpeg_sw_reset(reg); 851} 852 853static u32 mxc_jpeg_get_plane_size(struct mxc_jpeg_q_data *q_data, u32 plane_no) 854{ 855 const struct mxc_jpeg_fmt *fmt = q_data->fmt; 856 u32 size; 857 int i; 858 859 if (plane_no >= fmt->mem_planes) 860 return 0; 861 862 if (fmt->mem_planes == fmt->comp_planes) 863 return q_data->sizeimage[plane_no]; 864 865 if (plane_no < fmt->mem_planes - 1) 866 return q_data->sizeimage[plane_no]; 867 868 size = q_data->sizeimage[fmt->mem_planes - 1]; 869 870 /* Should be impossible given mxc_formats. */ 871 if (WARN_ON_ONCE(fmt->comp_planes > ARRAY_SIZE(q_data->sizeimage))) 872 return size; 873 874 for (i = fmt->mem_planes; i < fmt->comp_planes; i++) 875 size += q_data->sizeimage[i]; 876 877 return size; 878} 879 880static irqreturn_t mxc_jpeg_dec_irq(int irq, void *priv) 881{ 882 struct mxc_jpeg_dev *jpeg = priv; 883 struct mxc_jpeg_ctx *ctx; 884 void __iomem *reg = jpeg->base_reg; 885 struct device *dev = jpeg->dev; 886 struct vb2_v4l2_buffer *src_buf, *dst_buf; 887 struct mxc_jpeg_src_buf *jpeg_src_buf; 888 enum vb2_buffer_state buf_state; 889 u32 dec_ret, com_status; 890 unsigned long payload; 891 struct mxc_jpeg_q_data *q_data; 892 enum v4l2_buf_type cap_type = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE; 893 unsigned int slot; 894 895 spin_lock(&jpeg->hw_lock); 896 897 com_status = readl(reg + COM_STATUS); 898 slot = COM_STATUS_CUR_SLOT(com_status); 899 dev_dbg(dev, "Irq %d on slot %d.\n", irq, slot); 900 901 ctx = v4l2_m2m_get_curr_priv(jpeg->m2m_dev); 902 if (WARN_ON(!ctx)) 903 goto job_unlock; 904 905 if (slot != ctx->slot) { 906 /* TODO investigate when adding multi-instance support */ 907 dev_warn(dev, "IRQ slot %d != context slot %d.\n", 908 slot, ctx->slot); 909 goto job_unlock; 910 } 911 912 if (!jpeg->slot_data.used) 913 goto job_unlock; 914 915 dec_ret = readl(reg + MXC_SLOT_OFFSET(slot, SLOT_STATUS)); 916 writel(dec_ret, reg + MXC_SLOT_OFFSET(slot, SLOT_STATUS)); /* w1c */ 917 918 dst_buf = v4l2_m2m_next_dst_buf(ctx->fh.m2m_ctx); 919 src_buf = v4l2_m2m_next_src_buf(ctx->fh.m2m_ctx); 920 if (!dst_buf || !src_buf) { 921 dev_err(dev, "No source or destination buffer.\n"); 922 goto job_unlock; 923 } 924 jpeg_src_buf = vb2_to_mxc_buf(&src_buf->vb2_buf); 925 926 if (dec_ret & SLOT_STATUS_ENC_CONFIG_ERR) { 927 u32 ret = readl(reg + CAST_STATUS12); 928 929 dev_err(dev, "Encoder/decoder error, dec_ret = 0x%08x, status=0x%08x", 930 dec_ret, ret); 931 mxc_jpeg_clr_desc(reg, slot); 932 mxc_jpeg_sw_reset(reg); 933 buf_state = VB2_BUF_STATE_ERROR; 934 goto buffers_done; 935 } 936 937 if (!(dec_ret & SLOT_STATUS_FRMDONE)) 938 goto job_unlock; 939 940 if (jpeg->mode == MXC_JPEG_ENCODE && 941 ctx->enc_state == MXC_JPEG_ENC_CONF) { 942 q_data = mxc_jpeg_get_q_data(ctx, V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE); 943 ctx->enc_state = MXC_JPEG_ENCODING; 944 dev_dbg(dev, "Encoder config finished. Start encoding...\n"); 945 mxc_jpeg_enc_set_quality(dev, reg, ctx->jpeg_quality); 946 mxc_jpeg_enc_mode_go(dev, reg, mxc_jpeg_is_extended_sequential(q_data->fmt)); 947 goto job_unlock; 948 } 949 if (jpeg->mode == MXC_JPEG_DECODE && jpeg_src_buf->dht_needed) { 950 jpeg_src_buf->dht_needed = false; 951 dev_dbg(dev, "Decoder DHT cfg finished. Start decoding...\n"); 952 goto job_unlock; 953 } 954 955 if (jpeg->mode == MXC_JPEG_ENCODE) { 956 payload = readl(reg + MXC_SLOT_OFFSET(slot, SLOT_BUF_PTR)); 957 vb2_set_plane_payload(&dst_buf->vb2_buf, 0, payload); 958 dev_dbg(dev, "Encoding finished, payload size: %ld\n", 959 payload); 960 } else { 961 q_data = mxc_jpeg_get_q_data(ctx, cap_type); 962 payload = mxc_jpeg_get_plane_size(q_data, 0); 963 vb2_set_plane_payload(&dst_buf->vb2_buf, 0, payload); 964 vb2_set_plane_payload(&dst_buf->vb2_buf, 1, 0); 965 if (q_data->fmt->mem_planes == 2) { 966 payload = mxc_jpeg_get_plane_size(q_data, 1); 967 vb2_set_plane_payload(&dst_buf->vb2_buf, 1, payload); 968 } 969 dev_dbg(dev, "Decoding finished, payload size: %ld + %ld\n", 970 vb2_get_plane_payload(&dst_buf->vb2_buf, 0), 971 vb2_get_plane_payload(&dst_buf->vb2_buf, 1)); 972 } 973 974 /* short preview of the results */ 975 dev_dbg(dev, "src_buf preview: "); 976 print_mxc_buf(jpeg, &src_buf->vb2_buf, 32); 977 dev_dbg(dev, "dst_buf preview: "); 978 print_mxc_buf(jpeg, &dst_buf->vb2_buf, 32); 979 buf_state = VB2_BUF_STATE_DONE; 980 981buffers_done: 982 mxc_jpeg_job_finish(ctx, buf_state, false); 983 spin_unlock(&jpeg->hw_lock); 984 cancel_delayed_work(&ctx->task_timer); 985 v4l2_m2m_job_finish(jpeg->m2m_dev, ctx->fh.m2m_ctx); 986 return IRQ_HANDLED; 987job_unlock: 988 spin_unlock(&jpeg->hw_lock); 989 return IRQ_HANDLED; 990} 991 992static int mxc_jpeg_fixup_sof(struct mxc_jpeg_sof *sof, 993 u32 fourcc, 994 u16 w, u16 h) 995{ 996 int sof_length; 997 const struct mxc_jpeg_fmt *fmt = mxc_jpeg_find_format(fourcc); 998 999 if (fmt) 1000 sof->precision = fmt->precision; 1001 else 1002 sof->precision = 8; /* TODO allow 8/12 bit precision*/ 1003 sof->height = h; 1004 _bswap16(&sof->height); 1005 sof->width = w; 1006 _bswap16(&sof->width); 1007 1008 switch (fourcc) { 1009 case V4L2_PIX_FMT_NV12: 1010 case V4L2_PIX_FMT_NV12M: 1011 case V4L2_PIX_FMT_P012: 1012 case V4L2_PIX_FMT_P012M: 1013 sof->components_no = 3; 1014 sof->comp[0].v = 0x2; 1015 sof->comp[0].h = 0x2; 1016 break; 1017 case V4L2_PIX_FMT_YUYV: 1018 case V4L2_PIX_FMT_Y212: 1019 sof->components_no = 3; 1020 sof->comp[0].v = 0x1; 1021 sof->comp[0].h = 0x2; 1022 break; 1023 case V4L2_PIX_FMT_YUV24: 1024 case V4L2_PIX_FMT_YUV48_12: 1025 case V4L2_PIX_FMT_BGR24: 1026 case V4L2_PIX_FMT_BGR48_12: 1027 default: 1028 sof->components_no = 3; 1029 break; 1030 case V4L2_PIX_FMT_ABGR32: 1031 case V4L2_PIX_FMT_ABGR64_12: 1032 sof->components_no = 4; 1033 break; 1034 case V4L2_PIX_FMT_GREY: 1035 case V4L2_PIX_FMT_Y012: 1036 sof->components_no = 1; 1037 break; 1038 } 1039 sof_length = 8 + 3 * sof->components_no; 1040 sof->length = sof_length; 1041 _bswap16(&sof->length); 1042 1043 return sof_length; /* not swaped */ 1044} 1045 1046static int mxc_jpeg_fixup_sos(struct mxc_jpeg_sos *sos, 1047 u32 fourcc) 1048{ 1049 int sos_length; 1050 u8 *sof_u8 = (u8 *)sos; 1051 1052 switch (fourcc) { 1053 case V4L2_PIX_FMT_NV12: 1054 case V4L2_PIX_FMT_NV12M: 1055 case V4L2_PIX_FMT_P012: 1056 case V4L2_PIX_FMT_P012M: 1057 sos->components_no = 3; 1058 break; 1059 case V4L2_PIX_FMT_YUYV: 1060 case V4L2_PIX_FMT_Y212: 1061 sos->components_no = 3; 1062 break; 1063 case V4L2_PIX_FMT_YUV24: 1064 case V4L2_PIX_FMT_YUV48_12: 1065 case V4L2_PIX_FMT_BGR24: 1066 case V4L2_PIX_FMT_BGR48_12: 1067 default: 1068 sos->components_no = 3; 1069 break; 1070 case V4L2_PIX_FMT_ABGR32: 1071 case V4L2_PIX_FMT_ABGR64_12: 1072 sos->components_no = 4; 1073 break; 1074 case V4L2_PIX_FMT_GREY: 1075 case V4L2_PIX_FMT_Y012: 1076 sos->components_no = 1; 1077 break; 1078 } 1079 sos_length = 6 + 2 * sos->components_no; 1080 sos->length = sos_length; 1081 _bswap16(&sos->length); 1082 1083 /* SOS ignorable bytes, not so ignorable after all */ 1084 sof_u8[sos_length - 1] = 0x0; 1085 sof_u8[sos_length - 2] = 0x3f; 1086 sof_u8[sos_length - 3] = 0x0; 1087 1088 return sos_length; /* not swaped */ 1089} 1090 1091static unsigned int mxc_jpeg_setup_cfg_stream(void *cfg_stream_vaddr, 1092 u32 fourcc, 1093 u16 w, u16 h) 1094{ 1095 /* 1096 * There is a hardware issue that first 128 bytes of configuration data 1097 * can't be loaded correctly. 1098 * To avoid this issue, we need to write the configuration from 1099 * an offset which should be no less than 0x80 (128 bytes). 1100 */ 1101 unsigned int offset = 0x80; 1102 u8 *cfg = (u8 *)cfg_stream_vaddr; 1103 struct mxc_jpeg_sof *sof; 1104 struct mxc_jpeg_sos *sos; 1105 const struct mxc_jpeg_fmt *fmt = mxc_jpeg_find_format(fourcc); 1106 1107 if (!fmt) 1108 return 0; 1109 1110 memcpy(cfg + offset, jpeg_soi, ARRAY_SIZE(jpeg_soi)); 1111 offset += ARRAY_SIZE(jpeg_soi); 1112 1113 if (fmt->is_rgb) { 1114 memcpy(cfg + offset, jpeg_app14, sizeof(jpeg_app14)); 1115 offset += sizeof(jpeg_app14); 1116 } else { 1117 memcpy(cfg + offset, jpeg_app0, sizeof(jpeg_app0)); 1118 offset += sizeof(jpeg_app0); 1119 } 1120 1121 if (mxc_jpeg_is_extended_sequential(fmt)) { 1122 memcpy(cfg + offset, jpeg_dqt_extseq, sizeof(jpeg_dqt_extseq)); 1123 offset += sizeof(jpeg_dqt_extseq); 1124 1125 memcpy(cfg + offset, jpeg_sof_extseq, sizeof(jpeg_sof_extseq)); 1126 } else { 1127 memcpy(cfg + offset, jpeg_dqt, sizeof(jpeg_dqt)); 1128 offset += sizeof(jpeg_dqt); 1129 1130 memcpy(cfg + offset, jpeg_sof_maximal, sizeof(jpeg_sof_maximal)); 1131 } 1132 offset += 2; /* skip marker ID */ 1133 sof = (struct mxc_jpeg_sof *)(cfg + offset); 1134 offset += mxc_jpeg_fixup_sof(sof, fourcc, w, h); 1135 1136 if (mxc_jpeg_is_extended_sequential(fmt)) { 1137 memcpy(cfg + offset, jpeg_dht_extseq, sizeof(jpeg_dht_extseq)); 1138 offset += sizeof(jpeg_dht_extseq); 1139 } else { 1140 memcpy(cfg + offset, jpeg_dht, sizeof(jpeg_dht)); 1141 offset += sizeof(jpeg_dht); 1142 } 1143 1144 memcpy(cfg + offset, jpeg_dri, sizeof(jpeg_dri)); 1145 offset += sizeof(jpeg_dri); 1146 1147 memcpy(cfg + offset, jpeg_sos_maximal, sizeof(jpeg_sos_maximal)); 1148 offset += 2; /* skip marker ID */ 1149 sos = (struct mxc_jpeg_sos *)(cfg + offset); 1150 offset += mxc_jpeg_fixup_sos(sos, fourcc); 1151 1152 memcpy(cfg + offset, jpeg_image_red, sizeof(jpeg_image_red)); 1153 offset += sizeof(jpeg_image_red); 1154 1155 memcpy(cfg + offset, jpeg_eoi, sizeof(jpeg_eoi)); 1156 offset += sizeof(jpeg_eoi); 1157 1158 return offset; 1159} 1160 1161static void mxc_jpeg_config_dec_desc(struct vb2_buffer *out_buf, 1162 struct mxc_jpeg_ctx *ctx, 1163 struct vb2_buffer *src_buf, 1164 struct vb2_buffer *dst_buf) 1165{ 1166 enum v4l2_buf_type cap_type = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE; 1167 struct mxc_jpeg_q_data *q_data_cap; 1168 enum mxc_jpeg_image_format img_fmt; 1169 struct mxc_jpeg_dev *jpeg = ctx->mxc_jpeg; 1170 void __iomem *reg = jpeg->base_reg; 1171 unsigned int slot = ctx->slot; 1172 struct mxc_jpeg_desc *desc = jpeg->slot_data.desc; 1173 struct mxc_jpeg_desc *cfg_desc = jpeg->slot_data.cfg_desc; 1174 dma_addr_t desc_handle = jpeg->slot_data.desc_handle; 1175 dma_addr_t cfg_desc_handle = jpeg->slot_data.cfg_desc_handle; 1176 dma_addr_t cfg_stream_handle = jpeg->slot_data.cfg_stream_handle; 1177 unsigned int *cfg_size = &jpeg->slot_data.cfg_stream_size; 1178 void *cfg_stream_vaddr = jpeg->slot_data.cfg_stream_vaddr; 1179 struct mxc_jpeg_src_buf *jpeg_src_buf; 1180 1181 jpeg_src_buf = vb2_to_mxc_buf(src_buf); 1182 1183 /* setup the decoding descriptor */ 1184 desc->next_descpt_ptr = 0; /* end of chain */ 1185 q_data_cap = mxc_jpeg_get_q_data(ctx, cap_type); 1186 desc->imgsize = q_data_cap->w_adjusted << 16 | q_data_cap->h_adjusted; 1187 img_fmt = mxc_jpeg_fourcc_to_imgfmt(q_data_cap->fmt->fourcc); 1188 desc->stm_ctrl &= ~STM_CTRL_IMAGE_FORMAT(0xF); /* clear image format */ 1189 desc->stm_ctrl |= STM_CTRL_IMAGE_FORMAT(img_fmt); 1190 desc->stm_ctrl |= STM_CTRL_BITBUF_PTR_CLR(1); 1191 if (mxc_jpeg_is_extended_sequential(jpeg_src_buf->fmt)) 1192 desc->stm_ctrl |= STM_CTRL_PIXEL_PRECISION; 1193 else 1194 desc->stm_ctrl &= ~STM_CTRL_PIXEL_PRECISION; 1195 desc->line_pitch = q_data_cap->bytesperline[0]; 1196 mxc_jpeg_addrs(desc, dst_buf, src_buf, 0); 1197 mxc_jpeg_set_bufsize(desc, ALIGN(vb2_plane_size(src_buf, 0), 1024)); 1198 print_descriptor_info(jpeg->dev, desc); 1199 1200 if (!jpeg_src_buf->dht_needed) { 1201 /* validate the decoding descriptor */ 1202 mxc_jpeg_set_desc(desc_handle, reg, slot); 1203 return; 1204 } 1205 1206 /* 1207 * if a default huffman table is needed, use the config descriptor to 1208 * inject a DHT, by chaining it before the decoding descriptor 1209 */ 1210 *cfg_size = mxc_jpeg_setup_cfg_stream(cfg_stream_vaddr, 1211 V4L2_PIX_FMT_YUYV, 1212 MXC_JPEG_MIN_WIDTH, 1213 MXC_JPEG_MIN_HEIGHT); 1214 cfg_desc->next_descpt_ptr = desc_handle | MXC_NXT_DESCPT_EN; 1215 cfg_desc->buf_base0 = vb2_dma_contig_plane_dma_addr(dst_buf, 0); 1216 cfg_desc->buf_base1 = 0; 1217 cfg_desc->imgsize = MXC_JPEG_MIN_WIDTH << 16; 1218 cfg_desc->imgsize |= MXC_JPEG_MIN_HEIGHT; 1219 cfg_desc->line_pitch = MXC_JPEG_MIN_WIDTH * 2; 1220 cfg_desc->stm_ctrl = STM_CTRL_IMAGE_FORMAT(MXC_JPEG_YUV422); 1221 cfg_desc->stm_ctrl |= STM_CTRL_BITBUF_PTR_CLR(1); 1222 cfg_desc->stm_bufbase = cfg_stream_handle; 1223 cfg_desc->stm_bufsize = ALIGN(*cfg_size, 1024); 1224 print_descriptor_info(jpeg->dev, cfg_desc); 1225 1226 /* validate the configuration descriptor */ 1227 mxc_jpeg_set_desc(cfg_desc_handle, reg, slot); 1228} 1229 1230static void mxc_jpeg_config_enc_desc(struct vb2_buffer *out_buf, 1231 struct mxc_jpeg_ctx *ctx, 1232 struct vb2_buffer *src_buf, 1233 struct vb2_buffer *dst_buf) 1234{ 1235 struct mxc_jpeg_dev *jpeg = ctx->mxc_jpeg; 1236 void __iomem *reg = jpeg->base_reg; 1237 unsigned int slot = ctx->slot; 1238 struct mxc_jpeg_desc *desc = jpeg->slot_data.desc; 1239 struct mxc_jpeg_desc *cfg_desc = jpeg->slot_data.cfg_desc; 1240 dma_addr_t desc_handle = jpeg->slot_data.desc_handle; 1241 dma_addr_t cfg_desc_handle = jpeg->slot_data.cfg_desc_handle; 1242 void *cfg_stream_vaddr = jpeg->slot_data.cfg_stream_vaddr; 1243 struct mxc_jpeg_q_data *q_data; 1244 enum mxc_jpeg_image_format img_fmt; 1245 int w, h; 1246 1247 q_data = mxc_jpeg_get_q_data(ctx, src_buf->vb2_queue->type); 1248 1249 jpeg->slot_data.cfg_stream_size = 1250 mxc_jpeg_setup_cfg_stream(cfg_stream_vaddr, 1251 q_data->fmt->fourcc, 1252 q_data->crop.width, 1253 q_data->crop.height); 1254 1255 /* chain the config descriptor with the encoding descriptor */ 1256 cfg_desc->next_descpt_ptr = desc_handle | MXC_NXT_DESCPT_EN; 1257 1258 cfg_desc->buf_base0 = jpeg->slot_data.cfg_stream_handle; 1259 cfg_desc->buf_base1 = 0; 1260 cfg_desc->line_pitch = 0; 1261 cfg_desc->stm_bufbase = 0; /* no output expected */ 1262 cfg_desc->stm_bufsize = 0x0; 1263 cfg_desc->imgsize = 0; 1264 cfg_desc->stm_ctrl = STM_CTRL_CONFIG_MOD(1); 1265 cfg_desc->stm_ctrl |= STM_CTRL_BITBUF_PTR_CLR(1); 1266 1267 desc->next_descpt_ptr = 0; /* end of chain */ 1268 1269 /* use adjusted resolution for CAST IP job */ 1270 w = q_data->crop.width; 1271 h = q_data->crop.height; 1272 v4l_bound_align_image(&w, w, MXC_JPEG_MAX_WIDTH, q_data->fmt->h_align, 1273 &h, h, MXC_JPEG_MAX_HEIGHT, q_data->fmt->v_align, 0); 1274 mxc_jpeg_set_res(desc, w, h); 1275 mxc_jpeg_set_line_pitch(desc, q_data->bytesperline[0]); 1276 mxc_jpeg_set_bufsize(desc, ALIGN(vb2_plane_size(dst_buf, 0), 1024)); 1277 img_fmt = mxc_jpeg_fourcc_to_imgfmt(q_data->fmt->fourcc); 1278 if (img_fmt == MXC_JPEG_INVALID) 1279 dev_err(jpeg->dev, "No valid image format detected\n"); 1280 desc->stm_ctrl = STM_CTRL_CONFIG_MOD(0) | 1281 STM_CTRL_IMAGE_FORMAT(img_fmt); 1282 desc->stm_ctrl |= STM_CTRL_BITBUF_PTR_CLR(1); 1283 if (mxc_jpeg_is_extended_sequential(q_data->fmt)) 1284 desc->stm_ctrl |= STM_CTRL_PIXEL_PRECISION; 1285 else 1286 desc->stm_ctrl &= ~STM_CTRL_PIXEL_PRECISION; 1287 mxc_jpeg_addrs(desc, src_buf, dst_buf, 0); 1288 dev_dbg(jpeg->dev, "cfg_desc:\n"); 1289 print_descriptor_info(jpeg->dev, cfg_desc); 1290 dev_dbg(jpeg->dev, "enc desc:\n"); 1291 print_descriptor_info(jpeg->dev, desc); 1292 print_wrapper_info(jpeg->dev, reg); 1293 print_cast_status(jpeg->dev, reg, MXC_JPEG_ENCODE); 1294 1295 /* validate the configuration descriptor */ 1296 mxc_jpeg_set_desc(cfg_desc_handle, reg, slot); 1297} 1298 1299static const struct mxc_jpeg_fmt *mxc_jpeg_get_sibling_format(const struct mxc_jpeg_fmt *fmt) 1300{ 1301 int i; 1302 1303 for (i = 0; i < MXC_JPEG_NUM_FORMATS; i++) { 1304 if (mxc_formats[i].subsampling == fmt->subsampling && 1305 mxc_formats[i].nc == fmt->nc && 1306 mxc_formats[i].precision == fmt->precision && 1307 mxc_formats[i].is_rgb == fmt->is_rgb && 1308 mxc_formats[i].fourcc != fmt->fourcc) 1309 return &mxc_formats[i]; 1310 } 1311 1312 return NULL; 1313} 1314 1315static bool mxc_jpeg_compare_format(const struct mxc_jpeg_fmt *fmt1, 1316 const struct mxc_jpeg_fmt *fmt2) 1317{ 1318 if (fmt1 == fmt2) 1319 return true; 1320 if (mxc_jpeg_get_sibling_format(fmt1) == fmt2) 1321 return true; 1322 return false; 1323} 1324 1325static void mxc_jpeg_set_last_buffer(struct mxc_jpeg_ctx *ctx) 1326{ 1327 struct vb2_v4l2_buffer *next_dst_buf; 1328 1329 next_dst_buf = v4l2_m2m_dst_buf_remove(ctx->fh.m2m_ctx); 1330 if (!next_dst_buf) { 1331 ctx->fh.m2m_ctx->is_draining = true; 1332 ctx->fh.m2m_ctx->next_buf_last = true; 1333 return; 1334 } 1335 1336 v4l2_m2m_last_buffer_done(ctx->fh.m2m_ctx, next_dst_buf); 1337} 1338 1339static bool mxc_jpeg_source_change(struct mxc_jpeg_ctx *ctx, 1340 struct mxc_jpeg_src_buf *jpeg_src_buf) 1341{ 1342 struct device *dev = ctx->mxc_jpeg->dev; 1343 struct mxc_jpeg_q_data *q_data_cap; 1344 1345 if (!jpeg_src_buf->fmt) 1346 return false; 1347 1348 q_data_cap = mxc_jpeg_get_q_data(ctx, V4L2_BUF_TYPE_VIDEO_CAPTURE); 1349 if (mxc_jpeg_compare_format(q_data_cap->fmt, jpeg_src_buf->fmt)) 1350 jpeg_src_buf->fmt = q_data_cap->fmt; 1351 if (ctx->need_initial_source_change_evt || 1352 q_data_cap->fmt != jpeg_src_buf->fmt || 1353 q_data_cap->w != jpeg_src_buf->w || 1354 q_data_cap->h != jpeg_src_buf->h) { 1355 dev_dbg(dev, "Detected jpeg res=(%dx%d)->(%dx%d), pixfmt=%c%c%c%c\n", 1356 q_data_cap->w, q_data_cap->h, 1357 jpeg_src_buf->w, jpeg_src_buf->h, 1358 (jpeg_src_buf->fmt->fourcc & 0xff), 1359 (jpeg_src_buf->fmt->fourcc >> 8) & 0xff, 1360 (jpeg_src_buf->fmt->fourcc >> 16) & 0xff, 1361 (jpeg_src_buf->fmt->fourcc >> 24) & 0xff); 1362 1363 /* 1364 * set-up the capture queue with the pixelformat and resolution 1365 * detected from the jpeg output stream 1366 */ 1367 q_data_cap->w = jpeg_src_buf->w; 1368 q_data_cap->h = jpeg_src_buf->h; 1369 q_data_cap->fmt = jpeg_src_buf->fmt; 1370 q_data_cap->w_adjusted = q_data_cap->w; 1371 q_data_cap->h_adjusted = q_data_cap->h; 1372 q_data_cap->crop.left = 0; 1373 q_data_cap->crop.top = 0; 1374 q_data_cap->crop.width = jpeg_src_buf->w; 1375 q_data_cap->crop.height = jpeg_src_buf->h; 1376 1377 /* 1378 * align up the resolution for CAST IP, 1379 * but leave the buffer resolution unchanged 1380 */ 1381 v4l_bound_align_image(&q_data_cap->w_adjusted, 1382 q_data_cap->w_adjusted, /* adjust up */ 1383 MXC_JPEG_MAX_WIDTH, 1384 q_data_cap->fmt->h_align, 1385 &q_data_cap->h_adjusted, 1386 q_data_cap->h_adjusted, /* adjust up */ 1387 MXC_JPEG_MAX_HEIGHT, 1388 q_data_cap->fmt->v_align, 1389 0); 1390 1391 /* setup bytesperline/sizeimage for capture queue */ 1392 mxc_jpeg_bytesperline(q_data_cap, jpeg_src_buf->fmt->precision); 1393 mxc_jpeg_sizeimage(q_data_cap); 1394 notify_src_chg(ctx); 1395 ctx->source_change = 1; 1396 ctx->need_initial_source_change_evt = false; 1397 if (vb2_is_streaming(v4l2_m2m_get_dst_vq(ctx->fh.m2m_ctx))) 1398 mxc_jpeg_set_last_buffer(ctx); 1399 } 1400 1401 return ctx->source_change ? true : false; 1402} 1403 1404static int mxc_jpeg_job_ready(void *priv) 1405{ 1406 struct mxc_jpeg_ctx *ctx = priv; 1407 1408 return ctx->source_change ? 0 : 1; 1409} 1410 1411static void mxc_jpeg_device_run_timeout(struct work_struct *work) 1412{ 1413 struct delayed_work *dwork = to_delayed_work(work); 1414 struct mxc_jpeg_ctx *ctx = container_of(dwork, struct mxc_jpeg_ctx, task_timer); 1415 struct mxc_jpeg_dev *jpeg = ctx->mxc_jpeg; 1416 unsigned long flags; 1417 1418 spin_lock_irqsave(&ctx->mxc_jpeg->hw_lock, flags); 1419 if (ctx->mxc_jpeg->slot_data.used) { 1420 dev_warn(jpeg->dev, "%s timeout, cancel it\n", 1421 ctx->mxc_jpeg->mode == MXC_JPEG_DECODE ? "decode" : "encode"); 1422 mxc_jpeg_job_finish(ctx, VB2_BUF_STATE_ERROR, true); 1423 v4l2_m2m_job_finish(ctx->mxc_jpeg->m2m_dev, ctx->fh.m2m_ctx); 1424 } 1425 spin_unlock_irqrestore(&ctx->mxc_jpeg->hw_lock, flags); 1426} 1427 1428static void mxc_jpeg_device_run(void *priv) 1429{ 1430 struct mxc_jpeg_ctx *ctx = priv; 1431 struct mxc_jpeg_dev *jpeg = ctx->mxc_jpeg; 1432 void __iomem *reg = jpeg->base_reg; 1433 struct device *dev = jpeg->dev; 1434 struct vb2_v4l2_buffer *src_buf, *dst_buf; 1435 unsigned long flags; 1436 struct mxc_jpeg_q_data *q_data_cap, *q_data_out; 1437 struct mxc_jpeg_src_buf *jpeg_src_buf; 1438 1439 spin_lock_irqsave(&ctx->mxc_jpeg->hw_lock, flags); 1440 src_buf = v4l2_m2m_next_src_buf(ctx->fh.m2m_ctx); 1441 dst_buf = v4l2_m2m_next_dst_buf(ctx->fh.m2m_ctx); 1442 if (!src_buf || !dst_buf) { 1443 dev_err(dev, "Null src or dst buf\n"); 1444 goto end; 1445 } 1446 1447 q_data_cap = mxc_jpeg_get_q_data(ctx, V4L2_BUF_TYPE_VIDEO_CAPTURE); 1448 if (!q_data_cap) 1449 goto end; 1450 q_data_out = mxc_jpeg_get_q_data(ctx, V4L2_BUF_TYPE_VIDEO_OUTPUT); 1451 if (!q_data_out) 1452 goto end; 1453 src_buf->sequence = q_data_out->sequence++; 1454 dst_buf->sequence = q_data_cap->sequence++; 1455 1456 v4l2_m2m_buf_copy_metadata(src_buf, dst_buf, true); 1457 1458 jpeg_src_buf = vb2_to_mxc_buf(&src_buf->vb2_buf); 1459 if (q_data_cap->fmt->mem_planes != dst_buf->vb2_buf.num_planes) { 1460 dev_err(dev, "Capture format %s has %d planes, but capture buffer has %d planes\n", 1461 q_data_cap->fmt->name, q_data_cap->fmt->mem_planes, 1462 dst_buf->vb2_buf.num_planes); 1463 jpeg_src_buf->jpeg_parse_error = true; 1464 } 1465 if (jpeg_src_buf->jpeg_parse_error) { 1466 mxc_jpeg_check_and_set_last_buffer(ctx, src_buf, dst_buf); 1467 v4l2_m2m_src_buf_remove(ctx->fh.m2m_ctx); 1468 v4l2_m2m_dst_buf_remove(ctx->fh.m2m_ctx); 1469 v4l2_m2m_buf_done(src_buf, VB2_BUF_STATE_ERROR); 1470 v4l2_m2m_buf_done(dst_buf, VB2_BUF_STATE_ERROR); 1471 spin_unlock_irqrestore(&ctx->mxc_jpeg->hw_lock, flags); 1472 v4l2_m2m_job_finish(jpeg->m2m_dev, ctx->fh.m2m_ctx); 1473 1474 return; 1475 } 1476 if (ctx->mxc_jpeg->mode == MXC_JPEG_DECODE) { 1477 if (ctx->source_change || mxc_jpeg_source_change(ctx, jpeg_src_buf)) { 1478 spin_unlock_irqrestore(&ctx->mxc_jpeg->hw_lock, flags); 1479 v4l2_m2m_job_finish(jpeg->m2m_dev, ctx->fh.m2m_ctx); 1480 return; 1481 } 1482 } 1483 1484 mxc_jpeg_enable(reg); 1485 mxc_jpeg_set_l_endian(reg, 1); 1486 1487 ctx->slot = mxc_get_free_slot(&jpeg->slot_data); 1488 if (ctx->slot < 0) { 1489 dev_err(dev, "No more free slots\n"); 1490 goto end; 1491 } 1492 if (!mxc_jpeg_alloc_slot_data(jpeg)) { 1493 dev_err(dev, "Cannot allocate slot data\n"); 1494 goto end; 1495 } 1496 1497 mxc_jpeg_enable_slot(reg, ctx->slot); 1498 mxc_jpeg_enable_irq(reg, ctx->slot); 1499 1500 if (jpeg->mode == MXC_JPEG_ENCODE) { 1501 dev_dbg(dev, "Encoding on slot %d\n", ctx->slot); 1502 ctx->enc_state = MXC_JPEG_ENC_CONF; 1503 mxc_jpeg_config_enc_desc(&dst_buf->vb2_buf, ctx, 1504 &src_buf->vb2_buf, &dst_buf->vb2_buf); 1505 /* start config phase */ 1506 mxc_jpeg_enc_mode_conf(dev, reg, 1507 mxc_jpeg_is_extended_sequential(q_data_out->fmt)); 1508 } else { 1509 dev_dbg(dev, "Decoding on slot %d\n", ctx->slot); 1510 print_mxc_buf(jpeg, &src_buf->vb2_buf, 0); 1511 mxc_jpeg_config_dec_desc(&dst_buf->vb2_buf, ctx, 1512 &src_buf->vb2_buf, &dst_buf->vb2_buf); 1513 mxc_jpeg_dec_mode_go(dev, reg); 1514 } 1515 schedule_delayed_work(&ctx->task_timer, msecs_to_jiffies(hw_timeout)); 1516end: 1517 spin_unlock_irqrestore(&ctx->mxc_jpeg->hw_lock, flags); 1518} 1519 1520static int mxc_jpeg_decoder_cmd(struct file *file, void *priv, 1521 struct v4l2_decoder_cmd *cmd) 1522{ 1523 struct v4l2_fh *fh = file->private_data; 1524 struct mxc_jpeg_ctx *ctx = mxc_jpeg_fh_to_ctx(fh); 1525 unsigned long flags; 1526 int ret; 1527 1528 ret = v4l2_m2m_ioctl_try_decoder_cmd(file, fh, cmd); 1529 if (ret < 0) 1530 return ret; 1531 1532 if (!vb2_is_streaming(v4l2_m2m_get_src_vq(fh->m2m_ctx))) 1533 return 0; 1534 1535 spin_lock_irqsave(&ctx->mxc_jpeg->hw_lock, flags); 1536 ret = v4l2_m2m_ioctl_decoder_cmd(file, priv, cmd); 1537 spin_unlock_irqrestore(&ctx->mxc_jpeg->hw_lock, flags); 1538 if (ret < 0) 1539 return ret; 1540 1541 if (cmd->cmd == V4L2_DEC_CMD_STOP && 1542 v4l2_m2m_has_stopped(fh->m2m_ctx)) { 1543 notify_eos(ctx); 1544 ctx->header_parsed = false; 1545 } 1546 1547 if (cmd->cmd == V4L2_DEC_CMD_START && 1548 v4l2_m2m_has_stopped(fh->m2m_ctx)) 1549 vb2_clear_last_buffer_dequeued(&fh->m2m_ctx->cap_q_ctx.q); 1550 return 0; 1551} 1552 1553static int mxc_jpeg_encoder_cmd(struct file *file, void *priv, 1554 struct v4l2_encoder_cmd *cmd) 1555{ 1556 struct v4l2_fh *fh = file->private_data; 1557 struct mxc_jpeg_ctx *ctx = mxc_jpeg_fh_to_ctx(fh); 1558 unsigned long flags; 1559 int ret; 1560 1561 ret = v4l2_m2m_ioctl_try_encoder_cmd(file, fh, cmd); 1562 if (ret < 0) 1563 return ret; 1564 1565 if (!vb2_is_streaming(v4l2_m2m_get_src_vq(fh->m2m_ctx)) || 1566 !vb2_is_streaming(v4l2_m2m_get_dst_vq(fh->m2m_ctx))) 1567 return 0; 1568 1569 spin_lock_irqsave(&ctx->mxc_jpeg->hw_lock, flags); 1570 ret = v4l2_m2m_ioctl_encoder_cmd(file, fh, cmd); 1571 spin_unlock_irqrestore(&ctx->mxc_jpeg->hw_lock, flags); 1572 if (ret < 0) 1573 return 0; 1574 1575 if (cmd->cmd == V4L2_ENC_CMD_STOP && 1576 v4l2_m2m_has_stopped(fh->m2m_ctx)) 1577 notify_eos(ctx); 1578 1579 if (cmd->cmd == V4L2_ENC_CMD_START && 1580 v4l2_m2m_has_stopped(fh->m2m_ctx)) 1581 vb2_clear_last_buffer_dequeued(&fh->m2m_ctx->cap_q_ctx.q); 1582 1583 return 0; 1584} 1585 1586static int mxc_jpeg_queue_setup(struct vb2_queue *q, 1587 unsigned int *nbuffers, 1588 unsigned int *nplanes, 1589 unsigned int sizes[], 1590 struct device *alloc_ctxs[]) 1591{ 1592 struct mxc_jpeg_ctx *ctx = vb2_get_drv_priv(q); 1593 struct mxc_jpeg_q_data *q_data = NULL; 1594 int i; 1595 1596 q_data = mxc_jpeg_get_q_data(ctx, q->type); 1597 if (!q_data) 1598 return -EINVAL; 1599 1600 /* Handle CREATE_BUFS situation - *nplanes != 0 */ 1601 if (*nplanes) { 1602 if (*nplanes != q_data->fmt->mem_planes) 1603 return -EINVAL; 1604 for (i = 0; i < *nplanes; i++) { 1605 if (sizes[i] < mxc_jpeg_get_plane_size(q_data, i)) 1606 return -EINVAL; 1607 } 1608 return 0; 1609 } 1610 1611 /* Handle REQBUFS situation */ 1612 *nplanes = q_data->fmt->mem_planes; 1613 for (i = 0; i < *nplanes; i++) 1614 sizes[i] = mxc_jpeg_get_plane_size(q_data, i); 1615 1616 if (V4L2_TYPE_IS_OUTPUT(q->type)) 1617 ctx->need_initial_source_change_evt = true; 1618 1619 return 0; 1620} 1621 1622static int mxc_jpeg_start_streaming(struct vb2_queue *q, unsigned int count) 1623{ 1624 struct mxc_jpeg_ctx *ctx = vb2_get_drv_priv(q); 1625 struct mxc_jpeg_q_data *q_data = mxc_jpeg_get_q_data(ctx, q->type); 1626 int ret; 1627 1628 v4l2_m2m_update_start_streaming_state(ctx->fh.m2m_ctx, q); 1629 1630 if (ctx->mxc_jpeg->mode == MXC_JPEG_DECODE && V4L2_TYPE_IS_CAPTURE(q->type)) 1631 ctx->source_change = 0; 1632 dev_dbg(ctx->mxc_jpeg->dev, "Start streaming ctx=%p", ctx); 1633 q_data->sequence = 0; 1634 1635 ret = pm_runtime_resume_and_get(ctx->mxc_jpeg->dev); 1636 if (ret < 0) { 1637 dev_err(ctx->mxc_jpeg->dev, "Failed to power up jpeg\n"); 1638 return ret; 1639 } 1640 1641 return 0; 1642} 1643 1644static void mxc_jpeg_stop_streaming(struct vb2_queue *q) 1645{ 1646 struct mxc_jpeg_ctx *ctx = vb2_get_drv_priv(q); 1647 struct vb2_v4l2_buffer *vbuf; 1648 1649 dev_dbg(ctx->mxc_jpeg->dev, "Stop streaming ctx=%p", ctx); 1650 1651 /* Release all active buffers */ 1652 for (;;) { 1653 if (V4L2_TYPE_IS_OUTPUT(q->type)) 1654 vbuf = v4l2_m2m_src_buf_remove(ctx->fh.m2m_ctx); 1655 else 1656 vbuf = v4l2_m2m_dst_buf_remove(ctx->fh.m2m_ctx); 1657 if (!vbuf) 1658 break; 1659 v4l2_m2m_buf_done(vbuf, VB2_BUF_STATE_ERROR); 1660 } 1661 1662 v4l2_m2m_update_stop_streaming_state(ctx->fh.m2m_ctx, q); 1663 /* if V4L2_DEC_CMD_STOP is sent before the source change triggered, 1664 * restore the is_draining flag 1665 */ 1666 if (V4L2_TYPE_IS_CAPTURE(q->type) && ctx->source_change && ctx->fh.m2m_ctx->last_src_buf) 1667 ctx->fh.m2m_ctx->is_draining = true; 1668 1669 if (V4L2_TYPE_IS_OUTPUT(q->type) && 1670 v4l2_m2m_has_stopped(ctx->fh.m2m_ctx)) { 1671 notify_eos(ctx); 1672 ctx->header_parsed = false; 1673 } 1674 1675 pm_runtime_put_sync(&ctx->mxc_jpeg->pdev->dev); 1676} 1677 1678static int mxc_jpeg_valid_comp_id(struct device *dev, 1679 struct mxc_jpeg_sof *sof, 1680 struct mxc_jpeg_sos *sos) 1681{ 1682 int valid = 1; 1683 int i; 1684 1685 /* 1686 * there's a limitation in the IP that the component IDs must be 1687 * between 0..4, if they are not, let's patch them 1688 */ 1689 for (i = 0; i < sof->components_no; i++) 1690 if (sof->comp[i].id > MXC_JPEG_MAX_COMPONENTS) { 1691 valid = 0; 1692 dev_err(dev, "Component %d has invalid ID: %d", 1693 i, sof->comp[i].id); 1694 } 1695 if (!valid) 1696 /* patch all comp IDs if at least one is invalid */ 1697 for (i = 0; i < sof->components_no; i++) { 1698 dev_warn(dev, "Component %d ID patched to: %d", 1699 i, i + 1); 1700 sof->comp[i].id = i + 1; 1701 sos->comp[i].id = i + 1; 1702 } 1703 1704 return valid; 1705} 1706 1707static bool mxc_jpeg_match_image_format(const struct mxc_jpeg_fmt *fmt, 1708 const struct v4l2_jpeg_header *header) 1709{ 1710 if (fmt->subsampling != header->frame.subsampling || 1711 fmt->nc != header->frame.num_components || 1712 fmt->precision != header->frame.precision) 1713 return false; 1714 1715 /* 1716 * If the transform flag from APP14 marker is 0, images that are 1717 * encoded with 3 components have RGB colorspace, see Recommendation 1718 * ITU-T T.872 chapter 6.5.3 APP14 marker segment for colour encoding 1719 */ 1720 if (header->frame.subsampling == V4L2_JPEG_CHROMA_SUBSAMPLING_444) { 1721 u8 is_rgb = header->app14_tf == V4L2_JPEG_APP14_TF_CMYK_RGB ? 1 : 0; 1722 1723 if (is_rgb != fmt->is_rgb) 1724 return false; 1725 } 1726 return true; 1727} 1728 1729static u32 mxc_jpeg_get_image_format(struct device *dev, 1730 const struct v4l2_jpeg_header *header) 1731{ 1732 int i; 1733 u32 fourcc = 0; 1734 1735 for (i = 0; i < MXC_JPEG_NUM_FORMATS; i++) { 1736 if (mxc_jpeg_match_image_format(&mxc_formats[i], header)) { 1737 fourcc = mxc_formats[i].fourcc; 1738 break; 1739 } 1740 } 1741 if (fourcc == 0) { 1742 dev_err(dev, 1743 "Could not identify image format nc=%d, subsampling=%d, precision=%d\n", 1744 header->frame.num_components, 1745 header->frame.subsampling, 1746 header->frame.precision); 1747 return fourcc; 1748 } 1749 1750 return fourcc; 1751} 1752 1753static void mxc_jpeg_bytesperline(struct mxc_jpeg_q_data *q, u32 precision) 1754{ 1755 /* Bytes distance between the leftmost pixels in two adjacent lines */ 1756 if (q->fmt->fourcc == V4L2_PIX_FMT_JPEG) { 1757 /* bytesperline unused for compressed formats */ 1758 q->bytesperline[0] = 0; 1759 q->bytesperline[1] = 0; 1760 } else if (q->fmt->subsampling == V4L2_JPEG_CHROMA_SUBSAMPLING_420) { 1761 /* When the image format is planar the bytesperline value 1762 * applies to the first plane and is divided by the same factor 1763 * as the width field for the other planes 1764 */ 1765 q->bytesperline[0] = q->w_adjusted * DIV_ROUND_UP(precision, 8); 1766 q->bytesperline[1] = q->bytesperline[0]; 1767 } else if (q->fmt->subsampling == V4L2_JPEG_CHROMA_SUBSAMPLING_422) { 1768 q->bytesperline[0] = q->w_adjusted * DIV_ROUND_UP(precision, 8) * 2; 1769 q->bytesperline[1] = 0; 1770 } else if (q->fmt->subsampling == V4L2_JPEG_CHROMA_SUBSAMPLING_444) { 1771 q->bytesperline[0] = q->w_adjusted * DIV_ROUND_UP(precision, 8) * q->fmt->nc; 1772 q->bytesperline[1] = 0; 1773 } else { 1774 /* grayscale */ 1775 q->bytesperline[0] = q->w_adjusted * DIV_ROUND_UP(precision, 8); 1776 q->bytesperline[1] = 0; 1777 } 1778} 1779 1780static void mxc_jpeg_sizeimage(struct mxc_jpeg_q_data *q) 1781{ 1782 if (q->fmt->fourcc == V4L2_PIX_FMT_JPEG) { 1783 /* if no sizeimage from user, assume worst jpeg compression */ 1784 if (!q->sizeimage[0]) 1785 q->sizeimage[0] = 6 * q->w * q->h; 1786 q->sizeimage[1] = 0; 1787 1788 if (q->sizeimage[0] > MXC_JPEG_MAX_SIZEIMAGE) 1789 q->sizeimage[0] = MXC_JPEG_MAX_SIZEIMAGE; 1790 1791 /* jpeg stream size must be multiple of 1K */ 1792 q->sizeimage[0] = ALIGN(q->sizeimage[0], 1024); 1793 } else { 1794 q->sizeimage[0] = q->bytesperline[0] * q->h_adjusted; 1795 q->sizeimage[1] = 0; 1796 if (q->fmt->subsampling == V4L2_JPEG_CHROMA_SUBSAMPLING_420) 1797 q->sizeimage[1] = q->sizeimage[0] / 2; 1798 } 1799} 1800 1801static int mxc_jpeg_parse(struct mxc_jpeg_ctx *ctx, struct vb2_buffer *vb) 1802{ 1803 struct device *dev = ctx->mxc_jpeg->dev; 1804 struct mxc_jpeg_q_data *q_data_out; 1805 struct mxc_jpeg_q_data *q_data_cap; 1806 u32 fourcc; 1807 struct v4l2_jpeg_header header; 1808 struct mxc_jpeg_sof *psof = NULL; 1809 struct mxc_jpeg_sos *psos = NULL; 1810 struct mxc_jpeg_src_buf *jpeg_src_buf = vb2_to_mxc_buf(vb); 1811 u8 *src_addr = (u8 *)vb2_plane_vaddr(vb, 0); 1812 u32 size = vb2_get_plane_payload(vb, 0); 1813 int ret; 1814 1815 memset(&header, 0, sizeof(header)); 1816 ret = v4l2_jpeg_parse_header((void *)src_addr, size, &header); 1817 if (ret < 0) { 1818 dev_err(dev, "Error parsing JPEG stream markers\n"); 1819 return ret; 1820 } 1821 1822 /* if DHT marker present, no need to inject default one */ 1823 jpeg_src_buf->dht_needed = (header.num_dht == 0); 1824 1825 q_data_out = mxc_jpeg_get_q_data(ctx, 1826 V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE); 1827 if (q_data_out->w == 0 && q_data_out->h == 0) { 1828 dev_warn(dev, "Invalid user resolution 0x0"); 1829 dev_warn(dev, "Keeping resolution from JPEG: %dx%d", 1830 header.frame.width, header.frame.height); 1831 } else if (header.frame.width != q_data_out->w || 1832 header.frame.height != q_data_out->h) { 1833 dev_err(dev, 1834 "Resolution mismatch: %dx%d (JPEG) versus %dx%d(user)", 1835 header.frame.width, header.frame.height, 1836 q_data_out->w, q_data_out->h); 1837 } 1838 q_data_out->w = header.frame.width; 1839 q_data_out->h = header.frame.height; 1840 if (header.frame.width > MXC_JPEG_MAX_WIDTH || 1841 header.frame.height > MXC_JPEG_MAX_HEIGHT) { 1842 dev_err(dev, "JPEG width or height should be <= 8192: %dx%d\n", 1843 header.frame.width, header.frame.height); 1844 return -EINVAL; 1845 } 1846 if (header.frame.width < MXC_JPEG_MIN_WIDTH || 1847 header.frame.height < MXC_JPEG_MIN_HEIGHT) { 1848 dev_err(dev, "JPEG width or height should be > 64: %dx%d\n", 1849 header.frame.width, header.frame.height); 1850 return -EINVAL; 1851 } 1852 if (header.frame.num_components > V4L2_JPEG_MAX_COMPONENTS) { 1853 dev_err(dev, "JPEG number of components should be <=%d", 1854 V4L2_JPEG_MAX_COMPONENTS); 1855 return -EINVAL; 1856 } 1857 /* check and, if necessary, patch component IDs*/ 1858 psof = (struct mxc_jpeg_sof *)header.sof.start; 1859 psos = (struct mxc_jpeg_sos *)header.sos.start; 1860 if (!mxc_jpeg_valid_comp_id(dev, psof, psos)) 1861 dev_warn(dev, "JPEG component ids should be 0-3 or 1-4"); 1862 1863 q_data_cap = mxc_jpeg_get_q_data(ctx, V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE); 1864 if (q_data_cap->fmt && mxc_jpeg_match_image_format(q_data_cap->fmt, &header)) 1865 fourcc = q_data_cap->fmt->fourcc; 1866 else 1867 fourcc = mxc_jpeg_get_image_format(dev, &header); 1868 if (fourcc == 0) 1869 return -EINVAL; 1870 1871 jpeg_src_buf->fmt = mxc_jpeg_find_format(fourcc); 1872 jpeg_src_buf->w = header.frame.width; 1873 jpeg_src_buf->h = header.frame.height; 1874 ctx->header_parsed = true; 1875 1876 if (!v4l2_m2m_num_src_bufs_ready(ctx->fh.m2m_ctx)) 1877 mxc_jpeg_source_change(ctx, jpeg_src_buf); 1878 1879 return 0; 1880} 1881 1882static void mxc_jpeg_buf_queue(struct vb2_buffer *vb) 1883{ 1884 int ret; 1885 struct vb2_v4l2_buffer *vbuf = to_vb2_v4l2_buffer(vb); 1886 struct mxc_jpeg_ctx *ctx = vb2_get_drv_priv(vb->vb2_queue); 1887 struct mxc_jpeg_src_buf *jpeg_src_buf; 1888 1889 if (V4L2_TYPE_IS_CAPTURE(vb->vb2_queue->type) && 1890 vb2_is_streaming(vb->vb2_queue) && 1891 v4l2_m2m_dst_buf_is_last(ctx->fh.m2m_ctx)) { 1892 struct mxc_jpeg_q_data *q_data; 1893 1894 q_data = mxc_jpeg_get_q_data(ctx, vb->vb2_queue->type); 1895 vbuf->field = V4L2_FIELD_NONE; 1896 vbuf->sequence = q_data->sequence++; 1897 v4l2_m2m_last_buffer_done(ctx->fh.m2m_ctx, vbuf); 1898 notify_eos(ctx); 1899 ctx->header_parsed = false; 1900 return; 1901 } 1902 1903 if (vb->vb2_queue->type == V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE) 1904 goto end; 1905 1906 /* for V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE */ 1907 if (ctx->mxc_jpeg->mode != MXC_JPEG_DECODE) 1908 goto end; 1909 1910 jpeg_src_buf = vb2_to_mxc_buf(vb); 1911 jpeg_src_buf->jpeg_parse_error = false; 1912 ret = mxc_jpeg_parse(ctx, vb); 1913 if (ret) 1914 jpeg_src_buf->jpeg_parse_error = true; 1915 1916end: 1917 v4l2_m2m_buf_queue(ctx->fh.m2m_ctx, vbuf); 1918} 1919 1920static int mxc_jpeg_buf_out_validate(struct vb2_buffer *vb) 1921{ 1922 struct vb2_v4l2_buffer *vbuf = to_vb2_v4l2_buffer(vb); 1923 1924 vbuf->field = V4L2_FIELD_NONE; 1925 1926 return 0; 1927} 1928 1929static int mxc_jpeg_buf_prepare(struct vb2_buffer *vb) 1930{ 1931 struct vb2_v4l2_buffer *vbuf = to_vb2_v4l2_buffer(vb); 1932 struct mxc_jpeg_ctx *ctx = vb2_get_drv_priv(vb->vb2_queue); 1933 struct mxc_jpeg_q_data *q_data = NULL; 1934 struct device *dev = ctx->mxc_jpeg->dev; 1935 unsigned long sizeimage; 1936 int i; 1937 1938 vbuf->field = V4L2_FIELD_NONE; 1939 1940 q_data = mxc_jpeg_get_q_data(ctx, vb->vb2_queue->type); 1941 if (!q_data) 1942 return -EINVAL; 1943 for (i = 0; i < q_data->fmt->mem_planes; i++) { 1944 sizeimage = mxc_jpeg_get_plane_size(q_data, i); 1945 if (!ctx->source_change && vb2_plane_size(vb, i) < sizeimage) { 1946 dev_err(dev, "plane %d too small (%lu < %lu)", 1947 i, vb2_plane_size(vb, i), sizeimage); 1948 return -EINVAL; 1949 } 1950 } 1951 if (V4L2_TYPE_IS_CAPTURE(vb->vb2_queue->type)) { 1952 vb2_set_plane_payload(vb, 0, 0); 1953 vb2_set_plane_payload(vb, 1, 0); 1954 } 1955 return 0; 1956} 1957 1958static const struct vb2_ops mxc_jpeg_qops = { 1959 .queue_setup = mxc_jpeg_queue_setup, 1960 .wait_prepare = vb2_ops_wait_prepare, 1961 .wait_finish = vb2_ops_wait_finish, 1962 .buf_out_validate = mxc_jpeg_buf_out_validate, 1963 .buf_prepare = mxc_jpeg_buf_prepare, 1964 .start_streaming = mxc_jpeg_start_streaming, 1965 .stop_streaming = mxc_jpeg_stop_streaming, 1966 .buf_queue = mxc_jpeg_buf_queue, 1967}; 1968 1969static int mxc_jpeg_queue_init(void *priv, struct vb2_queue *src_vq, 1970 struct vb2_queue *dst_vq) 1971{ 1972 struct mxc_jpeg_ctx *ctx = priv; 1973 int ret; 1974 1975 src_vq->type = V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE; 1976 src_vq->io_modes = VB2_MMAP | VB2_DMABUF; 1977 src_vq->drv_priv = ctx; 1978 src_vq->buf_struct_size = sizeof(struct mxc_jpeg_src_buf); 1979 src_vq->ops = &mxc_jpeg_qops; 1980 src_vq->mem_ops = &vb2_dma_contig_memops; 1981 src_vq->timestamp_flags = V4L2_BUF_FLAG_TIMESTAMP_COPY; 1982 src_vq->lock = &ctx->mxc_jpeg->lock; 1983 src_vq->dev = ctx->mxc_jpeg->dev; 1984 1985 ret = vb2_queue_init(src_vq); 1986 if (ret) 1987 return ret; 1988 1989 dst_vq->type = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE; 1990 dst_vq->io_modes = VB2_MMAP | VB2_DMABUF; 1991 dst_vq->drv_priv = ctx; 1992 dst_vq->buf_struct_size = sizeof(struct v4l2_m2m_buffer); 1993 dst_vq->ops = &mxc_jpeg_qops; 1994 dst_vq->mem_ops = &vb2_dma_contig_memops; 1995 dst_vq->timestamp_flags = V4L2_BUF_FLAG_TIMESTAMP_COPY; 1996 dst_vq->lock = &ctx->mxc_jpeg->lock; 1997 dst_vq->dev = ctx->mxc_jpeg->dev; 1998 1999 ret = vb2_queue_init(dst_vq); 2000 return ret; 2001} 2002 2003static void mxc_jpeg_set_default_params(struct mxc_jpeg_ctx *ctx) 2004{ 2005 struct mxc_jpeg_q_data *out_q = &ctx->out_q; 2006 struct mxc_jpeg_q_data *cap_q = &ctx->cap_q; 2007 struct mxc_jpeg_q_data *q[2] = {out_q, cap_q}; 2008 int i; 2009 2010 if (ctx->mxc_jpeg->mode == MXC_JPEG_ENCODE) { 2011 out_q->fmt = mxc_jpeg_find_format(MXC_JPEG_DEFAULT_PFMT); 2012 cap_q->fmt = mxc_jpeg_find_format(V4L2_PIX_FMT_JPEG); 2013 } else { 2014 out_q->fmt = mxc_jpeg_find_format(V4L2_PIX_FMT_JPEG); 2015 cap_q->fmt = mxc_jpeg_find_format(MXC_JPEG_DEFAULT_PFMT); 2016 } 2017 2018 for (i = 0; i < 2; i++) { 2019 q[i]->w = MXC_JPEG_DEFAULT_WIDTH; 2020 q[i]->h = MXC_JPEG_DEFAULT_HEIGHT; 2021 q[i]->w_adjusted = MXC_JPEG_DEFAULT_WIDTH; 2022 q[i]->h_adjusted = MXC_JPEG_DEFAULT_HEIGHT; 2023 q[i]->crop.left = 0; 2024 q[i]->crop.top = 0; 2025 q[i]->crop.width = MXC_JPEG_DEFAULT_WIDTH; 2026 q[i]->crop.height = MXC_JPEG_DEFAULT_HEIGHT; 2027 mxc_jpeg_bytesperline(q[i], q[i]->fmt->precision); 2028 mxc_jpeg_sizeimage(q[i]); 2029 } 2030} 2031 2032static int mxc_jpeg_s_ctrl(struct v4l2_ctrl *ctrl) 2033{ 2034 struct mxc_jpeg_ctx *ctx = 2035 container_of(ctrl->handler, struct mxc_jpeg_ctx, ctrl_handler); 2036 2037 switch (ctrl->id) { 2038 case V4L2_CID_JPEG_COMPRESSION_QUALITY: 2039 ctx->jpeg_quality = ctrl->val; 2040 break; 2041 default: 2042 dev_err(ctx->mxc_jpeg->dev, "Invalid control, id = %d, val = %d\n", 2043 ctrl->id, ctrl->val); 2044 return -EINVAL; 2045 } 2046 2047 return 0; 2048} 2049 2050static const struct v4l2_ctrl_ops mxc_jpeg_ctrl_ops = { 2051 .s_ctrl = mxc_jpeg_s_ctrl, 2052}; 2053 2054static void mxc_jpeg_encode_ctrls(struct mxc_jpeg_ctx *ctx) 2055{ 2056 v4l2_ctrl_new_std(&ctx->ctrl_handler, &mxc_jpeg_ctrl_ops, 2057 V4L2_CID_JPEG_COMPRESSION_QUALITY, 1, 100, 1, 75); 2058} 2059 2060static int mxc_jpeg_ctrls_setup(struct mxc_jpeg_ctx *ctx) 2061{ 2062 int err; 2063 2064 v4l2_ctrl_handler_init(&ctx->ctrl_handler, 2); 2065 2066 if (ctx->mxc_jpeg->mode == MXC_JPEG_ENCODE) 2067 mxc_jpeg_encode_ctrls(ctx); 2068 2069 if (ctx->ctrl_handler.error) { 2070 err = ctx->ctrl_handler.error; 2071 2072 v4l2_ctrl_handler_free(&ctx->ctrl_handler); 2073 return err; 2074 } 2075 2076 err = v4l2_ctrl_handler_setup(&ctx->ctrl_handler); 2077 if (err) 2078 v4l2_ctrl_handler_free(&ctx->ctrl_handler); 2079 return err; 2080} 2081 2082static int mxc_jpeg_open(struct file *file) 2083{ 2084 struct mxc_jpeg_dev *mxc_jpeg = video_drvdata(file); 2085 struct video_device *mxc_vfd = video_devdata(file); 2086 struct device *dev = mxc_jpeg->dev; 2087 struct mxc_jpeg_ctx *ctx; 2088 int ret = 0; 2089 2090 ctx = kzalloc(sizeof(*ctx), GFP_KERNEL); 2091 if (!ctx) 2092 return -ENOMEM; 2093 2094 if (mutex_lock_interruptible(&mxc_jpeg->lock)) { 2095 ret = -ERESTARTSYS; 2096 goto free; 2097 } 2098 2099 v4l2_fh_init(&ctx->fh, mxc_vfd); 2100 file->private_data = &ctx->fh; 2101 v4l2_fh_add(&ctx->fh); 2102 2103 ctx->mxc_jpeg = mxc_jpeg; 2104 2105 ctx->fh.m2m_ctx = v4l2_m2m_ctx_init(mxc_jpeg->m2m_dev, ctx, 2106 mxc_jpeg_queue_init); 2107 2108 if (IS_ERR(ctx->fh.m2m_ctx)) { 2109 ret = PTR_ERR(ctx->fh.m2m_ctx); 2110 goto error; 2111 } 2112 2113 ret = mxc_jpeg_ctrls_setup(ctx); 2114 if (ret) { 2115 dev_err(ctx->mxc_jpeg->dev, "failed to setup mxc jpeg controls\n"); 2116 goto err_ctrls_setup; 2117 } 2118 ctx->fh.ctrl_handler = &ctx->ctrl_handler; 2119 mxc_jpeg_set_default_params(ctx); 2120 ctx->slot = -1; /* slot not allocated yet */ 2121 INIT_DELAYED_WORK(&ctx->task_timer, mxc_jpeg_device_run_timeout); 2122 2123 if (mxc_jpeg->mode == MXC_JPEG_DECODE) 2124 dev_dbg(dev, "Opened JPEG decoder instance %p\n", ctx); 2125 else 2126 dev_dbg(dev, "Opened JPEG encoder instance %p\n", ctx); 2127 mutex_unlock(&mxc_jpeg->lock); 2128 2129 return 0; 2130 2131err_ctrls_setup: 2132 v4l2_m2m_ctx_release(ctx->fh.m2m_ctx); 2133error: 2134 v4l2_fh_del(&ctx->fh); 2135 v4l2_fh_exit(&ctx->fh); 2136 mutex_unlock(&mxc_jpeg->lock); 2137free: 2138 kfree(ctx); 2139 return ret; 2140} 2141 2142static int mxc_jpeg_querycap(struct file *file, void *priv, 2143 struct v4l2_capability *cap) 2144{ 2145 strscpy(cap->driver, MXC_JPEG_NAME " codec", sizeof(cap->driver)); 2146 strscpy(cap->card, MXC_JPEG_NAME " codec", sizeof(cap->card)); 2147 cap->device_caps = V4L2_CAP_STREAMING | V4L2_CAP_VIDEO_M2M_MPLANE; 2148 cap->capabilities = cap->device_caps | V4L2_CAP_DEVICE_CAPS; 2149 2150 return 0; 2151} 2152 2153static int mxc_jpeg_enum_fmt_vid_cap(struct file *file, void *priv, 2154 struct v4l2_fmtdesc *f) 2155{ 2156 struct mxc_jpeg_ctx *ctx = mxc_jpeg_fh_to_ctx(priv); 2157 struct mxc_jpeg_q_data *q_data = mxc_jpeg_get_q_data(ctx, f->type); 2158 2159 if (ctx->mxc_jpeg->mode == MXC_JPEG_ENCODE) { 2160 return enum_fmt(mxc_formats, MXC_JPEG_NUM_FORMATS, f, 2161 MXC_JPEG_FMT_TYPE_ENC); 2162 } else if (!ctx->header_parsed) { 2163 return enum_fmt(mxc_formats, MXC_JPEG_NUM_FORMATS, f, 2164 MXC_JPEG_FMT_TYPE_RAW); 2165 } else { 2166 /* For the decoder CAPTURE queue, only enumerate the raw formats 2167 * supported for the format currently active on OUTPUT 2168 * (more precisely what was propagated on capture queue 2169 * after jpeg parse on the output buffer) 2170 */ 2171 int ret = -EINVAL; 2172 const struct mxc_jpeg_fmt *sibling; 2173 2174 switch (f->index) { 2175 case 0: 2176 f->pixelformat = q_data->fmt->fourcc; 2177 ret = 0; 2178 break; 2179 case 1: 2180 sibling = mxc_jpeg_get_sibling_format(q_data->fmt); 2181 if (sibling) { 2182 f->pixelformat = sibling->fourcc; 2183 ret = 0; 2184 } 2185 break; 2186 default: 2187 break; 2188 } 2189 return ret; 2190 } 2191} 2192 2193static int mxc_jpeg_enum_fmt_vid_out(struct file *file, void *priv, 2194 struct v4l2_fmtdesc *f) 2195{ 2196 struct mxc_jpeg_ctx *ctx = mxc_jpeg_fh_to_ctx(priv); 2197 u32 type = ctx->mxc_jpeg->mode == MXC_JPEG_DECODE ? MXC_JPEG_FMT_TYPE_ENC : 2198 MXC_JPEG_FMT_TYPE_RAW; 2199 int ret; 2200 2201 ret = enum_fmt(mxc_formats, MXC_JPEG_NUM_FORMATS, f, type); 2202 if (ret) 2203 return ret; 2204 if (ctx->mxc_jpeg->mode == MXC_JPEG_DECODE) 2205 f->flags = V4L2_FMT_FLAG_DYN_RESOLUTION; 2206 return 0; 2207} 2208 2209static u32 mxc_jpeg_get_fmt_type(struct mxc_jpeg_ctx *ctx, u32 type) 2210{ 2211 if (ctx->mxc_jpeg->mode == MXC_JPEG_DECODE) 2212 return V4L2_TYPE_IS_OUTPUT(type) ? MXC_JPEG_FMT_TYPE_ENC : MXC_JPEG_FMT_TYPE_RAW; 2213 else 2214 return V4L2_TYPE_IS_CAPTURE(type) ? MXC_JPEG_FMT_TYPE_ENC : MXC_JPEG_FMT_TYPE_RAW; 2215} 2216 2217static u32 mxc_jpeg_get_default_fourcc(struct mxc_jpeg_ctx *ctx, u32 type) 2218{ 2219 if (ctx->mxc_jpeg->mode == MXC_JPEG_DECODE) 2220 return V4L2_TYPE_IS_OUTPUT(type) ? V4L2_PIX_FMT_JPEG : MXC_JPEG_DEFAULT_PFMT; 2221 else 2222 return V4L2_TYPE_IS_CAPTURE(type) ? V4L2_PIX_FMT_JPEG : MXC_JPEG_DEFAULT_PFMT; 2223} 2224 2225static u32 mxc_jpeg_try_fourcc(struct mxc_jpeg_ctx *ctx, u32 fourcc) 2226{ 2227 const struct mxc_jpeg_fmt *sibling; 2228 struct mxc_jpeg_q_data *q_data_cap; 2229 2230 if (ctx->mxc_jpeg->mode != MXC_JPEG_DECODE) 2231 return fourcc; 2232 if (!ctx->header_parsed) 2233 return fourcc; 2234 2235 q_data_cap = &ctx->cap_q; 2236 if (q_data_cap->fmt->fourcc == fourcc) 2237 return fourcc; 2238 2239 sibling = mxc_jpeg_get_sibling_format(q_data_cap->fmt); 2240 if (sibling && sibling->fourcc == fourcc) 2241 return sibling->fourcc; 2242 2243 return q_data_cap->fmt->fourcc; 2244} 2245 2246static int mxc_jpeg_try_fmt(struct v4l2_format *f, 2247 struct mxc_jpeg_ctx *ctx, struct mxc_jpeg_q_data *q_data) 2248{ 2249 const struct mxc_jpeg_fmt *fmt; 2250 struct v4l2_pix_format_mplane *pix_mp = &f->fmt.pix_mp; 2251 struct v4l2_plane_pix_format *pfmt; 2252 u32 fourcc = f->fmt.pix_mp.pixelformat; 2253 u32 w = (pix_mp->width < MXC_JPEG_MAX_WIDTH) ? 2254 pix_mp->width : MXC_JPEG_MAX_WIDTH; 2255 u32 h = (pix_mp->height < MXC_JPEG_MAX_HEIGHT) ? 2256 pix_mp->height : MXC_JPEG_MAX_HEIGHT; 2257 int i; 2258 2259 fmt = mxc_jpeg_find_format(fourcc); 2260 if (!fmt || fmt->flags != mxc_jpeg_get_fmt_type(ctx, f->type)) { 2261 dev_warn(ctx->mxc_jpeg->dev, "Format not supported: %c%c%c%c, use the default.\n", 2262 (fourcc & 0xff), 2263 (fourcc >> 8) & 0xff, 2264 (fourcc >> 16) & 0xff, 2265 (fourcc >> 24) & 0xff); 2266 fourcc = mxc_jpeg_get_default_fourcc(ctx, f->type); 2267 fmt = mxc_jpeg_find_format(fourcc); 2268 if (!fmt) 2269 return -EINVAL; 2270 f->fmt.pix_mp.pixelformat = fourcc; 2271 } 2272 q_data->fmt = fmt; 2273 2274 memset(pix_mp->reserved, 0, sizeof(pix_mp->reserved)); 2275 pix_mp->field = V4L2_FIELD_NONE; 2276 pix_mp->num_planes = fmt->mem_planes; 2277 pix_mp->pixelformat = fmt->fourcc; 2278 2279 q_data->w = w; 2280 q_data->h = h; 2281 q_data->w_adjusted = w; 2282 q_data->h_adjusted = h; 2283 v4l_bound_align_image(&q_data->w_adjusted, 2284 w, /* adjust upwards*/ 2285 MXC_JPEG_MAX_WIDTH, 2286 fmt->h_align, 2287 &q_data->h_adjusted, 2288 h, /* adjust upwards*/ 2289 MXC_JPEG_MAX_HEIGHT, 2290 fmt->v_align, 2291 0); 2292 for (i = 0; i < pix_mp->num_planes; i++) { 2293 pfmt = &pix_mp->plane_fmt[i]; 2294 q_data->bytesperline[i] = pfmt->bytesperline; 2295 q_data->sizeimage[i] = pfmt->sizeimage; 2296 } 2297 2298 /* calculate bytesperline & sizeimage */ 2299 mxc_jpeg_bytesperline(q_data, fmt->precision); 2300 mxc_jpeg_sizeimage(q_data); 2301 2302 /* adjust user format according to our calculations */ 2303 for (i = 0; i < pix_mp->num_planes; i++) { 2304 pfmt = &pix_mp->plane_fmt[i]; 2305 memset(pfmt->reserved, 0, sizeof(pfmt->reserved)); 2306 pfmt->bytesperline = q_data->bytesperline[i]; 2307 pfmt->sizeimage = mxc_jpeg_get_plane_size(q_data, i); 2308 } 2309 2310 /* fix colorspace information to sRGB for both output & capture */ 2311 pix_mp->colorspace = V4L2_COLORSPACE_SRGB; 2312 pix_mp->ycbcr_enc = V4L2_YCBCR_ENC_601; 2313 pix_mp->xfer_func = V4L2_XFER_FUNC_SRGB; 2314 /* 2315 * this hardware does not change the range of the samples 2316 * but since inside JPEG the YUV quantization is full-range, 2317 * this driver will always use full-range for the raw frames, too 2318 */ 2319 pix_mp->quantization = V4L2_QUANTIZATION_FULL_RANGE; 2320 2321 if (fmt->flags == MXC_JPEG_FMT_TYPE_RAW) { 2322 q_data->crop.left = 0; 2323 q_data->crop.top = 0; 2324 q_data->crop.width = q_data->w; 2325 q_data->crop.height = q_data->h; 2326 } 2327 2328 pix_mp->width = q_data->w_adjusted; 2329 pix_mp->height = q_data->h_adjusted; 2330 2331 return 0; 2332} 2333 2334static int mxc_jpeg_try_fmt_vid_cap(struct file *file, void *priv, 2335 struct v4l2_format *f) 2336{ 2337 struct mxc_jpeg_ctx *ctx = mxc_jpeg_fh_to_ctx(priv); 2338 struct mxc_jpeg_dev *jpeg = ctx->mxc_jpeg; 2339 struct device *dev = jpeg->dev; 2340 struct mxc_jpeg_q_data tmp_q; 2341 2342 if (!V4L2_TYPE_IS_MULTIPLANAR(f->type)) { 2343 dev_err(dev, "TRY_FMT with Invalid type: %d\n", f->type); 2344 return -EINVAL; 2345 } 2346 2347 if (ctx->mxc_jpeg->mode != MXC_JPEG_DECODE && V4L2_TYPE_IS_CAPTURE(f->type)) 2348 f->fmt.pix_mp.pixelformat = mxc_jpeg_try_fourcc(ctx, f->fmt.pix_mp.pixelformat); 2349 2350 return mxc_jpeg_try_fmt(f, ctx, &tmp_q); 2351} 2352 2353static int mxc_jpeg_try_fmt_vid_out(struct file *file, void *priv, 2354 struct v4l2_format *f) 2355{ 2356 struct mxc_jpeg_ctx *ctx = mxc_jpeg_fh_to_ctx(priv); 2357 struct mxc_jpeg_dev *jpeg = ctx->mxc_jpeg; 2358 struct device *dev = jpeg->dev; 2359 struct mxc_jpeg_q_data tmp_q; 2360 2361 if (!V4L2_TYPE_IS_MULTIPLANAR(f->type)) { 2362 dev_err(dev, "TRY_FMT with Invalid type: %d\n", f->type); 2363 return -EINVAL; 2364 } 2365 2366 return mxc_jpeg_try_fmt(f, ctx, &tmp_q); 2367} 2368 2369static void mxc_jpeg_s_parsed_fmt(struct mxc_jpeg_ctx *ctx, struct v4l2_format *f) 2370{ 2371 struct v4l2_pix_format_mplane *pix_mp = &f->fmt.pix_mp; 2372 struct mxc_jpeg_q_data *q_data_cap; 2373 2374 if (ctx->mxc_jpeg->mode != MXC_JPEG_DECODE || !V4L2_TYPE_IS_CAPTURE(f->type)) 2375 return; 2376 if (!ctx->header_parsed) 2377 return; 2378 2379 q_data_cap = mxc_jpeg_get_q_data(ctx, f->type); 2380 pix_mp->pixelformat = mxc_jpeg_try_fourcc(ctx, pix_mp->pixelformat); 2381 pix_mp->width = q_data_cap->w; 2382 pix_mp->height = q_data_cap->h; 2383} 2384 2385static int mxc_jpeg_s_fmt(struct mxc_jpeg_ctx *ctx, 2386 struct v4l2_format *f) 2387{ 2388 struct vb2_queue *vq; 2389 struct mxc_jpeg_dev *jpeg = ctx->mxc_jpeg; 2390 2391 vq = v4l2_m2m_get_vq(ctx->fh.m2m_ctx, f->type); 2392 if (!vq) 2393 return -EINVAL; 2394 2395 if (vb2_is_busy(vq)) { 2396 v4l2_err(&jpeg->v4l2_dev, "queue busy\n"); 2397 return -EBUSY; 2398 } 2399 2400 mxc_jpeg_s_parsed_fmt(ctx, f); 2401 2402 return mxc_jpeg_try_fmt(f, ctx, mxc_jpeg_get_q_data(ctx, f->type)); 2403} 2404 2405static int mxc_jpeg_s_fmt_vid_cap(struct file *file, void *priv, 2406 struct v4l2_format *f) 2407{ 2408 return mxc_jpeg_s_fmt(mxc_jpeg_fh_to_ctx(priv), f); 2409} 2410 2411static int mxc_jpeg_s_fmt_vid_out(struct file *file, void *priv, 2412 struct v4l2_format *f) 2413{ 2414 int ret; 2415 struct mxc_jpeg_ctx *ctx = mxc_jpeg_fh_to_ctx(priv); 2416 struct vb2_queue *dst_vq; 2417 struct mxc_jpeg_q_data *q_data_cap; 2418 enum v4l2_buf_type cap_type = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE; 2419 struct v4l2_format fc; 2420 2421 ret = mxc_jpeg_s_fmt(mxc_jpeg_fh_to_ctx(priv), f); 2422 if (ret) 2423 return ret; 2424 2425 if (ctx->mxc_jpeg->mode != MXC_JPEG_DECODE) 2426 return 0; 2427 2428 dst_vq = v4l2_m2m_get_vq(ctx->fh.m2m_ctx, cap_type); 2429 if (!dst_vq) 2430 return -EINVAL; 2431 2432 if (vb2_is_busy(dst_vq)) 2433 return 0; 2434 2435 q_data_cap = mxc_jpeg_get_q_data(ctx, cap_type); 2436 if (q_data_cap->w == f->fmt.pix_mp.width && q_data_cap->h == f->fmt.pix_mp.height) 2437 return 0; 2438 memset(&fc, 0, sizeof(fc)); 2439 fc.type = cap_type; 2440 fc.fmt.pix_mp.pixelformat = q_data_cap->fmt->fourcc; 2441 fc.fmt.pix_mp.width = f->fmt.pix_mp.width; 2442 fc.fmt.pix_mp.height = f->fmt.pix_mp.height; 2443 2444 return mxc_jpeg_s_fmt_vid_cap(file, priv, &fc); 2445} 2446 2447static int mxc_jpeg_g_fmt_vid(struct file *file, void *priv, 2448 struct v4l2_format *f) 2449{ 2450 struct mxc_jpeg_ctx *ctx = mxc_jpeg_fh_to_ctx(priv); 2451 struct mxc_jpeg_dev *jpeg = ctx->mxc_jpeg; 2452 struct device *dev = jpeg->dev; 2453 struct v4l2_pix_format_mplane *pix_mp = &f->fmt.pix_mp; 2454 struct mxc_jpeg_q_data *q_data = mxc_jpeg_get_q_data(ctx, f->type); 2455 int i; 2456 2457 if (!V4L2_TYPE_IS_MULTIPLANAR(f->type)) { 2458 dev_err(dev, "G_FMT with Invalid type: %d\n", f->type); 2459 return -EINVAL; 2460 } 2461 2462 pix_mp->pixelformat = q_data->fmt->fourcc; 2463 pix_mp->width = q_data->w; 2464 pix_mp->height = q_data->h; 2465 pix_mp->field = V4L2_FIELD_NONE; 2466 if (q_data->fmt->flags == MXC_JPEG_FMT_TYPE_RAW) { 2467 pix_mp->width = q_data->w_adjusted; 2468 pix_mp->height = q_data->h_adjusted; 2469 } 2470 2471 /* fix colorspace information to sRGB for both output & capture */ 2472 pix_mp->colorspace = V4L2_COLORSPACE_SRGB; 2473 pix_mp->ycbcr_enc = V4L2_YCBCR_ENC_601; 2474 pix_mp->xfer_func = V4L2_XFER_FUNC_SRGB; 2475 pix_mp->quantization = V4L2_QUANTIZATION_FULL_RANGE; 2476 2477 pix_mp->num_planes = q_data->fmt->mem_planes; 2478 for (i = 0; i < pix_mp->num_planes; i++) { 2479 pix_mp->plane_fmt[i].bytesperline = q_data->bytesperline[i]; 2480 pix_mp->plane_fmt[i].sizeimage = mxc_jpeg_get_plane_size(q_data, i); 2481 } 2482 2483 return 0; 2484} 2485 2486static int mxc_jpeg_dec_g_selection(struct file *file, void *fh, struct v4l2_selection *s) 2487{ 2488 struct mxc_jpeg_ctx *ctx = mxc_jpeg_fh_to_ctx(fh); 2489 struct mxc_jpeg_q_data *q_data_cap; 2490 2491 if (s->type != V4L2_BUF_TYPE_VIDEO_CAPTURE && s->type != V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE) 2492 return -EINVAL; 2493 2494 q_data_cap = mxc_jpeg_get_q_data(ctx, s->type); 2495 2496 switch (s->target) { 2497 case V4L2_SEL_TGT_COMPOSE: 2498 case V4L2_SEL_TGT_COMPOSE_DEFAULT: 2499 s->r = q_data_cap->crop; 2500 break; 2501 case V4L2_SEL_TGT_COMPOSE_PADDED: 2502 case V4L2_SEL_TGT_COMPOSE_BOUNDS: 2503 s->r.left = 0; 2504 s->r.top = 0; 2505 s->r.width = q_data_cap->w_adjusted; 2506 s->r.height = q_data_cap->h_adjusted; 2507 break; 2508 default: 2509 return -EINVAL; 2510 } 2511 2512 return 0; 2513} 2514 2515static int mxc_jpeg_enc_g_selection(struct file *file, void *fh, struct v4l2_selection *s) 2516{ 2517 struct mxc_jpeg_ctx *ctx = mxc_jpeg_fh_to_ctx(fh); 2518 struct mxc_jpeg_q_data *q_data_out; 2519 2520 if (s->type != V4L2_BUF_TYPE_VIDEO_OUTPUT && s->type != V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE) 2521 return -EINVAL; 2522 2523 q_data_out = mxc_jpeg_get_q_data(ctx, s->type); 2524 2525 switch (s->target) { 2526 case V4L2_SEL_TGT_CROP_DEFAULT: 2527 case V4L2_SEL_TGT_CROP_BOUNDS: 2528 s->r.left = 0; 2529 s->r.top = 0; 2530 s->r.width = q_data_out->w; 2531 s->r.height = q_data_out->h; 2532 break; 2533 case V4L2_SEL_TGT_CROP: 2534 s->r = q_data_out->crop; 2535 break; 2536 default: 2537 return -EINVAL; 2538 } 2539 2540 return 0; 2541} 2542 2543static int mxc_jpeg_g_selection(struct file *file, void *fh, struct v4l2_selection *s) 2544{ 2545 struct mxc_jpeg_ctx *ctx = mxc_jpeg_fh_to_ctx(fh); 2546 2547 if (ctx->mxc_jpeg->mode == MXC_JPEG_DECODE) 2548 return mxc_jpeg_dec_g_selection(file, fh, s); 2549 else 2550 return mxc_jpeg_enc_g_selection(file, fh, s); 2551} 2552 2553static int mxc_jpeg_s_selection(struct file *file, void *fh, struct v4l2_selection *s) 2554{ 2555 struct mxc_jpeg_ctx *ctx = mxc_jpeg_fh_to_ctx(fh); 2556 struct mxc_jpeg_q_data *q_data_out; 2557 2558 if (ctx->mxc_jpeg->mode != MXC_JPEG_ENCODE) 2559 return -ENOTTY; 2560 2561 if (s->type != V4L2_BUF_TYPE_VIDEO_OUTPUT && s->type != V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE) 2562 return -EINVAL; 2563 if (s->target != V4L2_SEL_TGT_CROP) 2564 return -EINVAL; 2565 2566 q_data_out = mxc_jpeg_get_q_data(ctx, s->type); 2567 if (s->r.left || s->r.top) 2568 return -EINVAL; 2569 if (s->r.width > q_data_out->w || s->r.height > q_data_out->h) 2570 return -EINVAL; 2571 2572 q_data_out->crop.left = 0; 2573 q_data_out->crop.top = 0; 2574 q_data_out->crop.width = s->r.width; 2575 q_data_out->crop.height = s->r.height; 2576 2577 return 0; 2578} 2579 2580static int mxc_jpeg_subscribe_event(struct v4l2_fh *fh, 2581 const struct v4l2_event_subscription *sub) 2582{ 2583 switch (sub->type) { 2584 case V4L2_EVENT_EOS: 2585 return v4l2_event_subscribe(fh, sub, 0, NULL); 2586 case V4L2_EVENT_SOURCE_CHANGE: 2587 return v4l2_src_change_event_subscribe(fh, sub); 2588 case V4L2_EVENT_CTRL: 2589 return v4l2_ctrl_subscribe_event(fh, sub); 2590 default: 2591 return -EINVAL; 2592 } 2593} 2594 2595static const struct v4l2_ioctl_ops mxc_jpeg_ioctl_ops = { 2596 .vidioc_querycap = mxc_jpeg_querycap, 2597 .vidioc_enum_fmt_vid_cap = mxc_jpeg_enum_fmt_vid_cap, 2598 .vidioc_enum_fmt_vid_out = mxc_jpeg_enum_fmt_vid_out, 2599 2600 .vidioc_try_fmt_vid_cap_mplane = mxc_jpeg_try_fmt_vid_cap, 2601 .vidioc_try_fmt_vid_out_mplane = mxc_jpeg_try_fmt_vid_out, 2602 2603 .vidioc_s_fmt_vid_cap_mplane = mxc_jpeg_s_fmt_vid_cap, 2604 .vidioc_s_fmt_vid_out_mplane = mxc_jpeg_s_fmt_vid_out, 2605 2606 .vidioc_g_fmt_vid_cap_mplane = mxc_jpeg_g_fmt_vid, 2607 .vidioc_g_fmt_vid_out_mplane = mxc_jpeg_g_fmt_vid, 2608 2609 .vidioc_g_selection = mxc_jpeg_g_selection, 2610 .vidioc_s_selection = mxc_jpeg_s_selection, 2611 2612 .vidioc_subscribe_event = mxc_jpeg_subscribe_event, 2613 .vidioc_unsubscribe_event = v4l2_event_unsubscribe, 2614 2615 .vidioc_try_decoder_cmd = v4l2_m2m_ioctl_try_decoder_cmd, 2616 .vidioc_decoder_cmd = mxc_jpeg_decoder_cmd, 2617 .vidioc_try_encoder_cmd = v4l2_m2m_ioctl_try_encoder_cmd, 2618 .vidioc_encoder_cmd = mxc_jpeg_encoder_cmd, 2619 2620 .vidioc_qbuf = v4l2_m2m_ioctl_qbuf, 2621 .vidioc_dqbuf = v4l2_m2m_ioctl_dqbuf, 2622 2623 .vidioc_create_bufs = v4l2_m2m_ioctl_create_bufs, 2624 .vidioc_prepare_buf = v4l2_m2m_ioctl_prepare_buf, 2625 .vidioc_reqbufs = v4l2_m2m_ioctl_reqbufs, 2626 .vidioc_querybuf = v4l2_m2m_ioctl_querybuf, 2627 .vidioc_expbuf = v4l2_m2m_ioctl_expbuf, 2628 .vidioc_streamon = v4l2_m2m_ioctl_streamon, 2629 .vidioc_streamoff = v4l2_m2m_ioctl_streamoff, 2630}; 2631 2632static int mxc_jpeg_release(struct file *file) 2633{ 2634 struct mxc_jpeg_dev *mxc_jpeg = video_drvdata(file); 2635 struct mxc_jpeg_ctx *ctx = mxc_jpeg_fh_to_ctx(file->private_data); 2636 struct device *dev = mxc_jpeg->dev; 2637 2638 mutex_lock(&mxc_jpeg->lock); 2639 if (mxc_jpeg->mode == MXC_JPEG_DECODE) 2640 dev_dbg(dev, "Release JPEG decoder instance on slot %d.", 2641 ctx->slot); 2642 else 2643 dev_dbg(dev, "Release JPEG encoder instance on slot %d.", 2644 ctx->slot); 2645 v4l2_ctrl_handler_free(&ctx->ctrl_handler); 2646 v4l2_m2m_ctx_release(ctx->fh.m2m_ctx); 2647 v4l2_fh_del(&ctx->fh); 2648 v4l2_fh_exit(&ctx->fh); 2649 kfree(ctx); 2650 mutex_unlock(&mxc_jpeg->lock); 2651 2652 return 0; 2653} 2654 2655static const struct v4l2_file_operations mxc_jpeg_fops = { 2656 .owner = THIS_MODULE, 2657 .open = mxc_jpeg_open, 2658 .release = mxc_jpeg_release, 2659 .poll = v4l2_m2m_fop_poll, 2660 .unlocked_ioctl = video_ioctl2, 2661 .mmap = v4l2_m2m_fop_mmap, 2662}; 2663 2664static const struct v4l2_m2m_ops mxc_jpeg_m2m_ops = { 2665 .job_ready = mxc_jpeg_job_ready, 2666 .device_run = mxc_jpeg_device_run, 2667}; 2668 2669static void mxc_jpeg_detach_pm_domains(struct mxc_jpeg_dev *jpeg) 2670{ 2671 int i; 2672 2673 for (i = 0; i < jpeg->num_domains; i++) { 2674 if (jpeg->pd_link[i] && !IS_ERR(jpeg->pd_link[i])) 2675 device_link_del(jpeg->pd_link[i]); 2676 if (jpeg->pd_dev[i] && !IS_ERR(jpeg->pd_dev[i])) 2677 dev_pm_domain_detach(jpeg->pd_dev[i], true); 2678 jpeg->pd_dev[i] = NULL; 2679 jpeg->pd_link[i] = NULL; 2680 } 2681} 2682 2683static int mxc_jpeg_attach_pm_domains(struct mxc_jpeg_dev *jpeg) 2684{ 2685 struct device *dev = jpeg->dev; 2686 struct device_node *np = jpeg->pdev->dev.of_node; 2687 int i; 2688 int ret; 2689 2690 jpeg->num_domains = of_count_phandle_with_args(np, "power-domains", 2691 "#power-domain-cells"); 2692 if (jpeg->num_domains < 0) { 2693 dev_err(dev, "No power domains defined for jpeg node\n"); 2694 return jpeg->num_domains; 2695 } 2696 if (jpeg->num_domains == 1) { 2697 /* genpd_dev_pm_attach() attach automatically if power domains count is 1 */ 2698 jpeg->num_domains = 0; 2699 return 0; 2700 } 2701 2702 jpeg->pd_dev = devm_kmalloc_array(dev, jpeg->num_domains, 2703 sizeof(*jpeg->pd_dev), GFP_KERNEL); 2704 if (!jpeg->pd_dev) 2705 return -ENOMEM; 2706 2707 jpeg->pd_link = devm_kmalloc_array(dev, jpeg->num_domains, 2708 sizeof(*jpeg->pd_link), GFP_KERNEL); 2709 if (!jpeg->pd_link) 2710 return -ENOMEM; 2711 2712 for (i = 0; i < jpeg->num_domains; i++) { 2713 jpeg->pd_dev[i] = dev_pm_domain_attach_by_id(dev, i); 2714 if (IS_ERR(jpeg->pd_dev[i])) { 2715 ret = PTR_ERR(jpeg->pd_dev[i]); 2716 goto fail; 2717 } 2718 2719 jpeg->pd_link[i] = device_link_add(dev, jpeg->pd_dev[i], 2720 DL_FLAG_STATELESS | 2721 DL_FLAG_PM_RUNTIME); 2722 if (!jpeg->pd_link[i]) { 2723 ret = -EINVAL; 2724 goto fail; 2725 } 2726 } 2727 2728 return 0; 2729fail: 2730 mxc_jpeg_detach_pm_domains(jpeg); 2731 return ret; 2732} 2733 2734static int mxc_jpeg_probe(struct platform_device *pdev) 2735{ 2736 struct mxc_jpeg_dev *jpeg; 2737 struct device *dev = &pdev->dev; 2738 int dec_irq; 2739 int ret; 2740 int mode; 2741 const struct of_device_id *of_id; 2742 2743 of_id = of_match_node(mxc_jpeg_match, dev->of_node); 2744 if (!of_id) 2745 return -ENODEV; 2746 mode = *(const int *)of_id->data; 2747 2748 jpeg = devm_kzalloc(dev, sizeof(struct mxc_jpeg_dev), GFP_KERNEL); 2749 if (!jpeg) 2750 return -ENOMEM; 2751 2752 mutex_init(&jpeg->lock); 2753 spin_lock_init(&jpeg->hw_lock); 2754 2755 ret = dma_set_mask_and_coherent(dev, DMA_BIT_MASK(32)); 2756 if (ret) { 2757 dev_err(&pdev->dev, "No suitable DMA available.\n"); 2758 goto err_irq; 2759 } 2760 2761 jpeg->base_reg = devm_platform_ioremap_resource(pdev, 0); 2762 if (IS_ERR(jpeg->base_reg)) 2763 return PTR_ERR(jpeg->base_reg); 2764 2765 ret = of_property_read_u32_index(pdev->dev.of_node, "slot", 0, &jpeg->slot_data.slot); 2766 if (ret) 2767 jpeg->slot_data.slot = 0; 2768 dev_info(&pdev->dev, "choose slot %d\n", jpeg->slot_data.slot); 2769 dec_irq = platform_get_irq(pdev, 0); 2770 if (dec_irq < 0) { 2771 ret = dec_irq; 2772 goto err_irq; 2773 } 2774 ret = devm_request_irq(&pdev->dev, dec_irq, mxc_jpeg_dec_irq, 2775 0, pdev->name, jpeg); 2776 if (ret) { 2777 dev_err(&pdev->dev, "Failed to request irq %d (%d)\n", 2778 dec_irq, ret); 2779 goto err_irq; 2780 } 2781 2782 jpeg->pdev = pdev; 2783 jpeg->dev = dev; 2784 jpeg->mode = mode; 2785 2786 /* Get clocks */ 2787 ret = devm_clk_bulk_get_all(&pdev->dev, &jpeg->clks); 2788 if (ret < 0) { 2789 dev_err(dev, "failed to get clock\n"); 2790 goto err_clk; 2791 } 2792 jpeg->num_clks = ret; 2793 2794 ret = mxc_jpeg_attach_pm_domains(jpeg); 2795 if (ret < 0) { 2796 dev_err(dev, "failed to attach power domains %d\n", ret); 2797 return ret; 2798 } 2799 2800 /* v4l2 */ 2801 ret = v4l2_device_register(dev, &jpeg->v4l2_dev); 2802 if (ret) { 2803 dev_err(dev, "failed to register v4l2 device\n"); 2804 goto err_register; 2805 } 2806 jpeg->m2m_dev = v4l2_m2m_init(&mxc_jpeg_m2m_ops); 2807 if (IS_ERR(jpeg->m2m_dev)) { 2808 dev_err(dev, "failed to register v4l2 device\n"); 2809 ret = PTR_ERR(jpeg->m2m_dev); 2810 goto err_m2m; 2811 } 2812 2813 jpeg->dec_vdev = video_device_alloc(); 2814 if (!jpeg->dec_vdev) { 2815 dev_err(dev, "failed to register v4l2 device\n"); 2816 ret = -ENOMEM; 2817 goto err_vdev_alloc; 2818 } 2819 if (mode == MXC_JPEG_ENCODE) 2820 snprintf(jpeg->dec_vdev->name, 2821 sizeof(jpeg->dec_vdev->name), 2822 "%s-enc", MXC_JPEG_NAME); 2823 else 2824 snprintf(jpeg->dec_vdev->name, 2825 sizeof(jpeg->dec_vdev->name), 2826 "%s-dec", MXC_JPEG_NAME); 2827 2828 jpeg->dec_vdev->fops = &mxc_jpeg_fops; 2829 jpeg->dec_vdev->ioctl_ops = &mxc_jpeg_ioctl_ops; 2830 jpeg->dec_vdev->minor = -1; 2831 jpeg->dec_vdev->release = video_device_release; 2832 jpeg->dec_vdev->lock = &jpeg->lock; /* lock for ioctl serialization */ 2833 jpeg->dec_vdev->v4l2_dev = &jpeg->v4l2_dev; 2834 jpeg->dec_vdev->vfl_dir = VFL_DIR_M2M; 2835 jpeg->dec_vdev->device_caps = V4L2_CAP_STREAMING | 2836 V4L2_CAP_VIDEO_M2M_MPLANE; 2837 if (mode == MXC_JPEG_ENCODE) { 2838 v4l2_disable_ioctl(jpeg->dec_vdev, VIDIOC_DECODER_CMD); 2839 v4l2_disable_ioctl(jpeg->dec_vdev, VIDIOC_TRY_DECODER_CMD); 2840 } else { 2841 v4l2_disable_ioctl(jpeg->dec_vdev, VIDIOC_ENCODER_CMD); 2842 v4l2_disable_ioctl(jpeg->dec_vdev, VIDIOC_TRY_ENCODER_CMD); 2843 } 2844 ret = video_register_device(jpeg->dec_vdev, VFL_TYPE_VIDEO, -1); 2845 if (ret) { 2846 dev_err(dev, "failed to register video device\n"); 2847 goto err_vdev_register; 2848 } 2849 video_set_drvdata(jpeg->dec_vdev, jpeg); 2850 if (mode == MXC_JPEG_ENCODE) 2851 v4l2_info(&jpeg->v4l2_dev, 2852 "encoder device registered as /dev/video%d (%d,%d)\n", 2853 jpeg->dec_vdev->num, VIDEO_MAJOR, 2854 jpeg->dec_vdev->minor); 2855 else 2856 v4l2_info(&jpeg->v4l2_dev, 2857 "decoder device registered as /dev/video%d (%d,%d)\n", 2858 jpeg->dec_vdev->num, VIDEO_MAJOR, 2859 jpeg->dec_vdev->minor); 2860 2861 platform_set_drvdata(pdev, jpeg); 2862 pm_runtime_enable(dev); 2863 2864 return 0; 2865 2866err_vdev_register: 2867 video_device_release(jpeg->dec_vdev); 2868 2869err_vdev_alloc: 2870 v4l2_m2m_release(jpeg->m2m_dev); 2871 2872err_m2m: 2873 v4l2_device_unregister(&jpeg->v4l2_dev); 2874 2875err_register: 2876 mxc_jpeg_detach_pm_domains(jpeg); 2877 2878err_irq: 2879err_clk: 2880 return ret; 2881} 2882 2883#ifdef CONFIG_PM 2884static int mxc_jpeg_runtime_resume(struct device *dev) 2885{ 2886 struct mxc_jpeg_dev *jpeg = dev_get_drvdata(dev); 2887 int ret; 2888 2889 ret = clk_bulk_prepare_enable(jpeg->num_clks, jpeg->clks); 2890 if (ret < 0) { 2891 dev_err(dev, "failed to enable clock\n"); 2892 return ret; 2893 } 2894 2895 return 0; 2896} 2897 2898static int mxc_jpeg_runtime_suspend(struct device *dev) 2899{ 2900 struct mxc_jpeg_dev *jpeg = dev_get_drvdata(dev); 2901 2902 clk_bulk_disable_unprepare(jpeg->num_clks, jpeg->clks); 2903 2904 return 0; 2905} 2906#endif 2907 2908#ifdef CONFIG_PM_SLEEP 2909static int mxc_jpeg_suspend(struct device *dev) 2910{ 2911 struct mxc_jpeg_dev *jpeg = dev_get_drvdata(dev); 2912 2913 v4l2_m2m_suspend(jpeg->m2m_dev); 2914 return pm_runtime_force_suspend(dev); 2915} 2916 2917static int mxc_jpeg_resume(struct device *dev) 2918{ 2919 struct mxc_jpeg_dev *jpeg = dev_get_drvdata(dev); 2920 int ret; 2921 2922 ret = pm_runtime_force_resume(dev); 2923 if (ret < 0) 2924 return ret; 2925 2926 v4l2_m2m_resume(jpeg->m2m_dev); 2927 return ret; 2928} 2929#endif 2930 2931static const struct dev_pm_ops mxc_jpeg_pm_ops = { 2932 SET_RUNTIME_PM_OPS(mxc_jpeg_runtime_suspend, 2933 mxc_jpeg_runtime_resume, NULL) 2934 SET_SYSTEM_SLEEP_PM_OPS(mxc_jpeg_suspend, mxc_jpeg_resume) 2935}; 2936 2937static void mxc_jpeg_remove(struct platform_device *pdev) 2938{ 2939 struct mxc_jpeg_dev *jpeg = platform_get_drvdata(pdev); 2940 2941 mxc_jpeg_free_slot_data(jpeg); 2942 2943 pm_runtime_disable(&pdev->dev); 2944 video_unregister_device(jpeg->dec_vdev); 2945 v4l2_m2m_release(jpeg->m2m_dev); 2946 v4l2_device_unregister(&jpeg->v4l2_dev); 2947 mxc_jpeg_detach_pm_domains(jpeg); 2948} 2949 2950MODULE_DEVICE_TABLE(of, mxc_jpeg_match); 2951 2952static struct platform_driver mxc_jpeg_driver = { 2953 .probe = mxc_jpeg_probe, 2954 .remove_new = mxc_jpeg_remove, 2955 .driver = { 2956 .name = "mxc-jpeg", 2957 .of_match_table = mxc_jpeg_match, 2958 .pm = &mxc_jpeg_pm_ops, 2959 }, 2960}; 2961module_platform_driver(mxc_jpeg_driver); 2962 2963MODULE_AUTHOR("Zhengyu Shen <zhengyu.shen_1@nxp.com>"); 2964MODULE_AUTHOR("Mirela Rabulea <mirela.rabulea@nxp.com>"); 2965MODULE_DESCRIPTION("V4L2 driver for i.MX8 QXP/QM JPEG encoder/decoder"); 2966MODULE_LICENSE("GPL v2"); 2967