drivers/media/platform/sti/delta/delta-mjpeg-dec.c

   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 = &params_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 };