drivers/media/platform/rockchip/rkisp1/rkisp1-common.h

   1 /* SPDX-License-Identifier: (GPL-2.0+ OR MIT) */
   2 /*
   3  * Rockchip ISP1 Driver - Common definitions
   4  *
   5  * Copyright (C) 2019 Collabora, Ltd.
   6  *
   7  * Based on Rockchip ISP1 driver by Rockchip Electronics Co., Ltd.
   8  * Copyright (C) 2017 Rockchip Electronics Co., Ltd.
   9  */
  10
  11 #ifndef _RKISP1_COMMON_H
  12 #define _RKISP1_COMMON_H
  13
  14 #include <linux/clk.h>
  15 #include <linux/interrupt.h>
  16 #include <linux/mutex.h>
  17 #include <linux/rkisp1-config.h>
  18 #include <media/media-device.h>
  19 #include <media/media-entity.h>
  20 #include <media/v4l2-ctrls.h>
  21 #include <media/v4l2-device.h>
  22 #include <media/videobuf2-v4l2.h>
  23
  24 #include "rkisp1-regs.h"
  25
  26 struct dentry;
  27
  28 /*
  29  * flags on the 'direction' field in struct rkisp1_mbus_info' that indicate
  30  * on which pad the media bus format is supported
  31  */
  32 #define RKISP1_ISP_SD_SRC                       BIT(0)
  33 #define RKISP1_ISP_SD_SINK                      BIT(1)
  34
  35 /* min and max values for the widths and heights of the entities */
  36 #define RKISP1_ISP_MAX_WIDTH                    4032
  37 #define RKISP1_ISP_MAX_HEIGHT                   3024
  38 #define RKISP1_ISP_MIN_WIDTH                    32
  39 #define RKISP1_ISP_MIN_HEIGHT                   32
  40
  41 #define RKISP1_RSZ_MP_SRC_MAX_WIDTH             4416
  42 #define RKISP1_RSZ_MP_SRC_MAX_HEIGHT            3312
  43 #define RKISP1_RSZ_SP_SRC_MAX_WIDTH             1920
  44 #define RKISP1_RSZ_SP_SRC_MAX_HEIGHT            1920
  45 #define RKISP1_RSZ_SRC_MIN_WIDTH                32
  46 #define RKISP1_RSZ_SRC_MIN_HEIGHT               16
  47
  48 /* the default width and height of all the entities */
  49 #define RKISP1_DEFAULT_WIDTH                    800
  50 #define RKISP1_DEFAULT_HEIGHT                   600
  51
  52 #define RKISP1_DRIVER_NAME                      "rkisp1"
  53 #define RKISP1_BUS_INFO                         "platform:" RKISP1_DRIVER_NAME
  54
  55 /* maximum number of clocks */
  56 #define RKISP1_MAX_BUS_CLK                      8
  57
  58 /* a bitmask of the ready stats */
  59 #define RKISP1_STATS_MEAS_MASK                  (RKISP1_CIF_ISP_AWB_DONE |      \
  60                                                  RKISP1_CIF_ISP_AFM_FIN |       \
  61                                                  RKISP1_CIF_ISP_EXP_END |       \
  62                                                  RKISP1_CIF_ISP_HIST_MEASURE_RDY)
  63
  64 /* IRQ lines */
  65 enum rkisp1_irq_line {
  66         RKISP1_IRQ_ISP = 0,
  67         RKISP1_IRQ_MI,
  68         RKISP1_IRQ_MIPI,
  69         RKISP1_NUM_IRQS,
  70 };
  71
  72 /* enum for the resizer pads */
  73 enum rkisp1_rsz_pad {
  74         RKISP1_RSZ_PAD_SINK,
  75         RKISP1_RSZ_PAD_SRC,
  76         RKISP1_RSZ_PAD_MAX
  77 };
  78
  79 /* enum for the csi receiver pads */
  80 enum rkisp1_csi_pad {
  81         RKISP1_CSI_PAD_SINK,
  82         RKISP1_CSI_PAD_SRC,
  83         RKISP1_CSI_PAD_NUM
  84 };
  85
  86 /* enum for the capture id */
  87 enum rkisp1_stream_id {
  88         RKISP1_MAINPATH,
  89         RKISP1_SELFPATH,
  90 };
  91
  92 /* bayer patterns */
  93 enum rkisp1_fmt_raw_pat_type {
  94         RKISP1_RAW_RGGB = 0,
  95         RKISP1_RAW_GRBG,
  96         RKISP1_RAW_GBRG,
  97         RKISP1_RAW_BGGR,
  98 };
  99
 100 /* enum for the isp pads */
 101 enum rkisp1_isp_pad {
 102         RKISP1_ISP_PAD_SINK_VIDEO,
 103         RKISP1_ISP_PAD_SINK_PARAMS,
 104         RKISP1_ISP_PAD_SOURCE_VIDEO,
 105         RKISP1_ISP_PAD_SOURCE_STATS,
 106         RKISP1_ISP_PAD_MAX
 107 };
 108
 109 /*
 110  * enum rkisp1_feature - ISP features
 111  *
 112  * @RKISP1_FEATURE_MIPI_CSI2: The ISP has an internal MIPI CSI-2 receiver
 113  *
 114  * The ISP features are stored in a bitmask in &rkisp1_info.features and allow
 115  * the driver to implement support for features present in some ISP versions
 116  * only.
 117  */
 118 enum rkisp1_feature {
 119         RKISP1_FEATURE_MIPI_CSI2 = BIT(0),
 120 };
 121
 122 /*
 123  * struct rkisp1_info - Model-specific ISP Information
 124  *
 125  * @clks: array of ISP clock names
 126  * @clk_size: number of entries in the @clks array
 127  * @isrs: array of ISP interrupt descriptors
 128  * @isr_size: number of entries in the @isrs array
 129  * @isp_ver: ISP version
 130  * @features: bitmask of rkisp1_feature features implemented by the ISP
 131  *
 132  * This structure contains information about the ISP specific to a particular
 133  * ISP model, version, or integration in a particular SoC.
 134  */
 135 struct rkisp1_info {
 136         const char * const *clks;
 137         unsigned int clk_size;
 138         const struct rkisp1_isr_data *isrs;
 139         unsigned int isr_size;
 140         enum rkisp1_cif_isp_version isp_ver;
 141         unsigned int features;
 142 };
 143
 144 /*
 145  * struct rkisp1_sensor_async - A container for the v4l2_async_subdev to add to the notifier
 146  *                              of the v4l2-async API
 147  *
 148  * @asd:                async_subdev variable for the sensor
 149  * @index:              index of the sensor (counting sensor found in DT)
 150  * @source_ep:          fwnode for the sensor source endpoint
 151  * @lanes:              number of lanes
 152  * @mbus_type:          type of bus (currently only CSI2 is supported)
 153  * @mbus_flags:         media bus (V4L2_MBUS_*) flags
 154  * @sd:                 a pointer to v4l2_subdev struct of the sensor
 155  * @pixel_rate_ctrl:    pixel rate of the sensor, used to initialize the phy
 156  * @port:               port number (0: MIPI, 1: Parallel)
 157  */
 158 struct rkisp1_sensor_async {
 159         struct v4l2_async_connection asd;
 160         unsigned int index;
 161         struct fwnode_handle *source_ep;
 162         unsigned int lanes;
 163         enum v4l2_mbus_type mbus_type;
 164         unsigned int mbus_flags;
 165         struct v4l2_subdev *sd;
 166         struct v4l2_ctrl *pixel_rate_ctrl;
 167         unsigned int port;
 168 };
 169
 170 /*
 171  * struct rkisp1_csi - CSI receiver subdev
 172  *
 173  * @rkisp1: pointer to the rkisp1 device
 174  * @dphy: a pointer to the phy
 175  * @is_dphy_errctrl_disabled: if dphy errctrl is disabled (avoid endless interrupt)
 176  * @sd: v4l2_subdev variable
 177  * @pads: media pads
 178  * @source: source in-use, set when starting streaming
 179  */
 180 struct rkisp1_csi {
 181         struct rkisp1_device *rkisp1;
 182         struct phy *dphy;
 183         bool is_dphy_errctrl_disabled;
 184         struct v4l2_subdev sd;
 185         struct media_pad pads[RKISP1_CSI_PAD_NUM];
 186         struct v4l2_subdev *source;
 187 };
 188
 189 /*
 190  * struct rkisp1_isp - ISP subdev entity
 191  *
 192  * @sd:                         v4l2_subdev variable
 193  * @rkisp1:                     pointer to rkisp1_device
 194  * @pads:                       media pads
 195  * @sink_fmt:                   input format
 196  * @frame_sequence:             used to synchronize frame_id between video devices.
 197  */
 198 struct rkisp1_isp {
 199         struct v4l2_subdev sd;
 200         struct rkisp1_device *rkisp1;
 201         struct media_pad pads[RKISP1_ISP_PAD_MAX];
 202         const struct rkisp1_mbus_info *sink_fmt;
 203         __u32 frame_sequence;
 204 };
 205
 206 /*
 207  * struct rkisp1_vdev_node - Container for the video nodes: params, stats, mainpath, selfpath
 208  *
 209  * @buf_queue:  queue of buffers
 210  * @vlock:      lock of the video node
 211  * @vdev:       video node
 212  * @pad:        media pad
 213  */
 214 struct rkisp1_vdev_node {
 215         struct vb2_queue buf_queue;
 216         struct mutex vlock; /* ioctl serialization mutex */
 217         struct video_device vdev;
 218         struct media_pad pad;
 219 };
 220
 221 /*
 222  * struct rkisp1_buffer - A container for the vb2 buffers used by the video devices:
 223  *                        params, stats, mainpath, selfpath
 224  *
 225  * @vb:         vb2 buffer
 226  * @queue:      entry of the buffer in the queue
 227  * @buff_addr:  dma addresses of each plane, used only by the capture devices: selfpath, mainpath
 228  */
 229 struct rkisp1_buffer {
 230         struct vb2_v4l2_buffer vb;
 231         struct list_head queue;
 232         u32 buff_addr[VIDEO_MAX_PLANES];
 233 };
 234
 235 /*
 236  * struct rkisp1_dummy_buffer - A buffer to write the next frame to in case
 237  *                              there are no vb2 buffers available.
 238  *
 239  * @vaddr:      return value of call to dma_alloc_attrs.
 240  * @dma_addr:   dma address of the buffer.
 241  * @size:       size of the buffer.
 242  */
 243 struct rkisp1_dummy_buffer {
 244         void *vaddr;
 245         dma_addr_t dma_addr;
 246         u32 size;
 247 };
 248
 249 struct rkisp1_device;
 250
 251 /*
 252  * struct rkisp1_capture - ISP capture video device
 253  *
 254  * @vnode:        video node
 255  * @rkisp1:       pointer to rkisp1_device
 256  * @id:           id of the capture, one of RKISP1_SELFPATH, RKISP1_MAINPATH
 257  * @ops:          list of callbacks to configure the capture device.
 258  * @config:       a pointer to the list of registers to configure the capture format.
 259  * @is_streaming: device is streaming
 260  * @is_stopping:  stop_streaming callback was called and the device is in the process of
 261  *                stopping the streaming.
 262  * @done:         when stop_streaming callback is called, the device waits for the next irq
 263  *                handler to stop the streaming by waiting on the 'done' wait queue.
 264  *                If the irq handler is not called, the stream is stopped by the callback
 265  *                after timeout.
 266  * @sp_y_stride:  the selfpath allows to configure a y stride that is longer than the image width.
 267  * @buf.lock:     lock to protect buf.queue
 268  * @buf.queue:    queued buffer list
 269  * @buf.dummy:    dummy space to store dropped data
 270  *
 271  * rkisp1 uses shadow registers, so it needs two buffers at a time
 272  * @buf.curr:     the buffer used for current frame
 273  * @buf.next:     the buffer used for next frame
 274  * @pix.cfg:      pixel configuration
 275  * @pix.info:     a pointer to the v4l2_format_info of the pixel format
 276  * @pix.fmt:      buffer format
 277  */
 278 struct rkisp1_capture {
 279         struct rkisp1_vdev_node vnode;
 280         struct rkisp1_device *rkisp1;
 281         enum rkisp1_stream_id id;
 282         const struct rkisp1_capture_ops *ops;
 283         const struct rkisp1_capture_config *config;
 284         bool is_streaming;
 285         bool is_stopping;
 286         wait_queue_head_t done;
 287         unsigned int sp_y_stride;
 288         struct {
 289                 /* protects queue, curr and next */
 290                 spinlock_t lock;
 291                 struct list_head queue;
 292                 struct rkisp1_dummy_buffer dummy;
 293                 struct rkisp1_buffer *curr;
 294                 struct rkisp1_buffer *next;
 295         } buf;
 296         struct {
 297                 const struct rkisp1_capture_fmt_cfg *cfg;
 298                 const struct v4l2_format_info *info;
 299                 struct v4l2_pix_format_mplane fmt;
 300         } pix;
 301 };
 302
 303 struct rkisp1_stats;
 304 struct rkisp1_stats_ops {
 305         void (*get_awb_meas)(struct rkisp1_stats *stats,
 306                              struct rkisp1_stat_buffer *pbuf);
 307         void (*get_aec_meas)(struct rkisp1_stats *stats,
 308                              struct rkisp1_stat_buffer *pbuf);
 309         void (*get_hst_meas)(struct rkisp1_stats *stats,
 310                              struct rkisp1_stat_buffer *pbuf);
 311 };
 312
 313 /*
 314  * struct rkisp1_stats - ISP Statistics device
 315  *
 316  * @vnode:        video node
 317  * @rkisp1:       pointer to the rkisp1 device
 318  * @lock:         locks the buffer list 'stat'
 319  * @stat:         queue of rkisp1_buffer
 320  * @vdev_fmt:     v4l2_format of the metadata format
 321  */
 322 struct rkisp1_stats {
 323         struct rkisp1_vdev_node vnode;
 324         struct rkisp1_device *rkisp1;
 325         const struct rkisp1_stats_ops *ops;
 326
 327         spinlock_t lock; /* locks the buffers list 'stats' */
 328         struct list_head stat;
 329         struct v4l2_format vdev_fmt;
 330 };
 331
 332 struct rkisp1_params;
 333 struct rkisp1_params_ops {
 334         void (*lsc_matrix_config)(struct rkisp1_params *params,
 335                                   const struct rkisp1_cif_isp_lsc_config *pconfig);
 336         void (*goc_config)(struct rkisp1_params *params,
 337                            const struct rkisp1_cif_isp_goc_config *arg);
 338         void (*awb_meas_config)(struct rkisp1_params *params,
 339                                 const struct rkisp1_cif_isp_awb_meas_config *arg);
 340         void (*awb_meas_enable)(struct rkisp1_params *params,
 341                                 const struct rkisp1_cif_isp_awb_meas_config *arg,
 342                                 bool en);
 343         void (*awb_gain_config)(struct rkisp1_params *params,
 344                                 const struct rkisp1_cif_isp_awb_gain_config *arg);
 345         void (*aec_config)(struct rkisp1_params *params,
 346                            const struct rkisp1_cif_isp_aec_config *arg);
 347         void (*hst_config)(struct rkisp1_params *params,
 348                            const struct rkisp1_cif_isp_hst_config *arg);
 349         void (*hst_enable)(struct rkisp1_params *params,
 350                            const struct rkisp1_cif_isp_hst_config *arg, bool en);
 351         void (*afm_config)(struct rkisp1_params *params,
 352                            const struct rkisp1_cif_isp_afc_config *arg);
 353 };
 354
 355 /*
 356  * struct rkisp1_params - ISP input parameters device
 357  *
 358  * @vnode:              video node
 359  * @rkisp1:             pointer to the rkisp1 device
 360  * @ops:                pointer to the variant-specific operations
 361  * @config_lock:        locks the buffer list 'params'
 362  * @params:             queue of rkisp1_buffer
 363  * @vdev_fmt:           v4l2_format of the metadata format
 364  * @quantization:       the quantization configured on the isp's src pad
 365  * @raw_type:           the bayer pattern on the isp video sink pad
 366  */
 367 struct rkisp1_params {
 368         struct rkisp1_vdev_node vnode;
 369         struct rkisp1_device *rkisp1;
 370         const struct rkisp1_params_ops *ops;
 371
 372         spinlock_t config_lock; /* locks the buffers list 'params' */
 373         struct list_head params;
 374         struct v4l2_format vdev_fmt;
 375
 376         enum v4l2_quantization quantization;
 377         enum v4l2_ycbcr_encoding ycbcr_encoding;
 378         enum rkisp1_fmt_raw_pat_type raw_type;
 379 };
 380
 381 /*
 382  * struct rkisp1_resizer - Resizer subdev
 383  *
 384  * @sd:        v4l2_subdev variable
 385  * @regs_base: base register address offset
 386  * @id:        id of the resizer, one of RKISP1_SELFPATH, RKISP1_MAINPATH
 387  * @rkisp1:    pointer to the rkisp1 device
 388  * @pads:      media pads
 389  * @config:    the set of registers to configure the resizer
 390  */
 391 struct rkisp1_resizer {
 392         struct v4l2_subdev sd;
 393         u32 regs_base;
 394         enum rkisp1_stream_id id;
 395         struct rkisp1_device *rkisp1;
 396         struct media_pad pads[RKISP1_RSZ_PAD_MAX];
 397         const struct rkisp1_rsz_config *config;
 398 };
 399
 400 /*
 401  * struct rkisp1_debug - Values to be exposed on debugfs.
 402  *                       The parameters are counters of the number of times the
 403  *                       event occurred since the driver was loaded.
 404  *
 405  * @data_loss:                    loss of data occurred within a line, processing failure
 406  * @outform_size_error:           size error is generated in outmux submodule
 407  * @img_stabilization_size_error: size error is generated in image stabilization submodule
 408  * @inform_size_err:              size error is generated in inform submodule
 409  * @mipi_error:                   mipi error occurred
 410  * @stats_error:                  writing to the 'Interrupt clear register' did not clear
 411  *                                it in the register 'Masked interrupt status'
 412  * @stop_timeout:                 upon stream stop, the capture waits 1 second for the isr to stop
 413  *                                the stream. This param is incremented in case of timeout.
 414  * @frame_drop:                   a frame was ready but the buffer queue was empty so the frame
 415  *                                was not sent to userspace
 416  */
 417 struct rkisp1_debug {
 418         struct dentry *debugfs_dir;
 419         unsigned long data_loss;
 420         unsigned long outform_size_error;
 421         unsigned long img_stabilization_size_error;
 422         unsigned long inform_size_error;
 423         unsigned long irq_delay;
 424         unsigned long mipi_error;
 425         unsigned long stats_error;
 426         unsigned long stop_timeout[2];
 427         unsigned long frame_drop[2];
 428         unsigned long complete_frames;
 429 };
 430
 431 /*
 432  * struct rkisp1_device - ISP platform device
 433  *
 434  * @base_addr:     base register address
 435  * @dev:           a pointer to the struct device
 436  * @clk_size:      number of clocks
 437  * @clks:          array of clocks
 438  * @v4l2_dev:      v4l2_device variable
 439  * @media_dev:     media_device variable
 440  * @notifier:      a notifier to register on the v4l2-async API to be notified on the sensor
 441  * @source:        source subdev in-use, set when starting streaming
 442  * @csi:           internal CSI-2 receiver
 443  * @isp:           ISP sub-device
 444  * @resizer_devs:  resizer sub-devices
 445  * @capture_devs:  capture devices
 446  * @stats:         ISP statistics metadata capture device
 447  * @params:        ISP parameters metadata output device
 448  * @pipe:          media pipeline
 449  * @stream_lock:   serializes {start/stop}_streaming callbacks between the capture devices.
 450  * @debug:         debug params to be exposed on debugfs
 451  * @info:          version-specific ISP information
 452  * @irqs:          IRQ line numbers
 453  */
 454 struct rkisp1_device {
 455         void __iomem *base_addr;
 456         struct device *dev;
 457         unsigned int clk_size;
 458         struct clk_bulk_data clks[RKISP1_MAX_BUS_CLK];
 459         struct v4l2_device v4l2_dev;
 460         struct media_device media_dev;
 461         struct v4l2_async_notifier notifier;
 462         struct v4l2_subdev *source;
 463         struct rkisp1_csi csi;
 464         struct rkisp1_isp isp;
 465         struct rkisp1_resizer resizer_devs[2];
 466         struct rkisp1_capture capture_devs[2];
 467         struct rkisp1_stats stats;
 468         struct rkisp1_params params;
 469         struct media_pipeline pipe;
 470         struct mutex stream_lock; /* serialize {start/stop}_streaming cb between capture devices */
 471         struct rkisp1_debug debug;
 472         const struct rkisp1_info *info;
 473         int irqs[RKISP1_NUM_IRQS];
 474 };
 475
 476 /*
 477  * struct rkisp1_mbus_info - ISP media bus info, Translates media bus code to hardware
 478  *                           format values
 479  *
 480  * @mbus_code: media bus code
 481  * @pixel_enc: pixel encoding
 482  * @mipi_dt:   mipi data type
 483  * @yuv_seq:   the order of the Y, Cb, Cr values
 484  * @bus_width: bus width
 485  * @bayer_pat: bayer pattern
 486  * @direction: a bitmask of the flags indicating on which pad the format is supported on
 487  */
 488 struct rkisp1_mbus_info {
 489         u32 mbus_code;
 490         enum v4l2_pixel_encoding pixel_enc;
 491         u32 mipi_dt;
 492         u32 yuv_seq;
 493         u8 bus_width;
 494         enum rkisp1_fmt_raw_pat_type bayer_pat;
 495         unsigned int direction;
 496 };
 497
 498 static inline void
 499 rkisp1_write(struct rkisp1_device *rkisp1, unsigned int addr, u32 val)
 500 {
 501         writel(val, rkisp1->base_addr + addr);
 502 }
 503
 504 static inline u32 rkisp1_read(struct rkisp1_device *rkisp1, unsigned int addr)
 505 {
 506         return readl(rkisp1->base_addr + addr);
 507 }
 508
 509 /*
 510  * rkisp1_cap_enum_mbus_codes - A helper function that return the i'th supported mbus code
 511  *                              of the capture entity. This is used to enumerate the supported
 512  *                              mbus codes on the source pad of the resizer.
 513  *
 514  * @cap:  the capture entity
 515  * @code: the mbus code, the function reads the code->index and fills the code->code
 516  */
 517 int rkisp1_cap_enum_mbus_codes(struct rkisp1_capture *cap,
 518                                struct v4l2_subdev_mbus_code_enum *code);
 519
 520 /*
 521  * rkisp1_mbus_info_get_by_index - Retrieve the ith supported mbus info
 522  *
 523  * @index: index of the mbus info to fetch
 524  */
 525 const struct rkisp1_mbus_info *rkisp1_mbus_info_get_by_index(unsigned int index);
 526
 527 /*
 528  * rkisp1_sd_adjust_crop_rect - adjust a rectangle to fit into another rectangle.
 529  *
 530  * @crop:   rectangle to adjust.
 531  * @bounds: rectangle used as bounds.
 532  */
 533 void rkisp1_sd_adjust_crop_rect(struct v4l2_rect *crop,
 534                                 const struct v4l2_rect *bounds);
 535
 536 /*
 537  * rkisp1_sd_adjust_crop - adjust a rectangle to fit into media bus format
 538  *
 539  * @crop:   rectangle to adjust.
 540  * @bounds: media bus format used as bounds.
 541  */
 542 void rkisp1_sd_adjust_crop(struct v4l2_rect *crop,
 543                            const struct v4l2_mbus_framefmt *bounds);
 544
 545 /*
 546  * rkisp1_mbus_info_get_by_code - get the isp info of the media bus code
 547  *
 548  * @mbus_code: the media bus code
 549  */
 550 const struct rkisp1_mbus_info *rkisp1_mbus_info_get_by_code(u32 mbus_code);
 551
 552 /*
 553  * rkisp1_params_pre_configure - Configure the params before stream start
 554  *
 555  * @params:       pointer to rkisp1_params
 556  * @bayer_pat:    the bayer pattern on the isp video sink pad
 557  * @quantization: the quantization configured on the isp's src pad
 558  * @ycbcr_encoding: the ycbcr_encoding configured on the isp's src pad
 559  *
 560  * This function is called by the ISP entity just before the ISP gets started.
 561  * It applies the initial ISP parameters from the first params buffer, but
 562  * skips LSC as it needs to be configured after the ISP is started.
 563  */
 564 void rkisp1_params_pre_configure(struct rkisp1_params *params,
 565                                  enum rkisp1_fmt_raw_pat_type bayer_pat,
 566                                  enum v4l2_quantization quantization,
 567                                  enum v4l2_ycbcr_encoding ycbcr_encoding);
 568
 569 /*
 570  * rkisp1_params_post_configure - Configure the params after stream start
 571  *
 572  * @params:       pointer to rkisp1_params
 573  *
 574  * This function is called by the ISP entity just after the ISP gets started.
 575  * It applies the initial ISP LSC parameters from the first params buffer.
 576  */
 577 void rkisp1_params_post_configure(struct rkisp1_params *params);
 578
 579 /* rkisp1_params_disable - disable all parameters.
 580  *                         This function is called by the isp entity upon stream start
 581  *                         when capturing bayer format.
 582  *
 583  * @params: pointer to rkisp1_params.
 584  */
 585 void rkisp1_params_disable(struct rkisp1_params *params);
 586
 587 /* irq handlers */
 588 irqreturn_t rkisp1_isp_isr(int irq, void *ctx);
 589 irqreturn_t rkisp1_csi_isr(int irq, void *ctx);
 590 irqreturn_t rkisp1_capture_isr(int irq, void *ctx);
 591 void rkisp1_stats_isr(struct rkisp1_stats *stats, u32 isp_ris);
 592 void rkisp1_params_isr(struct rkisp1_device *rkisp1);
 593
 594 /* register/unregisters functions of the entities */
 595 int rkisp1_capture_devs_register(struct rkisp1_device *rkisp1);
 596 void rkisp1_capture_devs_unregister(struct rkisp1_device *rkisp1);
 597
 598 int rkisp1_isp_register(struct rkisp1_device *rkisp1);
 599 void rkisp1_isp_unregister(struct rkisp1_device *rkisp1);
 600
 601 int rkisp1_resizer_devs_register(struct rkisp1_device *rkisp1);
 602 void rkisp1_resizer_devs_unregister(struct rkisp1_device *rkisp1);
 603
 604 int rkisp1_stats_register(struct rkisp1_device *rkisp1);
 605 void rkisp1_stats_unregister(struct rkisp1_device *rkisp1);
 606
 607 int rkisp1_params_register(struct rkisp1_device *rkisp1);
 608 void rkisp1_params_unregister(struct rkisp1_device *rkisp1);
 609
 610 #if IS_ENABLED(CONFIG_DEBUG_FS)
 611 void rkisp1_debug_init(struct rkisp1_device *rkisp1);
 612 void rkisp1_debug_cleanup(struct rkisp1_device *rkisp1);
 613 #else
 614 static inline void rkisp1_debug_init(struct rkisp1_device *rkisp1)
 615 {
 616 }
 617 static inline void rkisp1_debug_cleanup(struct rkisp1_device *rkisp1)
 618 {
 619 }
 620 #endif
 621
 622 #endif /* _RKISP1_COMMON_H */