| /* |
| * drivers/amlogic/media/stream_input/amports/amstream_profile.c |
| * |
| * Copyright (C) 2016 Amlogic, Inc. All rights reserved. |
| * |
| * This program is free software; you can redistribute it and/or modify |
| * it under the terms of the GNU General Public License as published by |
| * the Free Software Foundation; either version 2 of the License, or |
| * (at your option) any later version. |
| * |
| * This program is distributed in the hope that it will be useful, but WITHOUT |
| * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or |
| * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for |
| * more details. |
| * |
| */ |
| |
| #include <linux/kernel.h> |
| #include <linux/fs.h> |
| #include <linux/device.h> |
| #include <linux/interrupt.h> |
| #include <linux/amlogic/media/utils/amstream.h> |
| #include <linux/amlogic/media/utils/vformat.h> |
| #include "../../../common/chips/decoder_cpu_ver_info.h" |
| #include "vdec.h" |
| |
| |
| |
| //static const struct codec_profile_t *vcodec_feature[SUPPORT_VDEC_NUM] = { 0 }; |
| |
| struct vcodec_feature { |
| int format; |
| int is_v4l; |
| }; |
| |
| static struct vcodec_feature feature[SUPPORT_VDEC_NUM]; |
| |
| static int vcodec_feature_idx; |
| static ulong last_time; |
| u8 buf[4096]; |
| |
| |
| static const char * const format_name[] = { |
| "ammvdec_mpeg12", |
| "ammvdec_mpeg4", |
| "ammvdec_h264", |
| "ammvdec_mjpeg", |
| "ammvdec_real", |
| "ammjpegdec", |
| "ammvdec_vc1", |
| "ammvdec_avs", |
| "ammvdec_yuv", |
| "ammvdec_h264mvc", |
| "ammvdec_h264_4k2k", |
| "ammvdec_h265", |
| "amvenc_avc", |
| "jpegenc", |
| "ammvdec_vp9", |
| "ammvdec_avs2", |
| "ammvdec_av1", |
| }; |
| |
| static int vcodec_feature_CC(u8 *buf, int size, int vformat, int is_v4l) |
| { |
| u8 *pbuf = buf; |
| |
| if (!is_v4l) { |
| switch (vformat) { |
| case VFORMAT_MPEG12: |
| case VFORMAT_H264: |
| case VFORMAT_AVS: |
| pbuf += snprintf(pbuf, size, " \"CC subtitle\" : \"true\"\n"); |
| break; |
| default: |
| break; |
| } |
| } |
| |
| return pbuf - buf; |
| } |
| |
| static int vcodec_feature_report_information(u8 *buf, int size, int vformat, int is_v4l) |
| { |
| u8 *pbuf = buf; |
| |
| if (!is_v4l) { |
| pbuf += snprintf(pbuf, size, " \"Decoder information report\" : \"true\"\n"); |
| } |
| |
| return pbuf - buf; |
| } |
| |
| static int vcodec_feature_i_only_mode(u8 *buf, int size, int vformat) |
| { |
| u8 *pbuf = buf; |
| |
| switch (vformat) { |
| case VFORMAT_MPEG12: |
| case VFORMAT_H264: |
| case VFORMAT_MPEG4: |
| case VFORMAT_HEVC: |
| case VFORMAT_AVS2: |
| pbuf += snprintf(pbuf, size, " \"I only mode\" : \"true\"\n"); |
| break; |
| default: |
| break; |
| } |
| |
| return pbuf - buf; |
| } |
| |
| static int vcodec_feature_dolbyVison(u8 *buf, int size, int vformat) |
| { |
| u8 *pbuf = buf; |
| |
| switch (vformat) { |
| case VFORMAT_H264: |
| case VFORMAT_HEVC: |
| case VFORMAT_AV1: |
| if ((get_cpu_major_id() >= AM_MESON_CPU_MAJOR_ID_GXM) && |
| (get_cpu_major_id() != AM_MESON_CPU_MAJOR_ID_T5) && |
| (get_cpu_major_id() != AM_MESON_CPU_MAJOR_ID_T5D) && |
| (get_cpu_major_id() != AM_MESON_CPU_MAJOR_ID_S4)) |
| pbuf += snprintf(pbuf, size, " \"DolbyVision\" : \"true\"\n"); |
| break; |
| default: |
| break; |
| } |
| |
| return pbuf - buf; |
| } |
| |
| static int vcodec_feature_HDR(u8 *buf, int size, int vformat) |
| { |
| u8 *pbuf = buf; |
| |
| switch (vformat) { |
| case VFORMAT_H264: |
| case VFORMAT_HEVC: |
| case VFORMAT_AV1: |
| case VFORMAT_AVS2: |
| case VFORMAT_VP9: |
| pbuf += snprintf(pbuf, size, " \"HDR\" : \"true\"\n"); |
| break; |
| default: |
| break; |
| } |
| |
| return pbuf - buf; |
| } |
| |
| |
| static int vcodec_feature_doublewrite(u8 *buf, int size, int vformat) |
| { |
| u8 *pbuf = buf; |
| int tsize = 0; |
| int s; |
| |
| switch (vformat) { |
| case VFORMAT_HEVC: |
| case VFORMAT_VP9: |
| case VFORMAT_AVS2: |
| case VFORMAT_AV1: |
| s = snprintf(pbuf, size - tsize, " \"DoubleWrite\" "); |
| tsize += s; |
| pbuf += s; |
| if ((get_cpu_major_id() != AM_MESON_CPU_MAJOR_ID_T7) && |
| (get_cpu_major_id() != AM_MESON_CPU_MAJOR_ID_T3)) { |
| s = snprintf(pbuf, size - tsize, "[ \"0\", \"1\", \"2\", \"3\", \"4\", \"0x10\", \"0x10000\", \"0x20000\"]\n"); |
| tsize += s; |
| pbuf += s; |
| } |
| else { |
| s = snprintf(pbuf, size - tsize, "[ \"0\", \"1\", \"2\", \"3\", \"4\", \"8\", \"0x10\", \"0x10000\", \"0x20000\"]\n"); |
| tsize += s; |
| pbuf += s; |
| } |
| break; |
| default: |
| break; |
| } |
| |
| return pbuf - buf; |
| } |
| |
| static int vcodec_feature_vdec_fence(u8 *buf, int size, int vformat) |
| { |
| u8 *pbuf = buf; |
| |
| switch (vformat) { |
| case VFORMAT_H264: |
| case VFORMAT_HEVC: |
| case VFORMAT_VP9: |
| if (get_cpu_major_id() >= AM_MESON_CPU_MAJOR_ID_GXM) |
| pbuf += snprintf(pbuf, size, " \"GameMode\" : \"true\"\n"); |
| break; |
| default: |
| break; |
| } |
| |
| return pbuf - buf; |
| } |
| |
| static int vcodec_feature_bitdepth(u8 *buf, int size, int vformat) |
| { |
| u8 *pbuf = buf; |
| |
| switch (vformat) { |
| case VFORMAT_HEVC: |
| case VFORMAT_VP9: |
| case VFORMAT_AVS2: |
| case VFORMAT_AV1: |
| if (get_cpu_major_id() >= AM_MESON_CPU_MAJOR_ID_GXBB) |
| pbuf += snprintf(pbuf, size, " \"BitDepth\" : \"10\"\n"); |
| else |
| pbuf += snprintf(pbuf, size, " \"BitDepth\" : \"8\"\n"); |
| break; |
| default: |
| break; |
| } |
| |
| return pbuf - buf; |
| } |
| |
| |
| static int vcodec_feature_MaxResolution(u8 *buf, int size, int vformat) |
| { |
| u8 *pbuf = buf; |
| |
| switch (vformat) { |
| case VFORMAT_HEVC: |
| case VFORMAT_VP9: |
| case VFORMAT_AVS2: |
| case VFORMAT_AV1: |
| if ((get_cpu_major_id() >= AM_MESON_CPU_MAJOR_ID_SM1) && |
| (get_cpu_major_id() != AM_MESON_CPU_MAJOR_ID_T5D)) |
| pbuf += snprintf(pbuf, size, " \"MaximumResolution\" : \"8k\"\n"); |
| else if (vdec_is_support_4k() && |
| (get_cpu_major_id() != AM_MESON_CPU_MAJOR_ID_T5D)) |
| pbuf += snprintf(pbuf, size, " \"MaximumResolution\" : \"4k60\"\n"); |
| else |
| pbuf += snprintf(pbuf, size, " \"MaximumResolution\" : \"1080p60\"\n"); |
| break; |
| case VFORMAT_H264: |
| if (vdec_is_support_4k()) |
| pbuf += snprintf(pbuf, size, " \"MaximumResolution\" : \"4k30\"\n"); |
| else |
| pbuf += snprintf(pbuf, size, " \"MaximumResolution\" : \"1080p60\"\n"); |
| break; |
| case VFORMAT_MPEG12: |
| case VFORMAT_MPEG4: |
| case VFORMAT_MJPEG: |
| case VFORMAT_VC1: |
| case VFORMAT_AVS: |
| pbuf += snprintf(pbuf, size, " \"MaximumResolution\" : \"1080p60\"\n"); |
| break; |
| default: |
| break; |
| } |
| |
| return pbuf - buf; |
| } |
| |
| static int vcodec_feature_clock(u8 *buf, int size, int vformat) |
| { |
| u8 *pbuf = buf; |
| |
| switch (vformat) { |
| case VFORMAT_HEVC: |
| case VFORMAT_VP9: |
| case VFORMAT_AVS2: |
| case VFORMAT_AV1: |
| if ((get_cpu_major_id() >= AM_MESON_CPU_MAJOR_ID_G12B) && |
| (get_cpu_major_id() != AM_MESON_CPU_MAJOR_ID_GXLX2) && |
| (get_cpu_major_id() != AM_MESON_CPU_MAJOR_ID_T5) && |
| (get_cpu_major_id() != AM_MESON_CPU_MAJOR_ID_T5D)) |
| pbuf += snprintf(pbuf, size, " \"ClockFrequency\" : \"800MHZ\"\n"); |
| else |
| pbuf += snprintf(pbuf, size, " \"ClockFrequency\" : \"667MHZ\"\n"); |
| break; |
| case VFORMAT_H264: |
| case VFORMAT_MPEG12: |
| case VFORMAT_MPEG4: |
| case VFORMAT_MJPEG: |
| case VFORMAT_VC1: |
| case VFORMAT_AVS: |
| if ((get_cpu_major_id() >= AM_MESON_CPU_MAJOR_ID_SM1) && |
| (get_cpu_major_id() != AM_MESON_CPU_MAJOR_ID_TL1) && |
| (get_cpu_major_id() != AM_MESON_CPU_MAJOR_ID_GXLX2) && |
| (get_cpu_major_id() != AM_MESON_CPU_MAJOR_ID_T5) && |
| (get_cpu_major_id() != AM_MESON_CPU_MAJOR_ID_T5D)) |
| pbuf += snprintf(pbuf, size, " \"ClockFrequency\" : \"800MHZ\"\n"); |
| else |
| pbuf += snprintf(pbuf, size, " \"ClockFrequency\" : \"667MHZ\"\n"); |
| break; |
| default: |
| break; |
| } |
| |
| return pbuf - buf; |
| } |
| |
| static int vcodec_feature_support_format(int vformat) |
| { |
| |
| switch (vformat) { |
| case VFORMAT_VP9: |
| if ((get_cpu_major_id() >= AM_MESON_CPU_MAJOR_ID_GXL) && |
| (get_cpu_major_id() != AM_MESON_CPU_MAJOR_ID_T5)) |
| return 1; |
| else |
| return 0; |
| case VFORMAT_AVS2: |
| if ((get_cpu_major_id() >= AM_MESON_CPU_MAJOR_ID_G12A) && |
| (get_cpu_major_id() != AM_MESON_CPU_MAJOR_ID_T5D)) |
| return 1; |
| else |
| return 0; |
| case VFORMAT_AV1: |
| if (((get_cpu_major_id() == AM_MESON_CPU_MAJOR_ID_TM2) && |
| is_cpu_tm2_revb()) || |
| ((get_cpu_major_id() > AM_MESON_CPU_MAJOR_ID_TM2) && |
| (get_cpu_major_id() != AM_MESON_CPU_MAJOR_ID_T5))) |
| return 1; |
| else |
| return 0; |
| case VFORMAT_AVS: |
| if ((get_cpu_major_id() >= AM_MESON_CPU_MAJOR_ID_GXM)) |
| return 1; |
| else |
| return 0; |
| case VFORMAT_MJPEG: |
| case VFORMAT_VC1: |
| case VFORMAT_MPEG4: |
| case VFORMAT_MPEG12: |
| case VFORMAT_H264: |
| case VFORMAT_HEVC: |
| return 1; |
| default: |
| break; |
| } |
| |
| return 0; |
| } |
| |
| static int vcodec_feature_FCC(u8 *buf, int size, int vformat, int is_v4l) |
| { |
| u8 *pbuf = buf; |
| |
| if (!is_v4l) { |
| switch (vformat) { |
| case VFORMAT_HEVC: |
| case VFORMAT_H264: |
| case VFORMAT_MPEG12: |
| pbuf += snprintf(pbuf, size, " \"Decoder FCC support\" : \"true\"\n"); |
| break; |
| default: |
| break; |
| } |
| } |
| |
| return pbuf - buf; |
| } |
| |
| static int vcodec_feature_RDMA(u8 *buf, int size, int vformat) |
| { |
| u8 *pbuf = buf; |
| |
| if (get_cpu_major_id() == AM_MESON_CPU_MAJOR_ID_T3) |
| pbuf += snprintf(pbuf, size, " \"Decoder RDMA support\" : \"true\"\n"); |
| |
| return pbuf - buf; |
| } |
| |
| static int vcodec_feature_v4ldec_nr(u8 *buf, int size, int vformat, int is_v4l) |
| { |
| u8 *pbuf = buf; |
| |
| if (is_v4l) { |
| pbuf += snprintf(pbuf, size, " \"V4ldec nr\" : \"true\"\n"); |
| } |
| |
| return pbuf - buf; |
| } |
| |
| static int vcodec_feature_ge2d_wrapper(u8 *buf, int size, int vformat, int is_v4l) |
| { |
| u8 *pbuf = buf; |
| |
| if (is_v4l && (get_cpu_major_id() == AM_MESON_CPU_MAJOR_ID_T7)) { |
| pbuf += snprintf(pbuf, size, " \"Ge2d wrapper\" : \"true\"\n"); |
| } |
| |
| return pbuf - buf; |
| } |
| |
| |
| |
| int vcodec_feature_get_feature(u8 *buf, int vformat, int is_v4l) |
| { |
| u8 *pbuf = buf; |
| int size = PAGE_SIZE; |
| int tsize = 0; |
| int s; |
| |
| s = snprintf(pbuf, size - tsize, " \"%s%s\": ", format_name[vformat], is_v4l ? "_v4l" : ""); |
| tsize += s; |
| pbuf += s; |
| |
| s = snprintf(pbuf, size - tsize, "{\n"); |
| tsize += s; |
| pbuf += s; |
| |
| s = vcodec_feature_CC(pbuf, size - tsize, vformat, is_v4l); |
| tsize += s; |
| pbuf += s; |
| |
| s = vcodec_feature_report_information(pbuf, size - tsize, vformat, is_v4l); |
| tsize += s; |
| pbuf += s; |
| |
| s = vcodec_feature_vdec_fence(pbuf, size - tsize, vformat); |
| tsize += s; |
| pbuf += s; |
| |
| s = vcodec_feature_i_only_mode(pbuf, size - tsize, vformat); |
| tsize += s; |
| pbuf += s; |
| |
| s = vcodec_feature_dolbyVison(pbuf, size - tsize, vformat); |
| tsize += s; |
| pbuf += s; |
| |
| s = vcodec_feature_HDR(pbuf, size - tsize, vformat); |
| tsize += s; |
| pbuf += s; |
| |
| s = vcodec_feature_doublewrite(pbuf, size - tsize, vformat); |
| tsize += s; |
| pbuf += s; |
| |
| s = vcodec_feature_bitdepth(pbuf, size - tsize, vformat); |
| tsize += s; |
| pbuf += s; |
| |
| s = vcodec_feature_MaxResolution(pbuf, size - tsize, vformat); |
| tsize += s; |
| pbuf += s; |
| |
| s = vcodec_feature_clock(pbuf, size - tsize, vformat); |
| tsize += s; |
| pbuf += s; |
| |
| s = vcodec_feature_FCC(pbuf, size - tsize, vformat, is_v4l); |
| tsize += s; |
| pbuf += s; |
| |
| s = vcodec_feature_RDMA(pbuf, size - tsize, vformat); |
| tsize += s; |
| pbuf += s; |
| |
| s = vcodec_feature_v4ldec_nr(pbuf, size - tsize, vformat, is_v4l); |
| tsize += s; |
| pbuf += s; |
| |
| s = vcodec_feature_ge2d_wrapper(pbuf, size - tsize, vformat, is_v4l); |
| tsize += s; |
| pbuf += s; |
| |
| s = snprintf(pbuf, size - tsize, " \"UcodeVersionRequest\" : \"0.3.10\"\n"); |
| tsize += s; |
| pbuf += s; |
| |
| s = snprintf(pbuf, size - tsize, " }\n"); |
| tsize += s; |
| pbuf += s; |
| |
| return pbuf - buf; |
| } |
| |
| |
| ssize_t vcodec_feature_read(char *buf) |
| { |
| static int read_count; |
| char *pbuf = buf; |
| |
| if (jiffies - last_time > 5 * HZ) { |
| read_count = 0; |
| /*timeout :not continue dump,dump from first. */ |
| } |
| |
| if (vcodec_feature_idx > 0) { |
| if (read_count == 0) |
| pbuf += snprintf(pbuf, PAGE_SIZE - (pbuf - buf), "{\n"); |
| pbuf += vcodec_feature_get_feature(pbuf, feature[read_count].format, feature[read_count].is_v4l); |
| read_count++; |
| if (read_count >= vcodec_feature_idx) { |
| read_count = 0; |
| pbuf += snprintf(pbuf, PAGE_SIZE - (pbuf - buf), "}"); |
| } |
| } |
| last_time = jiffies; |
| return pbuf - buf; |
| } |
| EXPORT_SYMBOL(vcodec_feature_read); |
| |
| |
| int vcodec_feature_register(int vformat, int is_v4l) |
| { |
| if ((vcodec_feature_idx < SUPPORT_VDEC_NUM) && vcodec_feature_support_format(vformat)) { |
| feature[vcodec_feature_idx].format = vformat; |
| feature[vcodec_feature_idx].is_v4l = is_v4l; |
| vcodec_feature_idx++; |
| //pr_debug("regist %s codec profile\n", vdec_profile->name); |
| } |
| |
| return 0; |
| } |
| EXPORT_SYMBOL(vcodec_feature_register); |
| |
| |
| |
