1 // SPDX-License-Identifier: GPL-2.0-only 2 /* linux/drivers/media/platform/samsung/s5p-jpeg/jpeg-core.c 3 * 4 * Copyright (c) 2011-2014 Samsung Electronics Co., Ltd. 5 * http://www.samsung.com 6 * 7 * Author: Andrzej Pietrasiewicz <andrzejtp2010@gmail.com> 8 * Author: Jacek Anaszewski <j.anaszewski@samsung.com> 9 */ 10 11 #include <linux/clk.h> 12 #include <linux/err.h> 13 #include <linux/gfp.h> 14 #include <linux/interrupt.h> 15 #include <linux/io.h> 16 #include <linux/kernel.h> 17 #include <linux/module.h> 18 #include <linux/of.h> 19 #include <linux/platform_device.h> 20 #include <linux/pm_runtime.h> 21 #include <linux/slab.h> 22 #include <linux/spinlock.h> 23 #include <linux/string.h> 24 #include <media/v4l2-event.h> 25 #include <media/v4l2-mem2mem.h> 26 #include <media/v4l2-ioctl.h> 27 #include <media/v4l2-rect.h> 28 #include <media/videobuf2-v4l2.h> 29 #include <media/videobuf2-dma-contig.h> 30 31 #include "jpeg-core.h" 32 #include "jpeg-hw-s5p.h" 33 #include "jpeg-hw-exynos4.h" 34 #include "jpeg-hw-exynos3250.h" 35 #include "jpeg-regs.h" 36 37 static struct s5p_jpeg_fmt sjpeg_formats[] = { 38 { 39 .fourcc = V4L2_PIX_FMT_JPEG, 40 .flags = SJPEG_FMT_FLAG_ENC_CAPTURE | 41 SJPEG_FMT_FLAG_DEC_OUTPUT | 42 SJPEG_FMT_FLAG_S5P | 43 SJPEG_FMT_FLAG_EXYNOS3250 | 44 SJPEG_FMT_FLAG_EXYNOS4, 45 }, 46 { 47 .fourcc = V4L2_PIX_FMT_YUYV, 48 .depth = 16, 49 .colplanes = 1, 50 .h_align = 4, 51 .v_align = 3, 52 .flags = SJPEG_FMT_FLAG_ENC_OUTPUT | 53 SJPEG_FMT_FLAG_DEC_CAPTURE | 54 SJPEG_FMT_FLAG_S5P | 55 SJPEG_FMT_NON_RGB, 56 .subsampling = V4L2_JPEG_CHROMA_SUBSAMPLING_422, 57 }, 58 { 59 .fourcc = V4L2_PIX_FMT_YUYV, 60 .depth = 16, 61 .colplanes = 1, 62 .h_align = 1, 63 .v_align = 0, 64 .flags = SJPEG_FMT_FLAG_ENC_OUTPUT | 65 SJPEG_FMT_FLAG_DEC_CAPTURE | 66 SJPEG_FMT_FLAG_EXYNOS4 | 67 SJPEG_FMT_NON_RGB, 68 .subsampling = V4L2_JPEG_CHROMA_SUBSAMPLING_422, 69 }, 70 { 71 .fourcc = V4L2_PIX_FMT_YUYV, 72 .depth = 16, 73 .colplanes = 1, 74 .h_align = 2, 75 .v_align = 0, 76 .flags = SJPEG_FMT_FLAG_ENC_OUTPUT | 77 SJPEG_FMT_FLAG_DEC_CAPTURE | 78 SJPEG_FMT_FLAG_EXYNOS3250 | 79 SJPEG_FMT_NON_RGB, 80 .subsampling = V4L2_JPEG_CHROMA_SUBSAMPLING_422, 81 }, 82 { 83 .fourcc = V4L2_PIX_FMT_YVYU, 84 .depth = 16, 85 .colplanes = 1, 86 .h_align = 1, 87 .v_align = 0, 88 .flags = SJPEG_FMT_FLAG_ENC_OUTPUT | 89 SJPEG_FMT_FLAG_DEC_CAPTURE | 90 SJPEG_FMT_FLAG_EXYNOS4 | 91 SJPEG_FMT_NON_RGB, 92 .subsampling = V4L2_JPEG_CHROMA_SUBSAMPLING_422, 93 }, 94 { 95 .fourcc = V4L2_PIX_FMT_YVYU, 96 .depth = 16, 97 .colplanes = 1, 98 .h_align = 2, 99 .v_align = 0, 100 .flags = SJPEG_FMT_FLAG_ENC_OUTPUT | 101 SJPEG_FMT_FLAG_DEC_CAPTURE | 102 SJPEG_FMT_FLAG_EXYNOS3250 | 103 SJPEG_FMT_NON_RGB, 104 .subsampling = V4L2_JPEG_CHROMA_SUBSAMPLING_422, 105 }, 106 { 107 .fourcc = V4L2_PIX_FMT_UYVY, 108 .depth = 16, 109 .colplanes = 1, 110 .h_align = 2, 111 .v_align = 0, 112 .flags = SJPEG_FMT_FLAG_ENC_OUTPUT | 113 SJPEG_FMT_FLAG_DEC_CAPTURE | 114 SJPEG_FMT_FLAG_EXYNOS3250 | 115 SJPEG_FMT_NON_RGB, 116 .subsampling = V4L2_JPEG_CHROMA_SUBSAMPLING_422, 117 }, 118 { 119 .fourcc = V4L2_PIX_FMT_VYUY, 120 .depth = 16, 121 .colplanes = 1, 122 .h_align = 2, 123 .v_align = 0, 124 .flags = SJPEG_FMT_FLAG_ENC_OUTPUT | 125 SJPEG_FMT_FLAG_DEC_CAPTURE | 126 SJPEG_FMT_FLAG_EXYNOS3250 | 127 SJPEG_FMT_NON_RGB, 128 .subsampling = V4L2_JPEG_CHROMA_SUBSAMPLING_422, 129 }, 130 { 131 .fourcc = V4L2_PIX_FMT_RGB565, 132 .depth = 16, 133 .colplanes = 1, 134 .h_align = 0, 135 .v_align = 0, 136 .flags = SJPEG_FMT_FLAG_ENC_OUTPUT | 137 SJPEG_FMT_FLAG_DEC_CAPTURE | 138 SJPEG_FMT_FLAG_EXYNOS4 | 139 SJPEG_FMT_RGB, 140 .subsampling = V4L2_JPEG_CHROMA_SUBSAMPLING_444, 141 }, 142 { 143 .fourcc = V4L2_PIX_FMT_RGB565, 144 .depth = 16, 145 .colplanes = 1, 146 .h_align = 2, 147 .v_align = 0, 148 .flags = SJPEG_FMT_FLAG_ENC_OUTPUT | 149 SJPEG_FMT_FLAG_DEC_CAPTURE | 150 SJPEG_FMT_FLAG_EXYNOS3250 | 151 SJPEG_FMT_RGB, 152 .subsampling = V4L2_JPEG_CHROMA_SUBSAMPLING_444, 153 }, 154 { 155 .fourcc = V4L2_PIX_FMT_RGB565X, 156 .depth = 16, 157 .colplanes = 1, 158 .h_align = 2, 159 .v_align = 0, 160 .flags = SJPEG_FMT_FLAG_ENC_OUTPUT | 161 SJPEG_FMT_FLAG_DEC_CAPTURE | 162 SJPEG_FMT_FLAG_EXYNOS3250 | 163 SJPEG_FMT_RGB, 164 .subsampling = V4L2_JPEG_CHROMA_SUBSAMPLING_444, 165 }, 166 { 167 .fourcc = V4L2_PIX_FMT_RGB565, 168 .depth = 16, 169 .colplanes = 1, 170 .h_align = 0, 171 .v_align = 0, 172 .flags = SJPEG_FMT_FLAG_ENC_OUTPUT | 173 SJPEG_FMT_FLAG_S5P | 174 SJPEG_FMT_RGB, 175 .subsampling = V4L2_JPEG_CHROMA_SUBSAMPLING_444, 176 }, 177 { 178 .fourcc = V4L2_PIX_FMT_RGB32, 179 .depth = 32, 180 .colplanes = 1, 181 .h_align = 0, 182 .v_align = 0, 183 .flags = SJPEG_FMT_FLAG_ENC_OUTPUT | 184 SJPEG_FMT_FLAG_DEC_CAPTURE | 185 SJPEG_FMT_FLAG_EXYNOS4 | 186 SJPEG_FMT_RGB, 187 .subsampling = V4L2_JPEG_CHROMA_SUBSAMPLING_444, 188 }, 189 { 190 .fourcc = V4L2_PIX_FMT_RGB32, 191 .depth = 32, 192 .colplanes = 1, 193 .h_align = 2, 194 .v_align = 0, 195 .flags = SJPEG_FMT_FLAG_ENC_OUTPUT | 196 SJPEG_FMT_FLAG_DEC_CAPTURE | 197 SJPEG_FMT_FLAG_EXYNOS3250 | 198 SJPEG_FMT_RGB, 199 .subsampling = V4L2_JPEG_CHROMA_SUBSAMPLING_444, 200 }, 201 { 202 .fourcc = V4L2_PIX_FMT_NV24, 203 .depth = 24, 204 .colplanes = 2, 205 .h_align = 0, 206 .v_align = 0, 207 .flags = SJPEG_FMT_FLAG_ENC_OUTPUT | 208 SJPEG_FMT_FLAG_DEC_CAPTURE | 209 SJPEG_FMT_FLAG_EXYNOS4 | 210 SJPEG_FMT_NON_RGB, 211 .subsampling = V4L2_JPEG_CHROMA_SUBSAMPLING_444, 212 }, 213 { 214 .fourcc = V4L2_PIX_FMT_NV42, 215 .depth = 24, 216 .colplanes = 2, 217 .h_align = 0, 218 .v_align = 0, 219 .flags = SJPEG_FMT_FLAG_ENC_OUTPUT | 220 SJPEG_FMT_FLAG_DEC_CAPTURE | 221 SJPEG_FMT_FLAG_EXYNOS4 | 222 SJPEG_FMT_NON_RGB, 223 .subsampling = V4L2_JPEG_CHROMA_SUBSAMPLING_444, 224 }, 225 { 226 .fourcc = V4L2_PIX_FMT_NV61, 227 .depth = 16, 228 .colplanes = 2, 229 .h_align = 1, 230 .v_align = 0, 231 .flags = SJPEG_FMT_FLAG_ENC_OUTPUT | 232 SJPEG_FMT_FLAG_DEC_CAPTURE | 233 SJPEG_FMT_FLAG_EXYNOS4 | 234 SJPEG_FMT_NON_RGB, 235 .subsampling = V4L2_JPEG_CHROMA_SUBSAMPLING_422, 236 }, 237 { 238 .fourcc = V4L2_PIX_FMT_NV16, 239 .depth = 16, 240 .colplanes = 2, 241 .h_align = 1, 242 .v_align = 0, 243 .flags = SJPEG_FMT_FLAG_ENC_OUTPUT | 244 SJPEG_FMT_FLAG_DEC_CAPTURE | 245 SJPEG_FMT_FLAG_EXYNOS4 | 246 SJPEG_FMT_NON_RGB, 247 .subsampling = V4L2_JPEG_CHROMA_SUBSAMPLING_422, 248 }, 249 { 250 .fourcc = V4L2_PIX_FMT_NV12, 251 .depth = 12, 252 .colplanes = 2, 253 .h_align = 1, 254 .v_align = 1, 255 .flags = SJPEG_FMT_FLAG_ENC_OUTPUT | 256 SJPEG_FMT_FLAG_DEC_CAPTURE | 257 SJPEG_FMT_FLAG_EXYNOS4 | 258 SJPEG_FMT_NON_RGB, 259 .subsampling = V4L2_JPEG_CHROMA_SUBSAMPLING_420, 260 }, 261 { 262 .fourcc = V4L2_PIX_FMT_NV12, 263 .depth = 12, 264 .colplanes = 2, 265 .h_align = 3, 266 .v_align = 3, 267 .flags = SJPEG_FMT_FLAG_ENC_OUTPUT | 268 SJPEG_FMT_FLAG_DEC_CAPTURE | 269 SJPEG_FMT_FLAG_EXYNOS3250 | 270 SJPEG_FMT_NON_RGB, 271 .subsampling = V4L2_JPEG_CHROMA_SUBSAMPLING_420, 272 }, 273 { 274 .fourcc = V4L2_PIX_FMT_NV12, 275 .depth = 12, 276 .colplanes = 2, 277 .h_align = 4, 278 .v_align = 4, 279 .flags = SJPEG_FMT_FLAG_ENC_OUTPUT | 280 SJPEG_FMT_FLAG_DEC_CAPTURE | 281 SJPEG_FMT_FLAG_S5P | 282 SJPEG_FMT_NON_RGB, 283 .subsampling = V4L2_JPEG_CHROMA_SUBSAMPLING_420, 284 }, 285 { 286 .fourcc = V4L2_PIX_FMT_NV21, 287 .depth = 12, 288 .colplanes = 2, 289 .h_align = 3, 290 .v_align = 3, 291 .flags = SJPEG_FMT_FLAG_ENC_OUTPUT | 292 SJPEG_FMT_FLAG_DEC_CAPTURE | 293 SJPEG_FMT_FLAG_EXYNOS3250 | 294 SJPEG_FMT_NON_RGB, 295 .subsampling = V4L2_JPEG_CHROMA_SUBSAMPLING_420, 296 }, 297 { 298 .fourcc = V4L2_PIX_FMT_NV21, 299 .depth = 12, 300 .colplanes = 2, 301 .h_align = 1, 302 .v_align = 1, 303 .flags = SJPEG_FMT_FLAG_ENC_OUTPUT | 304 SJPEG_FMT_FLAG_DEC_CAPTURE | 305 SJPEG_FMT_FLAG_EXYNOS3250 | 306 SJPEG_FMT_FLAG_EXYNOS4 | 307 SJPEG_FMT_NON_RGB, 308 .subsampling = V4L2_JPEG_CHROMA_SUBSAMPLING_420, 309 }, 310 { 311 .fourcc = V4L2_PIX_FMT_YUV420, 312 .depth = 12, 313 .colplanes = 3, 314 .h_align = 1, 315 .v_align = 1, 316 .flags = SJPEG_FMT_FLAG_ENC_OUTPUT | 317 SJPEG_FMT_FLAG_DEC_CAPTURE | 318 SJPEG_FMT_FLAG_EXYNOS4 | 319 SJPEG_FMT_NON_RGB, 320 .subsampling = V4L2_JPEG_CHROMA_SUBSAMPLING_420, 321 }, 322 { 323 .fourcc = V4L2_PIX_FMT_YUV420, 324 .depth = 12, 325 .colplanes = 3, 326 .h_align = 4, 327 .v_align = 4, 328 .flags = SJPEG_FMT_FLAG_ENC_OUTPUT | 329 SJPEG_FMT_FLAG_DEC_CAPTURE | 330 SJPEG_FMT_FLAG_EXYNOS3250 | 331 SJPEG_FMT_NON_RGB, 332 .subsampling = V4L2_JPEG_CHROMA_SUBSAMPLING_420, 333 }, 334 { 335 .fourcc = V4L2_PIX_FMT_GREY, 336 .depth = 8, 337 .colplanes = 1, 338 .flags = SJPEG_FMT_FLAG_ENC_OUTPUT | 339 SJPEG_FMT_FLAG_DEC_CAPTURE | 340 SJPEG_FMT_FLAG_EXYNOS4 | 341 SJPEG_FMT_NON_RGB, 342 .subsampling = V4L2_JPEG_CHROMA_SUBSAMPLING_GRAY, 343 }, 344 }; 345 #define SJPEG_NUM_FORMATS ARRAY_SIZE(sjpeg_formats) 346 347 static const unsigned char qtbl_luminance[4][64] = { 348 {/*level 0 - high compression quality */ 349 20, 16, 25, 39, 50, 46, 62, 68, 350 16, 18, 23, 38, 38, 53, 65, 68, 351 25, 23, 31, 38, 53, 65, 68, 68, 352 39, 38, 38, 53, 65, 68, 68, 68, 353 50, 38, 53, 65, 68, 68, 68, 68, 354 46, 53, 65, 68, 68, 68, 68, 68, 355 62, 65, 68, 68, 68, 68, 68, 68, 356 68, 68, 68, 68, 68, 68, 68, 68 357 }, 358 {/* level 1 */ 359 16, 11, 11, 16, 23, 27, 31, 30, 360 11, 12, 12, 15, 20, 23, 23, 30, 361 11, 12, 13, 16, 23, 26, 35, 47, 362 16, 15, 16, 23, 26, 37, 47, 64, 363 23, 20, 23, 26, 39, 51, 64, 64, 364 27, 23, 26, 37, 51, 64, 64, 64, 365 31, 23, 35, 47, 64, 64, 64, 64, 366 30, 30, 47, 64, 64, 64, 64, 64 367 }, 368 {/* level 2 */ 369 12, 8, 8, 12, 17, 21, 24, 23, 370 8, 9, 9, 11, 15, 19, 18, 23, 371 8, 9, 10, 12, 19, 20, 27, 36, 372 12, 11, 12, 21, 20, 28, 36, 53, 373 17, 15, 19, 20, 30, 39, 51, 59, 374 21, 19, 20, 28, 39, 51, 59, 59, 375 24, 18, 27, 36, 51, 59, 59, 59, 376 23, 23, 36, 53, 59, 59, 59, 59 377 }, 378 {/* level 3 - low compression quality */ 379 8, 6, 6, 8, 12, 14, 16, 17, 380 6, 6, 6, 8, 10, 13, 12, 15, 381 6, 6, 7, 8, 13, 14, 18, 24, 382 8, 8, 8, 14, 13, 19, 24, 35, 383 12, 10, 13, 13, 20, 26, 34, 39, 384 14, 13, 14, 19, 26, 34, 39, 39, 385 16, 12, 18, 24, 34, 39, 39, 39, 386 17, 15, 24, 35, 39, 39, 39, 39 387 } 388 }; 389 390 static const unsigned char qtbl_chrominance[4][64] = { 391 {/*level 0 - high compression quality */ 392 21, 25, 32, 38, 54, 68, 68, 68, 393 25, 28, 24, 38, 54, 68, 68, 68, 394 32, 24, 32, 43, 66, 68, 68, 68, 395 38, 38, 43, 53, 68, 68, 68, 68, 396 54, 54, 66, 68, 68, 68, 68, 68, 397 68, 68, 68, 68, 68, 68, 68, 68, 398 68, 68, 68, 68, 68, 68, 68, 68, 399 68, 68, 68, 68, 68, 68, 68, 68 400 }, 401 {/* level 1 */ 402 17, 15, 17, 21, 20, 26, 38, 48, 403 15, 19, 18, 17, 20, 26, 35, 43, 404 17, 18, 20, 22, 26, 30, 46, 53, 405 21, 17, 22, 28, 30, 39, 53, 64, 406 20, 20, 26, 30, 39, 48, 64, 64, 407 26, 26, 30, 39, 48, 63, 64, 64, 408 38, 35, 46, 53, 64, 64, 64, 64, 409 48, 43, 53, 64, 64, 64, 64, 64 410 }, 411 {/* level 2 */ 412 13, 11, 13, 16, 20, 20, 29, 37, 413 11, 14, 14, 14, 16, 20, 26, 32, 414 13, 14, 15, 17, 20, 23, 35, 40, 415 16, 14, 17, 21, 23, 30, 40, 50, 416 20, 16, 20, 23, 30, 37, 50, 59, 417 20, 20, 23, 30, 37, 48, 59, 59, 418 29, 26, 35, 40, 50, 59, 59, 59, 419 37, 32, 40, 50, 59, 59, 59, 59 420 }, 421 {/* level 3 - low compression quality */ 422 9, 8, 9, 11, 14, 17, 19, 24, 423 8, 10, 9, 11, 14, 13, 17, 22, 424 9, 9, 13, 14, 13, 15, 23, 26, 425 11, 11, 14, 14, 15, 20, 26, 33, 426 14, 14, 13, 15, 20, 24, 33, 39, 427 17, 13, 15, 20, 24, 32, 39, 39, 428 19, 17, 23, 26, 33, 39, 39, 39, 429 24, 22, 26, 33, 39, 39, 39, 39 430 } 431 }; 432 433 static const unsigned char hdctbl0[16] = { 434 0, 1, 5, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0 435 }; 436 437 static const unsigned char hdctblg0[12] = { 438 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0xa, 0xb 439 }; 440 static const unsigned char hactbl0[16] = { 441 0, 2, 1, 3, 3, 2, 4, 3, 5, 5, 4, 4, 0, 0, 1, 0x7d 442 }; 443 static const unsigned char hactblg0[162] = { 444 0x01, 0x02, 0x03, 0x00, 0x04, 0x11, 0x05, 0x12, 445 0x21, 0x31, 0x41, 0x06, 0x13, 0x51, 0x61, 0x07, 446 0x22, 0x71, 0x14, 0x32, 0x81, 0x91, 0xa1, 0x08, 447 0x23, 0x42, 0xb1, 0xc1, 0x15, 0x52, 0xd1, 0xf0, 448 0x24, 0x33, 0x62, 0x72, 0x82, 0x09, 0x0a, 0x16, 449 0x17, 0x18, 0x19, 0x1a, 0x25, 0x26, 0x27, 0x28, 450 0x29, 0x2a, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 451 0x3a, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 452 0x4a, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 453 0x5a, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 454 0x6a, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79, 455 0x7a, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89, 456 0x8a, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97, 0x98, 457 0x99, 0x9a, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7, 458 0xa8, 0xa9, 0xaa, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6, 459 0xb7, 0xb8, 0xb9, 0xba, 0xc2, 0xc3, 0xc4, 0xc5, 460 0xc6, 0xc7, 0xc8, 0xc9, 0xca, 0xd2, 0xd3, 0xd4, 461 0xd5, 0xd6, 0xd7, 0xd8, 0xd9, 0xda, 0xe1, 0xe2, 462 0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9, 0xea, 463 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8, 464 0xf9, 0xfa 465 }; 466 467 /* 468 * Fourcc downgrade schema lookup tables for 422 and 420 469 * chroma subsampling - fourcc on each position maps on the 470 * fourcc from the table fourcc_to_dwngrd_schema_id which allows 471 * to get the most suitable fourcc counterpart for the given 472 * downgraded subsampling property. 473 */ 474 static const u32 subs422_fourcc_dwngrd_schema[] = { 475 V4L2_PIX_FMT_NV16, 476 V4L2_PIX_FMT_NV61, 477 }; 478 479 static const u32 subs420_fourcc_dwngrd_schema[] = { 480 V4L2_PIX_FMT_NV12, 481 V4L2_PIX_FMT_NV21, 482 V4L2_PIX_FMT_NV12, 483 V4L2_PIX_FMT_NV21, 484 V4L2_PIX_FMT_NV12, 485 V4L2_PIX_FMT_NV21, 486 V4L2_PIX_FMT_GREY, 487 V4L2_PIX_FMT_GREY, 488 V4L2_PIX_FMT_GREY, 489 V4L2_PIX_FMT_GREY, 490 }; 491 492 /* 493 * Lookup table for translation of a fourcc to the position 494 * of its downgraded counterpart in the *fourcc_dwngrd_schema 495 * tables. 496 */ 497 static const u32 fourcc_to_dwngrd_schema_id[] = { 498 V4L2_PIX_FMT_NV24, 499 V4L2_PIX_FMT_NV42, 500 V4L2_PIX_FMT_NV16, 501 V4L2_PIX_FMT_NV61, 502 V4L2_PIX_FMT_YUYV, 503 V4L2_PIX_FMT_YVYU, 504 V4L2_PIX_FMT_NV12, 505 V4L2_PIX_FMT_NV21, 506 V4L2_PIX_FMT_YUV420, 507 V4L2_PIX_FMT_GREY, 508 }; 509 510 static int s5p_jpeg_get_dwngrd_sch_id_by_fourcc(u32 fourcc) 511 { 512 int i; 513 514 for (i = 0; i < ARRAY_SIZE(fourcc_to_dwngrd_schema_id); ++i) { 515 if (fourcc_to_dwngrd_schema_id[i] == fourcc) 516 return i; 517 } 518 519 return -EINVAL; 520 } 521 522 static int s5p_jpeg_adjust_fourcc_to_subsampling( 523 enum v4l2_jpeg_chroma_subsampling subs, 524 u32 in_fourcc, 525 u32 *out_fourcc, 526 struct s5p_jpeg_ctx *ctx) 527 { 528 int dwngrd_sch_id; 529 530 if (ctx->subsampling != V4L2_JPEG_CHROMA_SUBSAMPLING_GRAY) { 531 dwngrd_sch_id = 532 s5p_jpeg_get_dwngrd_sch_id_by_fourcc(in_fourcc); 533 if (dwngrd_sch_id < 0) 534 return -EINVAL; 535 } 536 537 switch (ctx->subsampling) { 538 case V4L2_JPEG_CHROMA_SUBSAMPLING_GRAY: 539 *out_fourcc = V4L2_PIX_FMT_GREY; 540 break; 541 case V4L2_JPEG_CHROMA_SUBSAMPLING_420: 542 if (dwngrd_sch_id > 543 ARRAY_SIZE(subs420_fourcc_dwngrd_schema) - 1) 544 return -EINVAL; 545 *out_fourcc = subs420_fourcc_dwngrd_schema[dwngrd_sch_id]; 546 break; 547 case V4L2_JPEG_CHROMA_SUBSAMPLING_422: 548 if (dwngrd_sch_id > 549 ARRAY_SIZE(subs422_fourcc_dwngrd_schema) - 1) 550 return -EINVAL; 551 *out_fourcc = subs422_fourcc_dwngrd_schema[dwngrd_sch_id]; 552 break; 553 default: 554 *out_fourcc = V4L2_PIX_FMT_GREY; 555 break; 556 } 557 558 return 0; 559 } 560 561 static int exynos4x12_decoded_subsampling[] = { 562 V4L2_JPEG_CHROMA_SUBSAMPLING_GRAY, 563 V4L2_JPEG_CHROMA_SUBSAMPLING_444, 564 V4L2_JPEG_CHROMA_SUBSAMPLING_422, 565 V4L2_JPEG_CHROMA_SUBSAMPLING_420, 566 }; 567 568 static int exynos3250_decoded_subsampling[] = { 569 V4L2_JPEG_CHROMA_SUBSAMPLING_444, 570 V4L2_JPEG_CHROMA_SUBSAMPLING_422, 571 V4L2_JPEG_CHROMA_SUBSAMPLING_420, 572 V4L2_JPEG_CHROMA_SUBSAMPLING_GRAY, 573 -1, 574 -1, 575 V4L2_JPEG_CHROMA_SUBSAMPLING_411, 576 }; 577 578 static inline struct s5p_jpeg_ctx *ctrl_to_ctx(struct v4l2_ctrl *c) 579 { 580 return container_of(c->handler, struct s5p_jpeg_ctx, ctrl_handler); 581 } 582 583 static inline struct s5p_jpeg_ctx *fh_to_ctx(struct v4l2_fh *fh) 584 { 585 return container_of(fh, struct s5p_jpeg_ctx, fh); 586 } 587 588 static int s5p_jpeg_to_user_subsampling(struct s5p_jpeg_ctx *ctx) 589 { 590 switch (ctx->jpeg->variant->version) { 591 case SJPEG_S5P: 592 WARN_ON(ctx->subsampling > 3); 593 if (ctx->subsampling > 2) 594 return V4L2_JPEG_CHROMA_SUBSAMPLING_GRAY; 595 return ctx->subsampling; 596 case SJPEG_EXYNOS3250: 597 case SJPEG_EXYNOS5420: 598 WARN_ON(ctx->subsampling > 6); 599 if (ctx->subsampling > 3) 600 return V4L2_JPEG_CHROMA_SUBSAMPLING_411; 601 return exynos3250_decoded_subsampling[ctx->subsampling]; 602 case SJPEG_EXYNOS4: 603 WARN_ON(ctx->subsampling > 3); 604 if (ctx->subsampling > 2) 605 return V4L2_JPEG_CHROMA_SUBSAMPLING_420; 606 return exynos4x12_decoded_subsampling[ctx->subsampling]; 607 case SJPEG_EXYNOS5433: 608 return ctx->subsampling; /* parsed from header */ 609 default: 610 WARN_ON(ctx->subsampling > 3); 611 return V4L2_JPEG_CHROMA_SUBSAMPLING_GRAY; 612 } 613 } 614 615 static inline void s5p_jpeg_set_qtbl(void __iomem *regs, 616 const unsigned char *qtbl, 617 unsigned long tab, int len) 618 { 619 int i; 620 621 for (i = 0; i < len; i++) 622 writel((unsigned int)qtbl[i], regs + tab + (i * 0x04)); 623 } 624 625 static inline void s5p_jpeg_set_qtbl_lum(void __iomem *regs, int quality) 626 { 627 /* this driver fills quantisation table 0 with data for luma */ 628 s5p_jpeg_set_qtbl(regs, qtbl_luminance[quality], 629 S5P_JPG_QTBL_CONTENT(0), 630 ARRAY_SIZE(qtbl_luminance[quality])); 631 } 632 633 static inline void s5p_jpeg_set_qtbl_chr(void __iomem *regs, int quality) 634 { 635 /* this driver fills quantisation table 1 with data for chroma */ 636 s5p_jpeg_set_qtbl(regs, qtbl_chrominance[quality], 637 S5P_JPG_QTBL_CONTENT(1), 638 ARRAY_SIZE(qtbl_chrominance[quality])); 639 } 640 641 static inline void s5p_jpeg_set_htbl(void __iomem *regs, 642 const unsigned char *htbl, 643 unsigned long tab, int len) 644 { 645 int i; 646 647 for (i = 0; i < len; i++) 648 writel((unsigned int)htbl[i], regs + tab + (i * 0x04)); 649 } 650 651 static inline void s5p_jpeg_set_hdctbl(void __iomem *regs) 652 { 653 /* this driver fills table 0 for this component */ 654 s5p_jpeg_set_htbl(regs, hdctbl0, S5P_JPG_HDCTBL(0), 655 ARRAY_SIZE(hdctbl0)); 656 } 657 658 static inline void s5p_jpeg_set_hdctblg(void __iomem *regs) 659 { 660 /* this driver fills table 0 for this component */ 661 s5p_jpeg_set_htbl(regs, hdctblg0, S5P_JPG_HDCTBLG(0), 662 ARRAY_SIZE(hdctblg0)); 663 } 664 665 static inline void s5p_jpeg_set_hactbl(void __iomem *regs) 666 { 667 /* this driver fills table 0 for this component */ 668 s5p_jpeg_set_htbl(regs, hactbl0, S5P_JPG_HACTBL(0), 669 ARRAY_SIZE(hactbl0)); 670 } 671 672 static inline void s5p_jpeg_set_hactblg(void __iomem *regs) 673 { 674 /* this driver fills table 0 for this component */ 675 s5p_jpeg_set_htbl(regs, hactblg0, S5P_JPG_HACTBLG(0), 676 ARRAY_SIZE(hactblg0)); 677 } 678 679 static inline void exynos4_jpeg_set_tbl(void __iomem *regs, 680 const unsigned char *tbl, 681 unsigned long tab, int len) 682 { 683 int i; 684 unsigned int dword; 685 686 for (i = 0; i < len; i += 4) { 687 dword = tbl[i] | 688 (tbl[i + 1] << 8) | 689 (tbl[i + 2] << 16) | 690 (tbl[i + 3] << 24); 691 writel(dword, regs + tab + i); 692 } 693 } 694 695 static inline void exynos4_jpeg_set_qtbl_lum(void __iomem *regs, int quality) 696 { 697 /* this driver fills quantisation table 0 with data for luma */ 698 exynos4_jpeg_set_tbl(regs, qtbl_luminance[quality], 699 EXYNOS4_QTBL_CONTENT(0), 700 ARRAY_SIZE(qtbl_luminance[quality])); 701 } 702 703 static inline void exynos4_jpeg_set_qtbl_chr(void __iomem *regs, int quality) 704 { 705 /* this driver fills quantisation table 1 with data for chroma */ 706 exynos4_jpeg_set_tbl(regs, qtbl_chrominance[quality], 707 EXYNOS4_QTBL_CONTENT(1), 708 ARRAY_SIZE(qtbl_chrominance[quality])); 709 } 710 711 static void exynos4_jpeg_set_huff_tbl(void __iomem *base) 712 { 713 exynos4_jpeg_set_tbl(base, hdctbl0, EXYNOS4_HUFF_TBL_HDCLL, 714 ARRAY_SIZE(hdctbl0)); 715 exynos4_jpeg_set_tbl(base, hdctbl0, EXYNOS4_HUFF_TBL_HDCCL, 716 ARRAY_SIZE(hdctbl0)); 717 exynos4_jpeg_set_tbl(base, hdctblg0, EXYNOS4_HUFF_TBL_HDCLV, 718 ARRAY_SIZE(hdctblg0)); 719 exynos4_jpeg_set_tbl(base, hdctblg0, EXYNOS4_HUFF_TBL_HDCCV, 720 ARRAY_SIZE(hdctblg0)); 721 exynos4_jpeg_set_tbl(base, hactbl0, EXYNOS4_HUFF_TBL_HACLL, 722 ARRAY_SIZE(hactbl0)); 723 exynos4_jpeg_set_tbl(base, hactbl0, EXYNOS4_HUFF_TBL_HACCL, 724 ARRAY_SIZE(hactbl0)); 725 exynos4_jpeg_set_tbl(base, hactblg0, EXYNOS4_HUFF_TBL_HACLV, 726 ARRAY_SIZE(hactblg0)); 727 exynos4_jpeg_set_tbl(base, hactblg0, EXYNOS4_HUFF_TBL_HACCV, 728 ARRAY_SIZE(hactblg0)); 729 } 730 731 static inline int __exynos4_huff_tbl(int class, int id, bool lenval) 732 { 733 /* 734 * class: 0 - DC, 1 - AC 735 * id: 0 - Y, 1 - Cb/Cr 736 */ 737 if (class) { 738 if (id) 739 return lenval ? EXYNOS4_HUFF_TBL_HACCL : 740 EXYNOS4_HUFF_TBL_HACCV; 741 return lenval ? EXYNOS4_HUFF_TBL_HACLL : EXYNOS4_HUFF_TBL_HACLV; 742 743 } 744 /* class == 0 */ 745 if (id) 746 return lenval ? EXYNOS4_HUFF_TBL_HDCCL : EXYNOS4_HUFF_TBL_HDCCV; 747 748 return lenval ? EXYNOS4_HUFF_TBL_HDCLL : EXYNOS4_HUFF_TBL_HDCLV; 749 } 750 751 static inline int exynos4_huff_tbl_len(int class, int id) 752 { 753 return __exynos4_huff_tbl(class, id, true); 754 } 755 756 static inline int exynos4_huff_tbl_val(int class, int id) 757 { 758 return __exynos4_huff_tbl(class, id, false); 759 } 760 761 static int get_byte(struct s5p_jpeg_buffer *buf); 762 static int get_word_be(struct s5p_jpeg_buffer *buf, unsigned int *word); 763 static void skip(struct s5p_jpeg_buffer *buf, long len); 764 765 static void exynos4_jpeg_parse_decode_h_tbl(struct s5p_jpeg_ctx *ctx) 766 { 767 struct s5p_jpeg *jpeg = ctx->jpeg; 768 struct vb2_v4l2_buffer *vb = v4l2_m2m_next_src_buf(ctx->fh.m2m_ctx); 769 struct s5p_jpeg_buffer jpeg_buffer; 770 unsigned int word; 771 int c, x, components; 772 773 jpeg_buffer.size = 2; /* Ls */ 774 jpeg_buffer.data = 775 (unsigned long)vb2_plane_vaddr(&vb->vb2_buf, 0) + ctx->out_q.sos + 2; 776 jpeg_buffer.curr = 0; 777 778 if (get_word_be(&jpeg_buffer, &word)) 779 return; 780 781 if (word < 2) 782 jpeg_buffer.size = 0; 783 else 784 jpeg_buffer.size = (long)word - 2; 785 786 jpeg_buffer.data += 2; 787 jpeg_buffer.curr = 0; 788 789 components = get_byte(&jpeg_buffer); 790 if (components == -1) 791 return; 792 while (components--) { 793 c = get_byte(&jpeg_buffer); 794 if (c == -1) 795 return; 796 x = get_byte(&jpeg_buffer); 797 if (x == -1) 798 return; 799 exynos4_jpeg_select_dec_h_tbl(jpeg->regs, c, 800 (((x >> 4) & 0x1) << 1) | (x & 0x1)); 801 } 802 803 } 804 805 static void exynos4_jpeg_parse_huff_tbl(struct s5p_jpeg_ctx *ctx) 806 { 807 struct s5p_jpeg *jpeg = ctx->jpeg; 808 struct vb2_v4l2_buffer *vb = v4l2_m2m_next_src_buf(ctx->fh.m2m_ctx); 809 struct s5p_jpeg_buffer jpeg_buffer; 810 unsigned int word; 811 int c, i, n, j; 812 813 for (j = 0; j < ctx->out_q.dht.n; ++j) { 814 jpeg_buffer.size = ctx->out_q.dht.len[j]; 815 jpeg_buffer.data = (unsigned long)vb2_plane_vaddr(&vb->vb2_buf, 0) + 816 ctx->out_q.dht.marker[j]; 817 jpeg_buffer.curr = 0; 818 819 word = 0; 820 while (jpeg_buffer.curr < jpeg_buffer.size) { 821 char id, class; 822 823 c = get_byte(&jpeg_buffer); 824 if (c == -1) 825 return; 826 id = c & 0xf; 827 class = (c >> 4) & 0xf; 828 n = 0; 829 for (i = 0; i < 16; ++i) { 830 c = get_byte(&jpeg_buffer); 831 if (c == -1) 832 return; 833 word |= c << ((i % 4) * 8); 834 if ((i + 1) % 4 == 0) { 835 writel(word, jpeg->regs + 836 exynos4_huff_tbl_len(class, id) + 837 (i / 4) * 4); 838 word = 0; 839 } 840 n += c; 841 } 842 word = 0; 843 for (i = 0; i < n; ++i) { 844 c = get_byte(&jpeg_buffer); 845 if (c == -1) 846 return; 847 word |= c << ((i % 4) * 8); 848 if ((i + 1) % 4 == 0) { 849 writel(word, jpeg->regs + 850 exynos4_huff_tbl_val(class, id) + 851 (i / 4) * 4); 852 word = 0; 853 } 854 } 855 if (i % 4) { 856 writel(word, jpeg->regs + 857 exynos4_huff_tbl_val(class, id) + (i / 4) * 4); 858 } 859 word = 0; 860 } 861 } 862 } 863 864 static void exynos4_jpeg_parse_decode_q_tbl(struct s5p_jpeg_ctx *ctx) 865 { 866 struct s5p_jpeg *jpeg = ctx->jpeg; 867 struct vb2_v4l2_buffer *vb = v4l2_m2m_next_src_buf(ctx->fh.m2m_ctx); 868 struct s5p_jpeg_buffer jpeg_buffer; 869 int c, x, components; 870 871 jpeg_buffer.size = ctx->out_q.sof_len; 872 jpeg_buffer.data = 873 (unsigned long)vb2_plane_vaddr(&vb->vb2_buf, 0) + ctx->out_q.sof; 874 jpeg_buffer.curr = 0; 875 876 skip(&jpeg_buffer, 5); /* P, Y, X */ 877 components = get_byte(&jpeg_buffer); 878 if (components == -1) 879 return; 880 881 exynos4_jpeg_set_dec_components(jpeg->regs, components); 882 883 while (components--) { 884 c = get_byte(&jpeg_buffer); 885 if (c == -1) 886 return; 887 skip(&jpeg_buffer, 1); 888 x = get_byte(&jpeg_buffer); 889 if (x == -1) 890 return; 891 exynos4_jpeg_select_dec_q_tbl(jpeg->regs, c, x); 892 } 893 } 894 895 static void exynos4_jpeg_parse_q_tbl(struct s5p_jpeg_ctx *ctx) 896 { 897 struct s5p_jpeg *jpeg = ctx->jpeg; 898 struct vb2_v4l2_buffer *vb = v4l2_m2m_next_src_buf(ctx->fh.m2m_ctx); 899 struct s5p_jpeg_buffer jpeg_buffer; 900 unsigned int word; 901 int c, i, j; 902 903 for (j = 0; j < ctx->out_q.dqt.n; ++j) { 904 jpeg_buffer.size = ctx->out_q.dqt.len[j]; 905 jpeg_buffer.data = (unsigned long)vb2_plane_vaddr(&vb->vb2_buf, 0) + 906 ctx->out_q.dqt.marker[j]; 907 jpeg_buffer.curr = 0; 908 909 word = 0; 910 while (jpeg_buffer.size - jpeg_buffer.curr >= 65) { 911 char id; 912 913 c = get_byte(&jpeg_buffer); 914 if (c == -1) 915 return; 916 id = c & 0xf; 917 /* nonzero means extended mode - not supported */ 918 if ((c >> 4) & 0xf) 919 return; 920 for (i = 0; i < 64; ++i) { 921 c = get_byte(&jpeg_buffer); 922 if (c == -1) 923 return; 924 word |= c << ((i % 4) * 8); 925 if ((i + 1) % 4 == 0) { 926 writel(word, jpeg->regs + 927 EXYNOS4_QTBL_CONTENT(id) + (i / 4) * 4); 928 word = 0; 929 } 930 } 931 word = 0; 932 } 933 } 934 } 935 936 /* 937 * ============================================================================ 938 * Device file operations 939 * ============================================================================ 940 */ 941 942 static int queue_init(void *priv, struct vb2_queue *src_vq, 943 struct vb2_queue *dst_vq); 944 static struct s5p_jpeg_fmt *s5p_jpeg_find_format(struct s5p_jpeg_ctx *ctx, 945 __u32 pixelformat, unsigned int fmt_type); 946 static int s5p_jpeg_controls_create(struct s5p_jpeg_ctx *ctx); 947 948 static int s5p_jpeg_open(struct file *file) 949 { 950 struct s5p_jpeg *jpeg = video_drvdata(file); 951 struct video_device *vfd = video_devdata(file); 952 struct s5p_jpeg_ctx *ctx; 953 struct s5p_jpeg_fmt *out_fmt, *cap_fmt; 954 int ret = 0; 955 956 ctx = kzalloc(sizeof(*ctx), GFP_KERNEL); 957 if (!ctx) 958 return -ENOMEM; 959 960 if (mutex_lock_interruptible(&jpeg->lock)) { 961 ret = -ERESTARTSYS; 962 goto free; 963 } 964 965 v4l2_fh_init(&ctx->fh, vfd); 966 /* Use separate control handler per file handle */ 967 ctx->fh.ctrl_handler = &ctx->ctrl_handler; 968 file->private_data = &ctx->fh; 969 v4l2_fh_add(&ctx->fh); 970 971 ctx->jpeg = jpeg; 972 if (vfd == jpeg->vfd_encoder) { 973 ctx->mode = S5P_JPEG_ENCODE; 974 out_fmt = s5p_jpeg_find_format(ctx, V4L2_PIX_FMT_RGB565, 975 FMT_TYPE_OUTPUT); 976 cap_fmt = s5p_jpeg_find_format(ctx, V4L2_PIX_FMT_JPEG, 977 FMT_TYPE_CAPTURE); 978 } else { 979 ctx->mode = S5P_JPEG_DECODE; 980 out_fmt = s5p_jpeg_find_format(ctx, V4L2_PIX_FMT_JPEG, 981 FMT_TYPE_OUTPUT); 982 cap_fmt = s5p_jpeg_find_format(ctx, V4L2_PIX_FMT_YUYV, 983 FMT_TYPE_CAPTURE); 984 ctx->scale_factor = EXYNOS3250_DEC_SCALE_FACTOR_8_8; 985 } 986 987 ctx->fh.m2m_ctx = v4l2_m2m_ctx_init(jpeg->m2m_dev, ctx, queue_init); 988 if (IS_ERR(ctx->fh.m2m_ctx)) { 989 ret = PTR_ERR(ctx->fh.m2m_ctx); 990 goto error; 991 } 992 993 ctx->out_q.fmt = out_fmt; 994 ctx->cap_q.fmt = cap_fmt; 995 996 ret = s5p_jpeg_controls_create(ctx); 997 if (ret < 0) 998 goto error; 999 1000 mutex_unlock(&jpeg->lock); 1001 return 0; 1002 1003 error: 1004 v4l2_fh_del(&ctx->fh); 1005 v4l2_fh_exit(&ctx->fh); 1006 mutex_unlock(&jpeg->lock); 1007 free: 1008 kfree(ctx); 1009 return ret; 1010 } 1011 1012 static int s5p_jpeg_release(struct file *file) 1013 { 1014 struct s5p_jpeg *jpeg = video_drvdata(file); 1015 struct s5p_jpeg_ctx *ctx = fh_to_ctx(file->private_data); 1016 1017 mutex_lock(&jpeg->lock); 1018 v4l2_m2m_ctx_release(ctx->fh.m2m_ctx); 1019 v4l2_ctrl_handler_free(&ctx->ctrl_handler); 1020 v4l2_fh_del(&ctx->fh); 1021 v4l2_fh_exit(&ctx->fh); 1022 kfree(ctx); 1023 mutex_unlock(&jpeg->lock); 1024 1025 return 0; 1026 } 1027 1028 static const struct v4l2_file_operations s5p_jpeg_fops = { 1029 .owner = THIS_MODULE, 1030 .open = s5p_jpeg_open, 1031 .release = s5p_jpeg_release, 1032 .poll = v4l2_m2m_fop_poll, 1033 .unlocked_ioctl = video_ioctl2, 1034 .mmap = v4l2_m2m_fop_mmap, 1035 }; 1036 1037 /* 1038 * ============================================================================ 1039 * video ioctl operations 1040 * ============================================================================ 1041 */ 1042 1043 static int get_byte(struct s5p_jpeg_buffer *buf) 1044 { 1045 if (buf->curr >= buf->size) 1046 return -1; 1047 1048 return ((unsigned char *)buf->data)[buf->curr++]; 1049 } 1050 1051 static int get_word_be(struct s5p_jpeg_buffer *buf, unsigned int *word) 1052 { 1053 unsigned int temp; 1054 int byte; 1055 1056 byte = get_byte(buf); 1057 if (byte == -1) 1058 return -1; 1059 temp = byte << 8; 1060 byte = get_byte(buf); 1061 if (byte == -1) 1062 return -1; 1063 *word = (unsigned int)byte | temp; 1064 1065 return 0; 1066 } 1067 1068 static void skip(struct s5p_jpeg_buffer *buf, long len) 1069 { 1070 if (len <= 0) 1071 return; 1072 1073 while (len--) 1074 get_byte(buf); 1075 } 1076 1077 static bool s5p_jpeg_subsampling_decode(struct s5p_jpeg_ctx *ctx, 1078 unsigned int subsampling) 1079 { 1080 unsigned int version; 1081 1082 switch (subsampling) { 1083 case 0x11: 1084 ctx->subsampling = V4L2_JPEG_CHROMA_SUBSAMPLING_444; 1085 break; 1086 case 0x21: 1087 ctx->subsampling = V4L2_JPEG_CHROMA_SUBSAMPLING_422; 1088 break; 1089 case 0x22: 1090 ctx->subsampling = V4L2_JPEG_CHROMA_SUBSAMPLING_420; 1091 break; 1092 case 0x33: 1093 ctx->subsampling = V4L2_JPEG_CHROMA_SUBSAMPLING_GRAY; 1094 break; 1095 case 0x41: 1096 /* 1097 * 4:1:1 subsampling only supported by 3250, 5420, and 5433 1098 * variants 1099 */ 1100 version = ctx->jpeg->variant->version; 1101 if (version != SJPEG_EXYNOS3250 && 1102 version != SJPEG_EXYNOS5420 && 1103 version != SJPEG_EXYNOS5433) 1104 return false; 1105 1106 ctx->subsampling = V4L2_JPEG_CHROMA_SUBSAMPLING_411; 1107 break; 1108 default: 1109 return false; 1110 } 1111 1112 return true; 1113 } 1114 1115 static bool s5p_jpeg_parse_hdr(struct s5p_jpeg_q_data *result, 1116 unsigned long buffer, unsigned long size, 1117 struct s5p_jpeg_ctx *ctx) 1118 { 1119 int c, components = 0, notfound, n_dht = 0, n_dqt = 0; 1120 unsigned int height = 0, width = 0, word, subsampling = 0; 1121 unsigned int sos = 0, sof = 0, sof_len = 0; 1122 unsigned int dht[S5P_JPEG_MAX_MARKER], dht_len[S5P_JPEG_MAX_MARKER]; 1123 unsigned int dqt[S5P_JPEG_MAX_MARKER], dqt_len[S5P_JPEG_MAX_MARKER]; 1124 long length; 1125 struct s5p_jpeg_buffer jpeg_buffer; 1126 1127 jpeg_buffer.size = size; 1128 jpeg_buffer.data = buffer; 1129 jpeg_buffer.curr = 0; 1130 1131 notfound = 1; 1132 while (notfound || !sos) { 1133 c = get_byte(&jpeg_buffer); 1134 if (c == -1) 1135 return false; 1136 if (c != 0xff) 1137 continue; 1138 do 1139 c = get_byte(&jpeg_buffer); 1140 while (c == 0xff); 1141 if (c == -1) 1142 return false; 1143 if (c == 0) 1144 continue; 1145 length = 0; 1146 switch (c) { 1147 /* JPEG_MARKER_SOF0: baseline JPEG */ 1148 case JPEG_MARKER_SOF0: 1149 if (get_word_be(&jpeg_buffer, &word)) 1150 break; 1151 length = (long)word - 2; 1152 if (length <= 0) 1153 return false; 1154 sof = jpeg_buffer.curr; /* after 0xffc0 */ 1155 sof_len = length; 1156 if (get_byte(&jpeg_buffer) == -1) 1157 break; 1158 if (get_word_be(&jpeg_buffer, &height)) 1159 break; 1160 if (get_word_be(&jpeg_buffer, &width)) 1161 break; 1162 components = get_byte(&jpeg_buffer); 1163 if (components == -1) 1164 break; 1165 1166 if (components == 1) { 1167 subsampling = 0x33; 1168 } else { 1169 skip(&jpeg_buffer, 1); 1170 subsampling = get_byte(&jpeg_buffer); 1171 skip(&jpeg_buffer, 1); 1172 } 1173 if (components > 3) 1174 return false; 1175 skip(&jpeg_buffer, components * 2); 1176 notfound = 0; 1177 break; 1178 1179 case JPEG_MARKER_DQT: 1180 if (get_word_be(&jpeg_buffer, &word)) 1181 break; 1182 length = (long)word - 2; 1183 if (length <= 0) 1184 return false; 1185 if (n_dqt >= S5P_JPEG_MAX_MARKER) 1186 return false; 1187 dqt[n_dqt] = jpeg_buffer.curr; /* after 0xffdb */ 1188 dqt_len[n_dqt++] = length; 1189 skip(&jpeg_buffer, length); 1190 break; 1191 1192 case JPEG_MARKER_DHT: 1193 if (get_word_be(&jpeg_buffer, &word)) 1194 break; 1195 length = (long)word - 2; 1196 if (length <= 0) 1197 return false; 1198 if (n_dht >= S5P_JPEG_MAX_MARKER) 1199 return false; 1200 dht[n_dht] = jpeg_buffer.curr; /* after 0xffc4 */ 1201 dht_len[n_dht++] = length; 1202 skip(&jpeg_buffer, length); 1203 break; 1204 1205 case JPEG_MARKER_SOS: 1206 sos = jpeg_buffer.curr - 2; /* 0xffda */ 1207 break; 1208 1209 /* skip payload-less markers */ 1210 case JPEG_MARKER_RST ... JPEG_MARKER_RST + 7: 1211 case JPEG_MARKER_SOI: 1212 case JPEG_MARKER_EOI: 1213 case JPEG_MARKER_TEM: 1214 break; 1215 1216 /* skip uninteresting payload markers */ 1217 default: 1218 if (get_word_be(&jpeg_buffer, &word)) 1219 break; 1220 length = (long)word - 2; 1221 /* No need to check underflows as skip() does it */ 1222 skip(&jpeg_buffer, length); 1223 break; 1224 } 1225 } 1226 1227 if (notfound || !sos || !s5p_jpeg_subsampling_decode(ctx, subsampling)) 1228 return false; 1229 1230 result->w = width; 1231 result->h = height; 1232 result->sos = sos; 1233 result->dht.n = n_dht; 1234 while (n_dht--) { 1235 result->dht.marker[n_dht] = dht[n_dht]; 1236 result->dht.len[n_dht] = dht_len[n_dht]; 1237 } 1238 result->dqt.n = n_dqt; 1239 while (n_dqt--) { 1240 result->dqt.marker[n_dqt] = dqt[n_dqt]; 1241 result->dqt.len[n_dqt] = dqt_len[n_dqt]; 1242 } 1243 result->sof = sof; 1244 result->sof_len = sof_len; 1245 1246 return true; 1247 } 1248 1249 static int s5p_jpeg_querycap(struct file *file, void *priv, 1250 struct v4l2_capability *cap) 1251 { 1252 struct s5p_jpeg_ctx *ctx = fh_to_ctx(priv); 1253 1254 if (ctx->mode == S5P_JPEG_ENCODE) { 1255 strscpy(cap->driver, S5P_JPEG_M2M_NAME, 1256 sizeof(cap->driver)); 1257 strscpy(cap->card, S5P_JPEG_M2M_NAME " encoder", 1258 sizeof(cap->card)); 1259 } else { 1260 strscpy(cap->driver, S5P_JPEG_M2M_NAME, 1261 sizeof(cap->driver)); 1262 strscpy(cap->card, S5P_JPEG_M2M_NAME " decoder", 1263 sizeof(cap->card)); 1264 } 1265 return 0; 1266 } 1267 1268 static int enum_fmt(struct s5p_jpeg_ctx *ctx, 1269 struct s5p_jpeg_fmt *sjpeg_formats, int n, 1270 struct v4l2_fmtdesc *f, u32 type) 1271 { 1272 int i, num = 0; 1273 unsigned int fmt_ver_flag = ctx->jpeg->variant->fmt_ver_flag; 1274 1275 for (i = 0; i < n; ++i) { 1276 if (sjpeg_formats[i].flags & type && 1277 sjpeg_formats[i].flags & fmt_ver_flag) { 1278 /* index-th format of type type found ? */ 1279 if (num == f->index) 1280 break; 1281 /* Correct type but haven't reached our index yet, 1282 * just increment per-type index 1283 */ 1284 ++num; 1285 } 1286 } 1287 1288 /* Format not found */ 1289 if (i >= n) 1290 return -EINVAL; 1291 1292 f->pixelformat = sjpeg_formats[i].fourcc; 1293 1294 return 0; 1295 } 1296 1297 static int s5p_jpeg_enum_fmt_vid_cap(struct file *file, void *priv, 1298 struct v4l2_fmtdesc *f) 1299 { 1300 struct s5p_jpeg_ctx *ctx = fh_to_ctx(priv); 1301 1302 if (ctx->mode == S5P_JPEG_ENCODE) 1303 return enum_fmt(ctx, sjpeg_formats, SJPEG_NUM_FORMATS, f, 1304 SJPEG_FMT_FLAG_ENC_CAPTURE); 1305 1306 return enum_fmt(ctx, sjpeg_formats, SJPEG_NUM_FORMATS, f, 1307 SJPEG_FMT_FLAG_DEC_CAPTURE); 1308 } 1309 1310 static int s5p_jpeg_enum_fmt_vid_out(struct file *file, void *priv, 1311 struct v4l2_fmtdesc *f) 1312 { 1313 struct s5p_jpeg_ctx *ctx = fh_to_ctx(priv); 1314 1315 if (ctx->mode == S5P_JPEG_ENCODE) 1316 return enum_fmt(ctx, sjpeg_formats, SJPEG_NUM_FORMATS, f, 1317 SJPEG_FMT_FLAG_ENC_OUTPUT); 1318 1319 return enum_fmt(ctx, sjpeg_formats, SJPEG_NUM_FORMATS, f, 1320 SJPEG_FMT_FLAG_DEC_OUTPUT); 1321 } 1322 1323 static struct s5p_jpeg_q_data *get_q_data(struct s5p_jpeg_ctx *ctx, 1324 enum v4l2_buf_type type) 1325 { 1326 if (type == V4L2_BUF_TYPE_VIDEO_OUTPUT) 1327 return &ctx->out_q; 1328 if (type == V4L2_BUF_TYPE_VIDEO_CAPTURE) 1329 return &ctx->cap_q; 1330 1331 return NULL; 1332 } 1333 1334 static int s5p_jpeg_g_fmt(struct file *file, void *priv, struct v4l2_format *f) 1335 { 1336 struct vb2_queue *vq; 1337 struct s5p_jpeg_q_data *q_data = NULL; 1338 struct v4l2_pix_format *pix = &f->fmt.pix; 1339 struct s5p_jpeg_ctx *ct = fh_to_ctx(priv); 1340 1341 vq = v4l2_m2m_get_vq(ct->fh.m2m_ctx, f->type); 1342 if (!vq) 1343 return -EINVAL; 1344 1345 if (f->type == V4L2_BUF_TYPE_VIDEO_CAPTURE && 1346 ct->mode == S5P_JPEG_DECODE && !ct->hdr_parsed) 1347 return -EINVAL; 1348 q_data = get_q_data(ct, f->type); 1349 BUG_ON(q_data == NULL); 1350 1351 pix->width = q_data->w; 1352 pix->height = q_data->h; 1353 pix->field = V4L2_FIELD_NONE; 1354 pix->pixelformat = q_data->fmt->fourcc; 1355 pix->bytesperline = 0; 1356 if (q_data->fmt->fourcc != V4L2_PIX_FMT_JPEG) { 1357 u32 bpl = q_data->w; 1358 1359 if (q_data->fmt->colplanes == 1) 1360 bpl = (bpl * q_data->fmt->depth) >> 3; 1361 pix->bytesperline = bpl; 1362 } 1363 pix->sizeimage = q_data->size; 1364 1365 return 0; 1366 } 1367 1368 static struct s5p_jpeg_fmt *s5p_jpeg_find_format(struct s5p_jpeg_ctx *ctx, 1369 u32 pixelformat, unsigned int fmt_type) 1370 { 1371 unsigned int k, fmt_flag; 1372 1373 if (ctx->mode == S5P_JPEG_ENCODE) 1374 fmt_flag = (fmt_type == FMT_TYPE_OUTPUT) ? 1375 SJPEG_FMT_FLAG_ENC_OUTPUT : 1376 SJPEG_FMT_FLAG_ENC_CAPTURE; 1377 else 1378 fmt_flag = (fmt_type == FMT_TYPE_OUTPUT) ? 1379 SJPEG_FMT_FLAG_DEC_OUTPUT : 1380 SJPEG_FMT_FLAG_DEC_CAPTURE; 1381 1382 for (k = 0; k < ARRAY_SIZE(sjpeg_formats); k++) { 1383 struct s5p_jpeg_fmt *fmt = &sjpeg_formats[k]; 1384 1385 if (fmt->fourcc == pixelformat && 1386 fmt->flags & fmt_flag && 1387 fmt->flags & ctx->jpeg->variant->fmt_ver_flag) { 1388 return fmt; 1389 } 1390 } 1391 1392 return NULL; 1393 } 1394 1395 static void jpeg_bound_align_image(struct s5p_jpeg_ctx *ctx, 1396 u32 *w, unsigned int wmin, unsigned int wmax, 1397 unsigned int walign, 1398 u32 *h, unsigned int hmin, unsigned int hmax, 1399 unsigned int halign) 1400 { 1401 int width, height, w_step, h_step; 1402 1403 width = *w; 1404 height = *h; 1405 1406 w_step = 1 << walign; 1407 h_step = 1 << halign; 1408 1409 if (ctx->jpeg->variant->hw3250_compat) { 1410 /* 1411 * Rightmost and bottommost pixels are cropped by the 1412 * Exynos3250/compatible JPEG IP for RGB formats, for the 1413 * specific width and height values respectively. This 1414 * assignment will result in v4l_bound_align_image returning 1415 * dimensions reduced by 1 for the aforementioned cases. 1416 */ 1417 if (w_step == 4 && ((width & 3) == 1)) { 1418 wmax = width; 1419 hmax = height; 1420 } 1421 } 1422 1423 v4l_bound_align_image(w, wmin, wmax, walign, h, hmin, hmax, halign, 0); 1424 1425 if (*w < width && (*w + w_step) < wmax) 1426 *w += w_step; 1427 if (*h < height && (*h + h_step) < hmax) 1428 *h += h_step; 1429 } 1430 1431 static int vidioc_try_fmt(struct v4l2_format *f, struct s5p_jpeg_fmt *fmt, 1432 struct s5p_jpeg_ctx *ctx, int q_type) 1433 { 1434 struct v4l2_pix_format *pix = &f->fmt.pix; 1435 1436 if (pix->field == V4L2_FIELD_ANY) 1437 pix->field = V4L2_FIELD_NONE; 1438 else if (pix->field != V4L2_FIELD_NONE) 1439 return -EINVAL; 1440 1441 /* V4L2 specification suggests the driver corrects the format struct 1442 * if any of the dimensions is unsupported 1443 */ 1444 if (q_type == FMT_TYPE_OUTPUT) 1445 jpeg_bound_align_image(ctx, &pix->width, S5P_JPEG_MIN_WIDTH, 1446 S5P_JPEG_MAX_WIDTH, 0, 1447 &pix->height, S5P_JPEG_MIN_HEIGHT, 1448 S5P_JPEG_MAX_HEIGHT, 0); 1449 else 1450 jpeg_bound_align_image(ctx, &pix->width, S5P_JPEG_MIN_WIDTH, 1451 S5P_JPEG_MAX_WIDTH, fmt->h_align, 1452 &pix->height, S5P_JPEG_MIN_HEIGHT, 1453 S5P_JPEG_MAX_HEIGHT, fmt->v_align); 1454 1455 if (fmt->fourcc == V4L2_PIX_FMT_JPEG) { 1456 if (pix->sizeimage <= 0) 1457 pix->sizeimage = PAGE_SIZE; 1458 pix->bytesperline = 0; 1459 } else { 1460 u32 bpl = pix->bytesperline; 1461 1462 if (fmt->colplanes > 1 && bpl < pix->width) 1463 bpl = pix->width; /* planar */ 1464 1465 if (fmt->colplanes == 1 && /* packed */ 1466 (bpl << 3) / fmt->depth < pix->width) 1467 bpl = (pix->width * fmt->depth) >> 3; 1468 1469 pix->bytesperline = bpl; 1470 pix->sizeimage = (pix->width * pix->height * fmt->depth) >> 3; 1471 } 1472 1473 return 0; 1474 } 1475 1476 static int s5p_jpeg_try_fmt_vid_cap(struct file *file, void *priv, 1477 struct v4l2_format *f) 1478 { 1479 struct s5p_jpeg_ctx *ctx = fh_to_ctx(priv); 1480 struct v4l2_pix_format *pix = &f->fmt.pix; 1481 struct s5p_jpeg_fmt *fmt; 1482 int ret; 1483 1484 fmt = s5p_jpeg_find_format(ctx, f->fmt.pix.pixelformat, 1485 FMT_TYPE_CAPTURE); 1486 if (!fmt) { 1487 v4l2_err(&ctx->jpeg->v4l2_dev, 1488 "Fourcc format (0x%08x) invalid.\n", 1489 f->fmt.pix.pixelformat); 1490 return -EINVAL; 1491 } 1492 1493 if (!ctx->jpeg->variant->hw_ex4_compat || ctx->mode != S5P_JPEG_DECODE) 1494 goto exit; 1495 1496 /* 1497 * The exynos4x12 device requires resulting YUV image 1498 * subsampling not to be lower than the input jpeg subsampling. 1499 * If this requirement is not met then downgrade the requested 1500 * capture format to the one with subsampling equal to the input jpeg. 1501 */ 1502 if ((fmt->flags & SJPEG_FMT_NON_RGB) && 1503 (fmt->subsampling < ctx->subsampling)) { 1504 ret = s5p_jpeg_adjust_fourcc_to_subsampling(ctx->subsampling, 1505 fmt->fourcc, 1506 &pix->pixelformat, 1507 ctx); 1508 if (ret < 0) 1509 pix->pixelformat = V4L2_PIX_FMT_GREY; 1510 1511 fmt = s5p_jpeg_find_format(ctx, pix->pixelformat, 1512 FMT_TYPE_CAPTURE); 1513 } 1514 1515 /* 1516 * Decompression of a JPEG file with 4:2:0 subsampling and odd 1517 * width to the YUV 4:2:0 compliant formats produces a raw image 1518 * with broken luma component. Adjust capture format to RGB565 1519 * in such a case. 1520 */ 1521 if (ctx->subsampling == V4L2_JPEG_CHROMA_SUBSAMPLING_420 && 1522 (ctx->out_q.w & 1) && 1523 (pix->pixelformat == V4L2_PIX_FMT_NV12 || 1524 pix->pixelformat == V4L2_PIX_FMT_NV21 || 1525 pix->pixelformat == V4L2_PIX_FMT_YUV420)) { 1526 pix->pixelformat = V4L2_PIX_FMT_RGB565; 1527 fmt = s5p_jpeg_find_format(ctx, pix->pixelformat, 1528 FMT_TYPE_CAPTURE); 1529 } 1530 1531 exit: 1532 return vidioc_try_fmt(f, fmt, ctx, FMT_TYPE_CAPTURE); 1533 } 1534 1535 static int s5p_jpeg_try_fmt_vid_out(struct file *file, void *priv, 1536 struct v4l2_format *f) 1537 { 1538 struct s5p_jpeg_ctx *ctx = fh_to_ctx(priv); 1539 struct s5p_jpeg_fmt *fmt; 1540 1541 fmt = s5p_jpeg_find_format(ctx, f->fmt.pix.pixelformat, 1542 FMT_TYPE_OUTPUT); 1543 if (!fmt) { 1544 v4l2_err(&ctx->jpeg->v4l2_dev, 1545 "Fourcc format (0x%08x) invalid.\n", 1546 f->fmt.pix.pixelformat); 1547 return -EINVAL; 1548 } 1549 1550 return vidioc_try_fmt(f, fmt, ctx, FMT_TYPE_OUTPUT); 1551 } 1552 1553 static int exynos4_jpeg_get_output_buffer_size(struct s5p_jpeg_ctx *ctx, 1554 struct v4l2_format *f, 1555 int fmt_depth) 1556 { 1557 struct v4l2_pix_format *pix = &f->fmt.pix; 1558 u32 pix_fmt = f->fmt.pix.pixelformat; 1559 int w = pix->width, h = pix->height, wh_align; 1560 int padding = 0; 1561 1562 if (pix_fmt == V4L2_PIX_FMT_RGB32 || 1563 pix_fmt == V4L2_PIX_FMT_RGB565 || 1564 pix_fmt == V4L2_PIX_FMT_NV24 || 1565 pix_fmt == V4L2_PIX_FMT_NV42 || 1566 pix_fmt == V4L2_PIX_FMT_NV12 || 1567 pix_fmt == V4L2_PIX_FMT_NV21 || 1568 pix_fmt == V4L2_PIX_FMT_YUV420) 1569 wh_align = 4; 1570 else 1571 wh_align = 1; 1572 1573 jpeg_bound_align_image(ctx, &w, S5P_JPEG_MIN_WIDTH, 1574 S5P_JPEG_MAX_WIDTH, wh_align, 1575 &h, S5P_JPEG_MIN_HEIGHT, 1576 S5P_JPEG_MAX_HEIGHT, wh_align); 1577 1578 if (ctx->jpeg->variant->version == SJPEG_EXYNOS4) 1579 padding = PAGE_SIZE; 1580 1581 return (w * h * fmt_depth >> 3) + padding; 1582 } 1583 1584 static int exynos3250_jpeg_try_downscale(struct s5p_jpeg_ctx *ctx, 1585 struct v4l2_rect *r); 1586 1587 static int s5p_jpeg_s_fmt(struct s5p_jpeg_ctx *ct, struct v4l2_format *f) 1588 { 1589 struct vb2_queue *vq; 1590 struct s5p_jpeg_q_data *q_data = NULL; 1591 struct v4l2_pix_format *pix = &f->fmt.pix; 1592 struct v4l2_ctrl *ctrl_subs; 1593 struct v4l2_rect scale_rect; 1594 unsigned int f_type; 1595 1596 vq = v4l2_m2m_get_vq(ct->fh.m2m_ctx, f->type); 1597 if (!vq) 1598 return -EINVAL; 1599 1600 q_data = get_q_data(ct, f->type); 1601 BUG_ON(q_data == NULL); 1602 1603 if (vb2_is_busy(vq)) { 1604 v4l2_err(&ct->jpeg->v4l2_dev, "%s queue busy\n", __func__); 1605 return -EBUSY; 1606 } 1607 1608 f_type = V4L2_TYPE_IS_OUTPUT(f->type) ? 1609 FMT_TYPE_OUTPUT : FMT_TYPE_CAPTURE; 1610 1611 q_data->fmt = s5p_jpeg_find_format(ct, pix->pixelformat, f_type); 1612 if (ct->mode == S5P_JPEG_ENCODE || 1613 (ct->mode == S5P_JPEG_DECODE && 1614 q_data->fmt->fourcc != V4L2_PIX_FMT_JPEG)) { 1615 q_data->w = pix->width; 1616 q_data->h = pix->height; 1617 } 1618 if (q_data->fmt->fourcc != V4L2_PIX_FMT_JPEG) { 1619 /* 1620 * During encoding Exynos4x12 SoCs access wider memory area 1621 * than it results from Image_x and Image_y values written to 1622 * the JPEG_IMAGE_SIZE register. In order to avoid sysmmu 1623 * page fault calculate proper buffer size in such a case. 1624 */ 1625 if (ct->jpeg->variant->hw_ex4_compat && 1626 f_type == FMT_TYPE_OUTPUT && ct->mode == S5P_JPEG_ENCODE) 1627 q_data->size = exynos4_jpeg_get_output_buffer_size(ct, 1628 f, 1629 q_data->fmt->depth); 1630 else 1631 q_data->size = q_data->w * q_data->h * 1632 q_data->fmt->depth >> 3; 1633 } else { 1634 q_data->size = pix->sizeimage; 1635 } 1636 1637 if (f_type == FMT_TYPE_OUTPUT) { 1638 ctrl_subs = v4l2_ctrl_find(&ct->ctrl_handler, 1639 V4L2_CID_JPEG_CHROMA_SUBSAMPLING); 1640 if (ctrl_subs) 1641 v4l2_ctrl_s_ctrl(ctrl_subs, q_data->fmt->subsampling); 1642 ct->crop_altered = false; 1643 } 1644 1645 /* 1646 * For decoding init crop_rect with capture buffer dimmensions which 1647 * contain aligned dimensions of the input JPEG image and do it only 1648 * if crop rectangle hasn't been altered by the user space e.g. with 1649 * S_SELECTION ioctl. For encoding assign output buffer dimensions. 1650 */ 1651 if (!ct->crop_altered && 1652 ((ct->mode == S5P_JPEG_DECODE && f_type == FMT_TYPE_CAPTURE) || 1653 (ct->mode == S5P_JPEG_ENCODE && f_type == FMT_TYPE_OUTPUT))) { 1654 ct->crop_rect.width = pix->width; 1655 ct->crop_rect.height = pix->height; 1656 } 1657 1658 /* 1659 * Prevent downscaling to YUV420 format by more than 2 1660 * for Exynos3250/compatible SoC as it produces broken raw image 1661 * in such cases. 1662 */ 1663 if (ct->mode == S5P_JPEG_DECODE && 1664 f_type == FMT_TYPE_CAPTURE && 1665 ct->jpeg->variant->hw3250_compat && 1666 pix->pixelformat == V4L2_PIX_FMT_YUV420 && 1667 ct->scale_factor > 2) { 1668 scale_rect.width = ct->out_q.w / 2; 1669 scale_rect.height = ct->out_q.h / 2; 1670 exynos3250_jpeg_try_downscale(ct, &scale_rect); 1671 } 1672 1673 return 0; 1674 } 1675 1676 static int s5p_jpeg_s_fmt_vid_cap(struct file *file, void *priv, 1677 struct v4l2_format *f) 1678 { 1679 int ret; 1680 1681 ret = s5p_jpeg_try_fmt_vid_cap(file, priv, f); 1682 if (ret) 1683 return ret; 1684 1685 return s5p_jpeg_s_fmt(fh_to_ctx(priv), f); 1686 } 1687 1688 static int s5p_jpeg_s_fmt_vid_out(struct file *file, void *priv, 1689 struct v4l2_format *f) 1690 { 1691 int ret; 1692 1693 ret = s5p_jpeg_try_fmt_vid_out(file, priv, f); 1694 if (ret) 1695 return ret; 1696 1697 return s5p_jpeg_s_fmt(fh_to_ctx(priv), f); 1698 } 1699 1700 static int s5p_jpeg_subscribe_event(struct v4l2_fh *fh, 1701 const struct v4l2_event_subscription *sub) 1702 { 1703 if (sub->type == V4L2_EVENT_SOURCE_CHANGE) 1704 return v4l2_src_change_event_subscribe(fh, sub); 1705 1706 return -EINVAL; 1707 } 1708 1709 static int exynos3250_jpeg_try_downscale(struct s5p_jpeg_ctx *ctx, 1710 struct v4l2_rect *r) 1711 { 1712 int w_ratio, h_ratio, scale_factor, cur_ratio, i; 1713 1714 w_ratio = ctx->out_q.w / r->width; 1715 h_ratio = ctx->out_q.h / r->height; 1716 1717 scale_factor = max(w_ratio, h_ratio); 1718 scale_factor = clamp_val(scale_factor, 1, 8); 1719 1720 /* Align scale ratio to the nearest power of 2 */ 1721 for (i = 0; i <= 3; ++i) { 1722 cur_ratio = 1 << i; 1723 if (scale_factor <= cur_ratio) { 1724 ctx->scale_factor = cur_ratio; 1725 break; 1726 } 1727 } 1728 1729 r->width = round_down(ctx->out_q.w / ctx->scale_factor, 2); 1730 r->height = round_down(ctx->out_q.h / ctx->scale_factor, 2); 1731 1732 ctx->crop_rect.width = r->width; 1733 ctx->crop_rect.height = r->height; 1734 ctx->crop_rect.left = 0; 1735 ctx->crop_rect.top = 0; 1736 1737 ctx->crop_altered = true; 1738 1739 return 0; 1740 } 1741 1742 static int exynos3250_jpeg_try_crop(struct s5p_jpeg_ctx *ctx, 1743 struct v4l2_rect *r) 1744 { 1745 struct v4l2_rect base_rect; 1746 int w_step, h_step; 1747 1748 switch (ctx->cap_q.fmt->fourcc) { 1749 case V4L2_PIX_FMT_NV12: 1750 case V4L2_PIX_FMT_NV21: 1751 w_step = 1; 1752 h_step = 2; 1753 break; 1754 case V4L2_PIX_FMT_YUV420: 1755 w_step = 2; 1756 h_step = 2; 1757 break; 1758 default: 1759 w_step = 1; 1760 h_step = 1; 1761 break; 1762 } 1763 1764 base_rect.top = 0; 1765 base_rect.left = 0; 1766 base_rect.width = ctx->out_q.w; 1767 base_rect.height = ctx->out_q.h; 1768 1769 r->width = round_down(r->width, w_step); 1770 r->height = round_down(r->height, h_step); 1771 r->left = round_down(r->left, 2); 1772 r->top = round_down(r->top, 2); 1773 1774 if (!v4l2_rect_enclosed(r, &base_rect)) 1775 return -EINVAL; 1776 1777 ctx->crop_rect.left = r->left; 1778 ctx->crop_rect.top = r->top; 1779 ctx->crop_rect.width = r->width; 1780 ctx->crop_rect.height = r->height; 1781 1782 ctx->crop_altered = true; 1783 1784 return 0; 1785 } 1786 1787 /* 1788 * V4L2 controls 1789 */ 1790 1791 static int s5p_jpeg_g_selection(struct file *file, void *priv, 1792 struct v4l2_selection *s) 1793 { 1794 struct s5p_jpeg_ctx *ctx = fh_to_ctx(priv); 1795 1796 if (s->type != V4L2_BUF_TYPE_VIDEO_OUTPUT && 1797 s->type != V4L2_BUF_TYPE_VIDEO_CAPTURE) 1798 return -EINVAL; 1799 1800 /* For JPEG blob active == default == bounds */ 1801 switch (s->target) { 1802 case V4L2_SEL_TGT_CROP: 1803 case V4L2_SEL_TGT_CROP_BOUNDS: 1804 case V4L2_SEL_TGT_CROP_DEFAULT: 1805 case V4L2_SEL_TGT_COMPOSE_DEFAULT: 1806 s->r.width = ctx->out_q.w; 1807 s->r.height = ctx->out_q.h; 1808 s->r.left = 0; 1809 s->r.top = 0; 1810 break; 1811 case V4L2_SEL_TGT_COMPOSE: 1812 case V4L2_SEL_TGT_COMPOSE_BOUNDS: 1813 case V4L2_SEL_TGT_COMPOSE_PADDED: 1814 s->r.width = ctx->crop_rect.width; 1815 s->r.height = ctx->crop_rect.height; 1816 s->r.left = ctx->crop_rect.left; 1817 s->r.top = ctx->crop_rect.top; 1818 break; 1819 default: 1820 return -EINVAL; 1821 } 1822 return 0; 1823 } 1824 1825 /* 1826 * V4L2 controls 1827 */ 1828 static int s5p_jpeg_s_selection(struct file *file, void *fh, 1829 struct v4l2_selection *s) 1830 { 1831 struct s5p_jpeg_ctx *ctx = fh_to_ctx(file->private_data); 1832 struct v4l2_rect *rect = &s->r; 1833 int ret = -EINVAL; 1834 1835 if (s->type != V4L2_BUF_TYPE_VIDEO_CAPTURE) 1836 return -EINVAL; 1837 1838 if (s->target == V4L2_SEL_TGT_COMPOSE) { 1839 if (ctx->mode != S5P_JPEG_DECODE) 1840 return -EINVAL; 1841 if (ctx->jpeg->variant->hw3250_compat) 1842 ret = exynos3250_jpeg_try_downscale(ctx, rect); 1843 } else if (s->target == V4L2_SEL_TGT_CROP) { 1844 if (ctx->mode != S5P_JPEG_ENCODE) 1845 return -EINVAL; 1846 if (ctx->jpeg->variant->hw3250_compat) 1847 ret = exynos3250_jpeg_try_crop(ctx, rect); 1848 } 1849 1850 return ret; 1851 } 1852 1853 static int s5p_jpeg_g_volatile_ctrl(struct v4l2_ctrl *ctrl) 1854 { 1855 struct s5p_jpeg_ctx *ctx = ctrl_to_ctx(ctrl); 1856 struct s5p_jpeg *jpeg = ctx->jpeg; 1857 unsigned long flags; 1858 1859 switch (ctrl->id) { 1860 case V4L2_CID_JPEG_CHROMA_SUBSAMPLING: 1861 spin_lock_irqsave(&jpeg->slock, flags); 1862 ctrl->val = s5p_jpeg_to_user_subsampling(ctx); 1863 spin_unlock_irqrestore(&jpeg->slock, flags); 1864 break; 1865 } 1866 1867 return 0; 1868 } 1869 1870 static int s5p_jpeg_adjust_subs_ctrl(struct s5p_jpeg_ctx *ctx, int *ctrl_val) 1871 { 1872 switch (ctx->jpeg->variant->version) { 1873 case SJPEG_S5P: 1874 return 0; 1875 case SJPEG_EXYNOS3250: 1876 case SJPEG_EXYNOS5420: 1877 /* 1878 * The exynos3250/compatible device can produce JPEG image only 1879 * of 4:4:4 subsampling when given RGB32 source image. 1880 */ 1881 if (ctx->out_q.fmt->fourcc == V4L2_PIX_FMT_RGB32) 1882 *ctrl_val = 0; 1883 break; 1884 case SJPEG_EXYNOS4: 1885 /* 1886 * The exynos4x12 device requires input raw image fourcc 1887 * to be V4L2_PIX_FMT_GREY if gray jpeg format 1888 * is to be set. 1889 */ 1890 if (ctx->out_q.fmt->fourcc != V4L2_PIX_FMT_GREY && 1891 *ctrl_val == V4L2_JPEG_CHROMA_SUBSAMPLING_GRAY) 1892 return -EINVAL; 1893 break; 1894 } 1895 1896 /* 1897 * The exynos4x12 and exynos3250/compatible devices require resulting 1898 * jpeg subsampling not to be lower than the input raw image 1899 * subsampling. 1900 */ 1901 if (ctx->out_q.fmt->subsampling > *ctrl_val) 1902 *ctrl_val = ctx->out_q.fmt->subsampling; 1903 1904 return 0; 1905 } 1906 1907 static int s5p_jpeg_try_ctrl(struct v4l2_ctrl *ctrl) 1908 { 1909 struct s5p_jpeg_ctx *ctx = ctrl_to_ctx(ctrl); 1910 unsigned long flags; 1911 int ret = 0; 1912 1913 spin_lock_irqsave(&ctx->jpeg->slock, flags); 1914 1915 if (ctrl->id == V4L2_CID_JPEG_CHROMA_SUBSAMPLING) 1916 ret = s5p_jpeg_adjust_subs_ctrl(ctx, &ctrl->val); 1917 1918 spin_unlock_irqrestore(&ctx->jpeg->slock, flags); 1919 return ret; 1920 } 1921 1922 static int s5p_jpeg_s_ctrl(struct v4l2_ctrl *ctrl) 1923 { 1924 struct s5p_jpeg_ctx *ctx = ctrl_to_ctx(ctrl); 1925 unsigned long flags; 1926 1927 spin_lock_irqsave(&ctx->jpeg->slock, flags); 1928 1929 switch (ctrl->id) { 1930 case V4L2_CID_JPEG_COMPRESSION_QUALITY: 1931 ctx->compr_quality = ctrl->val; 1932 break; 1933 case V4L2_CID_JPEG_RESTART_INTERVAL: 1934 ctx->restart_interval = ctrl->val; 1935 break; 1936 case V4L2_CID_JPEG_CHROMA_SUBSAMPLING: 1937 ctx->subsampling = ctrl->val; 1938 break; 1939 } 1940 1941 spin_unlock_irqrestore(&ctx->jpeg->slock, flags); 1942 return 0; 1943 } 1944 1945 static const struct v4l2_ctrl_ops s5p_jpeg_ctrl_ops = { 1946 .g_volatile_ctrl = s5p_jpeg_g_volatile_ctrl, 1947 .try_ctrl = s5p_jpeg_try_ctrl, 1948 .s_ctrl = s5p_jpeg_s_ctrl, 1949 }; 1950 1951 static int s5p_jpeg_controls_create(struct s5p_jpeg_ctx *ctx) 1952 { 1953 unsigned int mask = ~0x27; /* 444, 422, 420, GRAY */ 1954 struct v4l2_ctrl *ctrl; 1955 int ret; 1956 1957 v4l2_ctrl_handler_init(&ctx->ctrl_handler, 3); 1958 1959 if (ctx->mode == S5P_JPEG_ENCODE) { 1960 v4l2_ctrl_new_std(&ctx->ctrl_handler, &s5p_jpeg_ctrl_ops, 1961 V4L2_CID_JPEG_COMPRESSION_QUALITY, 1962 0, 3, 1, S5P_JPEG_COMPR_QUAL_WORST); 1963 1964 v4l2_ctrl_new_std(&ctx->ctrl_handler, &s5p_jpeg_ctrl_ops, 1965 V4L2_CID_JPEG_RESTART_INTERVAL, 1966 0, 0xffff, 1, 0); 1967 if (ctx->jpeg->variant->version == SJPEG_S5P) 1968 mask = ~0x06; /* 422, 420 */ 1969 } 1970 1971 ctrl = v4l2_ctrl_new_std_menu(&ctx->ctrl_handler, &s5p_jpeg_ctrl_ops, 1972 V4L2_CID_JPEG_CHROMA_SUBSAMPLING, 1973 V4L2_JPEG_CHROMA_SUBSAMPLING_GRAY, mask, 1974 V4L2_JPEG_CHROMA_SUBSAMPLING_422); 1975 1976 if (ctx->ctrl_handler.error) { 1977 ret = ctx->ctrl_handler.error; 1978 goto error_free; 1979 } 1980 1981 if (ctx->mode == S5P_JPEG_DECODE) 1982 ctrl->flags |= V4L2_CTRL_FLAG_VOLATILE | 1983 V4L2_CTRL_FLAG_READ_ONLY; 1984 1985 ret = v4l2_ctrl_handler_setup(&ctx->ctrl_handler); 1986 if (ret < 0) 1987 goto error_free; 1988 1989 return ret; 1990 1991 error_free: 1992 v4l2_ctrl_handler_free(&ctx->ctrl_handler); 1993 return ret; 1994 } 1995 1996 static const struct v4l2_ioctl_ops s5p_jpeg_ioctl_ops = { 1997 .vidioc_querycap = s5p_jpeg_querycap, 1998 1999 .vidioc_enum_fmt_vid_cap = s5p_jpeg_enum_fmt_vid_cap, 2000 .vidioc_enum_fmt_vid_out = s5p_jpeg_enum_fmt_vid_out, 2001 2002 .vidioc_g_fmt_vid_cap = s5p_jpeg_g_fmt, 2003 .vidioc_g_fmt_vid_out = s5p_jpeg_g_fmt, 2004 2005 .vidioc_try_fmt_vid_cap = s5p_jpeg_try_fmt_vid_cap, 2006 .vidioc_try_fmt_vid_out = s5p_jpeg_try_fmt_vid_out, 2007 2008 .vidioc_s_fmt_vid_cap = s5p_jpeg_s_fmt_vid_cap, 2009 .vidioc_s_fmt_vid_out = s5p_jpeg_s_fmt_vid_out, 2010 2011 .vidioc_reqbufs = v4l2_m2m_ioctl_reqbufs, 2012 .vidioc_querybuf = v4l2_m2m_ioctl_querybuf, 2013 .vidioc_qbuf = v4l2_m2m_ioctl_qbuf, 2014 .vidioc_dqbuf = v4l2_m2m_ioctl_dqbuf, 2015 2016 .vidioc_streamon = v4l2_m2m_ioctl_streamon, 2017 .vidioc_streamoff = v4l2_m2m_ioctl_streamoff, 2018 2019 .vidioc_g_selection = s5p_jpeg_g_selection, 2020 .vidioc_s_selection = s5p_jpeg_s_selection, 2021 2022 .vidioc_subscribe_event = s5p_jpeg_subscribe_event, 2023 .vidioc_unsubscribe_event = v4l2_event_unsubscribe, 2024 }; 2025 2026 /* 2027 * ============================================================================ 2028 * mem2mem callbacks 2029 * ============================================================================ 2030 */ 2031 2032 static void s5p_jpeg_device_run(void *priv) 2033 { 2034 struct s5p_jpeg_ctx *ctx = priv; 2035 struct s5p_jpeg *jpeg = ctx->jpeg; 2036 struct vb2_v4l2_buffer *src_buf, *dst_buf; 2037 unsigned long src_addr, dst_addr, flags; 2038 2039 spin_lock_irqsave(&ctx->jpeg->slock, flags); 2040 2041 src_buf = v4l2_m2m_next_src_buf(ctx->fh.m2m_ctx); 2042 dst_buf = v4l2_m2m_next_dst_buf(ctx->fh.m2m_ctx); 2043 src_addr = vb2_dma_contig_plane_dma_addr(&src_buf->vb2_buf, 0); 2044 dst_addr = vb2_dma_contig_plane_dma_addr(&dst_buf->vb2_buf, 0); 2045 2046 s5p_jpeg_reset(jpeg->regs); 2047 s5p_jpeg_poweron(jpeg->regs); 2048 s5p_jpeg_proc_mode(jpeg->regs, ctx->mode); 2049 if (ctx->mode == S5P_JPEG_ENCODE) { 2050 if (ctx->out_q.fmt->fourcc == V4L2_PIX_FMT_RGB565) 2051 s5p_jpeg_input_raw_mode(jpeg->regs, 2052 S5P_JPEG_RAW_IN_565); 2053 else 2054 s5p_jpeg_input_raw_mode(jpeg->regs, 2055 S5P_JPEG_RAW_IN_422); 2056 s5p_jpeg_subsampling_mode(jpeg->regs, ctx->subsampling); 2057 s5p_jpeg_dri(jpeg->regs, ctx->restart_interval); 2058 s5p_jpeg_x(jpeg->regs, ctx->out_q.w); 2059 s5p_jpeg_y(jpeg->regs, ctx->out_q.h); 2060 s5p_jpeg_imgadr(jpeg->regs, src_addr); 2061 s5p_jpeg_jpgadr(jpeg->regs, dst_addr); 2062 2063 /* ultimately comes from sizeimage from userspace */ 2064 s5p_jpeg_enc_stream_int(jpeg->regs, ctx->cap_q.size); 2065 2066 /* JPEG RGB to YCbCr conversion matrix */ 2067 s5p_jpeg_coef(jpeg->regs, 1, 1, S5P_JPEG_COEF11); 2068 s5p_jpeg_coef(jpeg->regs, 1, 2, S5P_JPEG_COEF12); 2069 s5p_jpeg_coef(jpeg->regs, 1, 3, S5P_JPEG_COEF13); 2070 s5p_jpeg_coef(jpeg->regs, 2, 1, S5P_JPEG_COEF21); 2071 s5p_jpeg_coef(jpeg->regs, 2, 2, S5P_JPEG_COEF22); 2072 s5p_jpeg_coef(jpeg->regs, 2, 3, S5P_JPEG_COEF23); 2073 s5p_jpeg_coef(jpeg->regs, 3, 1, S5P_JPEG_COEF31); 2074 s5p_jpeg_coef(jpeg->regs, 3, 2, S5P_JPEG_COEF32); 2075 s5p_jpeg_coef(jpeg->regs, 3, 3, S5P_JPEG_COEF33); 2076 2077 /* 2078 * JPEG IP allows storing 4 quantization tables 2079 * We fill table 0 for luma and table 1 for chroma 2080 */ 2081 s5p_jpeg_set_qtbl_lum(jpeg->regs, ctx->compr_quality); 2082 s5p_jpeg_set_qtbl_chr(jpeg->regs, ctx->compr_quality); 2083 /* use table 0 for Y */ 2084 s5p_jpeg_qtbl(jpeg->regs, 1, 0); 2085 /* use table 1 for Cb and Cr*/ 2086 s5p_jpeg_qtbl(jpeg->regs, 2, 1); 2087 s5p_jpeg_qtbl(jpeg->regs, 3, 1); 2088 2089 /* Y, Cb, Cr use Huffman table 0 */ 2090 s5p_jpeg_htbl_ac(jpeg->regs, 1); 2091 s5p_jpeg_htbl_dc(jpeg->regs, 1); 2092 s5p_jpeg_htbl_ac(jpeg->regs, 2); 2093 s5p_jpeg_htbl_dc(jpeg->regs, 2); 2094 s5p_jpeg_htbl_ac(jpeg->regs, 3); 2095 s5p_jpeg_htbl_dc(jpeg->regs, 3); 2096 } else { /* S5P_JPEG_DECODE */ 2097 s5p_jpeg_rst_int_enable(jpeg->regs, true); 2098 s5p_jpeg_data_num_int_enable(jpeg->regs, true); 2099 s5p_jpeg_final_mcu_num_int_enable(jpeg->regs, true); 2100 if (ctx->cap_q.fmt->fourcc == V4L2_PIX_FMT_YUYV) 2101 s5p_jpeg_outform_raw(jpeg->regs, S5P_JPEG_RAW_OUT_422); 2102 else 2103 s5p_jpeg_outform_raw(jpeg->regs, S5P_JPEG_RAW_OUT_420); 2104 s5p_jpeg_jpgadr(jpeg->regs, src_addr); 2105 s5p_jpeg_imgadr(jpeg->regs, dst_addr); 2106 } 2107 2108 s5p_jpeg_start(jpeg->regs); 2109 2110 spin_unlock_irqrestore(&ctx->jpeg->slock, flags); 2111 } 2112 2113 static void exynos4_jpeg_set_img_addr(struct s5p_jpeg_ctx *ctx) 2114 { 2115 struct s5p_jpeg *jpeg = ctx->jpeg; 2116 struct s5p_jpeg_fmt *fmt; 2117 struct vb2_v4l2_buffer *vb; 2118 struct s5p_jpeg_addr jpeg_addr = {}; 2119 u32 pix_size, padding_bytes = 0; 2120 2121 jpeg_addr.cb = 0; 2122 jpeg_addr.cr = 0; 2123 2124 pix_size = ctx->cap_q.w * ctx->cap_q.h; 2125 2126 if (ctx->mode == S5P_JPEG_ENCODE) { 2127 vb = v4l2_m2m_next_src_buf(ctx->fh.m2m_ctx); 2128 fmt = ctx->out_q.fmt; 2129 if (ctx->out_q.w % 2 && fmt->h_align > 0) 2130 padding_bytes = ctx->out_q.h; 2131 } else { 2132 fmt = ctx->cap_q.fmt; 2133 vb = v4l2_m2m_next_dst_buf(ctx->fh.m2m_ctx); 2134 } 2135 2136 jpeg_addr.y = vb2_dma_contig_plane_dma_addr(&vb->vb2_buf, 0); 2137 2138 if (fmt->colplanes == 2) { 2139 jpeg_addr.cb = jpeg_addr.y + pix_size - padding_bytes; 2140 } else if (fmt->colplanes == 3) { 2141 jpeg_addr.cb = jpeg_addr.y + pix_size; 2142 if (fmt->fourcc == V4L2_PIX_FMT_YUV420) 2143 jpeg_addr.cr = jpeg_addr.cb + pix_size / 4; 2144 else 2145 jpeg_addr.cr = jpeg_addr.cb + pix_size / 2; 2146 } 2147 2148 exynos4_jpeg_set_frame_buf_address(jpeg->regs, &jpeg_addr); 2149 } 2150 2151 static void exynos4_jpeg_set_jpeg_addr(struct s5p_jpeg_ctx *ctx) 2152 { 2153 struct s5p_jpeg *jpeg = ctx->jpeg; 2154 struct vb2_v4l2_buffer *vb; 2155 unsigned int jpeg_addr = 0; 2156 2157 if (ctx->mode == S5P_JPEG_ENCODE) 2158 vb = v4l2_m2m_next_dst_buf(ctx->fh.m2m_ctx); 2159 else 2160 vb = v4l2_m2m_next_src_buf(ctx->fh.m2m_ctx); 2161 2162 jpeg_addr = vb2_dma_contig_plane_dma_addr(&vb->vb2_buf, 0); 2163 if (jpeg->variant->version == SJPEG_EXYNOS5433 && 2164 ctx->mode == S5P_JPEG_DECODE) 2165 jpeg_addr += ctx->out_q.sos; 2166 exynos4_jpeg_set_stream_buf_address(jpeg->regs, jpeg_addr); 2167 } 2168 2169 static inline void exynos4_jpeg_set_img_fmt(void __iomem *base, 2170 unsigned int img_fmt) 2171 { 2172 __exynos4_jpeg_set_img_fmt(base, img_fmt, SJPEG_EXYNOS4); 2173 } 2174 2175 static inline void exynos5433_jpeg_set_img_fmt(void __iomem *base, 2176 unsigned int img_fmt) 2177 { 2178 __exynos4_jpeg_set_img_fmt(base, img_fmt, SJPEG_EXYNOS5433); 2179 } 2180 2181 static inline void exynos4_jpeg_set_enc_out_fmt(void __iomem *base, 2182 unsigned int out_fmt) 2183 { 2184 __exynos4_jpeg_set_enc_out_fmt(base, out_fmt, SJPEG_EXYNOS4); 2185 } 2186 2187 static inline void exynos5433_jpeg_set_enc_out_fmt(void __iomem *base, 2188 unsigned int out_fmt) 2189 { 2190 __exynos4_jpeg_set_enc_out_fmt(base, out_fmt, SJPEG_EXYNOS5433); 2191 } 2192 2193 static void exynos4_jpeg_device_run(void *priv) 2194 { 2195 struct s5p_jpeg_ctx *ctx = priv; 2196 struct s5p_jpeg *jpeg = ctx->jpeg; 2197 unsigned int bitstream_size; 2198 unsigned long flags; 2199 2200 spin_lock_irqsave(&jpeg->slock, flags); 2201 2202 if (ctx->mode == S5P_JPEG_ENCODE) { 2203 exynos4_jpeg_sw_reset(jpeg->regs); 2204 exynos4_jpeg_set_interrupt(jpeg->regs, jpeg->variant->version); 2205 exynos4_jpeg_set_huf_table_enable(jpeg->regs, 1); 2206 2207 exynos4_jpeg_set_huff_tbl(jpeg->regs); 2208 2209 /* 2210 * JPEG IP allows storing 4 quantization tables 2211 * We fill table 0 for luma and table 1 for chroma 2212 */ 2213 exynos4_jpeg_set_qtbl_lum(jpeg->regs, ctx->compr_quality); 2214 exynos4_jpeg_set_qtbl_chr(jpeg->regs, ctx->compr_quality); 2215 2216 exynos4_jpeg_set_encode_tbl_select(jpeg->regs, 2217 ctx->compr_quality); 2218 exynos4_jpeg_set_stream_size(jpeg->regs, ctx->cap_q.w, 2219 ctx->cap_q.h); 2220 2221 if (ctx->jpeg->variant->version == SJPEG_EXYNOS4) { 2222 exynos4_jpeg_set_enc_out_fmt(jpeg->regs, 2223 ctx->subsampling); 2224 exynos4_jpeg_set_img_fmt(jpeg->regs, 2225 ctx->out_q.fmt->fourcc); 2226 } else { 2227 exynos5433_jpeg_set_enc_out_fmt(jpeg->regs, 2228 ctx->subsampling); 2229 exynos5433_jpeg_set_img_fmt(jpeg->regs, 2230 ctx->out_q.fmt->fourcc); 2231 } 2232 exynos4_jpeg_set_img_addr(ctx); 2233 exynos4_jpeg_set_jpeg_addr(ctx); 2234 exynos4_jpeg_set_encode_hoff_cnt(jpeg->regs, 2235 ctx->out_q.fmt->fourcc); 2236 } else { 2237 exynos4_jpeg_sw_reset(jpeg->regs); 2238 exynos4_jpeg_set_interrupt(jpeg->regs, 2239 jpeg->variant->version); 2240 exynos4_jpeg_set_img_addr(ctx); 2241 exynos4_jpeg_set_jpeg_addr(ctx); 2242 2243 if (jpeg->variant->version == SJPEG_EXYNOS5433) { 2244 exynos4_jpeg_parse_huff_tbl(ctx); 2245 exynos4_jpeg_parse_decode_h_tbl(ctx); 2246 2247 exynos4_jpeg_parse_q_tbl(ctx); 2248 exynos4_jpeg_parse_decode_q_tbl(ctx); 2249 2250 exynos4_jpeg_set_huf_table_enable(jpeg->regs, 1); 2251 2252 exynos4_jpeg_set_stream_size(jpeg->regs, ctx->cap_q.w, 2253 ctx->cap_q.h); 2254 exynos5433_jpeg_set_enc_out_fmt(jpeg->regs, 2255 ctx->subsampling); 2256 exynos5433_jpeg_set_img_fmt(jpeg->regs, 2257 ctx->cap_q.fmt->fourcc); 2258 bitstream_size = DIV_ROUND_UP(ctx->out_q.size, 16); 2259 } else { 2260 exynos4_jpeg_set_img_fmt(jpeg->regs, 2261 ctx->cap_q.fmt->fourcc); 2262 bitstream_size = DIV_ROUND_UP(ctx->out_q.size, 32); 2263 } 2264 2265 exynos4_jpeg_set_dec_bitstream_size(jpeg->regs, bitstream_size); 2266 } 2267 2268 exynos4_jpeg_set_sys_int_enable(jpeg->regs, 1); 2269 exynos4_jpeg_set_enc_dec_mode(jpeg->regs, ctx->mode); 2270 2271 spin_unlock_irqrestore(&jpeg->slock, flags); 2272 } 2273 2274 static void exynos3250_jpeg_set_img_addr(struct s5p_jpeg_ctx *ctx) 2275 { 2276 struct s5p_jpeg *jpeg = ctx->jpeg; 2277 struct s5p_jpeg_fmt *fmt; 2278 struct vb2_v4l2_buffer *vb; 2279 struct s5p_jpeg_addr jpeg_addr = {}; 2280 u32 pix_size; 2281 2282 pix_size = ctx->cap_q.w * ctx->cap_q.h; 2283 2284 if (ctx->mode == S5P_JPEG_ENCODE) { 2285 vb = v4l2_m2m_next_src_buf(ctx->fh.m2m_ctx); 2286 fmt = ctx->out_q.fmt; 2287 } else { 2288 vb = v4l2_m2m_next_dst_buf(ctx->fh.m2m_ctx); 2289 fmt = ctx->cap_q.fmt; 2290 } 2291 2292 jpeg_addr.y = vb2_dma_contig_plane_dma_addr(&vb->vb2_buf, 0); 2293 2294 if (fmt->colplanes == 2) { 2295 jpeg_addr.cb = jpeg_addr.y + pix_size; 2296 } else if (fmt->colplanes == 3) { 2297 jpeg_addr.cb = jpeg_addr.y + pix_size; 2298 if (fmt->fourcc == V4L2_PIX_FMT_YUV420) 2299 jpeg_addr.cr = jpeg_addr.cb + pix_size / 4; 2300 else 2301 jpeg_addr.cr = jpeg_addr.cb + pix_size / 2; 2302 } 2303 2304 exynos3250_jpeg_imgadr(jpeg->regs, &jpeg_addr); 2305 } 2306 2307 static void exynos3250_jpeg_set_jpeg_addr(struct s5p_jpeg_ctx *ctx) 2308 { 2309 struct s5p_jpeg *jpeg = ctx->jpeg; 2310 struct vb2_v4l2_buffer *vb; 2311 unsigned int jpeg_addr = 0; 2312 2313 if (ctx->mode == S5P_JPEG_ENCODE) 2314 vb = v4l2_m2m_next_dst_buf(ctx->fh.m2m_ctx); 2315 else 2316 vb = v4l2_m2m_next_src_buf(ctx->fh.m2m_ctx); 2317 2318 jpeg_addr = vb2_dma_contig_plane_dma_addr(&vb->vb2_buf, 0); 2319 exynos3250_jpeg_jpgadr(jpeg->regs, jpeg_addr); 2320 } 2321 2322 static void exynos3250_jpeg_device_run(void *priv) 2323 { 2324 struct s5p_jpeg_ctx *ctx = priv; 2325 struct s5p_jpeg *jpeg = ctx->jpeg; 2326 unsigned long flags; 2327 2328 spin_lock_irqsave(&ctx->jpeg->slock, flags); 2329 2330 exynos3250_jpeg_reset(jpeg->regs); 2331 exynos3250_jpeg_set_dma_num(jpeg->regs); 2332 exynos3250_jpeg_poweron(jpeg->regs); 2333 exynos3250_jpeg_clk_set(jpeg->regs); 2334 exynos3250_jpeg_proc_mode(jpeg->regs, ctx->mode); 2335 2336 if (ctx->mode == S5P_JPEG_ENCODE) { 2337 exynos3250_jpeg_input_raw_fmt(jpeg->regs, 2338 ctx->out_q.fmt->fourcc); 2339 exynos3250_jpeg_dri(jpeg->regs, ctx->restart_interval); 2340 2341 /* 2342 * JPEG IP allows storing 4 quantization tables 2343 * We fill table 0 for luma and table 1 for chroma 2344 */ 2345 s5p_jpeg_set_qtbl_lum(jpeg->regs, ctx->compr_quality); 2346 s5p_jpeg_set_qtbl_chr(jpeg->regs, ctx->compr_quality); 2347 /* use table 0 for Y */ 2348 exynos3250_jpeg_qtbl(jpeg->regs, 1, 0); 2349 /* use table 1 for Cb and Cr*/ 2350 exynos3250_jpeg_qtbl(jpeg->regs, 2, 1); 2351 exynos3250_jpeg_qtbl(jpeg->regs, 3, 1); 2352 2353 /* 2354 * Some SoCs require setting Huffman tables before each run 2355 */ 2356 if (jpeg->variant->htbl_reinit) { 2357 s5p_jpeg_set_hdctbl(jpeg->regs); 2358 s5p_jpeg_set_hdctblg(jpeg->regs); 2359 s5p_jpeg_set_hactbl(jpeg->regs); 2360 s5p_jpeg_set_hactblg(jpeg->regs); 2361 } 2362 2363 /* Y, Cb, Cr use Huffman table 0 */ 2364 exynos3250_jpeg_htbl_ac(jpeg->regs, 1); 2365 exynos3250_jpeg_htbl_dc(jpeg->regs, 1); 2366 exynos3250_jpeg_htbl_ac(jpeg->regs, 2); 2367 exynos3250_jpeg_htbl_dc(jpeg->regs, 2); 2368 exynos3250_jpeg_htbl_ac(jpeg->regs, 3); 2369 exynos3250_jpeg_htbl_dc(jpeg->regs, 3); 2370 2371 exynos3250_jpeg_set_x(jpeg->regs, ctx->crop_rect.width); 2372 exynos3250_jpeg_set_y(jpeg->regs, ctx->crop_rect.height); 2373 exynos3250_jpeg_stride(jpeg->regs, ctx->out_q.fmt->fourcc, 2374 ctx->out_q.w); 2375 exynos3250_jpeg_offset(jpeg->regs, ctx->crop_rect.left, 2376 ctx->crop_rect.top); 2377 exynos3250_jpeg_set_img_addr(ctx); 2378 exynos3250_jpeg_set_jpeg_addr(ctx); 2379 exynos3250_jpeg_subsampling_mode(jpeg->regs, ctx->subsampling); 2380 2381 /* ultimately comes from sizeimage from userspace */ 2382 exynos3250_jpeg_enc_stream_bound(jpeg->regs, ctx->cap_q.size); 2383 2384 if (ctx->out_q.fmt->fourcc == V4L2_PIX_FMT_RGB565 || 2385 ctx->out_q.fmt->fourcc == V4L2_PIX_FMT_RGB565X || 2386 ctx->out_q.fmt->fourcc == V4L2_PIX_FMT_RGB32) 2387 exynos3250_jpeg_set_y16(jpeg->regs, true); 2388 } else { 2389 exynos3250_jpeg_set_img_addr(ctx); 2390 exynos3250_jpeg_set_jpeg_addr(ctx); 2391 exynos3250_jpeg_stride(jpeg->regs, ctx->cap_q.fmt->fourcc, 2392 ctx->cap_q.w); 2393 exynos3250_jpeg_offset(jpeg->regs, 0, 0); 2394 exynos3250_jpeg_dec_scaling_ratio(jpeg->regs, 2395 ctx->scale_factor); 2396 exynos3250_jpeg_dec_stream_size(jpeg->regs, ctx->out_q.size); 2397 exynos3250_jpeg_output_raw_fmt(jpeg->regs, 2398 ctx->cap_q.fmt->fourcc); 2399 } 2400 2401 exynos3250_jpeg_interrupts_enable(jpeg->regs); 2402 2403 /* JPEG RGB to YCbCr conversion matrix */ 2404 exynos3250_jpeg_coef(jpeg->regs, ctx->mode); 2405 2406 exynos3250_jpeg_set_timer(jpeg->regs, EXYNOS3250_IRQ_TIMEOUT); 2407 jpeg->irq_status = 0; 2408 exynos3250_jpeg_start(jpeg->regs); 2409 2410 spin_unlock_irqrestore(&ctx->jpeg->slock, flags); 2411 } 2412 2413 static int s5p_jpeg_job_ready(void *priv) 2414 { 2415 struct s5p_jpeg_ctx *ctx = priv; 2416 2417 if (ctx->mode == S5P_JPEG_DECODE) { 2418 /* 2419 * We have only one input buffer and one output buffer. If there 2420 * is a resolution change event, no need to continue decoding. 2421 */ 2422 if (ctx->state == JPEGCTX_RESOLUTION_CHANGE) 2423 return 0; 2424 2425 return ctx->hdr_parsed; 2426 } 2427 2428 return 1; 2429 } 2430 2431 static const struct v4l2_m2m_ops s5p_jpeg_m2m_ops = { 2432 .device_run = s5p_jpeg_device_run, 2433 .job_ready = s5p_jpeg_job_ready, 2434 }; 2435 2436 static const struct v4l2_m2m_ops exynos3250_jpeg_m2m_ops = { 2437 .device_run = exynos3250_jpeg_device_run, 2438 .job_ready = s5p_jpeg_job_ready, 2439 }; 2440 2441 static const struct v4l2_m2m_ops exynos4_jpeg_m2m_ops = { 2442 .device_run = exynos4_jpeg_device_run, 2443 .job_ready = s5p_jpeg_job_ready, 2444 }; 2445 2446 /* 2447 * ============================================================================ 2448 * Queue operations 2449 * ============================================================================ 2450 */ 2451 2452 static int s5p_jpeg_queue_setup(struct vb2_queue *vq, 2453 unsigned int *nbuffers, unsigned int *nplanes, 2454 unsigned int sizes[], struct device *alloc_devs[]) 2455 { 2456 struct s5p_jpeg_ctx *ctx = vb2_get_drv_priv(vq); 2457 struct s5p_jpeg_q_data *q_data = NULL; 2458 unsigned int size, count = *nbuffers; 2459 2460 q_data = get_q_data(ctx, vq->type); 2461 BUG_ON(q_data == NULL); 2462 2463 size = q_data->size; 2464 2465 /* 2466 * header is parsed during decoding and parsed information stored 2467 * in the context so we do not allow another buffer to overwrite it 2468 */ 2469 if (ctx->mode == S5P_JPEG_DECODE) 2470 count = 1; 2471 2472 *nbuffers = count; 2473 *nplanes = 1; 2474 sizes[0] = size; 2475 2476 return 0; 2477 } 2478 2479 static int s5p_jpeg_buf_prepare(struct vb2_buffer *vb) 2480 { 2481 struct s5p_jpeg_ctx *ctx = vb2_get_drv_priv(vb->vb2_queue); 2482 struct s5p_jpeg_q_data *q_data = NULL; 2483 2484 q_data = get_q_data(ctx, vb->vb2_queue->type); 2485 BUG_ON(q_data == NULL); 2486 2487 if (vb2_plane_size(vb, 0) < q_data->size) { 2488 pr_err("%s data will not fit into plane (%lu < %lu)\n", 2489 __func__, vb2_plane_size(vb, 0), 2490 (long)q_data->size); 2491 return -EINVAL; 2492 } 2493 2494 vb2_set_plane_payload(vb, 0, q_data->size); 2495 2496 return 0; 2497 } 2498 2499 static void s5p_jpeg_set_capture_queue_data(struct s5p_jpeg_ctx *ctx) 2500 { 2501 struct s5p_jpeg_q_data *q_data = &ctx->cap_q; 2502 2503 q_data->w = ctx->out_q.w; 2504 q_data->h = ctx->out_q.h; 2505 2506 /* 2507 * This call to jpeg_bound_align_image() takes care of width and 2508 * height values alignment when user space calls the QBUF of 2509 * OUTPUT buffer after the S_FMT of CAPTURE buffer. 2510 * Please note that on Exynos4x12 SoCs, resigning from executing 2511 * S_FMT on capture buffer for each JPEG image can result in a 2512 * hardware hangup if subsampling is lower than the one of input 2513 * JPEG. 2514 */ 2515 jpeg_bound_align_image(ctx, &q_data->w, S5P_JPEG_MIN_WIDTH, 2516 S5P_JPEG_MAX_WIDTH, q_data->fmt->h_align, 2517 &q_data->h, S5P_JPEG_MIN_HEIGHT, 2518 S5P_JPEG_MAX_HEIGHT, q_data->fmt->v_align); 2519 2520 q_data->size = q_data->w * q_data->h * q_data->fmt->depth >> 3; 2521 } 2522 2523 static void s5p_jpeg_buf_queue(struct vb2_buffer *vb) 2524 { 2525 struct vb2_v4l2_buffer *vbuf = to_vb2_v4l2_buffer(vb); 2526 struct s5p_jpeg_ctx *ctx = vb2_get_drv_priv(vb->vb2_queue); 2527 2528 if (ctx->mode == S5P_JPEG_DECODE && 2529 vb->vb2_queue->type == V4L2_BUF_TYPE_VIDEO_OUTPUT) { 2530 static const struct v4l2_event ev_src_ch = { 2531 .type = V4L2_EVENT_SOURCE_CHANGE, 2532 .u.src_change.changes = V4L2_EVENT_SRC_CH_RESOLUTION, 2533 }; 2534 struct vb2_queue *dst_vq; 2535 u32 ori_w; 2536 u32 ori_h; 2537 2538 dst_vq = v4l2_m2m_get_vq(ctx->fh.m2m_ctx, 2539 V4L2_BUF_TYPE_VIDEO_CAPTURE); 2540 ori_w = ctx->out_q.w; 2541 ori_h = ctx->out_q.h; 2542 2543 ctx->hdr_parsed = s5p_jpeg_parse_hdr(&ctx->out_q, 2544 (unsigned long)vb2_plane_vaddr(vb, 0), 2545 min((unsigned long)ctx->out_q.size, 2546 vb2_get_plane_payload(vb, 0)), ctx); 2547 if (!ctx->hdr_parsed) { 2548 vb2_buffer_done(vb, VB2_BUF_STATE_ERROR); 2549 return; 2550 } 2551 2552 /* 2553 * If there is a resolution change event, only update capture 2554 * queue when it is not streaming. Otherwise, update it in 2555 * STREAMOFF. See s5p_jpeg_stop_streaming for detail. 2556 */ 2557 if (ctx->out_q.w != ori_w || ctx->out_q.h != ori_h) { 2558 v4l2_event_queue_fh(&ctx->fh, &ev_src_ch); 2559 if (vb2_is_streaming(dst_vq)) 2560 ctx->state = JPEGCTX_RESOLUTION_CHANGE; 2561 else 2562 s5p_jpeg_set_capture_queue_data(ctx); 2563 } 2564 } 2565 2566 v4l2_m2m_buf_queue(ctx->fh.m2m_ctx, vbuf); 2567 } 2568 2569 static int s5p_jpeg_start_streaming(struct vb2_queue *q, unsigned int count) 2570 { 2571 struct s5p_jpeg_ctx *ctx = vb2_get_drv_priv(q); 2572 2573 return pm_runtime_resume_and_get(ctx->jpeg->dev); 2574 } 2575 2576 static void s5p_jpeg_stop_streaming(struct vb2_queue *q) 2577 { 2578 struct s5p_jpeg_ctx *ctx = vb2_get_drv_priv(q); 2579 2580 /* 2581 * STREAMOFF is an acknowledgment for resolution change event. 2582 * Before STREAMOFF, we still have to return the old resolution and 2583 * subsampling. Update capture queue when the stream is off. 2584 */ 2585 if (ctx->state == JPEGCTX_RESOLUTION_CHANGE && 2586 q->type == V4L2_BUF_TYPE_VIDEO_CAPTURE) { 2587 s5p_jpeg_set_capture_queue_data(ctx); 2588 ctx->state = JPEGCTX_RUNNING; 2589 } 2590 2591 pm_runtime_put(ctx->jpeg->dev); 2592 } 2593 2594 static const struct vb2_ops s5p_jpeg_qops = { 2595 .queue_setup = s5p_jpeg_queue_setup, 2596 .buf_prepare = s5p_jpeg_buf_prepare, 2597 .buf_queue = s5p_jpeg_buf_queue, 2598 .start_streaming = s5p_jpeg_start_streaming, 2599 .stop_streaming = s5p_jpeg_stop_streaming, 2600 }; 2601 2602 static int queue_init(void *priv, struct vb2_queue *src_vq, 2603 struct vb2_queue *dst_vq) 2604 { 2605 struct s5p_jpeg_ctx *ctx = priv; 2606 int ret; 2607 2608 src_vq->type = V4L2_BUF_TYPE_VIDEO_OUTPUT; 2609 src_vq->io_modes = VB2_MMAP | VB2_USERPTR; 2610 src_vq->drv_priv = ctx; 2611 src_vq->buf_struct_size = sizeof(struct v4l2_m2m_buffer); 2612 src_vq->ops = &s5p_jpeg_qops; 2613 src_vq->mem_ops = &vb2_dma_contig_memops; 2614 src_vq->timestamp_flags = V4L2_BUF_FLAG_TIMESTAMP_COPY; 2615 src_vq->lock = &ctx->jpeg->lock; 2616 src_vq->dev = ctx->jpeg->dev; 2617 2618 ret = vb2_queue_init(src_vq); 2619 if (ret) 2620 return ret; 2621 2622 dst_vq->type = V4L2_BUF_TYPE_VIDEO_CAPTURE; 2623 dst_vq->io_modes = VB2_MMAP | VB2_USERPTR; 2624 dst_vq->drv_priv = ctx; 2625 dst_vq->buf_struct_size = sizeof(struct v4l2_m2m_buffer); 2626 dst_vq->ops = &s5p_jpeg_qops; 2627 dst_vq->mem_ops = &vb2_dma_contig_memops; 2628 dst_vq->timestamp_flags = V4L2_BUF_FLAG_TIMESTAMP_COPY; 2629 dst_vq->lock = &ctx->jpeg->lock; 2630 dst_vq->dev = ctx->jpeg->dev; 2631 2632 return vb2_queue_init(dst_vq); 2633 } 2634 2635 /* 2636 * ============================================================================ 2637 * ISR 2638 * ============================================================================ 2639 */ 2640 2641 static irqreturn_t s5p_jpeg_irq(int irq, void *dev_id) 2642 { 2643 struct s5p_jpeg *jpeg = dev_id; 2644 struct s5p_jpeg_ctx *curr_ctx; 2645 struct vb2_v4l2_buffer *src_buf, *dst_buf; 2646 unsigned long payload_size = 0; 2647 enum vb2_buffer_state state = VB2_BUF_STATE_DONE; 2648 bool enc_jpeg_too_large = false; 2649 bool timer_elapsed = false; 2650 bool op_completed = false; 2651 2652 spin_lock(&jpeg->slock); 2653 2654 curr_ctx = v4l2_m2m_get_curr_priv(jpeg->m2m_dev); 2655 2656 src_buf = v4l2_m2m_src_buf_remove(curr_ctx->fh.m2m_ctx); 2657 dst_buf = v4l2_m2m_dst_buf_remove(curr_ctx->fh.m2m_ctx); 2658 2659 if (curr_ctx->mode == S5P_JPEG_ENCODE) 2660 enc_jpeg_too_large = s5p_jpeg_enc_stream_stat(jpeg->regs); 2661 timer_elapsed = s5p_jpeg_timer_stat(jpeg->regs); 2662 op_completed = s5p_jpeg_result_stat_ok(jpeg->regs); 2663 if (curr_ctx->mode == S5P_JPEG_DECODE) 2664 op_completed = op_completed && 2665 s5p_jpeg_stream_stat_ok(jpeg->regs); 2666 2667 if (enc_jpeg_too_large) { 2668 state = VB2_BUF_STATE_ERROR; 2669 s5p_jpeg_clear_enc_stream_stat(jpeg->regs); 2670 } else if (timer_elapsed) { 2671 state = VB2_BUF_STATE_ERROR; 2672 s5p_jpeg_clear_timer_stat(jpeg->regs); 2673 } else if (!op_completed) { 2674 state = VB2_BUF_STATE_ERROR; 2675 } else { 2676 payload_size = s5p_jpeg_compressed_size(jpeg->regs); 2677 } 2678 2679 dst_buf->timecode = src_buf->timecode; 2680 dst_buf->vb2_buf.timestamp = src_buf->vb2_buf.timestamp; 2681 dst_buf->flags &= ~V4L2_BUF_FLAG_TSTAMP_SRC_MASK; 2682 dst_buf->flags |= 2683 src_buf->flags & V4L2_BUF_FLAG_TSTAMP_SRC_MASK; 2684 2685 v4l2_m2m_buf_done(src_buf, state); 2686 if (curr_ctx->mode == S5P_JPEG_ENCODE) 2687 vb2_set_plane_payload(&dst_buf->vb2_buf, 0, payload_size); 2688 v4l2_m2m_buf_done(dst_buf, state); 2689 2690 curr_ctx->subsampling = s5p_jpeg_get_subsampling_mode(jpeg->regs); 2691 spin_unlock(&jpeg->slock); 2692 2693 s5p_jpeg_clear_int(jpeg->regs); 2694 2695 v4l2_m2m_job_finish(jpeg->m2m_dev, curr_ctx->fh.m2m_ctx); 2696 return IRQ_HANDLED; 2697 } 2698 2699 static irqreturn_t exynos4_jpeg_irq(int irq, void *priv) 2700 { 2701 unsigned int int_status; 2702 struct vb2_v4l2_buffer *src_vb, *dst_vb; 2703 struct s5p_jpeg *jpeg = priv; 2704 struct s5p_jpeg_ctx *curr_ctx; 2705 unsigned long payload_size = 0; 2706 2707 spin_lock(&jpeg->slock); 2708 2709 exynos4_jpeg_set_sys_int_enable(jpeg->regs, 0); 2710 2711 curr_ctx = v4l2_m2m_get_curr_priv(jpeg->m2m_dev); 2712 2713 src_vb = v4l2_m2m_src_buf_remove(curr_ctx->fh.m2m_ctx); 2714 dst_vb = v4l2_m2m_dst_buf_remove(curr_ctx->fh.m2m_ctx); 2715 2716 int_status = exynos4_jpeg_get_int_status(jpeg->regs); 2717 2718 if (int_status) { 2719 switch (int_status & 0x1f) { 2720 case 0x1: 2721 jpeg->irq_ret = ERR_PROT; 2722 break; 2723 case 0x2: 2724 jpeg->irq_ret = OK_ENC_OR_DEC; 2725 break; 2726 case 0x4: 2727 jpeg->irq_ret = ERR_DEC_INVALID_FORMAT; 2728 break; 2729 case 0x8: 2730 jpeg->irq_ret = ERR_MULTI_SCAN; 2731 break; 2732 case 0x10: 2733 jpeg->irq_ret = ERR_FRAME; 2734 break; 2735 default: 2736 jpeg->irq_ret = ERR_UNKNOWN; 2737 break; 2738 } 2739 } else { 2740 jpeg->irq_ret = ERR_UNKNOWN; 2741 } 2742 2743 if (jpeg->irq_ret == OK_ENC_OR_DEC) { 2744 if (curr_ctx->mode == S5P_JPEG_ENCODE) { 2745 payload_size = exynos4_jpeg_get_stream_size(jpeg->regs); 2746 vb2_set_plane_payload(&dst_vb->vb2_buf, 2747 0, payload_size); 2748 } 2749 v4l2_m2m_buf_done(src_vb, VB2_BUF_STATE_DONE); 2750 v4l2_m2m_buf_done(dst_vb, VB2_BUF_STATE_DONE); 2751 } else { 2752 v4l2_m2m_buf_done(src_vb, VB2_BUF_STATE_ERROR); 2753 v4l2_m2m_buf_done(dst_vb, VB2_BUF_STATE_ERROR); 2754 } 2755 2756 if (jpeg->variant->version == SJPEG_EXYNOS4) 2757 curr_ctx->subsampling = exynos4_jpeg_get_frame_fmt(jpeg->regs); 2758 2759 exynos4_jpeg_set_enc_dec_mode(jpeg->regs, S5P_JPEG_DISABLE); 2760 2761 spin_unlock(&jpeg->slock); 2762 2763 v4l2_m2m_job_finish(jpeg->m2m_dev, curr_ctx->fh.m2m_ctx); 2764 return IRQ_HANDLED; 2765 } 2766 2767 static irqreturn_t exynos3250_jpeg_irq(int irq, void *dev_id) 2768 { 2769 struct s5p_jpeg *jpeg = dev_id; 2770 struct s5p_jpeg_ctx *curr_ctx; 2771 struct vb2_v4l2_buffer *src_buf, *dst_buf; 2772 unsigned long payload_size = 0; 2773 enum vb2_buffer_state state = VB2_BUF_STATE_DONE; 2774 bool interrupt_timeout = false; 2775 bool stream_error = false; 2776 u32 irq_status; 2777 2778 spin_lock(&jpeg->slock); 2779 2780 irq_status = exynos3250_jpeg_get_timer_status(jpeg->regs); 2781 if (irq_status & EXYNOS3250_TIMER_INT_STAT) { 2782 exynos3250_jpeg_clear_timer_status(jpeg->regs); 2783 interrupt_timeout = true; 2784 dev_err(jpeg->dev, "Interrupt timeout occurred.\n"); 2785 } 2786 2787 irq_status = exynos3250_jpeg_get_int_status(jpeg->regs); 2788 exynos3250_jpeg_clear_int_status(jpeg->regs, irq_status); 2789 2790 jpeg->irq_status |= irq_status; 2791 2792 if (jpeg->variant->version == SJPEG_EXYNOS5420 && 2793 irq_status & EXYNOS3250_STREAM_STAT) { 2794 stream_error = true; 2795 dev_err(jpeg->dev, "Syntax error or unrecoverable error occurred.\n"); 2796 } 2797 2798 curr_ctx = v4l2_m2m_get_curr_priv(jpeg->m2m_dev); 2799 2800 if (!curr_ctx) 2801 goto exit_unlock; 2802 2803 if ((irq_status & EXYNOS3250_HEADER_STAT) && 2804 (curr_ctx->mode == S5P_JPEG_DECODE)) { 2805 exynos3250_jpeg_rstart(jpeg->regs); 2806 goto exit_unlock; 2807 } 2808 2809 if (jpeg->irq_status & (EXYNOS3250_JPEG_DONE | 2810 EXYNOS3250_WDMA_DONE | 2811 EXYNOS3250_RDMA_DONE | 2812 EXYNOS3250_RESULT_STAT)) 2813 payload_size = exynos3250_jpeg_compressed_size(jpeg->regs); 2814 else if (interrupt_timeout || stream_error) 2815 state = VB2_BUF_STATE_ERROR; 2816 else 2817 goto exit_unlock; 2818 2819 src_buf = v4l2_m2m_src_buf_remove(curr_ctx->fh.m2m_ctx); 2820 dst_buf = v4l2_m2m_dst_buf_remove(curr_ctx->fh.m2m_ctx); 2821 2822 dst_buf->timecode = src_buf->timecode; 2823 dst_buf->vb2_buf.timestamp = src_buf->vb2_buf.timestamp; 2824 2825 v4l2_m2m_buf_done(src_buf, state); 2826 if (curr_ctx->mode == S5P_JPEG_ENCODE) 2827 vb2_set_plane_payload(&dst_buf->vb2_buf, 0, payload_size); 2828 v4l2_m2m_buf_done(dst_buf, state); 2829 2830 curr_ctx->subsampling = 2831 exynos3250_jpeg_get_subsampling_mode(jpeg->regs); 2832 2833 spin_unlock(&jpeg->slock); 2834 2835 v4l2_m2m_job_finish(jpeg->m2m_dev, curr_ctx->fh.m2m_ctx); 2836 return IRQ_HANDLED; 2837 2838 exit_unlock: 2839 spin_unlock(&jpeg->slock); 2840 return IRQ_HANDLED; 2841 } 2842 2843 static void *jpeg_get_drv_data(struct device *dev); 2844 2845 /* 2846 * ============================================================================ 2847 * Driver basic infrastructure 2848 * ============================================================================ 2849 */ 2850 2851 static int s5p_jpeg_probe(struct platform_device *pdev) 2852 { 2853 struct s5p_jpeg *jpeg; 2854 int i, ret; 2855 2856 /* JPEG IP abstraction struct */ 2857 jpeg = devm_kzalloc(&pdev->dev, sizeof(struct s5p_jpeg), GFP_KERNEL); 2858 if (!jpeg) 2859 return -ENOMEM; 2860 2861 jpeg->variant = jpeg_get_drv_data(&pdev->dev); 2862 if (!jpeg->variant) 2863 return -ENODEV; 2864 2865 mutex_init(&jpeg->lock); 2866 spin_lock_init(&jpeg->slock); 2867 jpeg->dev = &pdev->dev; 2868 2869 /* memory-mapped registers */ 2870 jpeg->regs = devm_platform_ioremap_resource(pdev, 0); 2871 if (IS_ERR(jpeg->regs)) 2872 return PTR_ERR(jpeg->regs); 2873 2874 /* interrupt service routine registration */ 2875 jpeg->irq = ret = platform_get_irq(pdev, 0); 2876 if (ret < 0) 2877 return ret; 2878 2879 ret = devm_request_irq(&pdev->dev, jpeg->irq, jpeg->variant->jpeg_irq, 2880 0, dev_name(&pdev->dev), jpeg); 2881 if (ret) { 2882 dev_err(&pdev->dev, "cannot claim IRQ %d\n", jpeg->irq); 2883 return ret; 2884 } 2885 2886 /* clocks */ 2887 for (i = 0; i < jpeg->variant->num_clocks; i++) { 2888 jpeg->clocks[i] = devm_clk_get(&pdev->dev, 2889 jpeg->variant->clk_names[i]); 2890 if (IS_ERR(jpeg->clocks[i])) { 2891 dev_err(&pdev->dev, "failed to get clock: %s\n", 2892 jpeg->variant->clk_names[i]); 2893 return PTR_ERR(jpeg->clocks[i]); 2894 } 2895 } 2896 2897 /* v4l2 device */ 2898 ret = v4l2_device_register(&pdev->dev, &jpeg->v4l2_dev); 2899 if (ret) { 2900 dev_err(&pdev->dev, "Failed to register v4l2 device\n"); 2901 return ret; 2902 } 2903 2904 /* mem2mem device */ 2905 jpeg->m2m_dev = v4l2_m2m_init(jpeg->variant->m2m_ops); 2906 if (IS_ERR(jpeg->m2m_dev)) { 2907 v4l2_err(&jpeg->v4l2_dev, "Failed to init mem2mem device\n"); 2908 ret = PTR_ERR(jpeg->m2m_dev); 2909 goto device_register_rollback; 2910 } 2911 2912 vb2_dma_contig_set_max_seg_size(&pdev->dev, DMA_BIT_MASK(32)); 2913 2914 /* JPEG encoder /dev/videoX node */ 2915 jpeg->vfd_encoder = video_device_alloc(); 2916 if (!jpeg->vfd_encoder) { 2917 v4l2_err(&jpeg->v4l2_dev, "Failed to allocate video device\n"); 2918 ret = -ENOMEM; 2919 goto m2m_init_rollback; 2920 } 2921 snprintf(jpeg->vfd_encoder->name, sizeof(jpeg->vfd_encoder->name), 2922 "%s-enc", S5P_JPEG_M2M_NAME); 2923 jpeg->vfd_encoder->fops = &s5p_jpeg_fops; 2924 jpeg->vfd_encoder->ioctl_ops = &s5p_jpeg_ioctl_ops; 2925 jpeg->vfd_encoder->minor = -1; 2926 jpeg->vfd_encoder->release = video_device_release; 2927 jpeg->vfd_encoder->lock = &jpeg->lock; 2928 jpeg->vfd_encoder->v4l2_dev = &jpeg->v4l2_dev; 2929 jpeg->vfd_encoder->vfl_dir = VFL_DIR_M2M; 2930 jpeg->vfd_encoder->device_caps = V4L2_CAP_STREAMING | V4L2_CAP_VIDEO_M2M; 2931 2932 ret = video_register_device(jpeg->vfd_encoder, VFL_TYPE_VIDEO, -1); 2933 if (ret) { 2934 v4l2_err(&jpeg->v4l2_dev, "Failed to register video device\n"); 2935 video_device_release(jpeg->vfd_encoder); 2936 goto m2m_init_rollback; 2937 } 2938 2939 video_set_drvdata(jpeg->vfd_encoder, jpeg); 2940 v4l2_info(&jpeg->v4l2_dev, 2941 "encoder device registered as /dev/video%d\n", 2942 jpeg->vfd_encoder->num); 2943 2944 /* JPEG decoder /dev/videoX node */ 2945 jpeg->vfd_decoder = video_device_alloc(); 2946 if (!jpeg->vfd_decoder) { 2947 v4l2_err(&jpeg->v4l2_dev, "Failed to allocate video device\n"); 2948 ret = -ENOMEM; 2949 goto enc_vdev_register_rollback; 2950 } 2951 snprintf(jpeg->vfd_decoder->name, sizeof(jpeg->vfd_decoder->name), 2952 "%s-dec", S5P_JPEG_M2M_NAME); 2953 jpeg->vfd_decoder->fops = &s5p_jpeg_fops; 2954 jpeg->vfd_decoder->ioctl_ops = &s5p_jpeg_ioctl_ops; 2955 jpeg->vfd_decoder->minor = -1; 2956 jpeg->vfd_decoder->release = video_device_release; 2957 jpeg->vfd_decoder->lock = &jpeg->lock; 2958 jpeg->vfd_decoder->v4l2_dev = &jpeg->v4l2_dev; 2959 jpeg->vfd_decoder->vfl_dir = VFL_DIR_M2M; 2960 jpeg->vfd_decoder->device_caps = V4L2_CAP_STREAMING | V4L2_CAP_VIDEO_M2M; 2961 2962 ret = video_register_device(jpeg->vfd_decoder, VFL_TYPE_VIDEO, -1); 2963 if (ret) { 2964 v4l2_err(&jpeg->v4l2_dev, "Failed to register video device\n"); 2965 video_device_release(jpeg->vfd_decoder); 2966 goto enc_vdev_register_rollback; 2967 } 2968 2969 video_set_drvdata(jpeg->vfd_decoder, jpeg); 2970 v4l2_info(&jpeg->v4l2_dev, 2971 "decoder device registered as /dev/video%d\n", 2972 jpeg->vfd_decoder->num); 2973 2974 /* final statements & power management */ 2975 platform_set_drvdata(pdev, jpeg); 2976 2977 pm_runtime_enable(&pdev->dev); 2978 2979 v4l2_info(&jpeg->v4l2_dev, "Samsung S5P JPEG codec\n"); 2980 2981 return 0; 2982 2983 enc_vdev_register_rollback: 2984 video_unregister_device(jpeg->vfd_encoder); 2985 2986 m2m_init_rollback: 2987 v4l2_m2m_release(jpeg->m2m_dev); 2988 2989 device_register_rollback: 2990 v4l2_device_unregister(&jpeg->v4l2_dev); 2991 2992 return ret; 2993 } 2994 2995 static void s5p_jpeg_remove(struct platform_device *pdev) 2996 { 2997 struct s5p_jpeg *jpeg = platform_get_drvdata(pdev); 2998 int i; 2999 3000 pm_runtime_disable(jpeg->dev); 3001 3002 video_unregister_device(jpeg->vfd_decoder); 3003 video_unregister_device(jpeg->vfd_encoder); 3004 vb2_dma_contig_clear_max_seg_size(&pdev->dev); 3005 v4l2_m2m_release(jpeg->m2m_dev); 3006 v4l2_device_unregister(&jpeg->v4l2_dev); 3007 3008 if (!pm_runtime_status_suspended(&pdev->dev)) { 3009 for (i = jpeg->variant->num_clocks - 1; i >= 0; i--) 3010 clk_disable_unprepare(jpeg->clocks[i]); 3011 } 3012 } 3013 3014 #ifdef CONFIG_PM 3015 static int s5p_jpeg_runtime_suspend(struct device *dev) 3016 { 3017 struct s5p_jpeg *jpeg = dev_get_drvdata(dev); 3018 int i; 3019 3020 for (i = jpeg->variant->num_clocks - 1; i >= 0; i--) 3021 clk_disable_unprepare(jpeg->clocks[i]); 3022 3023 return 0; 3024 } 3025 3026 static int s5p_jpeg_runtime_resume(struct device *dev) 3027 { 3028 struct s5p_jpeg *jpeg = dev_get_drvdata(dev); 3029 unsigned long flags; 3030 int i, ret; 3031 3032 for (i = 0; i < jpeg->variant->num_clocks; i++) { 3033 ret = clk_prepare_enable(jpeg->clocks[i]); 3034 if (ret) { 3035 while (--i >= 0) 3036 clk_disable_unprepare(jpeg->clocks[i]); 3037 return ret; 3038 } 3039 } 3040 3041 spin_lock_irqsave(&jpeg->slock, flags); 3042 3043 /* 3044 * JPEG IP allows storing two Huffman tables for each component. 3045 * We fill table 0 for each component and do this here only 3046 * for S5PC210 and Exynos3250 SoCs. Exynos4x12 and Exynos542x SoC 3047 * require programming their Huffman tables each time the encoding 3048 * process is initialized, and thus it is accomplished in the 3049 * device_run callback of m2m_ops. 3050 */ 3051 if (!jpeg->variant->htbl_reinit) { 3052 s5p_jpeg_set_hdctbl(jpeg->regs); 3053 s5p_jpeg_set_hdctblg(jpeg->regs); 3054 s5p_jpeg_set_hactbl(jpeg->regs); 3055 s5p_jpeg_set_hactblg(jpeg->regs); 3056 } 3057 3058 spin_unlock_irqrestore(&jpeg->slock, flags); 3059 3060 return 0; 3061 } 3062 #endif /* CONFIG_PM */ 3063 3064 static const struct dev_pm_ops s5p_jpeg_pm_ops = { 3065 SET_SYSTEM_SLEEP_PM_OPS(pm_runtime_force_suspend, 3066 pm_runtime_force_resume) 3067 SET_RUNTIME_PM_OPS(s5p_jpeg_runtime_suspend, s5p_jpeg_runtime_resume, 3068 NULL) 3069 }; 3070 3071 static struct s5p_jpeg_variant s5p_jpeg_drvdata = { 3072 .version = SJPEG_S5P, 3073 .jpeg_irq = s5p_jpeg_irq, 3074 .m2m_ops = &s5p_jpeg_m2m_ops, 3075 .fmt_ver_flag = SJPEG_FMT_FLAG_S5P, 3076 .clk_names = {"jpeg"}, 3077 .num_clocks = 1, 3078 }; 3079 3080 static struct s5p_jpeg_variant exynos3250_jpeg_drvdata = { 3081 .version = SJPEG_EXYNOS3250, 3082 .jpeg_irq = exynos3250_jpeg_irq, 3083 .m2m_ops = &exynos3250_jpeg_m2m_ops, 3084 .fmt_ver_flag = SJPEG_FMT_FLAG_EXYNOS3250, 3085 .hw3250_compat = 1, 3086 .clk_names = {"jpeg", "sclk"}, 3087 .num_clocks = 2, 3088 }; 3089 3090 static struct s5p_jpeg_variant exynos4_jpeg_drvdata = { 3091 .version = SJPEG_EXYNOS4, 3092 .jpeg_irq = exynos4_jpeg_irq, 3093 .m2m_ops = &exynos4_jpeg_m2m_ops, 3094 .fmt_ver_flag = SJPEG_FMT_FLAG_EXYNOS4, 3095 .htbl_reinit = 1, 3096 .clk_names = {"jpeg"}, 3097 .num_clocks = 1, 3098 .hw_ex4_compat = 1, 3099 }; 3100 3101 static struct s5p_jpeg_variant exynos5420_jpeg_drvdata = { 3102 .version = SJPEG_EXYNOS5420, 3103 .jpeg_irq = exynos3250_jpeg_irq, /* intentionally 3250 */ 3104 .m2m_ops = &exynos3250_jpeg_m2m_ops, /* intentionally 3250 */ 3105 .fmt_ver_flag = SJPEG_FMT_FLAG_EXYNOS3250, /* intentionally 3250 */ 3106 .hw3250_compat = 1, 3107 .htbl_reinit = 1, 3108 .clk_names = {"jpeg"}, 3109 .num_clocks = 1, 3110 }; 3111 3112 static struct s5p_jpeg_variant exynos5433_jpeg_drvdata = { 3113 .version = SJPEG_EXYNOS5433, 3114 .jpeg_irq = exynos4_jpeg_irq, 3115 .m2m_ops = &exynos4_jpeg_m2m_ops, 3116 .fmt_ver_flag = SJPEG_FMT_FLAG_EXYNOS4, 3117 .htbl_reinit = 1, 3118 .clk_names = {"pclk", "aclk", "aclk_xiu", "sclk"}, 3119 .num_clocks = 4, 3120 .hw_ex4_compat = 1, 3121 }; 3122 3123 static const struct of_device_id samsung_jpeg_match[] = { 3124 { 3125 .compatible = "samsung,s5pv210-jpeg", 3126 .data = &s5p_jpeg_drvdata, 3127 }, { 3128 .compatible = "samsung,exynos3250-jpeg", 3129 .data = &exynos3250_jpeg_drvdata, 3130 }, { 3131 .compatible = "samsung,exynos4210-jpeg", 3132 .data = &exynos4_jpeg_drvdata, 3133 }, { 3134 .compatible = "samsung,exynos4212-jpeg", 3135 .data = &exynos4_jpeg_drvdata, 3136 }, { 3137 .compatible = "samsung,exynos5420-jpeg", 3138 .data = &exynos5420_jpeg_drvdata, 3139 }, { 3140 .compatible = "samsung,exynos5433-jpeg", 3141 .data = &exynos5433_jpeg_drvdata, 3142 }, 3143 {}, 3144 }; 3145 3146 MODULE_DEVICE_TABLE(of, samsung_jpeg_match); 3147 3148 static void *jpeg_get_drv_data(struct device *dev) 3149 { 3150 struct s5p_jpeg_variant *driver_data = NULL; 3151 const struct of_device_id *match; 3152 3153 if (!IS_ENABLED(CONFIG_OF) || !dev->of_node) 3154 return &s5p_jpeg_drvdata; 3155 3156 match = of_match_node(samsung_jpeg_match, dev->of_node); 3157 3158 if (match) 3159 driver_data = (struct s5p_jpeg_variant *)match->data; 3160 3161 return driver_data; 3162 } 3163 3164 static struct platform_driver s5p_jpeg_driver = { 3165 .probe = s5p_jpeg_probe, 3166 .remove = s5p_jpeg_remove, 3167 .driver = { 3168 .of_match_table = samsung_jpeg_match, 3169 .name = S5P_JPEG_M2M_NAME, 3170 .pm = &s5p_jpeg_pm_ops, 3171 }, 3172 }; 3173 3174 module_platform_driver(s5p_jpeg_driver); 3175 3176 MODULE_AUTHOR("Andrzej Pietrasiewicz <andrzejtp2010@gmail.com>"); 3177 MODULE_AUTHOR("Jacek Anaszewski <j.anaszewski@samsung.com>"); 3178 MODULE_DESCRIPTION("Samsung JPEG codec driver"); 3179 MODULE_LICENSE("GPL"); 3180