drivers/media/platform/sti/hva/hva.h

   1 /* SPDX-License-Identifier: GPL-2.0 */
   2 /*
   3  * Copyright (C) STMicroelectronics SA 2015
   4  * Authors: Yannick Fertre <yannick.fertre@st.com>
   5  *          Hugues Fruchet <hugues.fruchet@st.com>
   6  */
   7
   8 #ifndef HVA_H
   9 #define HVA_H
  10
  11 #include <media/v4l2-ctrls.h>
  12 #include <media/v4l2-device.h>
  13 #include <media/videobuf2-v4l2.h>
  14 #include <media/v4l2-mem2mem.h>
  15
  16 #define fh_to_ctx(f)    (container_of(f, struct hva_ctx, fh))
  17
  18 #define hva_to_dev(h)   (h->dev)
  19
  20 #define ctx_to_dev(c)   (c->hva_dev->dev)
  21
  22 #define ctx_to_hdev(c)  (c->hva_dev)
  23
  24 #define HVA_NAME        "st-hva"
  25 #define HVA_PREFIX      "[---:----]"
  26
  27 extern const struct hva_enc nv12h264enc;
  28 extern const struct hva_enc nv21h264enc;
  29
  30 /**
  31  * struct hva_frameinfo - information about hva frame
  32  *
  33  * @pixelformat:    fourcc code for uncompressed video format
  34  * @width:          width of frame
  35  * @height:         height of frame
  36  * @aligned_width:  width of frame (with encoder alignment constraint)
  37  * @aligned_height: height of frame (with encoder alignment constraint)
  38  * @size:           maximum size in bytes required for data
  39 */
  40 struct hva_frameinfo {
  41         u32     pixelformat;
  42         u32     width;
  43         u32     height;
  44         u32     aligned_width;
  45         u32     aligned_height;
  46         u32     size;
  47 };
  48
  49 /**
  50  * struct hva_streaminfo - information about hva stream
  51  *
  52  * @streamformat: fourcc code of compressed video format (H.264...)
  53  * @width:        width of stream
  54  * @height:       height of stream
  55  * @profile:      profile string
  56  * @level:        level string
  57  */
  58 struct hva_streaminfo {
  59         u32     streamformat;
  60         u32     width;
  61         u32     height;
  62         u8      profile[32];
  63         u8      level[32];
  64 };
  65
  66 /**
  67  * struct hva_controls - hva controls set
  68  *
  69  * @time_per_frame: time per frame in seconds
  70  * @bitrate_mode:   bitrate mode (constant bitrate or variable bitrate)
  71  * @gop_size:       groupe of picture size
  72  * @bitrate:        bitrate (in bps)
  73  * @aspect:         video aspect
  74  * @profile:        H.264 profile
  75  * @level:          H.264 level
  76  * @entropy_mode:   H.264 entropy mode (CABAC or CVLC)
  77  * @cpb_size:       coded picture buffer size (in kB)
  78  * @dct8x8:         transform mode 8x8 enable
  79  * @qpmin:          minimum quantizer
  80  * @qpmax:          maximum quantizer
  81  * @vui_sar:        pixel aspect ratio enable
  82  * @vui_sar_idc:    pixel aspect ratio identifier
  83  * @sei_fp:         sei frame packing arrangement enable
  84  * @sei_fp_type:    sei frame packing arrangement type
  85  */
  86 struct hva_controls {
  87         struct v4l2_fract                                       time_per_frame;
  88         enum v4l2_mpeg_video_bitrate_mode                       bitrate_mode;
  89         u32                                                     gop_size;
  90         u32                                                     bitrate;
  91         enum v4l2_mpeg_video_aspect                             aspect;
  92         enum v4l2_mpeg_video_h264_profile                       profile;
  93         enum v4l2_mpeg_video_h264_level                         level;
  94         enum v4l2_mpeg_video_h264_entropy_mode                  entropy_mode;
  95         u32                                                     cpb_size;
  96         bool                                                    dct8x8;
  97         u32                                                     qpmin;
  98         u32                                                     qpmax;
  99         bool                                                    vui_sar;
 100         enum v4l2_mpeg_video_h264_vui_sar_idc                   vui_sar_idc;
 101         bool                                                    sei_fp;
 102         enum v4l2_mpeg_video_h264_sei_fp_arrangement_type       sei_fp_type;
 103 };
 104
 105 /**
 106  * struct hva_frame - hva frame buffer (output)
 107  *
 108  * @vbuf:     video buffer information for V4L2
 109  * @list:     V4L2 m2m list that the frame belongs to
 110  * @info:     frame information (width, height, format, alignment...)
 111  * @paddr:    physical address (for hardware)
 112  * @vaddr:    virtual address (kernel can read/write)
 113  * @prepared: true if vaddr/paddr are resolved
 114  */
 115 struct hva_frame {
 116         struct vb2_v4l2_buffer  vbuf;
 117         struct list_head        list;
 118         struct hva_frameinfo    info;
 119         dma_addr_t              paddr;
 120         void                    *vaddr;
 121         bool                    prepared;
 122 };
 123
 124 /*
 125  * to_hva_frame() - cast struct vb2_v4l2_buffer * to struct hva_frame *
 126  */
 127 #define to_hva_frame(vb) \
 128         container_of(vb, struct hva_frame, vbuf)
 129
 130 /**
 131  * struct hva_stream - hva stream buffer (capture)
 132  *
 133  * @v4l2:       video buffer information for V4L2
 134  * @list:       V4L2 m2m list that the frame belongs to
 135  * @paddr:      physical address (for hardware)
 136  * @vaddr:      virtual address (kernel can read/write)
 137  * @prepared:   true if vaddr/paddr are resolved
 138  * @size:       size of the buffer in bytes
 139  * @bytesused:  number of bytes occupied by data in the buffer
 140  */
 141 struct hva_stream {
 142         struct vb2_v4l2_buffer  vbuf;
 143         struct list_head        list;
 144         dma_addr_t              paddr;
 145         void                    *vaddr;
 146         bool                    prepared;
 147         unsigned int            size;
 148         unsigned int            bytesused;
 149 };
 150
 151 /*
 152  * to_hva_stream() - cast struct vb2_v4l2_buffer * to struct hva_stream *
 153  */
 154 #define to_hva_stream(vb) \
 155         container_of(vb, struct hva_stream, vbuf)
 156
 157 #ifdef CONFIG_VIDEO_STI_HVA_DEBUGFS
 158 /**
 159  * struct hva_ctx_dbg - instance context debug info
 160  *
 161  * @debugfs_entry:      debugfs entry
 162  * @is_valid_period:    true if the sequence is valid for performance
 163  * @begin:              start time of last HW task
 164  * @total_duration:     total HW processing durations in 0.1ms
 165  * @cnt_duration:       number of HW processings
 166  * @min_duration:       minimum HW processing duration in 0.1ms
 167  * @max_duration:       maximum HW processing duration in 0.1ms
 168  * @avg_duration:       average HW processing duration in 0.1ms
 169  * @max_fps:            maximum frames encoded per second (in 0.1Hz)
 170  * @total_period:       total encoding periods in 0.1ms
 171  * @cnt_period:         number of periods
 172  * @min_period:         minimum encoding period in 0.1ms
 173  * @max_period:         maximum encoding period in 0.1ms
 174  * @avg_period:         average encoding period in 0.1ms
 175  * @total_stream_size:  total number of encoded bytes
 176  * @avg_fps:            average frames encoded per second (in 0.1Hz)
 177  * @window_duration:    duration of the sampling window in 0.1ms
 178  * @cnt_window:         number of samples in the window
 179  * @window_stream_size: number of encoded bytes upon the sampling window
 180  * @last_bitrate:       bitrate upon the last sampling window
 181  * @min_bitrate:        minimum bitrate in kbps
 182  * @max_bitrate:        maximum bitrate in kbps
 183  * @avg_bitrate:        average bitrate in kbps
 184  */
 185 struct hva_ctx_dbg {
 186         struct dentry   *debugfs_entry;
 187         bool            is_valid_period;
 188         ktime_t         begin;
 189         u32             total_duration;
 190         u32             cnt_duration;
 191         u32             min_duration;
 192         u32             max_duration;
 193         u32             avg_duration;
 194         u32             max_fps;
 195         u32             total_period;
 196         u32             cnt_period;
 197         u32             min_period;
 198         u32             max_period;
 199         u32             avg_period;
 200         u32             total_stream_size;
 201         u32             avg_fps;
 202         u32             window_duration;
 203         u32             cnt_window;
 204         u32             window_stream_size;
 205         u32             last_bitrate;
 206         u32             min_bitrate;
 207         u32             max_bitrate;
 208         u32             avg_bitrate;
 209 };
 210 #endif
 211
 212 struct hva_dev;
 213 struct hva_enc;
 214
 215 /**
 216  * struct hva_ctx - context of hva instance
 217  *
 218  * @hva_dev:         the device that this instance is associated with
 219  * @fh:              V4L2 file handle
 220  * @ctrl_handler:    V4L2 controls handler
 221  * @ctrls:           hva controls set
 222  * @id:              instance identifier
 223  * @aborting:        true if current job aborted
 224  * @name:            instance name (debug purpose)
 225  * @run_work:        encode work
 226  * @lock:            mutex used to lock access of this context
 227  * @flags:           validity of streaminfo and frameinfo fields
 228  * @frame_num:       frame number
 229  * @stream_num:      stream number
 230  * @max_stream_size: maximum size in bytes required for stream data
 231  * @colorspace:      colorspace identifier
 232  * @xfer_func:       transfer function identifier
 233  * @ycbcr_enc:       Y'CbCr encoding identifier
 234  * @quantization:    quantization identifier
 235  * @streaminfo:      stream properties
 236  * @frameinfo:       frame properties
 237  * @enc:             current encoder
 238  * @priv:            private codec data for this instance, allocated
 239  *                   by encoder @open time
 240  * @hw_err:          true if hardware error detected
 241  * @encoded_frames:  number of encoded frames
 242  * @sys_errors:      number of system errors (memory, resource, pm...)
 243  * @encode_errors:   number of encoding errors (hw/driver errors)
 244  * @frame_errors:    number of frame errors (format, size, header...)
 245  * @dbg:             context debug info
 246  */
 247 struct hva_ctx {
 248         struct hva_dev                  *hva_dev;
 249         struct v4l2_fh                  fh;
 250         struct v4l2_ctrl_handler        ctrl_handler;
 251         struct hva_controls             ctrls;
 252         u8                              id;
 253         bool                            aborting;
 254         char                            name[100];
 255         struct work_struct              run_work;
 256         /* mutex protecting this data structure */
 257         struct mutex                    lock;
 258         u32                             flags;
 259         u32                             frame_num;
 260         u32                             stream_num;
 261         u32                             max_stream_size;
 262         enum v4l2_colorspace            colorspace;
 263         enum v4l2_xfer_func             xfer_func;
 264         enum v4l2_ycbcr_encoding        ycbcr_enc;
 265         enum v4l2_quantization          quantization;
 266         struct hva_streaminfo           streaminfo;
 267         struct hva_frameinfo            frameinfo;
 268         struct hva_enc                  *enc;
 269         void                            *priv;
 270         bool                            hw_err;
 271         u32                             encoded_frames;
 272         u32                             sys_errors;
 273         u32                             encode_errors;
 274         u32                             frame_errors;
 275 #ifdef CONFIG_VIDEO_STI_HVA_DEBUGFS
 276         struct hva_ctx_dbg              dbg;
 277 #endif
 278 };
 279
 280 #define HVA_FLAG_STREAMINFO     0x0001
 281 #define HVA_FLAG_FRAMEINFO      0x0002
 282
 283 #ifdef CONFIG_VIDEO_STI_HVA_DEBUGFS
 284 /**
 285  * struct hva_dev_dbg - device debug info
 286  *
 287  * @debugfs_entry: debugfs entry
 288  * @last_ctx:      debug information about last running instance context
 289  */
 290 struct hva_dev_dbg {
 291         struct dentry   *debugfs_entry;
 292         struct hva_ctx  last_ctx;
 293 };
 294 #endif
 295
 296 #define HVA_MAX_INSTANCES       16
 297 #define HVA_MAX_ENCODERS        10
 298 #define HVA_MAX_FORMATS         HVA_MAX_ENCODERS
 299
 300 /**
 301  * struct hva_dev - abstraction for hva entity
 302  *
 303  * @v4l2_dev:            V4L2 device
 304  * @vdev:                video device
 305  * @pdev:                platform device
 306  * @dev:                 device
 307  * @lock:                mutex used for critical sections & V4L2 ops
 308  *                       serialization
 309  * @m2m_dev:             memory-to-memory V4L2 device information
 310  * @instances:           opened instances
 311  * @nb_of_instances:     number of opened instances
 312  * @instance_id:         rolling counter identifying an instance (debug purpose)
 313  * @regs:                register io memory access
 314  * @esram_addr:          esram address
 315  * @esram_size:          esram size
 316  * @clk:                 hva clock
 317  * @irq_its:             status interruption
 318  * @irq_err:             error interruption
 319  * @work_queue:          work queue to handle the encode jobs
 320  * @protect_mutex:       mutex used to lock access of hardware
 321  * @interrupt:           completion interrupt
 322  * @ip_version:          IP hardware version
 323  * @encoders:            registered encoders
 324  * @nb_of_encoders:      number of registered encoders
 325  * @pixelformats:        supported uncompressed video formats
 326  * @nb_of_pixelformats:  number of supported umcompressed video formats
 327  * @streamformats:       supported compressed video formats
 328  * @nb_of_streamformats: number of supported compressed video formats
 329  * @sfl_reg:             status fifo level register value
 330  * @sts_reg:             status register value
 331  * @lmi_err_reg:         local memory interface error register value
 332  * @emi_err_reg:         external memory interface error register value
 333  * @hec_mif_err_reg:     HEC memory interface error register value
 334  * @dbg:                 device debug info
 335  */
 336 struct hva_dev {
 337         struct v4l2_device      v4l2_dev;
 338         struct video_device     *vdev;
 339         struct platform_device  *pdev;
 340         struct device           *dev;
 341         /* mutex protecting vb2_queue structure */
 342         struct mutex            lock;
 343         struct v4l2_m2m_dev     *m2m_dev;
 344         struct hva_ctx          *instances[HVA_MAX_INSTANCES];
 345         unsigned int            nb_of_instances;
 346         unsigned int            instance_id;
 347         void __iomem            *regs;
 348         u32                     esram_addr;
 349         u32                     esram_size;
 350         struct clk              *clk;
 351         int                     irq_its;
 352         int                     irq_err;
 353         struct workqueue_struct *work_queue;
 354         /* mutex protecting hardware access */
 355         struct mutex            protect_mutex;
 356         struct completion       interrupt;
 357         unsigned long int       ip_version;
 358         const struct hva_enc    *encoders[HVA_MAX_ENCODERS];
 359         u32                     nb_of_encoders;
 360         u32                     pixelformats[HVA_MAX_FORMATS];
 361         u32                     nb_of_pixelformats;
 362         u32                     streamformats[HVA_MAX_FORMATS];
 363         u32                     nb_of_streamformats;
 364         u32                     sfl_reg;
 365         u32                     sts_reg;
 366         u32                     lmi_err_reg;
 367         u32                     emi_err_reg;
 368         u32                     hec_mif_err_reg;
 369 #ifdef CONFIG_VIDEO_STI_HVA_DEBUGFS
 370         struct hva_dev_dbg      dbg;
 371 #endif
 372 };
 373
 374 /**
 375  * struct hva_enc - hva encoder
 376  *
 377  * @name:         encoder name
 378  * @streamformat: fourcc code for compressed video format (H.264...)
 379  * @pixelformat:  fourcc code for uncompressed video format
 380  * @max_width:    maximum width of frame for this encoder
 381  * @max_height:   maximum height of frame for this encoder
 382  * @open:         open encoder
 383  * @close:        close encoder
 384  * @encode:       encode a frame (struct hva_frame) in a stream
 385  *                (struct hva_stream)
 386  */
 387
 388 struct hva_enc {
 389         const char      *name;
 390         u32             streamformat;
 391         u32             pixelformat;
 392         u32             max_width;
 393         u32             max_height;
 394         int             (*open)(struct hva_ctx *ctx);
 395         int             (*close)(struct hva_ctx *ctx);
 396         int             (*encode)(struct hva_ctx *ctx, struct hva_frame *frame,
 397                                   struct hva_stream *stream);
 398 };
 399
 400 #ifdef CONFIG_VIDEO_STI_HVA_DEBUGFS
 401 void hva_debugfs_create(struct hva_dev *hva);
 402 void hva_debugfs_remove(struct hva_dev *hva);
 403 void hva_dbg_ctx_create(struct hva_ctx *ctx);
 404 void hva_dbg_ctx_remove(struct hva_ctx *ctx);
 405 void hva_dbg_perf_begin(struct hva_ctx *ctx);
 406 void hva_dbg_perf_end(struct hva_ctx *ctx, struct hva_stream *stream);
 407 #endif
 408
 409 #endif /* HVA_H */