Commit 3e158e1f authored by Sakari Ailus's avatar Sakari Ailus Committed by Mauro Carvalho Chehab
Browse files

media: smiapp: Switch to CCS limits 



Use the CCS limit definitions instead of the SMIA ones. This allows
accessing CCS capabilities where needed as well as dropping the old SMIA
limits.

Signed-off-by: default avatarSakari Ailus <sakari.ailus@linux.intel.com>
Signed-off-by: default avatarMauro Carvalho Chehab <mchehab+huawei@kernel.org>
parent ca296a11

drivers/media/i2c/smiapp/Makefile

+1 −1
Original line number Diff line number Diff line 
# SPDX-License-Identifier: GPL-2.0-only

smiapp-objs			+= smiapp-core.o smiapp-regs.o \

				   smiapp-quirk.o smiapp-limits.o ccs-limits.o

				   smiapp-quirk.o ccs-limits.o

obj-$(CONFIG_VIDEO_SMIAPP)	+= smiapp.o



ccflags-y += -I $(srctree)/drivers/media/i2c

drivers/media/i2c/smiapp/smiapp-core.c

+105 −150
Original line number Diff line number Diff line
@@ -64,45 +64,6 @@ static const struct smiapp_module_ident smiapp_module_idents[] = { 
 *

 */



static u32 smiapp_get_limit(struct smiapp_sensor *sensor,

				 unsigned int limit)

{

	if (WARN_ON(limit >= SMIAPP_LIMIT_LAST))

		return 1;



	return sensor->limits[limit];

}



#define SMIA_LIM(sensor, limit) \

	smiapp_get_limit(sensor, SMIAPP_LIMIT_##limit)



static int smiapp_read_all_smia_limits(struct smiapp_sensor *sensor)

{

	struct i2c_client *client = v4l2_get_subdevdata(&sensor->src->sd);

	unsigned int i;

	int rval;



	for (i = 0; i < SMIAPP_LIMIT_LAST; i++) {

		u32 val;



		rval = smiapp_read(

			sensor, smiapp_reg_limits[i].addr, &val);

		if (rval)

			return rval;



		sensor->limits[i] = val;



		dev_dbg(&client->dev, "0x%8.8x \"%s\" = %u, 0x%x\n",

			smiapp_reg_limits[i].addr,

			smiapp_reg_limits[i].what, val, val);

	}



	if (SMIA_LIM(sensor, SCALER_N_MIN) == 0)

		smiapp_replace_limit(sensor, SMIAPP_LIMIT_SCALER_N_MIN, 16);



	return 0;

}



static void ccs_assign_limit(void *ptr, unsigned int width, u32 val)

{

	switch (width) {
@@ -253,6 +214,9 @@ static int ccs_read_all_limits(struct smiapp_sensor *sensor) 


	sensor->ccs_limits = alloc;



	if (CCS_LIM(sensor, SCALER_N_MIN) < 16)

		ccs_replace_limit(sensor, CCS_L_SCALER_N_MIN, 0, 16);



	return 0;



out_err:
@@ -444,35 +408,35 @@ static int smiapp_pll_try(struct smiapp_sensor *sensor, 
{

	struct i2c_client *client = v4l2_get_subdevdata(&sensor->src->sd);

	struct smiapp_pll_limits lim = {

		.min_pre_pll_clk_div = SMIA_LIM(sensor, MIN_PRE_PLL_CLK_DIV),

		.max_pre_pll_clk_div = SMIA_LIM(sensor, MAX_PRE_PLL_CLK_DIV),

		.min_pll_ip_freq_hz = SMIA_LIM(sensor, MIN_PLL_IP_FREQ_HZ),

		.max_pll_ip_freq_hz = SMIA_LIM(sensor, MAX_PLL_IP_FREQ_HZ),

		.min_pll_multiplier = SMIA_LIM(sensor, MIN_PLL_MULTIPLIER),

		.max_pll_multiplier = SMIA_LIM(sensor, MAX_PLL_MULTIPLIER),

		.min_pll_op_freq_hz = SMIA_LIM(sensor, MIN_PLL_OP_FREQ_HZ),

		.max_pll_op_freq_hz = SMIA_LIM(sensor, MAX_PLL_OP_FREQ_HZ),



		.op.min_sys_clk_div = SMIA_LIM(sensor, MIN_OP_SYS_CLK_DIV),

		.op.max_sys_clk_div = SMIA_LIM(sensor, MAX_OP_SYS_CLK_DIV),

		.op.min_pix_clk_div = SMIA_LIM(sensor, MIN_OP_PIX_CLK_DIV),

		.op.max_pix_clk_div = SMIA_LIM(sensor, MAX_OP_PIX_CLK_DIV),

		.op.min_sys_clk_freq_hz = SMIA_LIM(sensor, MIN_OP_SYS_CLK_FREQ_HZ),

		.op.max_sys_clk_freq_hz = SMIA_LIM(sensor, MAX_OP_SYS_CLK_FREQ_HZ),

		.op.min_pix_clk_freq_hz = SMIA_LIM(sensor, MIN_OP_PIX_CLK_FREQ_HZ),

		.op.max_pix_clk_freq_hz = SMIA_LIM(sensor, MAX_OP_PIX_CLK_FREQ_HZ),



		.vt.min_sys_clk_div = SMIA_LIM(sensor, MIN_VT_SYS_CLK_DIV),

		.vt.max_sys_clk_div = SMIA_LIM(sensor, MAX_VT_SYS_CLK_DIV),

		.vt.min_pix_clk_div = SMIA_LIM(sensor, MIN_VT_PIX_CLK_DIV),

		.vt.max_pix_clk_div = SMIA_LIM(sensor, MAX_VT_PIX_CLK_DIV),

		.vt.min_sys_clk_freq_hz = SMIA_LIM(sensor, MIN_VT_SYS_CLK_FREQ_HZ),

		.vt.max_sys_clk_freq_hz = SMIA_LIM(sensor, MAX_VT_SYS_CLK_FREQ_HZ),

		.vt.min_pix_clk_freq_hz = SMIA_LIM(sensor, MIN_VT_PIX_CLK_FREQ_HZ),

		.vt.max_pix_clk_freq_hz = SMIA_LIM(sensor, MAX_VT_PIX_CLK_FREQ_HZ),



		.min_line_length_pck_bin = SMIA_LIM(sensor, MIN_LINE_LENGTH_PCK_BIN),

		.min_line_length_pck = SMIA_LIM(sensor, MIN_LINE_LENGTH_PCK),

		.min_pre_pll_clk_div = CCS_LIM(sensor, MIN_PRE_PLL_CLK_DIV),

		.max_pre_pll_clk_div = CCS_LIM(sensor, MAX_PRE_PLL_CLK_DIV),

		.min_pll_ip_freq_hz = CCS_LIM(sensor, MIN_PLL_IP_CLK_FREQ_MHZ),

		.max_pll_ip_freq_hz = CCS_LIM(sensor, MAX_PLL_IP_CLK_FREQ_MHZ),

		.min_pll_multiplier = CCS_LIM(sensor, MIN_PLL_MULTIPLIER),

		.max_pll_multiplier = CCS_LIM(sensor, MAX_PLL_MULTIPLIER),

		.min_pll_op_freq_hz = CCS_LIM(sensor, MIN_PLL_OP_CLK_FREQ_MHZ),

		.max_pll_op_freq_hz = CCS_LIM(sensor, MAX_PLL_OP_CLK_FREQ_MHZ),



		.op.min_sys_clk_div = CCS_LIM(sensor, MIN_OP_SYS_CLK_DIV),

		.op.max_sys_clk_div = CCS_LIM(sensor, MAX_OP_SYS_CLK_DIV),

		.op.min_pix_clk_div = CCS_LIM(sensor, MIN_OP_PIX_CLK_DIV),

		.op.max_pix_clk_div = CCS_LIM(sensor, MAX_OP_PIX_CLK_DIV),

		.op.min_sys_clk_freq_hz = CCS_LIM(sensor, MIN_OP_SYS_CLK_FREQ_MHZ),

		.op.max_sys_clk_freq_hz = CCS_LIM(sensor, MAX_OP_SYS_CLK_FREQ_MHZ),

		.op.min_pix_clk_freq_hz = CCS_LIM(sensor, MIN_OP_PIX_CLK_FREQ_MHZ),

		.op.max_pix_clk_freq_hz = CCS_LIM(sensor, MAX_OP_PIX_CLK_FREQ_MHZ),



		.vt.min_sys_clk_div = CCS_LIM(sensor, MIN_VT_SYS_CLK_DIV),

		.vt.max_sys_clk_div = CCS_LIM(sensor, MAX_VT_SYS_CLK_DIV),

		.vt.min_pix_clk_div = CCS_LIM(sensor, MIN_VT_PIX_CLK_DIV),

		.vt.max_pix_clk_div = CCS_LIM(sensor, MAX_VT_PIX_CLK_DIV),

		.vt.min_sys_clk_freq_hz = CCS_LIM(sensor, MIN_VT_SYS_CLK_FREQ_MHZ),

		.vt.max_sys_clk_freq_hz = CCS_LIM(sensor, MAX_VT_SYS_CLK_FREQ_MHZ),

		.vt.min_pix_clk_freq_hz = CCS_LIM(sensor, MIN_VT_PIX_CLK_FREQ_MHZ),

		.vt.max_pix_clk_freq_hz = CCS_LIM(sensor, MAX_VT_PIX_CLK_FREQ_MHZ),



		.min_line_length_pck_bin = CCS_LIM(sensor, MIN_LINE_LENGTH_PCK_BIN),

		.min_line_length_pck = CCS_LIM(sensor, MIN_LINE_LENGTH_PCK),

	};



	return smiapp_pll_calculate(&client->dev, &lim, pll);
@@ -515,7 +479,7 @@ static void __smiapp_update_exposure_limits(struct smiapp_sensor *sensor) 


	max = sensor->pixel_array->crop[SMIAPP_PA_PAD_SRC].height

		+ sensor->vblank->val

		- SMIA_LIM(sensor, COARSE_INTEGRATION_TIME_MAX_MARGIN);

		- CCS_LIM(sensor, COARSE_INTEGRATION_TIME_MAX_MARGIN);



	__v4l2_ctrl_modify_range(ctrl, ctrl->minimum, max, ctrl->step, max);

}
@@ -770,10 +734,10 @@ static int smiapp_init_controls(struct smiapp_sensor *sensor) 
	sensor->analog_gain = v4l2_ctrl_new_std(

		&sensor->pixel_array->ctrl_handler, &smiapp_ctrl_ops,

		V4L2_CID_ANALOGUE_GAIN,

		SMIA_LIM(sensor, ANALOGUE_GAIN_CODE_MIN),

		SMIA_LIM(sensor, ANALOGUE_GAIN_CODE_MAX),

		max(SMIA_LIM(sensor, ANALOGUE_GAIN_CODE_STEP), 1U),

		SMIA_LIM(sensor, ANALOGUE_GAIN_CODE_MIN));

		CCS_LIM(sensor, ANALOG_GAIN_CODE_MIN),

		CCS_LIM(sensor, ANALOG_GAIN_CODE_MAX),

		max(CCS_LIM(sensor, ANALOG_GAIN_CODE_STEP), 1U),

		CCS_LIM(sensor, ANALOG_GAIN_CODE_MIN));



	/* Exposure limits will be updated soon, use just something here. */

	sensor->exposure = v4l2_ctrl_new_std(
@@ -1032,21 +996,21 @@ static void smiapp_update_blanking(struct smiapp_sensor *sensor) 
	int min, max;



	if (sensor->binning_vertical > 1 || sensor->binning_horizontal > 1) {

		min_fll = SMIA_LIM(sensor, MIN_FRAME_LENGTH_LINES_BIN);

		max_fll = SMIA_LIM(sensor, MAX_FRAME_LENGTH_LINES_BIN);

		min_llp = SMIA_LIM(sensor, MIN_LINE_LENGTH_PCK_BIN);

		max_llp = SMIA_LIM(sensor, MAX_LINE_LENGTH_PCK_BIN);

		min_lbp = SMIA_LIM(sensor, MIN_LINE_BLANKING_PCK_BIN);

		min_fll = CCS_LIM(sensor, MIN_FRAME_LENGTH_LINES_BIN);

		max_fll = CCS_LIM(sensor, MAX_FRAME_LENGTH_LINES_BIN);

		min_llp = CCS_LIM(sensor, MIN_LINE_LENGTH_PCK_BIN);

		max_llp = CCS_LIM(sensor, MAX_LINE_LENGTH_PCK_BIN);

		min_lbp = CCS_LIM(sensor, MIN_LINE_BLANKING_PCK_BIN);

	} else {

		min_fll = SMIA_LIM(sensor, MIN_FRAME_LENGTH_LINES);

		max_fll = SMIA_LIM(sensor, MAX_FRAME_LENGTH_LINES);

		min_llp = SMIA_LIM(sensor, MIN_LINE_LENGTH_PCK);

		max_llp = SMIA_LIM(sensor, MAX_LINE_LENGTH_PCK);

		min_lbp = SMIA_LIM(sensor, MIN_LINE_BLANKING_PCK);

		min_fll = CCS_LIM(sensor, MIN_FRAME_LENGTH_LINES);

		max_fll = CCS_LIM(sensor, MAX_FRAME_LENGTH_LINES);

		min_llp = CCS_LIM(sensor, MIN_LINE_LENGTH_PCK);

		max_llp = CCS_LIM(sensor, MAX_LINE_LENGTH_PCK);

		min_lbp = CCS_LIM(sensor, MIN_LINE_BLANKING_PCK);

	}



	min = max_t(int,

		    SMIA_LIM(sensor, MIN_FRAME_BLANKING_LINES),

		    CCS_LIM(sensor, MIN_FRAME_BLANKING_LINES),

		    min_fll -

		    sensor->pixel_array->crop[SMIAPP_PA_PAD_SRC].height);

	max = max_fll -	sensor->pixel_array->crop[SMIAPP_PA_PAD_SRC].height;
@@ -1124,8 +1088,8 @@ static int smiapp_read_nvm_page(struct smiapp_sensor *sensor, u32 p, u8 *nvm, 
		return -ENODATA;

	}



	if (SMIA_LIM(sensor, DATA_TRANSFER_IF_CAPABILITY) &

	    SMIAPP_DATA_TRANSFER_IF_CAPABILITY_POLL) {

	if (CCS_LIM(sensor, DATA_TRANSFER_IF_CAPABILITY) &

	    CCS_DATA_TRANSFER_IF_CAPABILITY_POLLING) {

		for (i = 1000; i > 0; i--) {

			if (s & SMIAPP_DATA_TRANSFER_IF_1_STATUS_RD_READY)

				break;
@@ -1577,8 +1541,8 @@ static int smiapp_start_streaming(struct smiapp_sensor *sensor) 
	 */



	/* Digital crop */

	if (SMIA_LIM(sensor, DIGITAL_CROP_CAPABILITY)

	    == SMIAPP_DIGITAL_CROP_CAPABILITY_INPUT_CROP) {

	if (CCS_LIM(sensor, DIGITAL_CROP_CAPABILITY)

	    == CCS_DIGITAL_CROP_CAPABILITY_INPUT_CROP) {

		rval = smiapp_write(

			sensor, SMIAPP_REG_U16_DIGITAL_CROP_X_OFFSET,

			sensor->scaler->crop[SMIAPP_PAD_SINK].left);
@@ -1605,8 +1569,8 @@ static int smiapp_start_streaming(struct smiapp_sensor *sensor) 
	}



	/* Scaling */

	if (SMIA_LIM(sensor, SCALING_CAPABILITY)

	    != SMIAPP_SCALING_CAPABILITY_NONE) {

	if (CCS_LIM(sensor, SCALING_CAPABILITY)

	    != CCS_SCALING_CAPABILITY_NONE) {

		rval = smiapp_write(sensor, SMIAPP_REG_U16_SCALING_MODE,

				    sensor->scaling_mode);

		if (rval < 0)
@@ -1628,9 +1592,9 @@ static int smiapp_start_streaming(struct smiapp_sensor *sensor) 
	if (rval < 0)

		goto out;



	if ((SMIA_LIM(sensor, FLASH_MODE_CAPABILITY) &

	     (SMIAPP_FLASH_MODE_CAPABILITY_SINGLE_STROBE |

	      SMIAPP_FLASH_MODE_CAPABILITY_MULTIPLE_STROBE)) &&

	if (CCS_LIM(sensor, FLASH_MODE_CAPABILITY) &

	    (CCS_FLASH_MODE_CAPABILITY_SINGLE_STROBE |

	     SMIAPP_FLASH_MODE_CAPABILITY_MULTIPLE_STROBE) &&

	    sensor->hwcfg->strobe_setup != NULL &&

	    sensor->hwcfg->strobe_setup->trigger != 0) {

		rval = smiapp_setup_flash_strobe(sensor);
@@ -1876,7 +1840,7 @@ static void smiapp_propagate(struct v4l2_subdev *subdev, 
		if (which == V4L2_SUBDEV_FORMAT_ACTIVE) {

			if (ssd == sensor->scaler) {

				sensor->scale_m =

					SMIA_LIM(sensor, SCALER_N_MIN);

					CCS_LIM(sensor, SCALER_N_MIN);

				sensor->scaling_mode =

					SMIAPP_SCALING_MODE_NONE;

			} else if (ssd == sensor->binner) {
@@ -1988,12 +1952,12 @@ static int smiapp_set_format(struct v4l2_subdev *subdev, 


	fmt->format.width =

		clamp(fmt->format.width,

		      SMIA_LIM(sensor, MIN_X_OUTPUT_SIZE),

		      SMIA_LIM(sensor, MAX_X_OUTPUT_SIZE));

		      CCS_LIM(sensor, MIN_X_OUTPUT_SIZE),

		      CCS_LIM(sensor, MAX_X_OUTPUT_SIZE));

	fmt->format.height =

		clamp(fmt->format.height,

		      SMIA_LIM(sensor, MIN_Y_OUTPUT_SIZE),

		      SMIA_LIM(sensor, MAX_Y_OUTPUT_SIZE));

		      CCS_LIM(sensor, MIN_Y_OUTPUT_SIZE),

		      CCS_LIM(sensor, MAX_Y_OUTPUT_SIZE));



	smiapp_get_crop_compose(subdev, cfg, crops, NULL, fmt->which);
@@ -2046,7 +2010,7 @@ static int scaling_goodness(struct v4l2_subdev *subdev, int w, int ask_w, 
	val -= abs(w - ask_w);

	val -= abs(h - ask_h);



	if (w < SMIA_LIM(sensor, MIN_X_OUTPUT_SIZE))

	if (w < CCS_LIM(sensor, MIN_X_OUTPUT_SIZE))

		val -= SCALING_GOODNESS_EXTREME;



	dev_dbg(&client->dev, "w %d ask_w %d h %d ask_h %d goodness %d\n",
@@ -2112,7 +2076,7 @@ static void smiapp_set_compose_scaler(struct v4l2_subdev *subdev, 
	struct i2c_client *client = v4l2_get_subdevdata(subdev);

	struct smiapp_sensor *sensor = to_smiapp_sensor(subdev);

	u32 min, max, a, b, max_m;

	u32 scale_m = SMIA_LIM(sensor, SCALER_N_MIN);

	u32 scale_m = CCS_LIM(sensor, SCALER_N_MIN);

	int mode = SMIAPP_SCALING_MODE_HORIZONTAL;

	u32 try[4];

	u32 ntry = 0;
@@ -2125,19 +2089,19 @@ static void smiapp_set_compose_scaler(struct v4l2_subdev *subdev, 
			      crops[SMIAPP_PAD_SINK]->height);



	a = crops[SMIAPP_PAD_SINK]->width

		* SMIA_LIM(sensor, SCALER_N_MIN) / sel->r.width;

		* CCS_LIM(sensor, SCALER_N_MIN) / sel->r.width;

	b = crops[SMIAPP_PAD_SINK]->height

		* SMIA_LIM(sensor, SCALER_N_MIN) / sel->r.height;

		* CCS_LIM(sensor, SCALER_N_MIN) / sel->r.height;

	max_m = crops[SMIAPP_PAD_SINK]->width

		* SMIA_LIM(sensor, SCALER_N_MIN)

		/ SMIA_LIM(sensor, MIN_X_OUTPUT_SIZE);

		* CCS_LIM(sensor, SCALER_N_MIN)

		/ CCS_LIM(sensor, MIN_X_OUTPUT_SIZE);



	a = clamp(a, SMIA_LIM(sensor, SCALER_M_MIN),

		  SMIA_LIM(sensor, SCALER_M_MAX));

	b = clamp(b, SMIA_LIM(sensor, SCALER_M_MIN),

		  SMIA_LIM(sensor, SCALER_M_MAX));

	max_m = clamp(max_m, SMIA_LIM(sensor, SCALER_M_MIN),

		      SMIA_LIM(sensor, SCALER_M_MAX));

	a = clamp(a, CCS_LIM(sensor, SCALER_M_MIN),

		  CCS_LIM(sensor, SCALER_M_MAX));

	b = clamp(b, CCS_LIM(sensor, SCALER_M_MIN),

		  CCS_LIM(sensor, SCALER_M_MAX));

	max_m = clamp(max_m, CCS_LIM(sensor, SCALER_M_MIN),

		      CCS_LIM(sensor, SCALER_M_MAX));



	dev_dbg(&client->dev, "scaling: a %d b %d max_m %d\n", a, b, max_m);
@@ -2163,8 +2127,7 @@ static void smiapp_set_compose_scaler(struct v4l2_subdev *subdev, 
		int this = scaling_goodness(

			subdev,

			crops[SMIAPP_PAD_SINK]->width

			/ try[i]

			* SMIA_LIM(sensor, SCALER_N_MIN),

			/ try[i] * CCS_LIM(sensor, SCALER_N_MIN),

			sel->r.width,

			crops[SMIAPP_PAD_SINK]->height,

			sel->r.height,
@@ -2178,18 +2141,18 @@ static void smiapp_set_compose_scaler(struct v4l2_subdev *subdev, 
			best = this;

		}



		if (SMIA_LIM(sensor, SCALING_CAPABILITY)

		    == SMIAPP_SCALING_CAPABILITY_HORIZONTAL)

		if (CCS_LIM(sensor, SCALING_CAPABILITY)

		    == CCS_SCALING_CAPABILITY_HORIZONTAL)

			continue;



		this = scaling_goodness(

			subdev, crops[SMIAPP_PAD_SINK]->width

			/ try[i]

			* SMIA_LIM(sensor, SCALER_N_MIN),

			* CCS_LIM(sensor, SCALER_N_MIN),

			sel->r.width,

			crops[SMIAPP_PAD_SINK]->height

			/ try[i]

			* SMIA_LIM(sensor, SCALER_N_MIN),

			* CCS_LIM(sensor, SCALER_N_MIN),

			sel->r.height,

			sel->flags);
@@ -2203,12 +2166,12 @@ static void smiapp_set_compose_scaler(struct v4l2_subdev *subdev, 
	sel->r.width =

		(crops[SMIAPP_PAD_SINK]->width

		 / scale_m

		 * SMIA_LIM(sensor, SCALER_N_MIN)) & ~1;

		 * CCS_LIM(sensor, SCALER_N_MIN)) & ~1;

	if (mode == SMIAPP_SCALING_MODE_BOTH)

		sel->r.height =

			(crops[SMIAPP_PAD_SINK]->height

			 / scale_m

			 * SMIA_LIM(sensor, SCALER_N_MIN))

			 * CCS_LIM(sensor, SCALER_N_MIN))

			& ~1;

	else

		sel->r.height = crops[SMIAPP_PAD_SINK]->height;
@@ -2262,10 +2225,9 @@ static int __smiapp_sel_supported(struct v4l2_subdev *subdev, 
		if (ssd == sensor->src

		    && sel->pad == SMIAPP_PAD_SRC)

			return 0;

		if (ssd == sensor->scaler

		    && sel->pad == SMIAPP_PAD_SINK

		    && SMIA_LIM(sensor, DIGITAL_CROP_CAPABILITY)

		    == SMIAPP_DIGITAL_CROP_CAPABILITY_INPUT_CROP)

		if (ssd == sensor->scaler && sel->pad == SMIAPP_PAD_SINK &&

		    CCS_LIM(sensor, DIGITAL_CROP_CAPABILITY)

		    == CCS_DIGITAL_CROP_CAPABILITY_INPUT_CROP)

			return 0;

		return -EINVAL;

	case V4L2_SEL_TGT_NATIVE_SIZE:
@@ -2279,9 +2241,8 @@ static int __smiapp_sel_supported(struct v4l2_subdev *subdev, 
			return -EINVAL;

		if (ssd == sensor->binner)

			return 0;

		if (ssd == sensor->scaler

		    && SMIA_LIM(sensor, SCALING_CAPABILITY)

		    != SMIAPP_SCALING_CAPABILITY_NONE)

		if (ssd == sensor->scaler && CCS_LIM(sensor, SCALING_CAPABILITY)

		    != CCS_SCALING_CAPABILITY_NONE)

			return 0;

		fallthrough;

	default:
@@ -2345,8 +2306,8 @@ static void smiapp_get_native_size(struct smiapp_subdev *ssd, 
{

	r->top = 0;

	r->left = 0;

	r->width = SMIA_LIM(ssd->sensor, X_ADDR_MAX) + 1;

	r->height = SMIA_LIM(ssd->sensor, Y_ADDR_MAX) + 1;

	r->width = CCS_LIM(ssd->sensor, X_ADDR_MAX) + 1;

	r->height = CCS_LIM(ssd->sensor, Y_ADDR_MAX) + 1;

}



static int __smiapp_get_selection(struct v4l2_subdev *subdev,
@@ -2431,10 +2392,10 @@ static int smiapp_set_selection(struct v4l2_subdev *subdev, 
	sel->r.height =	SMIAPP_ALIGN_DIM(sel->r.height, sel->flags);



	sel->r.width = max_t(unsigned int,

			     SMIA_LIM(sensor, MIN_X_OUTPUT_SIZE),

			     CCS_LIM(sensor, MIN_X_OUTPUT_SIZE),

			     sel->r.width);

	sel->r.height = max_t(unsigned int,

			      SMIA_LIM(sensor, MIN_Y_OUTPUT_SIZE),

			      CCS_LIM(sensor, MIN_Y_OUTPUT_SIZE),

			      sel->r.height);



	switch (sel->target) {
@@ -3123,12 +3084,6 @@ static int smiapp_probe(struct i2c_client *client) 
		goto out_power_off;

	}



	rval = smiapp_read_all_smia_limits(sensor);

	if (rval) {

		rval = -ENODEV;

		goto out_power_off;

	}



	rval = ccs_read_all_limits(sensor);

	if (rval)

		goto out_power_off;
@@ -3163,7 +3118,7 @@ static int smiapp_probe(struct i2c_client *client) 
		goto out_free_ccs_limits;

	}



	if (SMIA_LIM(sensor, BINNING_CAPABILITY)) {

	if (CCS_LIM(sensor, BINNING_CAPABILITY)) {

		u32 val;



		rval = smiapp_read(sensor,
@@ -3200,8 +3155,8 @@ static int smiapp_probe(struct i2c_client *client) 
	}



	if (sensor->minfo.smiapp_version &&

	    SMIA_LIM(sensor, DATA_TRANSFER_IF_CAPABILITY) &

	    SMIAPP_DATA_TRANSFER_IF_CAPABILITY_SUPPORTED) {

	    CCS_LIM(sensor, DATA_TRANSFER_IF_CAPABILITY) &

	    CCS_DATA_TRANSFER_IF_CAPABILITY_SUPPORTED) {

		if (device_create_file(&client->dev, &dev_attr_nvm) != 0) {

			dev_err(&client->dev, "sysfs nvm entry failed\n");

			rval = -EBUSY;
@@ -3210,22 +3165,22 @@ static int smiapp_probe(struct i2c_client *client) 
	}



	/* We consider this as profile 0 sensor if any of these are zero. */

	if (!SMIA_LIM(sensor, MIN_OP_SYS_CLK_DIV) ||

	    !SMIA_LIM(sensor, MAX_OP_SYS_CLK_DIV) ||

	    !SMIA_LIM(sensor, MIN_OP_PIX_CLK_DIV) ||

	    !SMIA_LIM(sensor, MAX_OP_PIX_CLK_DIV)) {

	if (!CCS_LIM(sensor, MIN_OP_SYS_CLK_DIV) ||

	    !CCS_LIM(sensor, MAX_OP_SYS_CLK_DIV) ||

	    !CCS_LIM(sensor, MIN_OP_PIX_CLK_DIV) ||

	    !CCS_LIM(sensor, MAX_OP_PIX_CLK_DIV)) {

		sensor->minfo.smiapp_profile = SMIAPP_PROFILE_0;

	} else if (SMIA_LIM(sensor, SCALING_CAPABILITY)

		   != SMIAPP_SCALING_CAPABILITY_NONE) {

		if (SMIA_LIM(sensor, SCALING_CAPABILITY)

		    == SMIAPP_SCALING_CAPABILITY_HORIZONTAL)

	} else if (CCS_LIM(sensor, SCALING_CAPABILITY)

		   != CCS_SCALING_CAPABILITY_NONE) {

		if (CCS_LIM(sensor, SCALING_CAPABILITY)

		    == CCS_SCALING_CAPABILITY_HORIZONTAL)

			sensor->minfo.smiapp_profile = SMIAPP_PROFILE_1;

		else

			sensor->minfo.smiapp_profile = SMIAPP_PROFILE_2;

		sensor->scaler = &sensor->ssds[sensor->ssds_used];

		sensor->ssds_used++;

	} else if (SMIA_LIM(sensor, DIGITAL_CROP_CAPABILITY)

		   == SMIAPP_DIGITAL_CROP_CAPABILITY_INPUT_CROP) {

	} else if (CCS_LIM(sensor, DIGITAL_CROP_CAPABILITY)

		   == CCS_DIGITAL_CROP_CAPABILITY_INPUT_CROP) {

		sensor->scaler = &sensor->ssds[sensor->ssds_used];

		sensor->ssds_used++;

	}
@@ -3234,13 +3189,13 @@ static int smiapp_probe(struct i2c_client *client) 
	sensor->pixel_array = &sensor->ssds[sensor->ssds_used];

	sensor->ssds_used++;



	sensor->scale_m = SMIA_LIM(sensor, SCALER_N_MIN);

	sensor->scale_m = CCS_LIM(sensor, SCALER_N_MIN);



	/* prepare PLL configuration input values */

	sensor->pll.bus_type = SMIAPP_PLL_BUS_TYPE_CSI2;

	sensor->pll.csi2.lanes = sensor->hwcfg->lanes;

	sensor->pll.ext_clk_freq_hz = sensor->hwcfg->ext_clk;

	sensor->pll.scale_n = SMIA_LIM(sensor, SCALER_N_MIN);

	sensor->pll.scale_n = CCS_LIM(sensor, SCALER_N_MIN);

	/* Profile 0 sensors have no separate OP clock branch. */

	if (sensor->minfo.smiapp_profile == SMIAPP_PROFILE_0)

		sensor->pll.flags |= SMIAPP_PLL_FLAG_NO_OP_CLOCKS;

drivers/media/i2c/smiapp/smiapp-limits.c

deleted100644 → 0
+0 −118
Original line number Diff line number Diff line 
// SPDX-License-Identifier: GPL-2.0-only

/*

 * drivers/media/i2c/smiapp/smiapp-limits.c

 *

 * Generic driver for SMIA/SMIA++ compliant camera modules

 *

 * Copyright (C) 2011--2012 Nokia Corporation

 * Contact: Sakari Ailus <sakari.ailus@iki.fi>

 */



#include "smiapp.h"



struct smiapp_reg_limits smiapp_reg_limits[] = {

	{ SMIAPP_REG_U16_ANALOGUE_GAIN_CAPABILITY, "analogue_gain_capability" }, /* 0 */

	{ SMIAPP_REG_U16_ANALOGUE_GAIN_CODE_MIN, "analogue_gain_code_min" },

	{ SMIAPP_REG_U16_ANALOGUE_GAIN_CODE_MAX, "analogue_gain_code_max" },

	{ SMIAPP_REG_U8_THS_ZERO_MIN, "ths_zero_min" },

	{ SMIAPP_REG_U8_TCLK_TRAIL_MIN, "tclk_trail_min" },

	{ SMIAPP_REG_U16_INTEGRATION_TIME_CAPABILITY, "integration_time_capability" }, /* 5 */

	{ SMIAPP_REG_U16_COARSE_INTEGRATION_TIME_MIN, "coarse_integration_time_min" },

	{ SMIAPP_REG_U16_COARSE_INTEGRATION_TIME_MAX_MARGIN, "coarse_integration_time_max_margin" },

	{ SMIAPP_REG_U16_FINE_INTEGRATION_TIME_MIN, "fine_integration_time_min" },

	{ SMIAPP_REG_U16_FINE_INTEGRATION_TIME_MAX_MARGIN, "fine_integration_time_max_margin" },

	{ SMIAPP_REG_U16_DIGITAL_GAIN_CAPABILITY, "digital_gain_capability" }, /* 10 */

	{ SMIAPP_REG_U16_DIGITAL_GAIN_MIN, "digital_gain_min" },

	{ SMIAPP_REG_U16_DIGITAL_GAIN_MAX, "digital_gain_max" },

	{ SMIAPP_REG_F32_MIN_EXT_CLK_FREQ_HZ, "min_ext_clk_freq_hz" },

	{ SMIAPP_REG_F32_MAX_EXT_CLK_FREQ_HZ, "max_ext_clk_freq_hz" },

	{ SMIAPP_REG_U16_MIN_PRE_PLL_CLK_DIV, "min_pre_pll_clk_div" }, /* 15 */

	{ SMIAPP_REG_U16_MAX_PRE_PLL_CLK_DIV, "max_pre_pll_clk_div" },

	{ SMIAPP_REG_F32_MIN_PLL_IP_FREQ_HZ, "min_pll_ip_freq_hz" },

	{ SMIAPP_REG_F32_MAX_PLL_IP_FREQ_HZ, "max_pll_ip_freq_hz" },

	{ SMIAPP_REG_U16_MIN_PLL_MULTIPLIER, "min_pll_multiplier" },

	{ SMIAPP_REG_U16_MAX_PLL_MULTIPLIER, "max_pll_multiplier" }, /* 20 */

	{ SMIAPP_REG_F32_MIN_PLL_OP_FREQ_HZ, "min_pll_op_freq_hz" },

	{ SMIAPP_REG_F32_MAX_PLL_OP_FREQ_HZ, "max_pll_op_freq_hz" },

	{ SMIAPP_REG_U16_MIN_VT_SYS_CLK_DIV, "min_vt_sys_clk_div" },

	{ SMIAPP_REG_U16_MAX_VT_SYS_CLK_DIV, "max_vt_sys_clk_div" },

	{ SMIAPP_REG_F32_MIN_VT_SYS_CLK_FREQ_HZ, "min_vt_sys_clk_freq_hz" }, /* 25 */

	{ SMIAPP_REG_F32_MAX_VT_SYS_CLK_FREQ_HZ, "max_vt_sys_clk_freq_hz" },

	{ SMIAPP_REG_F32_MIN_VT_PIX_CLK_FREQ_HZ, "min_vt_pix_clk_freq_hz" },

	{ SMIAPP_REG_F32_MAX_VT_PIX_CLK_FREQ_HZ, "max_vt_pix_clk_freq_hz" },

	{ SMIAPP_REG_U16_MIN_VT_PIX_CLK_DIV, "min_vt_pix_clk_div" },

	{ SMIAPP_REG_U16_MAX_VT_PIX_CLK_DIV, "max_vt_pix_clk_div" }, /* 30 */

	{ SMIAPP_REG_U16_MIN_FRAME_LENGTH_LINES, "min_frame_length_lines" },

	{ SMIAPP_REG_U16_MAX_FRAME_LENGTH_LINES, "max_frame_length_lines" },

	{ SMIAPP_REG_U16_MIN_LINE_LENGTH_PCK, "min_line_length_pck" },

	{ SMIAPP_REG_U16_MAX_LINE_LENGTH_PCK, "max_line_length_pck" },

	{ SMIAPP_REG_U16_MIN_LINE_BLANKING_PCK, "min_line_blanking_pck" }, /* 35 */

	{ SMIAPP_REG_U16_MIN_FRAME_BLANKING_LINES, "min_frame_blanking_lines" },

	{ SMIAPP_REG_U8_MIN_LINE_LENGTH_PCK_STEP_SIZE, "min_line_length_pck_step_size" },

	{ SMIAPP_REG_U16_MIN_OP_SYS_CLK_DIV, "min_op_sys_clk_div" },

	{ SMIAPP_REG_U16_MAX_OP_SYS_CLK_DIV, "max_op_sys_clk_div" },

	{ SMIAPP_REG_F32_MIN_OP_SYS_CLK_FREQ_HZ, "min_op_sys_clk_freq_hz" }, /* 40 */

	{ SMIAPP_REG_F32_MAX_OP_SYS_CLK_FREQ_HZ, "max_op_sys_clk_freq_hz" },

	{ SMIAPP_REG_U16_MIN_OP_PIX_CLK_DIV, "min_op_pix_clk_div" },

	{ SMIAPP_REG_U16_MAX_OP_PIX_CLK_DIV, "max_op_pix_clk_div" },

	{ SMIAPP_REG_F32_MIN_OP_PIX_CLK_FREQ_HZ, "min_op_pix_clk_freq_hz" },

	{ SMIAPP_REG_F32_MAX_OP_PIX_CLK_FREQ_HZ, "max_op_pix_clk_freq_hz" }, /* 45 */

	{ SMIAPP_REG_U16_X_ADDR_MIN, "x_addr_min" },

	{ SMIAPP_REG_U16_Y_ADDR_MIN, "y_addr_min" },

	{ SMIAPP_REG_U16_X_ADDR_MAX, "x_addr_max" },

	{ SMIAPP_REG_U16_Y_ADDR_MAX, "y_addr_max" },

	{ SMIAPP_REG_U16_MIN_X_OUTPUT_SIZE, "min_x_output_size" }, /* 50 */

	{ SMIAPP_REG_U16_MIN_Y_OUTPUT_SIZE, "min_y_output_size" },

	{ SMIAPP_REG_U16_MAX_X_OUTPUT_SIZE, "max_x_output_size" },

	{ SMIAPP_REG_U16_MAX_Y_OUTPUT_SIZE, "max_y_output_size" },

	{ SMIAPP_REG_U16_MIN_EVEN_INC, "min_even_inc" },

	{ SMIAPP_REG_U16_MAX_EVEN_INC, "max_even_inc" }, /* 55 */

	{ SMIAPP_REG_U16_MIN_ODD_INC, "min_odd_inc" },

	{ SMIAPP_REG_U16_MAX_ODD_INC, "max_odd_inc" },

	{ SMIAPP_REG_U16_SCALING_CAPABILITY, "scaling_capability" },

	{ SMIAPP_REG_U16_SCALER_M_MIN, "scaler_m_min" },

	{ SMIAPP_REG_U16_SCALER_M_MAX, "scaler_m_max" }, /* 60 */

	{ SMIAPP_REG_U16_SCALER_N_MIN, "scaler_n_min" },

	{ SMIAPP_REG_U16_SCALER_N_MAX, "scaler_n_max" },

	{ SMIAPP_REG_U16_SPATIAL_SAMPLING_CAPABILITY, "spatial_sampling_capability" },

	{ SMIAPP_REG_U8_DIGITAL_CROP_CAPABILITY, "digital_crop_capability" },

	{ SMIAPP_REG_U16_COMPRESSION_CAPABILITY, "compression_capability" }, /* 65 */

	{ SMIAPP_REG_U8_FIFO_SUPPORT_CAPABILITY, "fifo_support_capability" },

	{ SMIAPP_REG_U8_DPHY_CTRL_CAPABILITY, "dphy_ctrl_capability" },

	{ SMIAPP_REG_U8_CSI_LANE_MODE_CAPABILITY, "csi_lane_mode_capability" },

	{ SMIAPP_REG_U8_CSI_SIGNALLING_MODE_CAPABILITY, "csi_signalling_mode_capability" },

	{ SMIAPP_REG_U8_FAST_STANDBY_CAPABILITY, "fast_standby_capability" }, /* 70 */

	{ SMIAPP_REG_U8_CCI_ADDRESS_CONTROL_CAPABILITY, "cci_address_control_capability" },

	{ SMIAPP_REG_U32_MAX_PER_LANE_BITRATE_1_LANE_MODE_MBPS, "max_per_lane_bitrate_1_lane_mode_mbps" },

	{ SMIAPP_REG_U32_MAX_PER_LANE_BITRATE_2_LANE_MODE_MBPS, "max_per_lane_bitrate_2_lane_mode_mbps" },

	{ SMIAPP_REG_U32_MAX_PER_LANE_BITRATE_3_LANE_MODE_MBPS, "max_per_lane_bitrate_3_lane_mode_mbps" },

	{ SMIAPP_REG_U32_MAX_PER_LANE_BITRATE_4_LANE_MODE_MBPS, "max_per_lane_bitrate_4_lane_mode_mbps" }, /* 75 */

	{ SMIAPP_REG_U8_TEMP_SENSOR_CAPABILITY, "temp_sensor_capability" },

	{ SMIAPP_REG_U16_MIN_FRAME_LENGTH_LINES_BIN, "min_frame_length_lines_bin" },

	{ SMIAPP_REG_U16_MAX_FRAME_LENGTH_LINES_BIN, "max_frame_length_lines_bin" },

	{ SMIAPP_REG_U16_MIN_LINE_LENGTH_PCK_BIN, "min_line_length_pck_bin" },

	{ SMIAPP_REG_U16_MAX_LINE_LENGTH_PCK_BIN, "max_line_length_pck_bin" }, /* 80 */

	{ SMIAPP_REG_U16_MIN_LINE_BLANKING_PCK_BIN, "min_line_blanking_pck_bin" },

	{ SMIAPP_REG_U16_FINE_INTEGRATION_TIME_MIN_BIN, "fine_integration_time_min_bin" },

	{ SMIAPP_REG_U16_FINE_INTEGRATION_TIME_MAX_MARGIN_BIN, "fine_integration_time_max_margin_bin" },

	{ SMIAPP_REG_U8_BINNING_CAPABILITY, "binning_capability" },

	{ SMIAPP_REG_U8_BINNING_WEIGHTING_CAPABILITY, "binning_weighting_capability" }, /* 85 */

	{ SMIAPP_REG_U8_DATA_TRANSFER_IF_CAPABILITY, "data_transfer_if_capability" },

	{ SMIAPP_REG_U8_SHADING_CORRECTION_CAPABILITY, "shading_correction_capability" },

	{ SMIAPP_REG_U8_GREEN_IMBALANCE_CAPABILITY, "green_imbalance_capability" },

	{ SMIAPP_REG_U8_BLACK_LEVEL_CAPABILITY, "black_level_capability" },

	{ SMIAPP_REG_U8_MODULE_SPECIFIC_CORRECTION_CAPABILITY, "module_specific_correction_capability" }, /* 90 */

	{ SMIAPP_REG_U16_DEFECT_CORRECTION_CAPABILITY, "defect_correction_capability" },

	{ SMIAPP_REG_U16_DEFECT_CORRECTION_CAPABILITY_2, "defect_correction_capability_2" },

	{ SMIAPP_REG_U8_EDOF_CAPABILITY, "edof_capability" },

	{ SMIAPP_REG_U8_COLOUR_FEEDBACK_CAPABILITY, "colour_feedback_capability" },

	{ SMIAPP_REG_U8_ESTIMATION_MODE_CAPABILITY, "estimation_mode_capability" }, /* 95 */

	{ SMIAPP_REG_U8_ESTIMATION_ZONE_CAPABILITY, "estimation_zone_capability" },

	{ SMIAPP_REG_U16_CAPABILITY_TRDY_MIN, "capability_trdy_min" },

	{ SMIAPP_REG_U8_FLASH_MODE_CAPABILITY, "flash_mode_capability" },

	{ SMIAPP_REG_U8_ACTUATOR_CAPABILITY, "actuator_capability" },

	{ SMIAPP_REG_U8_BRACKETING_LUT_CAPABILITY_1, "bracketing_lut_capability_1" }, /* 100 */

	{ SMIAPP_REG_U8_BRACKETING_LUT_CAPABILITY_2, "bracketing_lut_capability_2" },

	{ SMIAPP_REG_U16_ANALOGUE_GAIN_CODE_STEP, "analogue_gain_code_step" },

	{ 0, NULL },

};

drivers/media/i2c/smiapp/smiapp-limits.h

deleted100644 → 0
+0 −114

File deleted.

Preview size limit exceeded, changes collapsed.

drivers/media/i2c/smiapp/smiapp-quirk.c

+7 −18

File changed.

Preview size limit exceeded, changes collapsed.