android15-6.6-lts/s

// SPDX-License-Identifier: GPL-2.0
/*
 * Support for Intel Camera Imaging ISP subsystem.
 * Copyright (c) 2010 - 2015, Intel Corporation.
 *
 * This program is free software; you can redistribute it and/or modify it
 * under the terms and conditions of the GNU General Public License,
 * version 2, as published by the Free Software Foundation.
 *
 * This program is distributed in the hope 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 "platform_support.h"

#include "ia_css_inputfifo.h"

#include "device_access.h"

#define __INLINE_SP__
#include "sp.h"
#define __INLINE_ISP__
#include "isp.h"
#define __INLINE_IRQ__
#include "irq.h"
#define __INLINE_FIFO_MONITOR__
#include "fifo_monitor.h"

#define __INLINE_EVENT__
#include "event_fifo.h"
#define __INLINE_SP__

#include "input_system.h"	/* MIPI_PREDICTOR_NONE,... */

#include "assert_support.h"

/* System independent */
#include "sh_css_internal.h"
#include "ia_css_isys.h"

#define HBLANK_CYCLES (187)
#define MARKER_CYCLES (6)

#include <hive_isp_css_streaming_to_mipi_types_hrt.h>

/* The data type is used to send special cases:
 * yuv420: odd lines (1, 3 etc) are twice as wide as even
 *         lines (0, 2, 4 etc).
 * rgb: for two pixels per clock, the R and B values are sent
 *      to output_0 while only G is sent to output_1. This means
 *      that output_1 only gets half the number of values of output_0.
 *      WARNING: This type should also be used for Legacy YUV420.
 * regular: used for all other data types (RAW, YUV422, etc)
 */
enum inputfifo_mipi_data_type {
	inputfifo_mipi_data_type_regular,
	inputfifo_mipi_data_type_yuv420,
	inputfifo_mipi_data_type_yuv420_legacy,
	inputfifo_mipi_data_type_rgb,
};

static unsigned int inputfifo_curr_ch_id, inputfifo_curr_fmt_type;
struct inputfifo_instance {
	unsigned int				ch_id;
	enum atomisp_input_format	input_format;
	bool						two_ppc;
	bool						streaming;
	unsigned int				hblank_cycles;
	unsigned int				marker_cycles;
	unsigned int				fmt_type;
	enum inputfifo_mipi_data_type	type;
};

/*
 * Maintain a basic streaming to Mipi administration with ch_id as index
 * ch_id maps on the "Mipi virtual channel ID" and can have value 0..3
 */
#define INPUTFIFO_NR_OF_S2M_CHANNELS	(4)
static struct inputfifo_instance
	inputfifo_inst_admin[INPUTFIFO_NR_OF_S2M_CHANNELS];

/* Streaming to MIPI */
static unsigned int inputfifo_wrap_marker(
    /* static inline unsigned inputfifo_wrap_marker( */
    unsigned int marker)
{
	return marker |
	       (inputfifo_curr_ch_id << HIVE_STR_TO_MIPI_CH_ID_LSB) |
	       (inputfifo_curr_fmt_type << _HIVE_STR_TO_MIPI_FMT_TYPE_LSB);
}

static inline void
_sh_css_fifo_snd(unsigned int token)
{
	while (!can_event_send_token(STR2MIPI_EVENT_ID))
		udelay(1);
	event_send_token(STR2MIPI_EVENT_ID, token);
	return;
}

static void inputfifo_send_data_a(
    /* static inline void inputfifo_send_data_a( */
    unsigned int data)
{
	unsigned int token = (1 << HIVE_STR_TO_MIPI_VALID_A_BIT) |
			     (data << HIVE_STR_TO_MIPI_DATA_A_LSB);
	_sh_css_fifo_snd(token);
	return;
}

static void inputfifo_send_data_b(
    /* static inline void inputfifo_send_data_b( */
    unsigned int data)
{
	unsigned int token = (1 << HIVE_STR_TO_MIPI_VALID_B_BIT) |
			     (data << _HIVE_STR_TO_MIPI_DATA_B_LSB);
	_sh_css_fifo_snd(token);
	return;
}

static void inputfifo_send_data(
    /* static inline void inputfifo_send_data( */
    unsigned int a,
    unsigned int b)
{
	unsigned int token = ((1 << HIVE_STR_TO_MIPI_VALID_A_BIT) |
			      (1 << HIVE_STR_TO_MIPI_VALID_B_BIT) |
			      (a << HIVE_STR_TO_MIPI_DATA_A_LSB) |
			      (b << _HIVE_STR_TO_MIPI_DATA_B_LSB));
	_sh_css_fifo_snd(token);
	return;
}

static void inputfifo_send_sol(void)
/* static inline void inputfifo_send_sol(void) */
{
	hrt_data	token = inputfifo_wrap_marker(
				1 << HIVE_STR_TO_MIPI_SOL_BIT);

	_sh_css_fifo_snd(token);
	return;
}

static void inputfifo_send_eol(void)
/* static inline void inputfifo_send_eol(void) */
{
	hrt_data	token = inputfifo_wrap_marker(
				1 << HIVE_STR_TO_MIPI_EOL_BIT);
	_sh_css_fifo_snd(token);
	return;
}

static void inputfifo_send_sof(void)
/* static inline void inputfifo_send_sof(void) */
{
	hrt_data	token = inputfifo_wrap_marker(
				1 << HIVE_STR_TO_MIPI_SOF_BIT);

	_sh_css_fifo_snd(token);
	return;
}

static void inputfifo_send_eof(void)
/* static inline void inputfifo_send_eof(void) */
{
	hrt_data	token = inputfifo_wrap_marker(
				1 << HIVE_STR_TO_MIPI_EOF_BIT);
	_sh_css_fifo_snd(token);
	return;
}

static void inputfifo_send_ch_id_and_fmt_type(
    /* static inline
    void inputfifo_send_ch_id_and_fmt_type( */
    unsigned int ch_id,
    unsigned int fmt_type)
{
	hrt_data	token;

	inputfifo_curr_ch_id = ch_id & _HIVE_ISP_CH_ID_MASK;
	inputfifo_curr_fmt_type = fmt_type & _HIVE_ISP_FMT_TYPE_MASK;
	/* we send an zero marker, this will wrap the ch_id and
	 * fmt_type automatically.
	 */
	token = inputfifo_wrap_marker(0);
	_sh_css_fifo_snd(token);
	return;
}

static void inputfifo_send_empty_token(void)
/* static inline void inputfifo_send_empty_token(void) */
{
	hrt_data	token = inputfifo_wrap_marker(0);

	_sh_css_fifo_snd(token);
	return;
}

static void inputfifo_start_frame(
    /* static inline void inputfifo_start_frame( */
    unsigned int ch_id,
    unsigned int fmt_type)
{
	inputfifo_send_ch_id_and_fmt_type(ch_id, fmt_type);
	inputfifo_send_sof();
	return;
}

static void inputfifo_end_frame(
    unsigned int marker_cycles)
{
	unsigned int i;

	for (i = 0; i < marker_cycles; i++)
		inputfifo_send_empty_token();
	inputfifo_send_eof();
	return;
}

static void inputfifo_send_line2(
    const unsigned short *data,
    unsigned int width,
    const unsigned short *data2,
    unsigned int width2,
    unsigned int hblank_cycles,
    unsigned int marker_cycles,
    unsigned int two_ppc,
    enum inputfifo_mipi_data_type type)
{
	unsigned int i, is_rgb = 0, is_legacy = 0;

	assert(data);
	assert((data2) || (width2 == 0));
	if (type == inputfifo_mipi_data_type_rgb)
		is_rgb = 1;

	if (type == inputfifo_mipi_data_type_yuv420_legacy)
		is_legacy = 1;

	for (i = 0; i < hblank_cycles; i++)
		inputfifo_send_empty_token();
	inputfifo_send_sol();
	for (i = 0; i < marker_cycles; i++)
		inputfifo_send_empty_token();
	for (i = 0; i < width; i++, data++) {
		/* for RGB in two_ppc, we only actually send 2 pixels per
		 * clock in the even pixels (0, 2 etc). In the other cycles,
		 * we only send 1 pixel, to data[0].
		 */
		unsigned int send_two_pixels = two_ppc;

		if ((is_rgb || is_legacy) && (i % 3 == 2))
			send_two_pixels = 0;
		if (send_two_pixels) {
			if (i + 1 == width) {
				/* for jpg (binary) copy, this can occur
				 * if the file contains an odd number of bytes.
				 */
				inputfifo_send_data(
				    data[0], 0);
			} else {
				inputfifo_send_data(
				    data[0], data[1]);
			}
			/* Additional increment because we send 2 pixels */
			data++;
			i++;
		} else if (two_ppc && is_legacy) {
			inputfifo_send_data_b(data[0]);
		} else {
			inputfifo_send_data_a(data[0]);
		}
	}

	for (i = 0; i < width2; i++, data2++) {
		/* for RGB in two_ppc, we only actually send 2 pixels per
		 * clock in the even pixels (0, 2 etc). In the other cycles,
		 * we only send 1 pixel, to data2[0].
		 */
		unsigned int send_two_pixels = two_ppc;

		if ((is_rgb || is_legacy) && (i % 3 == 2))
			send_two_pixels = 0;
		if (send_two_pixels) {
			if (i + 1 == width2) {
				/* for jpg (binary) copy, this can occur
				 * if the file contains an odd number of bytes.
				 */
				inputfifo_send_data(
				    data2[0], 0);
			} else {
				inputfifo_send_data(
				    data2[0], data2[1]);
			}
			/* Additional increment because we send 2 pixels */
			data2++;
			i++;
		} else if (two_ppc && is_legacy) {
			inputfifo_send_data_b(data2[0]);
		} else {
			inputfifo_send_data_a(data2[0]);
		}
	}
	for (i = 0; i < hblank_cycles; i++)
		inputfifo_send_empty_token();
	inputfifo_send_eol();
	return;
}

static void
inputfifo_send_line(const unsigned short *data,
		    unsigned int width,
		    unsigned int hblank_cycles,
		    unsigned int marker_cycles,
		    unsigned int two_ppc,
		    enum inputfifo_mipi_data_type type)
{
	assert(data);
	inputfifo_send_line2(data, width, NULL, 0,
			     hblank_cycles,
			     marker_cycles,
			     two_ppc,
			     type);
}

/* Send a frame of data into the input network via the GP FIFO.
 *  Parameters:
 *   - data: array of 16 bit values that contains all data for the frame.
 *   - width: width of a line in number of subpixels, for yuv420 it is the
 *            number of Y components per line.
 *   - height: height of the frame in number of lines.
 *   - ch_id: channel ID.
 *   - fmt_type: format type.
 *   - hblank_cycles: length of horizontal blanking in cycles.
 *   - marker_cycles: number of empty cycles after start-of-line and before
 *                    end-of-frame.
 *   - two_ppc: boolean, describes whether to send one or two pixels per clock
 *              cycle. In this mode, we sent pixels N and N+1 in the same cycle,
 *              to IF_PRIM_A and IF_PRIM_B respectively. The caller must make
 *              sure the input data has been formatted correctly for this.
 *              For example, for RGB formats this means that unused values
 *              must be inserted.
 *   - yuv420: boolean, describes whether (non-legacy) yuv420 data is used. In
 *             this mode, the odd lines (1,3,5 etc) are half as long as the
 *             even lines (2,4,6 etc).
 *             Note that the first line is odd (1) and the second line is even
 *             (2).
 *
 * This function does not do any reordering of pixels, the caller must make
 * sure the data is in the righ format. Please refer to the CSS receiver
 * documentation for details on the data formats.
 */

static void inputfifo_send_frame(
    const unsigned short *data,
    unsigned int width,
    unsigned int height,
    unsigned int ch_id,
    unsigned int fmt_type,
    unsigned int hblank_cycles,
    unsigned int marker_cycles,
    unsigned int two_ppc,
    enum inputfifo_mipi_data_type type)
{
	unsigned int i;

	assert(data);
	inputfifo_start_frame(ch_id, fmt_type);

	for (i = 0; i < height; i++) {
		if ((type == inputfifo_mipi_data_type_yuv420) &&
		    (i & 1) == 1) {
			inputfifo_send_line(data, 2 * width,
					    hblank_cycles,
					    marker_cycles,
					    two_ppc, type);
			data += 2 * width;
		} else {
			inputfifo_send_line(data, width,
					    hblank_cycles,
					    marker_cycles,
					    two_ppc, type);
			data += width;
		}
	}
	inputfifo_end_frame(marker_cycles);
	return;
}

static enum inputfifo_mipi_data_type inputfifo_determine_type(
    enum atomisp_input_format input_format)
{
	enum inputfifo_mipi_data_type type;

	type = inputfifo_mipi_data_type_regular;
	if (input_format == ATOMISP_INPUT_FORMAT_YUV420_8_LEGACY) {
		type =
		    inputfifo_mipi_data_type_yuv420_legacy;
	} else if (input_format == ATOMISP_INPUT_FORMAT_YUV420_8  ||
		   input_format == ATOMISP_INPUT_FORMAT_YUV420_10 ||
		   input_format == ATOMISP_INPUT_FORMAT_YUV420_16) {
		type =
		    inputfifo_mipi_data_type_yuv420;
	} else if (input_format >= ATOMISP_INPUT_FORMAT_RGB_444 &&
		   input_format <= ATOMISP_INPUT_FORMAT_RGB_888) {
		type =
		    inputfifo_mipi_data_type_rgb;
	}
	return type;
}

static struct inputfifo_instance *inputfifo_get_inst(
    unsigned int ch_id)
{
	return &inputfifo_inst_admin[ch_id];
}

void ia_css_inputfifo_send_input_frame(
    const unsigned short *data,
    unsigned int width,
    unsigned int height,
    unsigned int ch_id,
    enum atomisp_input_format input_format,
    bool two_ppc)
{
	unsigned int fmt_type, hblank_cycles, marker_cycles;
	enum inputfifo_mipi_data_type type;

	assert(data);
	hblank_cycles = HBLANK_CYCLES;
	marker_cycles = MARKER_CYCLES;
	ia_css_isys_convert_stream_format_to_mipi_format(input_format,
		MIPI_PREDICTOR_NONE,
		&fmt_type);

	type = inputfifo_determine_type(input_format);

	inputfifo_send_frame(data, width, height,
			     ch_id, fmt_type, hblank_cycles, marker_cycles,
			     two_ppc, type);
}

void ia_css_inputfifo_start_frame(
    unsigned int ch_id,
    enum atomisp_input_format input_format,
    bool two_ppc)
{
	struct inputfifo_instance *s2mi;

	s2mi = inputfifo_get_inst(ch_id);

	s2mi->ch_id = ch_id;
	ia_css_isys_convert_stream_format_to_mipi_format(input_format,
		MIPI_PREDICTOR_NONE,
		&s2mi->fmt_type);
	s2mi->two_ppc = two_ppc;
	s2mi->type = inputfifo_determine_type(input_format);
	s2mi->hblank_cycles = HBLANK_CYCLES;
	s2mi->marker_cycles = MARKER_CYCLES;
	s2mi->streaming = true;

	inputfifo_start_frame(ch_id, s2mi->fmt_type);
	return;
}

void ia_css_inputfifo_send_line(
    unsigned int ch_id,
    const unsigned short *data,
    unsigned int width,
    const unsigned short *data2,
    unsigned int width2)
{
	struct inputfifo_instance *s2mi;

	assert(data);
	assert((data2) || (width2 == 0));
	s2mi = inputfifo_get_inst(ch_id);

	/* Set global variables that indicate channel_id and format_type */
	inputfifo_curr_ch_id = (s2mi->ch_id) & _HIVE_ISP_CH_ID_MASK;
	inputfifo_curr_fmt_type = (s2mi->fmt_type) & _HIVE_ISP_FMT_TYPE_MASK;

	inputfifo_send_line2(data, width, data2, width2,
			     s2mi->hblank_cycles,
			     s2mi->marker_cycles,
			     s2mi->two_ppc,
			     s2mi->type);
}

void ia_css_inputfifo_send_embedded_line(
    unsigned int	ch_id,
    enum atomisp_input_format	data_type,
    const unsigned short	*data,
    unsigned int	width)
{
	struct inputfifo_instance *s2mi;
	unsigned int fmt_type;

	assert(data);
	s2mi = inputfifo_get_inst(ch_id);
	ia_css_isys_convert_stream_format_to_mipi_format(data_type,
		MIPI_PREDICTOR_NONE, &fmt_type);

	/* Set format_type for metadata line. */
	inputfifo_curr_fmt_type = fmt_type & _HIVE_ISP_FMT_TYPE_MASK;

	inputfifo_send_line(data, width, s2mi->hblank_cycles, s2mi->marker_cycles,
			    s2mi->two_ppc, inputfifo_mipi_data_type_regular);
}

void ia_css_inputfifo_end_frame(
    unsigned int	ch_id)
{
	struct inputfifo_instance *s2mi;

	s2mi = inputfifo_get_inst(ch_id);

	/* Set global variables that indicate channel_id and format_type */
	inputfifo_curr_ch_id = (s2mi->ch_id) & _HIVE_ISP_CH_ID_MASK;
	inputfifo_curr_fmt_type = (s2mi->fmt_type) & _HIVE_ISP_FMT_TYPE_MASK;

	/* Call existing HRT function */
	inputfifo_end_frame(s2mi->marker_cycles);

	s2mi->streaming = false;
	return;
}