1 // SPDX-License-Identifier: GPL-2.0 2 /* 3 * Copyright (C) STMicroelectronics SA 2013 4 * Author: Hugues Fruchet <hugues.fruchet@st.com> for STMicroelectronics. 5 */ 6 7 #include <linux/slab.h> 8 9 #include "delta.h" 10 #include "delta-ipc.h" 11 #include "delta-mjpeg.h" 12 #include "delta-mjpeg-fw.h" 13 14 #define DELTA_MJPEG_MAX_RESO DELTA_MAX_RESO 15 16 struct delta_mjpeg_ctx { 17 /* jpeg header */ 18 struct mjpeg_header header_struct; 19 struct mjpeg_header *header; 20 21 /* ipc */ 22 void *ipc_hdl; 23 struct delta_buf *ipc_buf; 24 25 /* decoded output frame */ 26 struct delta_frame *out_frame; 27 28 unsigned char str[3000]; 29 }; 30 31 #define to_ctx(ctx) ((struct delta_mjpeg_ctx *)(ctx)->priv) 32 33 static char *ipc_open_param_str(struct jpeg_video_decode_init_params_t *p, 34 char *str, unsigned int len) 35 { 36 char *b = str; 37 38 if (!p) 39 return ""; 40 41 b += snprintf(b, len, 42 "jpeg_video_decode_init_params_t\n" 43 "circular_buffer_begin_addr_p 0x%x\n" 44 "circular_buffer_end_addr_p 0x%x\n", 45 p->circular_buffer_begin_addr_p, 46 p->circular_buffer_end_addr_p); 47 48 return str; 49 } 50 51 static char *ipc_decode_param_str(struct jpeg_decode_params_t *p, 52 char *str, unsigned int len) 53 { 54 char *b = str; 55 56 if (!p) 57 return ""; 58 59 b += snprintf(b, len, 60 "jpeg_decode_params_t\n" 61 "picture_start_addr_p 0x%x\n" 62 "picture_end_addr_p 0x%x\n" 63 "decoding_mode %d\n" 64 "display_buffer_addr.display_decimated_luma_p 0x%x\n" 65 "display_buffer_addr.display_decimated_chroma_p 0x%x\n" 66 "main_aux_enable %d\n" 67 "additional_flags 0x%x\n" 68 "field_flag %x\n" 69 "is_jpeg_image %x\n", 70 p->picture_start_addr_p, 71 p->picture_end_addr_p, 72 p->decoding_mode, 73 p->display_buffer_addr.display_decimated_luma_p, 74 p->display_buffer_addr.display_decimated_chroma_p, 75 p->main_aux_enable, p->additional_flags, 76 p->field_flag, 77 p->is_jpeg_image); 78 79 return str; 80 } 81 82 static inline bool is_stream_error(enum jpeg_decoding_error_t err) 83 { 84 switch (err) { 85 case JPEG_DECODER_UNDEFINED_HUFF_TABLE: 86 case JPEG_DECODER_BAD_RESTART_MARKER: 87 case JPEG_DECODER_BAD_SOS_SPECTRAL: 88 case JPEG_DECODER_BAD_SOS_SUCCESSIVE: 89 case JPEG_DECODER_BAD_HEADER_LENGTH: 90 case JPEG_DECODER_BAD_COUNT_VALUE: 91 case JPEG_DECODER_BAD_DHT_MARKER: 92 case JPEG_DECODER_BAD_INDEX_VALUE: 93 case JPEG_DECODER_BAD_NUMBER_HUFFMAN_TABLES: 94 case JPEG_DECODER_BAD_QUANT_TABLE_LENGTH: 95 case JPEG_DECODER_BAD_NUMBER_QUANT_TABLES: 96 case JPEG_DECODER_BAD_COMPONENT_COUNT: 97 return true; 98 default: 99 return false; 100 } 101 } 102 103 static inline const char *err_str(enum jpeg_decoding_error_t err) 104 { 105 switch (err) { 106 case JPEG_DECODER_NO_ERROR: 107 return "JPEG_DECODER_NO_ERROR"; 108 case JPEG_DECODER_UNDEFINED_HUFF_TABLE: 109 return "JPEG_DECODER_UNDEFINED_HUFF_TABLE"; 110 case JPEG_DECODER_UNSUPPORTED_MARKER: 111 return "JPEG_DECODER_UNSUPPORTED_MARKER"; 112 case JPEG_DECODER_UNABLE_ALLOCATE_MEMORY: 113 return "JPEG_DECODER_UNABLE_ALLOCATE_MEMORY"; 114 case JPEG_DECODER_NON_SUPPORTED_SAMP_FACTORS: 115 return "JPEG_DECODER_NON_SUPPORTED_SAMP_FACTORS"; 116 case JPEG_DECODER_BAD_PARAMETER: 117 return "JPEG_DECODER_BAD_PARAMETER"; 118 case JPEG_DECODER_DECODE_ERROR: 119 return "JPEG_DECODER_DECODE_ERROR"; 120 case JPEG_DECODER_BAD_RESTART_MARKER: 121 return "JPEG_DECODER_BAD_RESTART_MARKER"; 122 case JPEG_DECODER_UNSUPPORTED_COLORSPACE: 123 return "JPEG_DECODER_UNSUPPORTED_COLORSPACE"; 124 case JPEG_DECODER_BAD_SOS_SPECTRAL: 125 return "JPEG_DECODER_BAD_SOS_SPECTRAL"; 126 case JPEG_DECODER_BAD_SOS_SUCCESSIVE: 127 return "JPEG_DECODER_BAD_SOS_SUCCESSIVE"; 128 case JPEG_DECODER_BAD_HEADER_LENGTH: 129 return "JPEG_DECODER_BAD_HEADER_LENGTH"; 130 case JPEG_DECODER_BAD_COUNT_VALUE: 131 return "JPEG_DECODER_BAD_COUNT_VALUE"; 132 case JPEG_DECODER_BAD_DHT_MARKER: 133 return "JPEG_DECODER_BAD_DHT_MARKER"; 134 case JPEG_DECODER_BAD_INDEX_VALUE: 135 return "JPEG_DECODER_BAD_INDEX_VALUE"; 136 case JPEG_DECODER_BAD_NUMBER_HUFFMAN_TABLES: 137 return "JPEG_DECODER_BAD_NUMBER_HUFFMAN_TABLES"; 138 case JPEG_DECODER_BAD_QUANT_TABLE_LENGTH: 139 return "JPEG_DECODER_BAD_QUANT_TABLE_LENGTH"; 140 case JPEG_DECODER_BAD_NUMBER_QUANT_TABLES: 141 return "JPEG_DECODER_BAD_NUMBER_QUANT_TABLES"; 142 case JPEG_DECODER_BAD_COMPONENT_COUNT: 143 return "JPEG_DECODER_BAD_COMPONENT_COUNT"; 144 case JPEG_DECODER_DIVIDE_BY_ZERO_ERROR: 145 return "JPEG_DECODER_DIVIDE_BY_ZERO_ERROR"; 146 case JPEG_DECODER_NOT_JPG_IMAGE: 147 return "JPEG_DECODER_NOT_JPG_IMAGE"; 148 case JPEG_DECODER_UNSUPPORTED_ROTATION_ANGLE: 149 return "JPEG_DECODER_UNSUPPORTED_ROTATION_ANGLE"; 150 case JPEG_DECODER_UNSUPPORTED_SCALING: 151 return "JPEG_DECODER_UNSUPPORTED_SCALING"; 152 case JPEG_DECODER_INSUFFICIENT_OUTPUTBUFFER_SIZE: 153 return "JPEG_DECODER_INSUFFICIENT_OUTPUTBUFFER_SIZE"; 154 case JPEG_DECODER_BAD_HWCFG_GP_VERSION_VALUE: 155 return "JPEG_DECODER_BAD_HWCFG_GP_VERSION_VALUE"; 156 case JPEG_DECODER_BAD_VALUE_FROM_RED: 157 return "JPEG_DECODER_BAD_VALUE_FROM_RED"; 158 case JPEG_DECODER_BAD_SUBREGION_PARAMETERS: 159 return "JPEG_DECODER_BAD_SUBREGION_PARAMETERS"; 160 case JPEG_DECODER_PROGRESSIVE_DECODE_NOT_SUPPORTED: 161 return "JPEG_DECODER_PROGRESSIVE_DECODE_NOT_SUPPORTED"; 162 case JPEG_DECODER_ERROR_TASK_TIMEOUT: 163 return "JPEG_DECODER_ERROR_TASK_TIMEOUT"; 164 case JPEG_DECODER_ERROR_FEATURE_NOT_SUPPORTED: 165 return "JPEG_DECODER_ERROR_FEATURE_NOT_SUPPORTED"; 166 default: 167 return "!unknown MJPEG error!"; 168 } 169 } 170 171 static bool delta_mjpeg_check_status(struct delta_ctx *pctx, 172 struct jpeg_decode_return_params_t *status) 173 { 174 struct delta_dev *delta = pctx->dev; 175 bool dump = false; 176 177 if (status->error_code == JPEG_DECODER_NO_ERROR) 178 goto out; 179 180 if (is_stream_error(status->error_code)) { 181 dev_warn_ratelimited(delta->dev, 182 "%s firmware: stream error @ frame %d (%s)\n", 183 pctx->name, pctx->decoded_frames, 184 err_str(status->error_code)); 185 pctx->stream_errors++; 186 } else { 187 dev_warn_ratelimited(delta->dev, 188 "%s firmware: decode error @ frame %d (%s)\n", 189 pctx->name, pctx->decoded_frames, 190 err_str(status->error_code)); 191 pctx->decode_errors++; 192 dump = true; 193 } 194 195 out: 196 dev_dbg(delta->dev, 197 "%s firmware: decoding time(us)=%d\n", pctx->name, 198 status->decode_time_in_us); 199 200 return dump; 201 } 202 203 static int delta_mjpeg_ipc_open(struct delta_ctx *pctx) 204 { 205 struct delta_dev *delta = pctx->dev; 206 struct delta_mjpeg_ctx *ctx = to_ctx(pctx); 207 int ret = 0; 208 struct jpeg_video_decode_init_params_t params_struct; 209 struct jpeg_video_decode_init_params_t *params = ¶ms_struct; 210 struct delta_buf *ipc_buf; 211 u32 ipc_buf_size; 212 struct delta_ipc_param ipc_param; 213 void *hdl; 214 215 memset(params, 0, sizeof(*params)); 216 params->circular_buffer_begin_addr_p = 0x00000000; 217 params->circular_buffer_end_addr_p = 0xffffffff; 218 219 dev_vdbg(delta->dev, 220 "%s %s\n", pctx->name, 221 ipc_open_param_str(params, ctx->str, sizeof(ctx->str))); 222 223 ipc_param.size = sizeof(*params); 224 ipc_param.data = params; 225 ipc_buf_size = sizeof(struct jpeg_decode_params_t) + 226 sizeof(struct jpeg_decode_return_params_t); 227 ret = delta_ipc_open(pctx, "JPEG_DECODER_HW0", &ipc_param, 228 ipc_buf_size, &ipc_buf, &hdl); 229 if (ret) { 230 dev_err(delta->dev, 231 "%s dumping command %s\n", pctx->name, 232 ipc_open_param_str(params, ctx->str, sizeof(ctx->str))); 233 return ret; 234 } 235 236 ctx->ipc_buf = ipc_buf; 237 ctx->ipc_hdl = hdl; 238 239 return 0; 240 } 241 242 static int delta_mjpeg_ipc_decode(struct delta_ctx *pctx, struct delta_au *au) 243 { 244 struct delta_dev *delta = pctx->dev; 245 struct delta_mjpeg_ctx *ctx = to_ctx(pctx); 246 int ret = 0; 247 struct jpeg_decode_params_t *params = ctx->ipc_buf->vaddr; 248 struct jpeg_decode_return_params_t *status = 249 ctx->ipc_buf->vaddr + sizeof(*params); 250 struct delta_frame *frame; 251 struct delta_ipc_param ipc_param, ipc_status; 252 253 ret = delta_get_free_frame(pctx, &frame); 254 if (ret) 255 return ret; 256 257 memset(params, 0, sizeof(*params)); 258 259 params->picture_start_addr_p = (u32)(au->paddr); 260 params->picture_end_addr_p = (u32)(au->paddr + au->size - 1); 261 262 /* 263 * !WARNING! 264 * the NV12 decoded frame is only available 265 * on decimated output when enabling flag 266 * "JPEG_ADDITIONAL_FLAG_420MB"... 267 * the non decimated output gives YUV422SP 268 */ 269 params->main_aux_enable = JPEG_DISP_AUX_EN; 270 params->additional_flags = JPEG_ADDITIONAL_FLAG_420MB; 271 params->horizontal_decimation_factor = JPEG_HDEC_1; 272 params->vertical_decimation_factor = JPEG_VDEC_1; 273 params->decoding_mode = JPEG_NORMAL_DECODE; 274 275 params->display_buffer_addr.struct_size = 276 sizeof(struct jpeg_display_buffer_address_t); 277 params->display_buffer_addr.display_decimated_luma_p = 278 (u32)frame->paddr; 279 params->display_buffer_addr.display_decimated_chroma_p = 280 (u32)(frame->paddr 281 + frame->info.aligned_width * frame->info.aligned_height); 282 283 dev_vdbg(delta->dev, 284 "%s %s\n", pctx->name, 285 ipc_decode_param_str(params, ctx->str, sizeof(ctx->str))); 286 287 /* status */ 288 memset(status, 0, sizeof(*status)); 289 status->error_code = JPEG_DECODER_NO_ERROR; 290 291 ipc_param.size = sizeof(*params); 292 ipc_param.data = params; 293 ipc_status.size = sizeof(*status); 294 ipc_status.data = status; 295 ret = delta_ipc_decode(ctx->ipc_hdl, &ipc_param, &ipc_status); 296 if (ret) { 297 dev_err(delta->dev, 298 "%s dumping command %s\n", pctx->name, 299 ipc_decode_param_str(params, ctx->str, 300 sizeof(ctx->str))); 301 return ret; 302 } 303 304 pctx->decoded_frames++; 305 306 /* check firmware decoding status */ 307 if (delta_mjpeg_check_status(pctx, status)) { 308 dev_err(delta->dev, 309 "%s dumping command %s\n", pctx->name, 310 ipc_decode_param_str(params, ctx->str, 311 sizeof(ctx->str))); 312 } 313 314 frame->field = V4L2_FIELD_NONE; 315 frame->flags = V4L2_BUF_FLAG_KEYFRAME; 316 frame->state |= DELTA_FRAME_DEC; 317 318 ctx->out_frame = frame; 319 320 return 0; 321 } 322 323 static int delta_mjpeg_open(struct delta_ctx *pctx) 324 { 325 struct delta_mjpeg_ctx *ctx; 326 327 ctx = kzalloc(sizeof(*ctx), GFP_KERNEL); 328 if (!ctx) 329 return -ENOMEM; 330 pctx->priv = ctx; 331 332 return 0; 333 } 334 335 static int delta_mjpeg_close(struct delta_ctx *pctx) 336 { 337 struct delta_mjpeg_ctx *ctx = to_ctx(pctx); 338 339 if (ctx->ipc_hdl) { 340 delta_ipc_close(ctx->ipc_hdl); 341 ctx->ipc_hdl = NULL; 342 } 343 344 kfree(ctx); 345 346 return 0; 347 } 348 349 static int delta_mjpeg_get_streaminfo(struct delta_ctx *pctx, 350 struct delta_streaminfo *streaminfo) 351 { 352 struct delta_mjpeg_ctx *ctx = to_ctx(pctx); 353 354 if (!ctx->header) 355 goto nodata; 356 357 streaminfo->streamformat = V4L2_PIX_FMT_MJPEG; 358 streaminfo->width = ctx->header->frame_width; 359 streaminfo->height = ctx->header->frame_height; 360 361 /* progressive stream */ 362 streaminfo->field = V4L2_FIELD_NONE; 363 364 streaminfo->dpb = 1; 365 366 return 0; 367 368 nodata: 369 return -ENODATA; 370 } 371 372 static int delta_mjpeg_decode(struct delta_ctx *pctx, struct delta_au *pau) 373 { 374 struct delta_dev *delta = pctx->dev; 375 struct delta_mjpeg_ctx *ctx = to_ctx(pctx); 376 int ret; 377 struct delta_au au = *pau; 378 unsigned int data_offset = 0; 379 struct mjpeg_header *header = &ctx->header_struct; 380 381 if (!ctx->header) { 382 ret = delta_mjpeg_read_header(pctx, au.vaddr, au.size, 383 header, &data_offset); 384 if (ret) { 385 pctx->stream_errors++; 386 goto err; 387 } 388 if (header->frame_width * header->frame_height > 389 DELTA_MJPEG_MAX_RESO) { 390 dev_err(delta->dev, 391 "%s stream resolution too large: %dx%d > %d pixels budget\n", 392 pctx->name, 393 header->frame_width, 394 header->frame_height, DELTA_MJPEG_MAX_RESO); 395 ret = -EINVAL; 396 goto err; 397 } 398 ctx->header = header; 399 goto out; 400 } 401 402 if (!ctx->ipc_hdl) { 403 ret = delta_mjpeg_ipc_open(pctx); 404 if (ret) 405 goto err; 406 } 407 408 ret = delta_mjpeg_read_header(pctx, au.vaddr, au.size, 409 ctx->header, &data_offset); 410 if (ret) { 411 pctx->stream_errors++; 412 goto err; 413 } 414 415 au.paddr += data_offset; 416 au.vaddr += data_offset; 417 418 ret = delta_mjpeg_ipc_decode(pctx, &au); 419 if (ret) 420 goto err; 421 422 out: 423 return 0; 424 425 err: 426 return ret; 427 } 428 429 static int delta_mjpeg_get_frame(struct delta_ctx *pctx, 430 struct delta_frame **frame) 431 { 432 struct delta_mjpeg_ctx *ctx = to_ctx(pctx); 433 434 if (!ctx->out_frame) 435 return -ENODATA; 436 437 *frame = ctx->out_frame; 438 439 ctx->out_frame = NULL; 440 441 return 0; 442 } 443 444 const struct delta_dec mjpegdec = { 445 .name = "MJPEG", 446 .streamformat = V4L2_PIX_FMT_MJPEG, 447 .pixelformat = V4L2_PIX_FMT_NV12, 448 .open = delta_mjpeg_open, 449 .close = delta_mjpeg_close, 450 .get_streaminfo = delta_mjpeg_get_streaminfo, 451 .get_frameinfo = delta_get_frameinfo_default, 452 .decode = delta_mjpeg_decode, 453 .get_frame = delta_mjpeg_get_frame, 454 .recycle = delta_recycle_default, 455 }; 456