Commit a88883d1 authored by Sakari Ailus's avatar Sakari Ailus Committed by Hans Verkuil
Browse files

media: ccs: Rely on sub-device state locking 



Rely on sub-device state locking to serialise access to driver's data
structures. The driver-provided mutex is used as the state lock for all
driver sub-devices.

Signed-off-by: default avatarSakari Ailus <sakari.ailus@linux.intel.com>
Signed-off-by: default avatarHans Verkuil <hverkuil+cisco@kernel.org>
parent 0fc3caab

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

+70 −76
Original line number Diff line number Diff line
@@ -541,12 +541,13 @@ static int ccs_pll_update(struct ccs_sensor *sensor) 
 *

 */



static void __ccs_update_exposure_limits(struct ccs_sensor *sensor)

static void __ccs_update_exposure_limits(struct ccs_sensor *sensor,

					 const struct v4l2_rect *pa_src)

{

	struct v4l2_ctrl *ctrl = sensor->exposure;

	int max;



	max = sensor->pa_src.height + sensor->vblank->val -

	max = pa_src->height + sensor->vblank->val -

		CCS_LIM(sensor, COARSE_INTEGRATION_TIME_MAX_MARGIN);



	__v4l2_ctrl_modify_range(ctrl, ctrl->minimum, max, ctrl->step, max);
@@ -649,12 +650,20 @@ static int ccs_set_ctrl(struct v4l2_ctrl *ctrl) 
		container_of(ctrl->handler, struct ccs_subdev, ctrl_handler)

			->sensor;

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

	struct v4l2_subdev_state *state;

	const struct v4l2_rect *pa_src = NULL;

	int pm_status;

	u32 orient = 0;

	unsigned int i;

	int exposure;

	int rval;



	if (ctrl->id == V4L2_CID_VBLANK || ctrl->id == V4L2_CID_HBLANK) {

		state = v4l2_subdev_get_locked_active_state(&sensor->pixel_array->sd);

		pa_src = v4l2_subdev_state_get_crop(state, CCS_PA_PAD_SRC,

						    CCS_STREAM_PIXEL);

	}



	switch (ctrl->id) {

	case V4L2_CID_HFLIP:

	case V4L2_CID_VFLIP:
@@ -673,7 +682,7 @@ static int ccs_set_ctrl(struct v4l2_ctrl *ctrl) 
	case V4L2_CID_VBLANK:

		exposure = sensor->exposure->val;



		__ccs_update_exposure_limits(sensor);

		__ccs_update_exposure_limits(sensor, pa_src);



		if (exposure > sensor->exposure->maximum) {

			sensor->exposure->val =	sensor->exposure->maximum;
@@ -765,12 +774,12 @@ static int ccs_set_ctrl(struct v4l2_ctrl *ctrl) 
		break;

	case V4L2_CID_VBLANK:

		rval = ccs_write(sensor, FRAME_LENGTH_LINES,

				 sensor->pa_src.height + ctrl->val);

				 pa_src->height + ctrl->val);



		break;

	case V4L2_CID_HBLANK:

		rval = ccs_write(sensor, LINE_LENGTH_PCK,

				 sensor->pa_src.width + ctrl->val);

				 pa_src->width + ctrl->val);



		break;

	case V4L2_CID_TEST_PATTERN:
@@ -1223,7 +1232,8 @@ static int ccs_get_mbus_formats(struct ccs_sensor *sensor) 
	return 0;

}



static void ccs_update_blanking(struct ccs_sensor *sensor)

static void ccs_update_blanking(struct ccs_sensor *sensor,

				const struct v4l2_rect *pa_src)

{

	struct v4l2_ctrl *vblank = sensor->vblank;

	struct v4l2_ctrl *hblank = sensor->hblank;
@@ -1246,21 +1256,26 @@ static void ccs_update_blanking(struct ccs_sensor *sensor) 


	min = max_t(int,

		    CCS_LIM(sensor, MIN_FRAME_BLANKING_LINES),

		    min_fll - sensor->pa_src.height);

	max = max_fll -	sensor->pa_src.height;

		    min_fll - pa_src->height);

	max = max_fll -	pa_src->height;



	__v4l2_ctrl_modify_range(vblank, min, max, vblank->step, min);



	min = max_t(int, min_llp - sensor->pa_src.width, min_lbp);

	max = max_llp - sensor->pa_src.width;

	min = max_t(int, min_llp - pa_src->width, min_lbp);

	max = max_llp - pa_src->width;



	__v4l2_ctrl_modify_range(hblank, min, max, hblank->step, min);



	__ccs_update_exposure_limits(sensor);

	__ccs_update_exposure_limits(sensor, pa_src);

}



static int ccs_pll_blanking_update(struct ccs_sensor *sensor)

{

	struct v4l2_subdev_state *state =

		v4l2_subdev_get_locked_active_state(&sensor->pixel_array->sd);

	const struct v4l2_rect *pa_src =

		v4l2_subdev_state_get_crop(state, CCS_PA_PAD_SRC,

					   CCS_STREAM_PIXEL);

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

	int rval;
@@ -1269,15 +1284,15 @@ static int ccs_pll_blanking_update(struct ccs_sensor *sensor) 
		return rval;



	/* Output from pixel array, including blanking */

	ccs_update_blanking(sensor);

	ccs_update_blanking(sensor, pa_src);



	dev_dbg(&client->dev, "vblank\t\t%d\n", sensor->vblank->val);

	dev_dbg(&client->dev, "hblank\t\t%d\n", sensor->hblank->val);



	dev_dbg(&client->dev, "real timeperframe\t100/%d\n",

		sensor->pll.pixel_rate_pixel_array /

		((sensor->pa_src.width + sensor->hblank->val) *

		 (sensor->pa_src.height + sensor->vblank->val) / 100));

		((pa_src->width + sensor->hblank->val) *

		 (pa_src->height + sensor->vblank->val) / 100));



	return 0;

}
@@ -1782,6 +1797,16 @@ static int ccs_enable_streams(struct v4l2_subdev *subdev, 
			      u64 streams_mask)

{

	struct ccs_sensor *sensor = to_ccs_sensor(subdev);

	struct v4l2_subdev_state *pa_state =

		v4l2_subdev_get_locked_active_state(&sensor->pixel_array->sd);

	struct v4l2_subdev_state *src_state =

		v4l2_subdev_get_locked_active_state(&sensor->src->sd);

	const struct v4l2_rect *pa_src =

		v4l2_subdev_state_get_crop(pa_state, CCS_PA_PAD_SRC,

					   CCS_STREAM_PIXEL);

	const struct v4l2_rect *src_src =

		v4l2_subdev_state_get_crop(src_state, CCS_PAD_SRC,

					   CCS_STREAM_PIXEL);

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

	unsigned int binning_mode;

	int rval;
@@ -1829,22 +1854,20 @@ static int ccs_enable_streams(struct v4l2_subdev *subdev, 
		goto err_pm_put;



	/* Analog crop start coordinates */

	rval = ccs_write(sensor, X_ADDR_START, sensor->pa_src.left);

	rval = ccs_write(sensor, X_ADDR_START, pa_src->left);

	if (rval < 0)

		goto err_pm_put;



	rval = ccs_write(sensor, Y_ADDR_START, sensor->pa_src.top);

	rval = ccs_write(sensor, Y_ADDR_START, pa_src->top);

	if (rval < 0)

		goto err_pm_put;



	/* Analog crop end coordinates */

	rval = ccs_write(sensor, X_ADDR_END,

			 sensor->pa_src.left + sensor->pa_src.width - 1);

	rval = ccs_write(sensor, X_ADDR_END, pa_src->left + pa_src->width - 1);

	if (rval < 0)

		goto err_pm_put;



	rval = ccs_write(sensor, Y_ADDR_END,

			 sensor->pa_src.top + sensor->pa_src.height - 1);

	rval = ccs_write(sensor, Y_ADDR_END, pa_src->top + pa_src->height - 1);

	if (rval < 0)

		goto err_pm_put;
@@ -1856,23 +1879,30 @@ static int ccs_enable_streams(struct v4l2_subdev *subdev, 
	/* Digital crop */

	if (CCS_LIM(sensor, DIGITAL_CROP_CAPABILITY)

	    == CCS_DIGITAL_CROP_CAPABILITY_INPUT_CROP) {

		struct v4l2_subdev_state *scaler_state =

			v4l2_subdev_get_locked_active_state(&sensor->scaler->sd);

		const struct v4l2_rect *scaler_sink =

			v4l2_subdev_state_get_crop(scaler_state,

						   sensor->scaler->sink_pad,

						   CCS_STREAM_PIXEL);



		rval = ccs_write(sensor, DIGITAL_CROP_X_OFFSET,

				 sensor->scaler_sink.left);

				 scaler_sink->left);

		if (rval < 0)

			goto err_pm_put;



		rval = ccs_write(sensor, DIGITAL_CROP_Y_OFFSET,

				 sensor->scaler_sink.top);

				 scaler_sink->top);

		if (rval < 0)

			goto err_pm_put;



		rval = ccs_write(sensor, DIGITAL_CROP_IMAGE_WIDTH,

				 sensor->scaler_sink.width);

				 scaler_sink->width);

		if (rval < 0)

			goto err_pm_put;



		rval = ccs_write(sensor, DIGITAL_CROP_IMAGE_HEIGHT,

				 sensor->scaler_sink.height);

				 scaler_sink->height);

		if (rval < 0)

			goto err_pm_put;

	}
@@ -1890,10 +1920,10 @@ static int ccs_enable_streams(struct v4l2_subdev *subdev, 
	}



	/* Output size from sensor */

	rval = ccs_write(sensor, X_OUTPUT_SIZE, sensor->src_src.width);

	rval = ccs_write(sensor, X_OUTPUT_SIZE, src_src->width);

	if (rval < 0)

		goto err_pm_put;

	rval = ccs_write(sensor, Y_OUTPUT_SIZE, sensor->src_src.height);

	rval = ccs_write(sensor, Y_OUTPUT_SIZE, src_src->height);

	if (rval < 0)

		goto err_pm_put;
@@ -2022,20 +2052,17 @@ static int ccs_enum_mbus_code(struct v4l2_subdev *subdev, 
	struct ccs_sensor *sensor = to_ccs_sensor(subdev);

	unsigned int i;

	int idx = -1;

	int rval = -EINVAL;



	mutex_lock(&sensor->mutex);



	dev_err(&client->dev, "subdev %s, pad %u, index %u\n",

		subdev->name, code->pad, code->index);



	if (subdev != &sensor->src->sd || code->pad != CCS_PAD_SRC) {

		if (code->index)

			goto out;

			return -EINVAL;



		code->code = sensor->internal_csi_format->code;

		rval = 0;

		goto out;



		return 0;

	}



	for (i = 0; i < ARRAY_SIZE(ccs_csi_data_formats); i++) {
@@ -2046,18 +2073,14 @@ static int ccs_enum_mbus_code(struct v4l2_subdev *subdev, 
			code->code = ccs_csi_data_formats[i].code;

			dev_err(&client->dev, "found index %u, i %u, code %x\n",

				code->index, i, code->code);

			rval = 0;

			break;

			return 0;

		}

	}



out:

	mutex_unlock(&sensor->mutex);



	return rval;

	return -EINVAL;

}



static u32 __ccs_get_mbus_code(struct v4l2_subdev *subdev, unsigned int pad)

static u32 ccs_get_mbus_code(struct v4l2_subdev *subdev, unsigned int pad)

{

	struct ccs_sensor *sensor = to_ccs_sensor(subdev);
@@ -2067,30 +2090,16 @@ static u32 __ccs_get_mbus_code(struct v4l2_subdev *subdev, unsigned int pad) 
		return sensor->internal_csi_format->code;

}



static int __ccs_get_format(struct v4l2_subdev *subdev,

static int ccs_get_format(struct v4l2_subdev *subdev,

			  struct v4l2_subdev_state *sd_state,

			  struct v4l2_subdev_format *fmt)

{

	fmt->format = *v4l2_subdev_state_get_format(sd_state, fmt->pad);

	fmt->format.code = __ccs_get_mbus_code(subdev, fmt->pad);

	fmt->format.code = ccs_get_mbus_code(subdev, fmt->pad);



	return 0;

}



static int ccs_get_format(struct v4l2_subdev *subdev,

			  struct v4l2_subdev_state *sd_state,

			  struct v4l2_subdev_format *fmt)

{

	struct ccs_sensor *sensor = to_ccs_sensor(subdev);

	int rval;



	mutex_lock(&sensor->mutex);

	rval = __ccs_get_format(subdev, sd_state, fmt);

	mutex_unlock(&sensor->mutex);



	return rval;

}



/* Changes require propagation only on sink pad. */

static void ccs_propagate(struct v4l2_subdev *subdev,

			  struct v4l2_subdev_state *sd_state, int which,
@@ -2114,7 +2123,6 @@ static void ccs_propagate(struct v4l2_subdev *subdev, 
				sensor->scale_m = CCS_LIM(sensor, SCALER_N_MIN);

				sensor->scaling_mode =

					CCS_SCALING_MODE_NO_SCALING;

				sensor->scaler_sink = *comp;

			} else if (ssd == sensor->binner) {

				sensor->binning_horizontal = 1;

				sensor->binning_vertical = 1;
@@ -2129,8 +2137,6 @@ static void ccs_propagate(struct v4l2_subdev *subdev, 
						   CCS_STREAM_PIXEL);

		fmt->width = comp->width;

		fmt->height = comp->height;

		if (which == V4L2_SUBDEV_FORMAT_ACTIVE && ssd == sensor->src)

			sensor->src_src = *crop;

		break;

	default:

		WARN_ON_ONCE(1);
@@ -2149,7 +2155,7 @@ static int ccs_set_format_source(struct v4l2_subdev *subdev, 
	unsigned int i;

	int rval;



	rval = __ccs_get_format(subdev, sd_state, fmt);

	rval = ccs_get_format(subdev, sd_state, fmt);

	if (rval)

		return rval;
@@ -2198,20 +2204,17 @@ static int ccs_set_format(struct v4l2_subdev *subdev, 
	struct ccs_subdev *ssd = to_ccs_subdev(subdev);

	struct v4l2_rect *crop;



	mutex_lock(&sensor->mutex);



	if (fmt->pad == ssd->source_pad) {

		int rval;



		rval = ccs_set_format_source(subdev, sd_state, fmt);



		mutex_unlock(&sensor->mutex);



		return rval;

	}



	/* Sink pad. Width and height are changeable here. */

	fmt->format.code = __ccs_get_mbus_code(subdev, fmt->pad);

	fmt->format.code = ccs_get_mbus_code(subdev, fmt->pad);



	fmt->format.width &= ~1;

	fmt->format.height &= ~1;

	fmt->format.field = V4L2_FIELD_NONE;
@@ -2234,8 +2237,6 @@ static int ccs_set_format(struct v4l2_subdev *subdev, 
	crop->height = fmt->format.height;

	ccs_propagate(subdev, sd_state, fmt->which, V4L2_SEL_TGT_CROP);



	mutex_unlock(&sensor->mutex);



	return 0;

}
@@ -2537,9 +2538,6 @@ static int ccs_set_crop(struct v4l2_subdev *subdev, 


	if (ssd != sensor->pixel_array && sel->pad == CCS_PAD_SINK)

		ccs_propagate(subdev, sd_state, sel->which, V4L2_SEL_TGT_CROP);

	else if (sel->which == V4L2_SUBDEV_FORMAT_ACTIVE &&

		 ssd == sensor->pixel_array)

		sensor->pa_src = sel->r;



	return 0;

}
@@ -2609,8 +2607,6 @@ static int ccs_set_selection(struct v4l2_subdev *subdev, 
	if (ret)

		return ret;



	mutex_lock(&sensor->mutex);



	sel->r.left = max(0, sel->r.left & ~1);

	sel->r.top = max(0, sel->r.top & ~1);

	sel->r.width = CCS_ALIGN_DIM(sel->r.width, sel->flags);
@@ -2632,7 +2628,6 @@ static int ccs_set_selection(struct v4l2_subdev *subdev, 
		ret = -EINVAL;

	}



	mutex_unlock(&sensor->mutex);

	return ret;

}
@@ -3002,6 +2997,7 @@ static int ccs_init_subdev(struct ccs_sensor *sensor, 


	ssd->sd.flags |= V4L2_SUBDEV_FL_HAS_DEVNODE;

	ssd->sd.entity.function = function;

	ssd->sd.state_lock = &sensor->mutex;

	ssd->sensor = sensor;



	ssd->npads = num_pads;
@@ -3059,10 +3055,8 @@ static int ccs_init_state(struct v4l2_subdev *sd, 
	fmt->field = V4L2_FIELD_NONE;



	if (ssd == sensor->pixel_array) {

		if (is_active)

			sensor->pa_src = *crop;



		mutex_unlock(&sensor->mutex);



		return 0;

	}

drivers/media/i2c/ccs/ccs.h

+0 −1
Original line number Diff line number Diff line
@@ -225,7 +225,6 @@ struct ccs_sensor { 
	u32 mbus_frame_fmts;

	const struct ccs_csi_data_format *csi_format;

	const struct ccs_csi_data_format *internal_csi_format;

	struct v4l2_rect pa_src, scaler_sink, src_src;

	u32 default_mbus_frame_fmts;

	int default_pixel_order;

	struct ccs_data_container sdata, mdata;