drivers/media/platform/allegro-dvt/allegro-mail.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  * Copyright (C) 2019 Pengutronix, Michael Tretter <kernel@pengutronix.de>
   4  *
   5  * Helper functions for handling messages that are send via mailbox to the
   6  * Allegro VCU firmware.
   7  */
   8
   9 #include <linux/bitfield.h>
  10 #include <linux/export.h>
  11 #include <linux/errno.h>
  12 #include <linux/string.h>
  13 #include <linux/videodev2.h>
  14
  15 #include "allegro-mail.h"
  16
  17 const char *msg_type_name(enum mcu_msg_type type)
  18 {
  19         static char buf[13];
  20
  21         switch (type) {
  22         case MCU_MSG_TYPE_INIT:
  23                 return "INIT";
  24         case MCU_MSG_TYPE_CREATE_CHANNEL:
  25                 return "CREATE_CHANNEL";
  26         case MCU_MSG_TYPE_DESTROY_CHANNEL:
  27                 return "DESTROY_CHANNEL";
  28         case MCU_MSG_TYPE_ENCODE_FRAME:
  29                 return "ENCODE_FRAME";
  30         case MCU_MSG_TYPE_PUT_STREAM_BUFFER:
  31                 return "PUT_STREAM_BUFFER";
  32         case MCU_MSG_TYPE_PUSH_BUFFER_INTERMEDIATE:
  33                 return "PUSH_BUFFER_INTERMEDIATE";
  34         case MCU_MSG_TYPE_PUSH_BUFFER_REFERENCE:
  35                 return "PUSH_BUFFER_REFERENCE";
  36         default:
  37                 snprintf(buf, sizeof(buf), "(0x%04x)", type);
  38                 return buf;
  39         }
  40 }
  41 EXPORT_SYMBOL(msg_type_name);
  42
  43 static ssize_t
  44 allegro_enc_init(u32 *dst, struct mcu_msg_init_request *msg)
  45 {
  46         unsigned int i = 0;
  47         enum mcu_msg_version version = msg->header.version;
  48
  49         dst[i++] = msg->reserved0;
  50         dst[i++] = msg->suballoc_dma;
  51         dst[i++] = msg->suballoc_size;
  52         dst[i++] = msg->encoder_buffer_size;
  53         dst[i++] = msg->encoder_buffer_color_depth;
  54         dst[i++] = msg->num_cores;
  55         if (version >= MCU_MSG_VERSION_2019_2) {
  56                 dst[i++] = msg->clk_rate;
  57                 dst[i++] = 0;
  58         }
  59
  60         return i * sizeof(*dst);
  61 }
  62
  63 static inline u32 settings_get_mcu_codec(struct create_channel_param *param)
  64 {
  65         enum mcu_msg_version version = param->version;
  66         u32 pixelformat = param->codec;
  67
  68         if (version < MCU_MSG_VERSION_2019_2) {
  69                 switch (pixelformat) {
  70                 case V4L2_PIX_FMT_HEVC:
  71                         return 2;
  72                 case V4L2_PIX_FMT_H264:
  73                 default:
  74                         return 1;
  75                 }
  76         } else {
  77                 switch (pixelformat) {
  78                 case V4L2_PIX_FMT_HEVC:
  79                         return 1;
  80                 case V4L2_PIX_FMT_H264:
  81                 default:
  82                         return 0;
  83                 }
  84         }
  85 }
  86
  87 ssize_t
  88 allegro_encode_config_blob(u32 *dst, struct create_channel_param *param)
  89 {
  90         enum mcu_msg_version version = param->version;
  91         unsigned int i = 0;
  92         unsigned int j = 0;
  93         u32 val;
  94         unsigned int codec = settings_get_mcu_codec(param);
  95
  96         if (version >= MCU_MSG_VERSION_2019_2)
  97                 dst[i++] = param->layer_id;
  98         dst[i++] = FIELD_PREP(GENMASK(31, 16), param->height) |
  99                    FIELD_PREP(GENMASK(15, 0), param->width);
 100         if (version >= MCU_MSG_VERSION_2019_2)
 101                 dst[i++] = param->videomode;
 102         dst[i++] = param->format;
 103         if (version < MCU_MSG_VERSION_2019_2)
 104                 dst[i++] = param->colorspace;
 105         dst[i++] = param->src_mode;
 106         if (version >= MCU_MSG_VERSION_2019_2)
 107                 dst[i++] = param->src_bit_depth;
 108         dst[i++] = FIELD_PREP(GENMASK(31, 24), codec) |
 109                    FIELD_PREP(GENMASK(23, 8), param->constraint_set_flags) |
 110                    FIELD_PREP(GENMASK(7, 0), param->profile);
 111         dst[i++] = FIELD_PREP(GENMASK(31, 16), param->tier) |
 112                    FIELD_PREP(GENMASK(15, 0), param->level);
 113
 114         val = 0;
 115         val |= param->temporal_mvp_enable ? BIT(20) : 0;
 116         val |= FIELD_PREP(GENMASK(7, 4), param->log2_max_frame_num);
 117         if (version >= MCU_MSG_VERSION_2019_2)
 118                 val |= FIELD_PREP(GENMASK(3, 0), param->log2_max_poc - 1);
 119         else
 120                 val |= FIELD_PREP(GENMASK(3, 0), param->log2_max_poc);
 121         dst[i++] = val;
 122
 123         val = 0;
 124         val |= param->enable_reordering ? BIT(0) : 0;
 125         val |= param->dbf_ovr_en ? BIT(2) : 0;
 126         val |= param->override_lf ? BIT(12) : 0;
 127         dst[i++] = val;
 128
 129         if (version >= MCU_MSG_VERSION_2019_2) {
 130                 val = 0;
 131                 val |= param->custom_lda ? BIT(2) : 0;
 132                 val |= param->rdo_cost_mode ? BIT(20) : 0;
 133                 dst[i++] = val;
 134
 135                 val = 0;
 136                 val |= param->lf ? BIT(2) : 0;
 137                 val |= param->lf_x_tile ? BIT(3) : 0;
 138                 val |= param->lf_x_slice ? BIT(4) : 0;
 139                 dst[i++] = val;
 140         } else {
 141                 val = 0;
 142                 dst[i++] = val;
 143         }
 144
 145         dst[i++] = FIELD_PREP(GENMASK(15, 8), param->beta_offset) |
 146                    FIELD_PREP(GENMASK(7, 0), param->tc_offset);
 147         dst[i++] = param->unknown11;
 148         dst[i++] = param->unknown12;
 149         dst[i++] = param->num_slices;
 150         dst[i++] = param->encoder_buffer_offset;
 151         dst[i++] = param->encoder_buffer_enabled;
 152
 153         dst[i++] = FIELD_PREP(GENMASK(31, 16), param->clip_vrt_range) |
 154                    FIELD_PREP(GENMASK(15, 0), param->clip_hrz_range);
 155         dst[i++] = FIELD_PREP(GENMASK(31, 16), param->me_range[1]) |
 156                    FIELD_PREP(GENMASK(15, 0), param->me_range[0]);
 157         dst[i++] = FIELD_PREP(GENMASK(31, 16), param->me_range[3]) |
 158                    FIELD_PREP(GENMASK(15, 0), param->me_range[2]);
 159         dst[i++] = FIELD_PREP(GENMASK(31, 24), param->min_tu_size) |
 160                    FIELD_PREP(GENMASK(23, 16), param->max_tu_size) |
 161                    FIELD_PREP(GENMASK(15, 8), param->min_cu_size) |
 162                    FIELD_PREP(GENMASK(8, 0), param->max_cu_size);
 163         dst[i++] = FIELD_PREP(GENMASK(15, 8), param->max_transfo_depth_intra) |
 164                    FIELD_PREP(GENMASK(7, 0), param->max_transfo_depth_inter);
 165         dst[i++] = param->entropy_mode;
 166         dst[i++] = param->wp_mode;
 167
 168         dst[i++] = param->rate_control_mode;
 169         dst[i++] = param->initial_rem_delay;
 170         dst[i++] = param->cpb_size;
 171         dst[i++] = FIELD_PREP(GENMASK(31, 16), param->clk_ratio) |
 172                    FIELD_PREP(GENMASK(15, 0), param->framerate);
 173         dst[i++] = param->target_bitrate;
 174         dst[i++] = param->max_bitrate;
 175         dst[i++] = FIELD_PREP(GENMASK(31, 16), param->min_qp) |
 176                    FIELD_PREP(GENMASK(15, 0), param->initial_qp);
 177         dst[i++] = FIELD_PREP(GENMASK(31, 16), param->ip_delta) |
 178                    FIELD_PREP(GENMASK(15, 0), param->max_qp);
 179         dst[i++] = FIELD_PREP(GENMASK(31, 16), param->golden_ref) |
 180                    FIELD_PREP(GENMASK(15, 0), param->pb_delta);
 181         dst[i++] = FIELD_PREP(GENMASK(31, 16), param->golden_ref_frequency) |
 182                    FIELD_PREP(GENMASK(15, 0), param->golden_delta);
 183         if (version >= MCU_MSG_VERSION_2019_2)
 184                 dst[i++] = param->rate_control_option;
 185         else
 186                 dst[i++] = 0;
 187
 188         if (version >= MCU_MSG_VERSION_2019_2) {
 189                 dst[i++] = param->num_pixel;
 190                 dst[i++] = FIELD_PREP(GENMASK(31, 16), param->max_pixel_value) |
 191                         FIELD_PREP(GENMASK(15, 0), param->max_psnr);
 192                 for (j = 0; j < 3; j++)
 193                         dst[i++] = param->maxpicturesize[j];
 194         }
 195
 196         if (version >= MCU_MSG_VERSION_2019_2)
 197                 dst[i++] = param->gop_ctrl_mode;
 198         else
 199                 dst[i++] = 0;
 200
 201         if (version >= MCU_MSG_VERSION_2019_2)
 202                 dst[i++] = FIELD_PREP(GENMASK(31, 24), param->freq_golden_ref) |
 203                            FIELD_PREP(GENMASK(23, 16), param->num_b) |
 204                            FIELD_PREP(GENMASK(15, 0), param->gop_length);
 205         dst[i++] = param->freq_idr;
 206         if (version >= MCU_MSG_VERSION_2019_2)
 207                 dst[i++] = param->enable_lt;
 208         dst[i++] = param->freq_lt;
 209         dst[i++] = param->gdr_mode;
 210         if (version < MCU_MSG_VERSION_2019_2)
 211                 dst[i++] = FIELD_PREP(GENMASK(31, 24), param->freq_golden_ref) |
 212                            FIELD_PREP(GENMASK(23, 16), param->num_b) |
 213                            FIELD_PREP(GENMASK(15, 0), param->gop_length);
 214
 215         if (version >= MCU_MSG_VERSION_2019_2)
 216                 dst[i++] = param->tmpdqp;
 217
 218         dst[i++] = param->subframe_latency;
 219         dst[i++] = param->lda_control_mode;
 220         if (version < MCU_MSG_VERSION_2019_2)
 221                 dst[i++] = param->unknown41;
 222
 223         if (version >= MCU_MSG_VERSION_2019_2) {
 224                 for (j = 0; j < 6; j++)
 225                         dst[i++] = param->lda_factors[j];
 226                 dst[i++] = param->max_num_merge_cand;
 227         }
 228
 229         return i * sizeof(*dst);
 230 }
 231
 232 static ssize_t
 233 allegro_enc_create_channel(u32 *dst, struct mcu_msg_create_channel *msg)
 234 {
 235         enum mcu_msg_version version = msg->header.version;
 236         unsigned int i = 0;
 237
 238         dst[i++] = msg->user_id;
 239
 240         if (version >= MCU_MSG_VERSION_2019_2) {
 241                 dst[i++] = msg->blob_mcu_addr;
 242         } else {
 243                 memcpy(&dst[i], msg->blob, msg->blob_size);
 244                 i += msg->blob_size / sizeof(*dst);
 245         }
 246
 247         if (version >= MCU_MSG_VERSION_2019_2)
 248                 dst[i++] = msg->ep1_addr;
 249
 250         return i * sizeof(*dst);
 251 }
 252
 253 ssize_t allegro_decode_config_blob(struct create_channel_param *param,
 254                                    struct mcu_msg_create_channel_response *msg,
 255                                    u32 *src)
 256 {
 257         enum mcu_msg_version version = msg->header.version;
 258
 259         if (version >= MCU_MSG_VERSION_2019_2) {
 260                 param->num_ref_idx_l0 = FIELD_GET(GENMASK(7, 4), src[9]);
 261                 param->num_ref_idx_l1 = FIELD_GET(GENMASK(11, 8), src[9]);
 262         } else {
 263                 param->num_ref_idx_l0 = msg->num_ref_idx_l0;
 264                 param->num_ref_idx_l1 = msg->num_ref_idx_l1;
 265         }
 266
 267         return 0;
 268 }
 269
 270 static ssize_t
 271 allegro_enc_destroy_channel(u32 *dst, struct mcu_msg_destroy_channel *msg)
 272 {
 273         unsigned int i = 0;
 274
 275         dst[i++] = msg->channel_id;
 276
 277         return i * sizeof(*dst);
 278 }
 279
 280 static ssize_t
 281 allegro_enc_push_buffers(u32 *dst, struct mcu_msg_push_buffers_internal *msg)
 282 {
 283         unsigned int i = 0;
 284         struct mcu_msg_push_buffers_internal_buffer *buffer;
 285         unsigned int num_buffers = msg->num_buffers;
 286         unsigned int j;
 287
 288         dst[i++] = msg->channel_id;
 289
 290         for (j = 0; j < num_buffers; j++) {
 291                 buffer = &msg->buffer[j];
 292                 dst[i++] = buffer->dma_addr;
 293                 dst[i++] = buffer->mcu_addr;
 294                 dst[i++] = buffer->size;
 295         }
 296
 297         return i * sizeof(*dst);
 298 }
 299
 300 static ssize_t
 301 allegro_enc_put_stream_buffer(u32 *dst,
 302                               struct mcu_msg_put_stream_buffer *msg)
 303 {
 304         unsigned int i = 0;
 305
 306         dst[i++] = msg->channel_id;
 307         dst[i++] = msg->dma_addr;
 308         dst[i++] = msg->mcu_addr;
 309         dst[i++] = msg->size;
 310         dst[i++] = msg->offset;
 311         dst[i++] = lower_32_bits(msg->dst_handle);
 312         dst[i++] = upper_32_bits(msg->dst_handle);
 313
 314         return i * sizeof(*dst);
 315 }
 316
 317 static ssize_t
 318 allegro_enc_encode_frame(u32 *dst, struct mcu_msg_encode_frame *msg)
 319 {
 320         enum mcu_msg_version version = msg->header.version;
 321         unsigned int i = 0;
 322
 323         dst[i++] = msg->channel_id;
 324
 325         dst[i++] = msg->reserved;
 326         dst[i++] = msg->encoding_options;
 327         dst[i++] = FIELD_PREP(GENMASK(31, 16), msg->padding) |
 328                    FIELD_PREP(GENMASK(15, 0), msg->pps_qp);
 329
 330         if (version >= MCU_MSG_VERSION_2019_2) {
 331                 dst[i++] = 0;
 332                 dst[i++] = 0;
 333                 dst[i++] = 0;
 334                 dst[i++] = 0;
 335         }
 336
 337         dst[i++] = lower_32_bits(msg->user_param);
 338         dst[i++] = upper_32_bits(msg->user_param);
 339         dst[i++] = lower_32_bits(msg->src_handle);
 340         dst[i++] = upper_32_bits(msg->src_handle);
 341         dst[i++] = msg->request_options;
 342         dst[i++] = msg->src_y;
 343         dst[i++] = msg->src_uv;
 344         if (version >= MCU_MSG_VERSION_2019_2)
 345                 dst[i++] = msg->is_10_bit;
 346         dst[i++] = msg->stride;
 347         if (version >= MCU_MSG_VERSION_2019_2)
 348                 dst[i++] = msg->format;
 349         dst[i++] = msg->ep2;
 350         dst[i++] = lower_32_bits(msg->ep2_v);
 351         dst[i++] = upper_32_bits(msg->ep2_v);
 352
 353         return i * sizeof(*dst);
 354 }
 355
 356 static ssize_t
 357 allegro_dec_init(struct mcu_msg_init_response *msg, u32 *src)
 358 {
 359         unsigned int i = 0;
 360
 361         msg->reserved0 = src[i++];
 362
 363         return i * sizeof(*src);
 364 }
 365
 366 static ssize_t
 367 allegro_dec_create_channel(struct mcu_msg_create_channel_response *msg,
 368                            u32 *src)
 369 {
 370         enum mcu_msg_version version = msg->header.version;
 371         unsigned int i = 0;
 372
 373         msg->channel_id = src[i++];
 374         msg->user_id = src[i++];
 375         /*
 376          * Version >= MCU_MSG_VERSION_2019_2 is handled in
 377          * allegro_decode_config_blob().
 378          */
 379         if (version < MCU_MSG_VERSION_2019_2) {
 380                 msg->options = src[i++];
 381                 msg->num_core = src[i++];
 382                 msg->num_ref_idx_l0 = FIELD_GET(GENMASK(7, 4), src[i]);
 383                 msg->num_ref_idx_l1 = FIELD_GET(GENMASK(11, 8), src[i++]);
 384         }
 385         msg->int_buffers_count = src[i++];
 386         msg->int_buffers_size = src[i++];
 387         msg->rec_buffers_count = src[i++];
 388         msg->rec_buffers_size = src[i++];
 389         msg->reserved = src[i++];
 390         msg->error_code = src[i++];
 391
 392         return i * sizeof(*src);
 393 }
 394
 395 static ssize_t
 396 allegro_dec_destroy_channel(struct mcu_msg_destroy_channel_response *msg,
 397                             u32 *src)
 398 {
 399         unsigned int i = 0;
 400
 401         msg->channel_id = src[i++];
 402
 403         return i * sizeof(*src);
 404 }
 405
 406 static ssize_t
 407 allegro_dec_encode_frame(struct mcu_msg_encode_frame_response *msg, u32 *src)
 408 {
 409         enum mcu_msg_version version = msg->header.version;
 410         unsigned int i = 0;
 411         unsigned int j;
 412
 413         msg->channel_id = src[i++];
 414
 415         msg->dst_handle = src[i++];
 416         msg->dst_handle |= (((u64)src[i++]) << 32);
 417         msg->user_param = src[i++];
 418         msg->user_param |= (((u64)src[i++]) << 32);
 419         msg->src_handle = src[i++];
 420         msg->src_handle |= (((u64)src[i++]) << 32);
 421         msg->skip = FIELD_GET(GENMASK(31, 16), src[i]);
 422         msg->is_ref = FIELD_GET(GENMASK(15, 0), src[i++]);
 423         msg->initial_removal_delay = src[i++];
 424         msg->dpb_output_delay = src[i++];
 425         msg->size = src[i++];
 426         msg->frame_tag_size = src[i++];
 427         msg->stuffing = src[i++];
 428         msg->filler = src[i++];
 429         msg->num_row = FIELD_GET(GENMASK(31, 16), src[i]);
 430         msg->num_column = FIELD_GET(GENMASK(15, 0), src[i++]);
 431         msg->num_ref_idx_l1 = FIELD_GET(GENMASK(31, 24), src[i]);
 432         msg->num_ref_idx_l0 = FIELD_GET(GENMASK(23, 16), src[i]);
 433         msg->qp = FIELD_GET(GENMASK(15, 0), src[i++]);
 434         msg->partition_table_offset = src[i++];
 435         msg->partition_table_size = src[i++];
 436         msg->sum_complex = src[i++];
 437         for (j = 0; j < 4; j++)
 438                 msg->tile_width[j] = src[i++];
 439         for (j = 0; j < 22; j++)
 440                 msg->tile_height[j] = src[i++];
 441         msg->error_code = src[i++];
 442         msg->slice_type = src[i++];
 443         msg->pic_struct = src[i++];
 444         msg->reserved = FIELD_GET(GENMASK(31, 24), src[i]);
 445         msg->is_last_slice = FIELD_GET(GENMASK(23, 16), src[i]);
 446         msg->is_first_slice = FIELD_GET(GENMASK(15, 8), src[i]);
 447         msg->is_idr = FIELD_GET(GENMASK(7, 0), src[i++]);
 448
 449         msg->reserved1 = FIELD_GET(GENMASK(31, 16), src[i]);
 450         msg->pps_qp = FIELD_GET(GENMASK(15, 0), src[i++]);
 451
 452         msg->reserved2 = src[i++];
 453         if (version >= MCU_MSG_VERSION_2019_2) {
 454                 msg->reserved3 = src[i++];
 455                 msg->reserved4 = src[i++];
 456                 msg->reserved5 = src[i++];
 457                 msg->reserved6 = src[i++];
 458         }
 459
 460         return i * sizeof(*src);
 461 }
 462
 463 /**
 464  * allegro_encode_mail() - Encode allegro messages to firmware format
 465  * @dst: Pointer to the memory that will be filled with data
 466  * @msg: The allegro message that will be encoded
 467  */
 468 ssize_t allegro_encode_mail(u32 *dst, void *msg)
 469 {
 470         const struct mcu_msg_header *header = msg;
 471         ssize_t size;
 472
 473         if (!msg || !dst)
 474                 return -EINVAL;
 475
 476         switch (header->type) {
 477         case MCU_MSG_TYPE_INIT:
 478                 size = allegro_enc_init(&dst[1], msg);
 479                 break;
 480         case MCU_MSG_TYPE_CREATE_CHANNEL:
 481                 size = allegro_enc_create_channel(&dst[1], msg);
 482                 break;
 483         case MCU_MSG_TYPE_DESTROY_CHANNEL:
 484                 size = allegro_enc_destroy_channel(&dst[1], msg);
 485                 break;
 486         case MCU_MSG_TYPE_ENCODE_FRAME:
 487                 size = allegro_enc_encode_frame(&dst[1], msg);
 488                 break;
 489         case MCU_MSG_TYPE_PUT_STREAM_BUFFER:
 490                 size = allegro_enc_put_stream_buffer(&dst[1], msg);
 491                 break;
 492         case MCU_MSG_TYPE_PUSH_BUFFER_INTERMEDIATE:
 493         case MCU_MSG_TYPE_PUSH_BUFFER_REFERENCE:
 494                 size = allegro_enc_push_buffers(&dst[1], msg);
 495                 break;
 496         default:
 497                 return -EINVAL;
 498         }
 499
 500         /*
 501          * The encoded messages might have different length depending on
 502          * the firmware version or certain fields. Therefore, we have to
 503          * set the body length after encoding the message.
 504          */
 505         dst[0] = FIELD_PREP(GENMASK(31, 16), header->type) |
 506                  FIELD_PREP(GENMASK(15, 0), size);
 507
 508         return size + sizeof(*dst);
 509 }
 510
 511 /**
 512  * allegro_decode_mail() - Parse allegro messages from the firmware.
 513  * @msg: The mcu_msg_response that will be filled with parsed values.
 514  * @src: Pointer to the memory that will be parsed
 515  *
 516  * The message format in the mailbox depends on the firmware. Parse the
 517  * different formats into a uniform message format that can be used without
 518  * taking care of the firmware version.
 519  */
 520 int allegro_decode_mail(void *msg, u32 *src)
 521 {
 522         struct mcu_msg_header *header;
 523
 524         if (!src || !msg)
 525                 return -EINVAL;
 526
 527         header = msg;
 528         header->type = FIELD_GET(GENMASK(31, 16), src[0]);
 529
 530         src++;
 531         switch (header->type) {
 532         case MCU_MSG_TYPE_INIT:
 533                 allegro_dec_init(msg, src);
 534                 break;
 535         case MCU_MSG_TYPE_CREATE_CHANNEL:
 536                 allegro_dec_create_channel(msg, src);
 537                 break;
 538         case MCU_MSG_TYPE_DESTROY_CHANNEL:
 539                 allegro_dec_destroy_channel(msg, src);
 540                 break;
 541         case MCU_MSG_TYPE_ENCODE_FRAME:
 542                 allegro_dec_encode_frame(msg, src);
 543                 break;
 544         default:
 545                 return -EINVAL;
 546         }
 547
 548         return 0;
 549 }