vimc: Virtual Media Control VPU's

Initialize the test pattern generator on the sensor Generate a colored bar image instead of a grey one

Signed-off-by Helen Fornazier <[email protected]>

---
 drivers/media/platform/vimc/Kconfig       |  1 +
 drivers/media/platform/vimc/vimc-sensor.c | 44 ++++++++++++++++++++++++++--
 2 files changed, 43 insertions(+), 2 deletions(-)

drivers/media/platform/vimc/vimc-sensor.c +0 -0

 #include <media/v4l2-subdev.h>
 
 #include "vimc-sensor.h"

drivers/media/platform/vimc/vimc-sensor.c +13 -0

+	tpg_s_bytesperline(&vsen->tpg, 0,
+			   vsen->mbus_format.width * vpix->bpp);
+	tpg_s_buf_height(&vsen->tpg, vsen->mbus_format.height);
+	tpg_s_fourcc(&vsen->tpg, vpix->pixelformat);
+	/* TODO: check why the tpg_s_field need this third argument if
+	 * it is already receiving the field */
+	tpg_s_field(&vsen->tpg, vsen->mbus_format.field,
+		    vsen->mbus_format.field == V4L2_FIELD_ALTERNATE);
+	tpg_s_colorspace(&vsen->tpg, vsen->mbus_format.colorspace);
+	tpg_s_ycbcr_enc(&vsen->tpg, vsen->mbus_format.ycbcr_enc);
+	tpg_s_quantization(&vsen->tpg, vsen->mbus_format.quantization);
+	tpg_s_xfer_func(&vsen->tpg, vsen->mbus_format.xfer_func);
+}

Initialize the test pattern generator on the sensor Generate a colored bar image instead of a grey one

Signed-off-by Helen Fornazier <[email protected]>

---
 drivers/media/platform/vimc/Kconfig       |  1 +
 drivers/media/platform/vimc/vimc-sensor.c | 44 +++++++++++++++++++++++++++++--
 2 files changed, 43 insertions(+), 2 deletions(-)

drivers/media/platform/vimc/Kconfig +1 -0

index 81279f4..7cf7e84 100644
@@ -1,6 +1,7 @@
 config VIDEO_VIMC
 	tristate "Virtual Media Controller Driver (VIMC)"
 	select VIDEO_V4L2_SUBDEV_API
+	select VIDEO_TPG
 	default n
 	---help---
 	  Skeleton driver for Virtual Media Controller

drivers/media/platform/vimc/vimc-sensor.c +11 -0

index d613792..a2879ad 100644
@@ -16,15 +16,19 @@
  */
 
 #include <linux/freezer.h>
+#include <media/tpg.h>
 #include <linux/vmalloc.h>
 #include <linux/v4l2-mediabus.h>
 #include <media/v4l2-subdev.h>
 
 #include "vimc-sensor.h"
 
+#define VIMC_SEN_FRAME_MAX_WIDTH 4096
+
 struct vimc_sen_device {
 	struct vimc_ent_device ved;
 	struct v4l2_subdev sd;
+	struct tpg_data tpg;
 	struct v4l2_device *v4l2_dev;
 	struct device *dev;
 	struct task_struct *kthread_sen;

@@ -87,6 +91,29 @@ static int vimc_sen_get_fmt(struct v4l2_subdev *sd,
 	return 0;
 }
 
+static void vimc_sen_tpg_s_format(struct vimc_sen_device *vsen)
+{
+	const struct vimc_pix_map *vpix;
+
+	vpix = vimc_pix_map_by_code(vsen->mbus_format.code);
+	/* This should never be NULL, as we won't allow any format other then
+	 * the ones in the vimc_pix_map_list table */

drivers/media/platform/vimc/vimc-sensor.c +18 -2

+	tpg_s_colorspace(&vsen->tpg, vsen->mbus_format.colorspace);
+	tpg_s_ycbcr_enc(&vsen->tpg, vsen->mbus_format.ycbcr_enc);
+	tpg_s_quantization(&vsen->tpg, vsen->mbus_format.quantization);
+	tpg_s_xfer_func(&vsen->tpg, vsen->mbus_format.xfer_func);
+}
+
 static const struct v4l2_subdev_pad_ops vimc_sen_pad_ops = {
 	.enum_mbus_code		= vimc_sen_enum_mbus_code,
 	.enum_frame_size	= vimc_sen_enum_frame_size,

@@ -112,7 +139,7 @@ static int vimc_thread_sen(void *data)
 		if (kthread_should_stop())
 			break;
 
-		memset(vsen->frame, 100, vsen->frame_size);
+		tpg_fill_plane_buffer(&vsen->tpg, V4L2_STD_PAL, 0, vsen->frame);
 
 		/* Send the frame to all source pads */
 		for (i = 0; i < vsen->sd.entity.num_pads; i++)

@@ -192,6 +219,7 @@ static void vimc_sen_destroy(struct vimc_ent_device *ved)
 	struct vimc_sen_device *vsen = container_of(ved,
 						struct vimc_sen_device, ved);
 
+	tpg_free(&vsen->tpg);
 	media_entity_cleanup(ved->ent);
 	v4l2_device_unregister_subdev(&vsen->sd);
 	kfree(vsen);

@@ -242,6 +270,16 @@ struct vimc_ent_device *vimc_sen_create(struct v4l2_device *v4l2_dev,
 	vsen->mbus_format.quantization = V4L2_QUANTIZATION_FULL_RANGE;
 	vsen->mbus_format.xfer_func = V4L2_XFER_FUNC_SRGB;
 
+	/* Initialize the test pattern generator */
+	tpg_init(&vsen->tpg, vsen->mbus_format.width,
+		 vsen->mbus_format.height);
+	ret = tpg_alloc(&vsen->tpg, VIMC_SEN_FRAME_MAX_WIDTH);
+	if (ret)
+		goto err_clean_m_ent;
+
+	/* Configure the tpg */
+	vimc_sen_tpg_s_format(vsen);
+
 	/* Fill the vimc_ent_device struct */
 	vsen->ved.destroy = vimc_sen_destroy;
 	vsen->ved.ent = &vsen->sd.entity;

@@ -261,11 +299,13 @@ struct vimc_ent_device *vimc_sen_create(struct v4l2_device *v4l2_dev,
 	if (ret) {
 		dev_err(vsen->dev,
 			"subdev register failed (err=%d)\n", ret);
-		goto err_clean_m_ent;

Quoted 2 lines · Helen Fornazier

Initialize the test pattern generator on the sensor Generate a colored bar image instead of a grey one

You don't want to put the tpg in every sensor and have all the blocks in between process the video. This is all virtual, so all that is necessary is to put the tpg in every DMA engine (video node) but have the subdevs modify the tpg setting when you start the pipeline.

So the source would set the width/height to the sensor resolution, and it will initialize the crop/compose rectangles. Every other entity in the pipeline will continue modifying according to what they do. E.g. a scaler will just change the compose rectangle.

When you start streaming the tpg will generate the image based on all those settings as if all the entities would actually do the work.

Of course, this assumes the processing the entities do map to what the tpg can do, but that's true for vimc.

An additional advantage is that the entities can use a wide range of mediabus formats since the tpg can generate basically anything. Implementing multiplanar is similarly easy. This would be much harder if you had to write the image processing code for the entities since you'd either have to support lots of different formats (impractical) or limit yourself to just a few.

Quoted 2 lines · Helen Fornazier

Initialize the test pattern generator on the sensor Generate a colored bar image instead of a grey one

You don't want to put the tpg in every sensor and have all the blocks in between process the video. This is all virtual, so all that is necessary is to put the tpg in every DMA engine (video node) but have the subdevs modify the tpg setting when you start the pipeline.

So the source would set the width/height to the sensor resolution, and it will initialize the crop/compose rectangles. Every other entity in the pipeline will continue modifying according to what they do. E.g. a scaler will just change the compose rectangle.

When you start streaming the tpg will generate the image based on all those settings as if all the entities would actually do the work.

Of course, this assumes the processing the entities do map to what the tpg can do, but that's true for vimc.

An additional advantage is that the entities can use a wide range of mediabus formats since the tpg can generate basically anything. Implementing multiplanar is similarly easy. This would be much harder if you had to write the image processing code for the entities since you'd either have to support lots of different formats (impractical) or limit yourself to just a few.

Quoted 54 lines

Signed-off-by Helen Fornazier <[email protected]>

---
 drivers/media/platform/vimc/Kconfig       |  1 +
 drivers/media/platform/vimc/vimc-sensor.c | 44 +++++++++++++++++++++++++++++--
 2 files changed, 43 insertions(+), 2 deletions(-)

drivers/media/platform/vimc/Kconfig +1 -0

index 81279f4..7cf7e84 100644
@@ -1,6 +1,7 @@
 config VIDEO_VIMC
      tristate "Virtual Media Controller Driver (VIMC)"
      select VIDEO_V4L2_SUBDEV_API
+     select VIDEO_TPG
      default n
      ---help---
        Skeleton driver for Virtual Media Controller

drivers/media/platform/vimc/vimc-sensor.c +11 -0

index d613792..a2879ad 100644
@@ -16,15 +16,19 @@
  */
 
 #include <linux/freezer.h>
+#include <media/tpg.h>
 #include <linux/vmalloc.h>
 #include <linux/v4l2-mediabus.h>
 #include <media/v4l2-subdev.h>
 
 #include "vimc-sensor.h"
 
+#define VIMC_SEN_FRAME_MAX_WIDTH 4096
+
 struct vimc_sen_device {
      struct vimc_ent_device ved;
      struct v4l2_subdev sd;
+     struct tpg_data tpg;
      struct v4l2_device *v4l2_dev;
      struct device *dev;
      struct task_struct *kthread_sen;

@@ -87,6 +91,29 @@ static int vimc_sen_get_fmt(struct v4l2_subdev *sd,
      return 0;
 }
 
+static void vimc_sen_tpg_s_format(struct vimc_sen_device *vsen)
+{
+     const struct vimc_pix_map *vpix;
+
+     vpix = vimc_pix_map_by_code(vsen->mbus_format.code);
+     /* This should never be NULL, as we won't allow any format other then
+      * the ones in the vimc_pix_map_list table */

drivers/media/platform/vimc/vimc-sensor.c static int vimc_sen_get_fmt(struct v4l2_subdev *sd, · line 110

Quoted 10 lines

drivers/media/platform/vimc/vimc-sensor.c +10 -0

+     BUG_ON(!vpix);
+
+     tpg_s_bytesperline(&vsen->tpg, 0,
+                        vsen->mbus_format.width * vpix->bpp);
+     tpg_s_buf_height(&vsen->tpg, vsen->mbus_format.height);
+     tpg_s_fourcc(&vsen->tpg, vpix->pixelformat);
+     /* TODO: check why the tpg_s_field need this third argument if
+      * it is already receiving the field */
+     tpg_s_field(&vsen->tpg, vsen->mbus_format.field,
+                 vsen->mbus_format.field == V4L2_FIELD_ALTERNATE);

Actually the second argument argument cannot be FIELD_ALTERNATE. If it is field ALTERNATE, then the second argument must be either FIELD_TOP or
FIELD_BOTTOM: i.e. it tells the generator which field comes first in the FIELD_ALTERNATE case.

And in case you are wondering: it's always FIELD_TOP except for 60 Hz SDTV formats where it is FIELD_BOTTOM.

Quoted 50 lines

drivers/media/platform/vimc/vimc-sensor.c +18 -2

+     tpg_s_colorspace(&vsen->tpg, vsen->mbus_format.colorspace);
+     tpg_s_ycbcr_enc(&vsen->tpg, vsen->mbus_format.ycbcr_enc);
+     tpg_s_quantization(&vsen->tpg, vsen->mbus_format.quantization);
+     tpg_s_xfer_func(&vsen->tpg, vsen->mbus_format.xfer_func);
+}
+
 static const struct v4l2_subdev_pad_ops vimc_sen_pad_ops = {
      .enum_mbus_code         = vimc_sen_enum_mbus_code,
      .enum_frame_size        = vimc_sen_enum_frame_size,

@@ -112,7 +139,7 @@ static int vimc_thread_sen(void *data)
              if (kthread_should_stop())
                      break;
 
-             memset(vsen->frame, 100, vsen->frame_size);
+             tpg_fill_plane_buffer(&vsen->tpg, V4L2_STD_PAL, 0, vsen->frame);
 
              /* Send the frame to all source pads */
              for (i = 0; i < vsen->sd.entity.num_pads; i++)

@@ -192,6 +219,7 @@ static void vimc_sen_destroy(struct vimc_ent_device *ved)
      struct vimc_sen_device *vsen = container_of(ved,
                                              struct vimc_sen_device, ved);
 
+     tpg_free(&vsen->tpg);
      media_entity_cleanup(ved->ent);
      v4l2_device_unregister_subdev(&vsen->sd);
      kfree(vsen);

@@ -242,6 +270,16 @@ struct vimc_ent_device *vimc_sen_create(struct v4l2_device *v4l2_dev,
      vsen->mbus_format.quantization = V4L2_QUANTIZATION_FULL_RANGE;
      vsen->mbus_format.xfer_func = V4L2_XFER_FUNC_SRGB;
 
+     /* Initialize the test pattern generator */
+     tpg_init(&vsen->tpg, vsen->mbus_format.width,
+              vsen->mbus_format.height);
+     ret = tpg_alloc(&vsen->tpg, VIMC_SEN_FRAME_MAX_WIDTH);
+     if (ret)
+             goto err_clean_m_ent;
+
+     /* Configure the tpg */
+     vimc_sen_tpg_s_format(vsen);
+
      /* Fill the vimc_ent_device struct */
      vsen->ved.destroy = vimc_sen_destroy;
      vsen->ved.ent = &vsen->sd.entity;

@@ -261,11 +299,13 @@ struct vimc_ent_device *vimc_sen_create(struct v4l2_device *v4l2_dev,
      if (ret) {
              dev_err(vsen->dev,
                      "subdev register failed (err=%d)\n", ret);
-             goto err_clean_m_ent;

drivers/media/platform/vimc/vimc-sensor.c struct vimc_ent_device *vimc_sen_create(struct v4l2_device *v4l2_dev, · line 311

Quoted 10 lines

drivers/media/platform/vimc/vimc-sensor.c +3 -0

+             goto err_free_tpg;
      }
 
      return &vsen->ved;
 
+err_free_tpg:
+     tpg_free(&vsen->tpg);
 err_clean_m_ent:
      media_entity_cleanup(&vsen->sd.entity);
 err_clean_pads:

Regards,

Hans

As all the subdevices in the topology will be initialized in the same way, to avoid code repetition the vimc_ent_sd_init/cleanup helper functions were created

Signed-off-by Helen Fornazier <[email protected]>

---
 drivers/media/platform/vimc/vimc-core.c   |  76 ++++++++++++++++++++++
 drivers/media/platform/vimc/vimc-core.h   |  17 +++++
 drivers/media/platform/vimc/vimc-sensor.c | 104  ++++++++------------------
 3 files changed, 123 insertions(+), 74 deletions(-)

(quoted diff) +0 -0

b/drivers/media/platform/vimc/vimc-core.c index 3ef9b51..96d53fd 100644

drivers/media/platform/vimc/vimc-core.c +0 -0

@@ -332,6 +332,82 @@ struct media_pad *vimc_pads_init(u16 num_pads, const
 unsigned long *pads_flag) return pads;
 }

drivers/media/platform/vimc/vimc-core.c +9 -0

+	kfree(vsd);
+}
+
+struct vimc_ent_subdevice *vimc_ent_sd_init(size_t struct_size,
+				struct v4l2_device *v4l2_dev,
+				const char *const name,
+				u16 num_pads,
+				const unsigned long *pads_flag,
+				const struct v4l2_subdev_ops *sd_ops,

drivers/media/platform/vimc/vimc-core.c +48 -0

+	if (!vsd)
+		return ERR_PTR(-ENOMEM);
+
+	/* Link the vimc_deb_device struct with the v4l2 parent */
+	vsd->v4l2_dev = v4l2_dev;
+	/* Link the vimc_deb_device struct with the dev parent */
+	vsd->dev = v4l2_dev->dev;
+
+	/* Allocate the pads */
+	vsd->ved.pads = vimc_pads_init(num_pads, pads_flag);
+	if (IS_ERR(vsd->ved.pads)) {
+		ret = PTR_ERR(vsd->ved.pads);
+		goto err_free_vsd;
+	}
+
+	/* Initialize the media entity */
+	vsd->sd.entity.name = name;
+	vsd->sd.entity.type = MEDIA_ENT_T_V4L2_SUBDEV;
+	ret = media_entity_init(&vsd->sd.entity, num_pads,
+				vsd->ved.pads, num_pads);
+	if (ret)
+		goto err_clean_pads;
+
+	/* Fill the vimc_ent_device struct */
+	vsd->ved.destroy = sd_destroy;
+	vsd->ved.ent = &vsd->sd.entity;
+
+	/* Initialize the subdev */
+	v4l2_subdev_init(&vsd->sd, sd_ops);
+	vsd->sd.entity.ops = &vimc_ent_sd_mops;
+	vsd->sd.owner = THIS_MODULE;
+	strlcpy(vsd->sd.name, name, sizeof(vsd->sd.name));
+	v4l2_set_subdevdata(&vsd->sd, vsd);
+
+	/* Expose this subdev to user space */
+	vsd->sd.flags = V4L2_SUBDEV_FL_HAS_DEVNODE;
+
+	/* return the created vimc subdevice*/
+	return vsd;
+
+err_clean_pads:
+	vimc_pads_cleanup(vsd->ved.pads);
+err_free_vsd:
+	kfree(vsd);
+
+	return ERR_PTR(ret);
+}
+
 /* TODO: remove this function when all the
  * entities specific code are implemented */
 static void vimc_raw_destroy(struct vimc_ent_device *ved)

(quoted diff) +0 -0

b/drivers/media/platform/vimc/vimc-core.h index be05469..295a554 100644

drivers/media/platform/vimc/vimc-core.h +12 -0

+};
+
 int vimc_propagate_frame(struct device *dev,
 			 struct media_pad *src, const void *frame);
 

@@ -48,6 +55,16 @@ static inline void vimc_pads_cleanup(struct media_pad
 *pads) kfree(pads);
 }
 
+/* Helper function to initialize/cleanup a subdevice used */
+struct vimc_ent_subdevice *vimc_ent_sd_init(size_t struct_size,
+				struct v4l2_device *v4l2_dev,
+				const char *const name,
+				u16 num_pads,
+				const unsigned long *pads_flag,
+				const struct v4l2_subdev_ops *sd_ops,
+				void (*sd_destroy)(struct vimc_ent_device *));
+void vimc_ent_sd_cleanup(struct vimc_ent_subdevice *vsd);
+
 const struct vimc_pix_map *vimc_pix_map_by_code(u32 code);
 
 const struct vimc_pix_map *vimc_pix_map_by_pixelformat(u32 pixelformat);

(quoted diff) +0 -0

b/drivers/media/platform/vimc/vimc-sensor.c index a2879ad..319bebb 100644

drivers/media/platform/vimc/vimc-sensor.c +14 -19

@@ -26,11 +26,8 @@
 #define VIMC_SEN_FRAME_MAX_WIDTH 4096
 
 struct vimc_sen_device {
-	struct vimc_ent_device ved;
-	struct v4l2_subdev sd;
+	struct vimc_ent_subdevice vsd;
 	struct tpg_data tpg;
-	struct v4l2_device *v4l2_dev;
-	struct device *dev;
 	struct task_struct *kthread_sen;
 	u8 *frame;
 	/* The active format */

@@ -45,7 +42,7 @@ static int vimc_sen_enum_mbus_code(struct v4l2_subdev *sd,
 struct vimc_sen_device *vsen = v4l2_get_subdevdata(sd);
 
 	/* Check if it is a valid pad */
-	if (code->pad >= vsen->sd.entity.num_pads)
+	if (code->pad >= vsen->vsd.sd.entity.num_pads)
 		return -EINVAL;
 
 	code->code = vsen->mbus_format.code;

@@ -60,8 +57,8 @@ static int vimc_sen_enum_frame_size(struct v4l2_subdev
 *sd, struct vimc_sen_device *vsen = v4l2_get_subdevdata(sd);
 
 	/* Check if it is a valid pad */
-	if (fse->pad >= vsen->sd.entity.num_pads ||
-	    !(vsen->sd.entity.pads[fse->pad].flags & MEDIA_PAD_FL_SOURCE))
+	if (fse->pad >= vsen->vsd.sd.entity.num_pads ||
+	    !(vsen->vsd.sd.entity.pads[fse->pad].flags & MEDIA_PAD_FL_SOURCE))
 		return -EINVAL;
 
 	/* TODO: Add support to other formats */

@@ -122,11 +119,6 @@ static const struct v4l2_subdev_pad_ops
 vimc_sen_pad_ops = { .set_fmt		= vimc_sen_get_fmt,
 };
 
-/* media operations */
-static const struct media_entity_operations vimc_sen_mops = {
-	.link_validate = v4l2_subdev_link_validate,
-};
-
 static int vimc_thread_sen(void *data)
 {
 	unsigned int i;

@@ -142,11 +134,13 @@ static int vimc_thread_sen(void *data)
 		tpg_fill_plane_buffer(&vsen->tpg, V4L2_STD_PAL, 0, vsen->frame);
 
 		/* Send the frame to all source pads */
-		for (i = 0; i < vsen->sd.entity.num_pads; i++)
-			if (vsen->sd.entity.pads[i].flags & MEDIA_PAD_FL_SOURCE)
-				vimc_propagate_frame(vsen->dev,
-						     &vsen->sd.entity.pads[i],
-						     vsen->frame);
+		for (i = 0; i < vsen->vsd.sd.entity.num_pads; i++) {
+			struct media_pad *pad = &vsen->vsd.sd.entity.pads[i];
+
+			if (pad->flags & MEDIA_PAD_FL_SOURCE)
+				vimc_propagate_frame(vsen->vsd.dev,
+						     pad, vsen->frame);
+		}
 
 		/* Wait one second */
 		schedule_timeout_interruptible(HZ);

@@ -182,9 +176,10 @@ static int vimc_sen_s_stream(struct v4l2_subdev *sd,
 int enable)
 
 		/* Initialize the image generator thread */
 		vsen->kthread_sen = kthread_run(vimc_thread_sen, vsen,
-						"%s-sen", vsen->v4l2_dev->name);
+					"%s-sen", vsen->vsd.v4l2_dev->name);
 		if (IS_ERR(vsen->kthread_sen)) {
-			v4l2_err(vsen->v4l2_dev, "kernel_thread() failed\n");
+			v4l2_err(vsen->vsd.v4l2_dev,
+				 "kernel_thread() failed\n");
 			vfree(vsen->frame);
 			vsen->frame = NULL;

drivers/media/platform/vimc/vimc-sensor.c +16 -55

 			return PTR_ERR(vsen->kthread_sen);

@@ -216,13 +211,11 @@ static const struct v4l2_subdev_ops vimc_sen_ops = {
 
 static void vimc_sen_destroy(struct vimc_ent_device *ved)
 {
-	struct vimc_sen_device *vsen = container_of(ved,
-						struct vimc_sen_device, ved);
+	struct vimc_sen_device *vsen = container_of(ved, struct vimc_sen_device,
+						    vsd.ved);
 
 	tpg_free(&vsen->tpg);
-	media_entity_cleanup(ved->ent);
-	v4l2_device_unregister_subdev(&vsen->sd);
-	kfree(vsen);
+	vimc_ent_sd_cleanup(&vsen->vsd);
 }
 
 struct vimc_ent_device *vimc_sen_create(struct v4l2_device *v4l2_dev,

@@ -232,34 +225,15 @@ struct vimc_ent_device *vimc_sen_create(struct
 v4l2_device *v4l2_dev, {
 	int ret;
 	struct vimc_sen_device *vsen;
+	struct vimc_ent_subdevice *vsd;
 
-	if (!v4l2_dev || !v4l2_dev->dev || !name || (num_pads && !pads_flag))
-		return ERR_PTR(-EINVAL);
-
-	/* Allocate the vsen struct */
-	vsen = kzalloc(sizeof(*vsen), GFP_KERNEL);
-	if (!vsen)
-		return ERR_PTR(-ENOMEM);
-
-	/* Link the vimc_sen_device struct with the v4l2 parent */
-	vsen->v4l2_dev = v4l2_dev;
-	/* Link the vimc_sen_device struct with the dev parent */
-	vsen->dev = v4l2_dev->dev;
+	vsd = vimc_ent_sd_init(sizeof(struct vimc_sen_device),
+			       v4l2_dev, name, num_pads, pads_flag,
+			       &vimc_sen_ops, vimc_sen_destroy);
+	if (IS_ERR(vsd))
+		return (struct vimc_ent_device *)vsd;
 
-	/* Allocate the pads */
-	vsen->ved.pads = vimc_pads_init(num_pads, pads_flag);
-	if (IS_ERR(vsen->ved.pads)) {
-		ret = PTR_ERR(vsen->ved.pads);
-		goto err_free_vsen;
-	}
-
-	/* Initialize the media entity */
-	vsen->sd.entity.name = name;
-	vsen->sd.entity.type = MEDIA_ENT_T_V4L2_SUBDEV;
-	ret = media_entity_init(&vsen->sd.entity, num_pads,
-				vsen->ved.pads, num_pads);
-	if (ret)
-		goto err_clean_pads;
+	vsen = container_of(vsd, struct vimc_sen_device, vsd);
 
 	/* Set the active frame format (this is hardcoded for now) */
 	vsen->mbus_format.width = 640;

@@ -275,43 +249,25 @@ struct vimc_ent_device *vimc_sen_create(struct
 v4l2_device *v4l2_dev, vsen->mbus_format.height);
 	ret = tpg_alloc(&vsen->tpg, VIMC_SEN_FRAME_MAX_WIDTH);
 	if (ret)
-		goto err_clean_m_ent;
+		goto err_clean_vsd;
 
 	/* Configure the tpg */
 	vimc_sen_tpg_s_format(vsen);
 
-	/* Fill the vimc_ent_device struct */
-	vsen->ved.destroy = vimc_sen_destroy;
-	vsen->ved.ent = &vsen->sd.entity;
-
-	/* Initialize the subdev */
-	v4l2_subdev_init(&vsen->sd, &vimc_sen_ops);
-	vsen->sd.entity.ops = &vimc_sen_mops;
-	vsen->sd.owner = THIS_MODULE;
-	strlcpy(vsen->sd.name, name, sizeof(vsen->sd.name));
-	v4l2_set_subdevdata(&vsen->sd, vsen);
-
-	/* Expose this subdev to user space */
-	vsen->sd.flags = V4L2_SUBDEV_FL_HAS_DEVNODE;
-
 	/* Register the subdev with the v4l2 and the media framework */
-	ret = v4l2_device_register_subdev(vsen->v4l2_dev, &vsen->sd);
+	ret = v4l2_device_register_subdev(vsen->vsd.v4l2_dev, &vsen->vsd.sd);
 	if (ret) {
-		dev_err(vsen->dev,
+		dev_err(vsen->vsd.dev,
 			"subdev register failed (err=%d)\n", ret);
 		goto err_free_tpg;
 	}
 
-	return &vsen->ved;
+	return &vsen->vsd.ved;
 
 err_free_tpg:
 	tpg_free(&vsen->tpg);
-err_clean_m_ent:
-	media_entity_cleanup(&vsen->sd.entity);
-err_clean_pads:
-	vimc_pads_cleanup(vsen->ved.pads);
-err_free_vsen:
-	kfree(vsen);
+err_clean_vsd:
+	vimc_ent_sd_cleanup(vsd);
 
 	return ERR_PTR(ret);
 }

Move the vimc_cap_pipeline_s_stream from the vimc-cap.c to vimc-core.c as this core will be reused by other subdevices to activate the stream in their directly connected nodes

Signed-off-by Helen Fornazier <[email protected]>

---
 drivers/media/platform/vimc/vimc-capture.c | 32  ++------------------------
 drivers/media/platform/vimc/vimc-core.c    | 27 +++++++++++++++++++++++++
 drivers/media/platform/vimc/vimc-core.h    |  4 ++++
 3 files changed, 33 insertions(+), 30 deletions(-)

(quoted diff) +0 -0

b/drivers/media/platform/vimc/vimc-capture.c index 161ddc9..7d21966 100644

drivers/media/platform/vimc/vimc-capture.c +0 -28

@@ -163,34 +163,6 @@ static void vimc_cap_return_all_buffers(struct
 vimc_cap_device *vcap, spin_unlock(&vcap->qlock);
 }
 
-static int vimc_cap_pipeline_s_stream(struct vimc_cap_device *vcap, int
 enable)
-{
-	int ret;
-	struct media_pad *pad;
-	struct media_entity *entity;
-	struct v4l2_subdev *sd;
-
-	/* Start the stream in the subdevice direct connected */
-	entity = &vcap->vdev.entity;
-	pad = media_entity_remote_pad(&entity->pads[0]);
-
-	/* If we are not connected to any subdev node, it means there is nothing
-	 * to activate on the pipe (e.g. we can be connected with an input
-	 * device or we are not connected at all)*/
-	if (pad == NULL ||
-	    media_entity_type(pad->entity) != MEDIA_ENT_T_V4L2_SUBDEV)
-		return 0;
-
-	entity = pad->entity;
-	sd = media_entity_to_v4l2_subdev(entity);
-
-	ret = v4l2_subdev_call(sd, video, s_stream, enable);
-	if (ret && ret != -ENOIOCTLCMD)
-		return ret;
-
-	return 0;
-}
-
 static int vimc_cap_start_streaming(struct vb2_queue *vq, unsigned int
 count) {

drivers/media/platform/vimc/vimc-capture.c +2 -2

 	struct vimc_cap_device *vcap = vb2_get_drv_priv(vq);

@@ -208,7 +180,7 @@ static int vimc_cap_start_streaming(struct vb2_queue
 *vq, unsigned int count) }
 
 	/* Enable streaming from the pipe */
-	ret = vimc_cap_pipeline_s_stream(vcap, 1);
+	ret = vimc_pipeline_s_stream(&vcap->vdev.entity, 1);
 	if (ret) {
 		vimc_cap_return_all_buffers(vcap, VB2_BUF_STATE_QUEUED);
 		return ret;

@@ -226,7 +198,7 @@ static void vimc_cap_stop_streaming(struct vb2_queue
 *vq) struct vimc_cap_device *vcap = vb2_get_drv_priv(vq);
 
 	/* Disable streaming from the pipe */
-	vimc_cap_pipeline_s_stream(vcap, 0);
+	vimc_pipeline_s_stream(&vcap->vdev.entity, 0);
 
 	/* Stop the media pipeline */
 	media_entity_pipeline_stop(&vcap->vdev.entity);

(quoted diff) +0 -0

b/drivers/media/platform/vimc/vimc-core.c index 96d53fd..a824b31 100644

drivers/media/platform/vimc/vimc-core.c +3 -0

@@ -312,6 +312,33 @@ static void vimc_device_unregister(struct vimc_device
 *vimc) }
 }
 
+int vimc_pipeline_s_stream(struct media_entity *entity, int enable)
+{
+	int ret;

drivers/media/platform/vimc/vimc-core.c +14 -0

+	if (pad == NULL ||
+	    media_entity_type(pad->entity) != MEDIA_ENT_T_V4L2_SUBDEV)
+		return 0;
+
+	entity = pad->entity;
+	sd = media_entity_to_v4l2_subdev(entity);
+
+	ret = v4l2_subdev_call(sd, video, s_stream, enable);
+	if (ret && ret != -ENOIOCTLCMD)
+		return ret;
+
+	return 0;
+}
+
 /* Helper function to allocate and initialize pads */
 struct media_pad *vimc_pads_init(u16 num_pads, const unsigned long
 *pads_flag) {

(quoted diff) +0 -0

b/drivers/media/platform/vimc/vimc-core.h index 295a554..38d4855 100644

drivers/media/platform/vimc/vimc-core.h +2 -0

+int vimc_pipeline_s_stream(struct media_entity *entity, int enable);
+
 const struct vimc_pix_map *vimc_pix_map_by_code(u32 code);
 
 const struct vimc_pix_map *vimc_pix_map_by_pixelformat(u32 pixelformat);

Implement the debayer filter and integrate it with the core

Signed-off-by Helen Fornazier <[email protected]>

---
 drivers/media/platform/vimc/Makefile       |   2 +-
 drivers/media/platform/vimc/vimc-core.c    |   6 +-
 drivers/media/platform/vimc/vimc-core.h    |   2 +
 drivers/media/platform/vimc/vimc-debayer.c | 471 ++++++++++++++++++++++++++
 drivers/media/platform/vimc/vimc-debayer.h |  28 ++
 5 files changed, 507 insertions(+), 2 deletions(-)
 create mode 100644 drivers/media/platform/vimc/vimc-debayer.c
 create mode 100644 drivers/media/platform/vimc/vimc-debayer.h

(quoted diff) +0 -0

b/drivers/media/platform/vimc/Makefile index c45195e..a6708f9 100644

drivers/media/platform/vimc/Makefile +1 -1

@@ -1,3 +1,3 @@
-vimc-objs := vimc-core.o vimc-capture.o vimc-sensor.o
+vimc-objs := vimc-core.o vimc-capture.o vimc-debayer.o vimc-sensor.o
 
 obj-$(CONFIG_VIDEO_VIMC) += vimc.o

(quoted diff) +0 -0

b/drivers/media/platform/vimc/vimc-core.c index a824b31..373ea9c 100644

drivers/media/platform/vimc/vimc-core.c +5 -1

@@ -24,6 +24,7 @@
 
 #include "vimc-capture.h"
 #include "vimc-core.h"
+#include "vimc-debayer.h"
 #include "vimc-sensor.h"
 
 #define VIMC_PDEV_NAME "vimc"

@@ -552,9 +553,12 @@ static int vimc_device_register(struct vimc_device
 *vimc) create_func = vimc_cap_create;
 			break;
 
+		case VIMC_ENT_NODE_DEBAYER:
+			create_func = vimc_deb_create;
+			break;
+
 		/* TODO: Instantiate the specific topology node */
 		case VIMC_ENT_NODE_INPUT:
-		case VIMC_ENT_NODE_DEBAYER:
 		case VIMC_ENT_NODE_SCALER:
 		default:
 			/* TODO: remove this when all the entities specific

(quoted diff) +0 -0

b/drivers/media/platform/vimc/vimc-core.h index 38d4855..892341a 100644

drivers/media/platform/vimc/vimc-core.h +2 -0

@@ -20,6 +20,8 @@
 
 #include <media/v4l2-device.h>
 
+#define VIMC_FRAME_INDEX(lin, col, width, bpp) ((lin * width + col) * bpp)
+
 /* Struct which matches the MEDIA_BUS_FMT_ codes with the corresponding
  * V4L2_PIX_FMT_ fourcc pixelformat and its bytes per pixel (bpp) */
 struct vimc_pix_map {

(quoted diff) +0 -0

b/drivers/media/platform/vimc/vimc-debayer.c new file mode 100644 index 0000000..470b336

drivers/media/platform/vimc/vimc-debayer.c new file +15 -0

@@ -0,0 +1,471 @@
+/*
+ * vimc-debayer.c Virtual Media Controller Driver
+ *
+ * Copyright (C) 2015 Helen Fornazier <[email protected]>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that 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.
+ *

drivers/media/platform/vimc/vimc-debayer.c new file +1 -0

+ * NOTE: the window size need to be an odd number, as the main pixel stays

in
+ * the center of it, otherwise the next odd number is considered */

drivers/media/platform/vimc/vimc-debayer.c new file +9 -0

+#define VIMC_DEB_MEAN_WINDOW_SIZE 3
+
+enum vimc_deb_rgb_colors {
+	VIMC_DEB_RED = 0,
+	VIMC_DEB_GREEN = 1,
+	VIMC_DEB_BLUE = 2,
+};
+
+struct vimc_deb_pix_map {

drivers/media/platform/vimc/vimc-debayer.c new file +5 -0

+	void (*set_rgb_src)(struct vimc_deb_device *vdeb, unsigned int lin,
+			    unsigned int col, unsigned int rgb[3]);
+	/* Values calculated when the stream starts */
+	u8 *src_frame;
+	unsigned int src_frame_size;

drivers/media/platform/vimc/vimc-debayer.c new file +77 -0

+	},
+	{
+		.code = MEDIA_BUS_FMT_SGBRG8_1X8,
+		.order = { {VIMC_DEB_GREEN, VIMC_DEB_BLUE},
+			   {VIMC_DEB_RED, VIMC_DEB_GREEN} }
+	},
+	{
+		.code = MEDIA_BUS_FMT_SGRBG8_1X8,
+		.order = { {VIMC_DEB_GREEN, VIMC_DEB_RED},
+			   {VIMC_DEB_BLUE, VIMC_DEB_GREEN} }
+	},
+	{
+		.code = MEDIA_BUS_FMT_SRGGB8_1X8,
+		.order = { {VIMC_DEB_RED, VIMC_DEB_GREEN},
+			   {VIMC_DEB_GREEN, VIMC_DEB_BLUE} }
+	},
+	{
+		.code = MEDIA_BUS_FMT_SBGGR10_1X10,
+		.order = { {VIMC_DEB_BLUE, VIMC_DEB_GREEN},
+			   {VIMC_DEB_GREEN, VIMC_DEB_RED} }
+	},
+	{
+		.code = MEDIA_BUS_FMT_SGBRG10_1X10,
+		.order = { {VIMC_DEB_GREEN, VIMC_DEB_BLUE},
+			   {VIMC_DEB_RED, VIMC_DEB_GREEN} }
+	},
+	{
+		.code = MEDIA_BUS_FMT_SGRBG10_1X10,
+		.order = { {VIMC_DEB_GREEN, VIMC_DEB_RED},
+			   {VIMC_DEB_BLUE, VIMC_DEB_GREEN} }
+	},
+	{
+		.code = MEDIA_BUS_FMT_SRGGB10_1X10,
+		.order = { {VIMC_DEB_RED, VIMC_DEB_GREEN},
+			   {VIMC_DEB_GREEN, VIMC_DEB_BLUE} }
+	},
+	{
+		.code = MEDIA_BUS_FMT_SBGGR12_1X12,
+		.order = { {VIMC_DEB_BLUE, VIMC_DEB_GREEN},
+			   {VIMC_DEB_GREEN, VIMC_DEB_RED} }
+	},
+	{
+		.code = MEDIA_BUS_FMT_SGBRG12_1X12,
+		.order = { {VIMC_DEB_GREEN, VIMC_DEB_BLUE},
+			   {VIMC_DEB_RED, VIMC_DEB_GREEN} }
+	},
+	{
+		.code = MEDIA_BUS_FMT_SGRBG12_1X12,
+		.order = { {VIMC_DEB_GREEN, VIMC_DEB_RED},
+			   {VIMC_DEB_BLUE, VIMC_DEB_GREEN} }
+	},
+	{
+		.code = MEDIA_BUS_FMT_SRGGB12_1X12,
+		.order = { {VIMC_DEB_RED, VIMC_DEB_GREEN},
+			   {VIMC_DEB_GREEN, VIMC_DEB_BLUE} }
+	},
+};
+
+static const struct vimc_deb_pix_map *vimc_deb_pix_map_by_code(u32 code)
+{
+	unsigned int i;
+
+	for (i = 0; i < ARRAY_SIZE(vimc_deb_pix_map_list); i++)
+		if (vimc_deb_pix_map_list[i].code == code)
+			return &vimc_deb_pix_map_list[i];
+
+	return NULL;
+}
+
+static int vimc_deb_enum_mbus_code(struct v4l2_subdev *sd,
+				   struct v4l2_subdev_pad_config *cfg,
+				   struct v4l2_subdev_mbus_code_enum *code)
+{
+	struct vimc_deb_device *vdeb = v4l2_get_subdevdata(sd);
+	struct media_pad *pad;
+
+	/* Check if it is a valid pad */

drivers/media/platform/vimc/vimc-debayer.c new file +64 -0

+	return 0;
+}
+
+static int vimc_deb_enum_frame_size(struct v4l2_subdev *sd,
+				    struct v4l2_subdev_pad_config *cfg,
+				    struct v4l2_subdev_frame_size_enum *fse)
+{
+	struct vimc_deb_device *vdeb = v4l2_get_subdevdata(sd);
+	struct media_pad *pad;
+
+	/* Check if it is a valid pad */
+	if (fse->pad >= vdeb->vsd.sd.entity.num_pads)
+		return -EINVAL;
+
+	/* TODO: Add support to other formats sizes */
+
+	pad = &vdeb->vsd.sd.entity.pads[fse->pad];
+	if ((pad->flags & MEDIA_PAD_FL_SOURCE)) {
+		fse->min_width = vdeb->src_mbus_fmt.width;
+		fse->max_width = vdeb->src_mbus_fmt.width;
+		fse->min_height = vdeb->src_mbus_fmt.height;
+		fse->max_height = vdeb->src_mbus_fmt.height;
+	} else if ((pad->flags & MEDIA_PAD_FL_SINK)) {
+		fse->min_width = vdeb->sink_mbus_fmt.width;
+		fse->max_width = vdeb->sink_mbus_fmt.width;
+		fse->min_height = vdeb->sink_mbus_fmt.height;
+		fse->max_height = vdeb->sink_mbus_fmt.height;
+	} else
+		return -EINVAL;
+
+	return 0;
+}
+
+static int vimc_deb_get_fmt(struct v4l2_subdev *sd,
+			    struct v4l2_subdev_pad_config *cfg,
+			    struct v4l2_subdev_format *format)
+{
+	struct vimc_deb_device *vdeb = v4l2_get_subdevdata(sd);
+	struct media_pad *pad;
+
+	/* Check if it is a valid pad */
+	if (format->pad >= vdeb->vsd.sd.entity.num_pads)
+		return -EINVAL;
+
+	pad = &vdeb->vsd.sd.entity.pads[format->pad];
+	if ((pad->flags & MEDIA_PAD_FL_SOURCE))
+		format->format = vdeb->src_mbus_fmt;
+	else if ((pad->flags & MEDIA_PAD_FL_SINK))
+		format->format = vdeb->sink_mbus_fmt;
+	else
+		return -EINVAL;
+
+	return 0;
+}
+
+static const struct v4l2_subdev_pad_ops vimc_deb_pad_ops = {
+	.enum_mbus_code		= vimc_deb_enum_mbus_code,
+	.enum_frame_size	= vimc_deb_enum_frame_size,
+	.get_fmt		= vimc_deb_get_fmt,
+	/* TODO: Add support to other formats */
+	.set_fmt		= vimc_deb_get_fmt,
+};
+
+static void vimc_deb_set_rgb_mbus_fmt_rgb888_1x24(struct vimc_deb_device

*vdeb,

drivers/media/platform/vimc/vimc-debayer.c new file +16 -0

+						  unsigned int lin,
+						  unsigned int col,
+						  unsigned int rgb[3])
+{
+	unsigned int i, index;
+
+	index = VIMC_FRAME_INDEX(lin, col, vdeb->src_mbus_fmt.width, 3);
+	for (i = 0; i < 3; i++)
+		vdeb->src_frame[index + i] = rgb[i];
+}
+
+static int vimc_deb_s_stream(struct v4l2_subdev *sd, int enable)
+{
+	struct vimc_deb_device *vdeb = v4l2_get_subdevdata(sd);
+
+	if (enable) {

drivers/media/platform/vimc/vimc-debayer.c new file +103 -0

+		vdeb->src_frame_size = vdeb->src_mbus_fmt.width *
+				       vpix->bpp * vdeb->src_mbus_fmt.height;
+
+		/* Save the bytes per pixel of the sink */
+		vpix = vimc_pix_map_by_code(vdeb->sink_mbus_fmt.code);
+		/* This should never be NULL, as we won't allow any format
+		 * other then the ones in the vimc_pix_map_list table */
+		BUG_ON(!vpix);
+		vdeb->sink_bpp = vpix->bpp;
+
+		/* Get the corresponding pixel map from the table */
+		vdeb->sink_pix_map = vimc_deb_pix_map_by_code(
+						vdeb->sink_mbus_fmt.code);
+		/* This should never be NULL, as we won't allow any format
+		 * in sink pad other then the ones in the
+		 * vimc_deb_pix_map_list table */
+		BUG_ON(!vdeb->sink_pix_map);
+
+		/* Allocate the frame buffer. Use vmalloc to be able to
+		 * allocate a large amount of memory*/
+		vdeb->src_frame = vmalloc(vdeb->src_frame_size);
+		if (!vdeb->src_frame)
+			return -ENOMEM;
+
+		/* Turn the stream on in the subdevices directly connected */
+		if (vimc_pipeline_s_stream(&vdeb->vsd.sd.entity, 1)) {
+			vfree(vdeb->src_frame);
+			vdeb->src_frame = NULL;
+			return -EINVAL;
+		}
+
+	} else {
+		if (!vdeb->src_frame)
+			return -EINVAL;
+		vfree(vdeb->src_frame);
+		vdeb->src_frame = NULL;
+		vimc_pipeline_s_stream(&vdeb->vsd.sd.entity, 0);
+	}
+
+	return 0;
+}
+
+struct v4l2_subdev_video_ops vimc_deb_video_ops = {
+	.s_stream = vimc_deb_s_stream,
+};
+
+static const struct v4l2_subdev_ops vimc_deb_ops = {
+	.pad = &vimc_deb_pad_ops,
+	.video = &vimc_deb_video_ops,
+};
+
+static unsigned int vimc_deb_get_val(const u8 *bytes,
+				     const unsigned int n_bytes)
+{
+	unsigned int i;
+	unsigned int acc = 0;
+
+	for (i = 0; i < n_bytes; i++)
+		acc = acc + (bytes[i] << (8 * i));
+
+	return acc;
+}
+
+static void vimc_deb_calc_rgb_sink(struct vimc_deb_device *vdeb,
+				   const u8 *frame,
+				   const unsigned int lin,
+				   const unsigned int col,
+				   unsigned int rgb[3])
+{
+	unsigned int i, seek, wlin, wcol;
+	unsigned int n_rgb[3] = {0, 0, 0};
+
+	for (i = 0; i < 3; i++)
+		rgb[i] = 0;
+
+	/* Calculate how many we need to subtract to get to the pixel in
+	 * the top left corner of the mean window (considering the current
+	 * pixel as the center) */
+	seek = vdeb->mean_win_size / 2;
+
+	/* Sum the values of the colors in the mean window */
+
+	dev_dbg(vdeb->vsd.dev,
+		"deb: %s: --- Calc pixel %dx%d, window mean %d, seek %d ---\n",
+		vdeb->vsd.sd.name, lin, col, vdeb->sink_mbus_fmt.height, seek);
+
+	/* Iterate through all the lines in the mean window, start
+	 * with zero if the pixel is outside the frame and don't pass
+	 * the height when the pixel is in the bottom border of the
+	 * frame */
+	for (wlin = seek > lin ? 0 : lin - seek;
+	     wlin < lin + seek + 1 && wlin < vdeb->sink_mbus_fmt.height;
+	     wlin++) {
+
+		/* Iterate through all the columns in the mean window, start
+		 * with zero if the pixel is outside the frame and don't pass
+		 * the width when the pixel is in the right border of the
+		 * frame */
+		for (wcol = seek > col ? 0 : col - seek;
+		     wcol < col + seek + 1 && wcol < vdeb->sink_mbus_fmt.width;
+		     wcol++) {
+			enum vimc_deb_rgb_colors color;
+			unsigned int index;

drivers/media/platform/vimc/vimc-debayer.c new file +18 -0

+				vdeb->vsd.sd.name, index, wlin, wcol, color);
+
+			/* Get its value */
+			rgb[color] = rgb[color] +
+				vimc_deb_get_val(&frame[index], vdeb->sink_bpp);
+
+			/* Save how many values we already added */
+			n_rgb[color]++;
+
+			dev_dbg(vdeb->vsd.dev,
+				"deb: %s: RGB CALC: val %d, n %d\n",
+				vdeb->vsd.sd.name, rgb[color], n_rgb[color]);
+		}
+	}
+
+	/* Calculate the mean */
+	for (i = 0; i < 3; i++) {
+		dev_dbg(vdeb->vsd.dev, "deb: %s: PRE CALC: %dx%d Color %d, val %d, n

%d\n", + vdeb->vsd.sd.name, lin, col, i, rgb[i], n_rgb[i]);

drivers/media/platform/vimc/vimc-debayer.c new file +51 -0

+			vdeb->vsd.sd.name, lin, col, i, rgb[i]);
+	}
+}
+
+static void vimc_deb_process_frame(struct vimc_ent_device *ved,
+				   struct media_pad *sink,
+				   const void *sink_frame)
+{
+	struct vimc_deb_device *vdeb = container_of(ved,
+					struct vimc_deb_device, vsd.ved);
+	unsigned int rgb[3];
+	unsigned int i, j;
+
+	/* If the stream in this node is not active, just return */
+	if (!vdeb->src_frame)
+		return;
+
+	for (i = 0; i < vdeb->src_mbus_fmt.height; i++)
+		for (j = 0; j < vdeb->src_mbus_fmt.width; j++) {
+			vimc_deb_calc_rgb_sink(vdeb, sink_frame, i, j, rgb);
+			vdeb->set_rgb_src(vdeb, i, j, rgb);
+		}
+
+	/* Propagate the frame thought all source pads */
+	for (i = 0; i < vdeb->vsd.sd.entity.num_pads; i++) {
+		struct media_pad *pad = &vdeb->vsd.sd.entity.pads[i];
+
+		if (pad->flags & MEDIA_PAD_FL_SOURCE)
+			vimc_propagate_frame(vdeb->vsd.dev,
+					     pad, vdeb->src_frame);
+	}
+}
+
+static void vimc_deb_destroy(struct vimc_ent_device *ved)
+{
+	struct vimc_deb_device *vdeb = container_of(ved, struct vimc_deb_device,
+						    vsd.ved);
+
+	vimc_ent_sd_cleanup(&vdeb->vsd);
+}
+
+struct vimc_ent_device *vimc_deb_create(struct v4l2_device *v4l2_dev,
+					const char *const name,
+					u16 num_pads,
+					const unsigned long *pads_flag)
+{
+	int ret;
+	struct vimc_deb_device *vdeb;
+	struct vimc_ent_subdevice *vsd;
+
+	vsd = vimc_ent_sd_init(sizeof(struct vimc_deb_device),

drivers/media/platform/vimc/vimc-debayer.c new file +34 -0

+	vdeb->sink_mbus_fmt.field = V4L2_FIELD_NONE;
+	vdeb->sink_mbus_fmt.colorspace = V4L2_COLORSPACE_SRGB;
+	vdeb->sink_mbus_fmt.quantization = V4L2_QUANTIZATION_FULL_RANGE;
+	vdeb->sink_mbus_fmt.xfer_func = V4L2_XFER_FUNC_SRGB;
+	vdeb->sink_mbus_fmt.code = MEDIA_BUS_FMT_SRGGB8_1X8;
+
+	vdeb->src_mbus_fmt.width = 640;
+	vdeb->src_mbus_fmt.height = 480;
+	vdeb->src_mbus_fmt.field = V4L2_FIELD_NONE;
+	vdeb->src_mbus_fmt.colorspace = V4L2_COLORSPACE_SRGB;
+	vdeb->src_mbus_fmt.quantization = V4L2_QUANTIZATION_FULL_RANGE;
+	vdeb->src_mbus_fmt.xfer_func = V4L2_XFER_FUNC_SRGB;
+	vdeb->src_mbus_fmt.code = MEDIA_BUS_FMT_RGB888_1X24;
+	vdeb->set_rgb_src = vimc_deb_set_rgb_mbus_fmt_rgb888_1x24;
+
+	/* Set the window size to calculate the mean */
+	vdeb->mean_win_size = VIMC_DEB_MEAN_WINDOW_SIZE;
+
+	/* Set the process frame callback */
+	vdeb->vsd.ved.process_frame = vimc_deb_process_frame;
+
+	/* Register the subdev with the v4l2 and the media framework */
+	ret = v4l2_device_register_subdev(vdeb->vsd.v4l2_dev, &vdeb->vsd.sd);
+	if (ret) {
+		dev_err(vdeb->vsd.dev,
+			"subdev register failed (err=%d)\n", ret);
+
+		vimc_ent_sd_cleanup(vsd);
+
+		return ERR_PTR(ret);
+	}
+
+	return &vdeb->vsd.ved;
+}

(quoted diff) +0 -0

b/drivers/media/platform/vimc/vimc-debayer.h new file mode 100644 index 0000000..bc00c97

drivers/media/platform/vimc/vimc-debayer.h new file +28 -0

@@ -0,0 +1,28 @@
+/*
+ * vimc-debayer.h Virtual Media Controller Driver
+ *
+ * Copyright (C) 2015 Helen Fornazier <[email protected]>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that 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.
+ *
+ */
+
+#ifndef _VIMC_DEBAYER_H_
+#define _VIMC_DEBAYER_H_
+
+#include "vimc-core.h"
+
+struct vimc_ent_device *vimc_deb_create(struct v4l2_device *v4l2_dev,
+					const char *const name,
+					u16 num_pads,
+					const unsigned long *pads_flag);
+
+#endif

Implement scaler and integrated with the core

Signed-off-by Helen Fornazier <[email protected]>

---
 drivers/media/platform/vimc/Makefile      |   3 +-
 drivers/media/platform/vimc/vimc-core.c   |   6 +-
 drivers/media/platform/vimc/vimc-scaler.c | 321 +++++++++++++++++++++++++++
 drivers/media/platform/vimc/vimc-scaler.h |  28 +++
 4 files changed, 356 insertions(+), 2 deletions(-)
 create mode 100644 drivers/media/platform/vimc/vimc-scaler.c
 create mode 100644 drivers/media/platform/vimc/vimc-scaler.h

(quoted diff) +0 -0

b/drivers/media/platform/vimc/vimc-scaler.c new file mode 100644 index 0000000..ea26930

drivers/media/platform/vimc/vimc-scaler.c new file +8 -0

@@ -0,0 +1,321 @@
+/*
+ * vimc-scaler.c Virtual Media Controller Driver
+ *
+ * Copyright (C) 2015 Helen Fornazier <[email protected]>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or

drivers/media/platform/vimc/vimc-scaler.c new file +22 -0

+#include <linux/vmalloc.h>
+#include <linux/v4l2-mediabus.h>
+#include <media/v4l2-subdev.h>
+
+#include "vimc-scaler.h"
+
+/* TODO: add this as a parameter of this module */
+#define VIMC_SCA_MULTIPLIER 3
+
+struct vimc_sca_device {
+	struct vimc_ent_subdevice vsd;
+	unsigned int mult;
+	/* The active format */
+	struct v4l2_mbus_framefmt sink_mbus_fmt;
+	unsigned int src_width;
+	unsigned int src_height;
+	/* Values calculated when the stream starts */
+	u8 *src_frame;
+	unsigned int src_frame_size;
+	unsigned int src_line_size;
+	unsigned int bpp;
+};

drivers/media/platform/vimc/vimc-scaler.c new file +178 -0

+	code->code = vsca->sink_mbus_fmt.code;
+
+	return 0;
+}
+
+static int vimc_sca_enum_frame_size(struct v4l2_subdev *sd,
+				    struct v4l2_subdev_pad_config *cfg,
+				    struct v4l2_subdev_frame_size_enum *fse)
+{
+	struct vimc_sca_device *vsca = v4l2_get_subdevdata(sd);
+	struct media_pad *pad;
+
+	/* Check if it is a valid pad */
+	if (fse->pad >= vsca->vsd.sd.entity.num_pads)
+		return -EINVAL;
+
+	/* TODO: Add support to other formats sizes */
+
+	pad = &vsca->vsd.sd.entity.pads[fse->pad];
+	if ((pad->flags & MEDIA_PAD_FL_SOURCE)) {
+		fse->min_width = vsca->src_width;
+		fse->max_width = vsca->src_width;
+		fse->min_height = vsca->src_height;
+		fse->max_height = vsca->src_height;
+	} else if ((pad->flags & MEDIA_PAD_FL_SINK)) {
+		fse->min_width = vsca->sink_mbus_fmt.width;
+		fse->max_width = vsca->sink_mbus_fmt.width;
+		fse->min_height = vsca->sink_mbus_fmt.height;
+		fse->max_height = vsca->sink_mbus_fmt.height;
+	} else
+		return -EINVAL;
+
+	return 0;
+}
+
+static int vimc_sca_get_fmt(struct v4l2_subdev *sd,
+			    struct v4l2_subdev_pad_config *cfg,
+			    struct v4l2_subdev_format *format)
+{
+	struct vimc_sca_device *vsca = v4l2_get_subdevdata(sd);
+	struct media_pad *pad;
+
+	/* Check if it is a valid pad */
+	if (format->pad >= vsca->vsd.sd.entity.num_pads)
+		return -EINVAL;
+
+	pad = &vsca->vsd.sd.entity.pads[format->pad];
+	if ((pad->flags & MEDIA_PAD_FL_SOURCE)) {
+		format->format = vsca->sink_mbus_fmt;
+		format->format.width = vsca->src_width;
+		format->format.height = vsca->src_height;
+	} else if ((pad->flags & MEDIA_PAD_FL_SINK))
+		format->format = vsca->sink_mbus_fmt;
+	else
+		return -EINVAL;
+
+	return 0;
+}
+
+static const struct v4l2_subdev_pad_ops vimc_sca_pad_ops = {
+	.enum_mbus_code		= vimc_sca_enum_mbus_code,
+	.enum_frame_size	= vimc_sca_enum_frame_size,
+	.get_fmt		= vimc_sca_get_fmt,
+	/* TODO: Add support to other formats */
+	.set_fmt		= vimc_sca_get_fmt,
+};
+
+static int vimc_sca_s_stream(struct v4l2_subdev *sd, int enable)
+{
+	struct vimc_sca_device *vsca = v4l2_get_subdevdata(sd);
+
+	if (enable) {
+		const struct vimc_pix_map *vpix;
+
+		if (vsca->src_frame)
+			return -EINVAL;
+
+		/* Save the bytes per pixel of the sink */
+		vpix = vimc_pix_map_by_code(vsca->sink_mbus_fmt.code);
+		/* This should never be NULL, as we won't allow any format
+		 * other then the ones in the vimc_pix_map_list table */
+		BUG_ON(!vpix);
+		vsca->bpp = vpix->bpp;
+
+		/* Calculate the width in bytes of the src frame */
+		vsca->src_line_size = vsca->src_width * vsca->bpp;
+
+		/* Calculate the frame size of the source pad */
+		vsca->src_frame_size = vsca->src_line_size * vsca->src_height;
+
+		/* Allocate the frame buffer. Use vmalloc to be able to
+		 * allocate a large amount of memory*/
+		vsca->src_frame = vmalloc(vsca->src_frame_size);
+		if (!vsca->src_frame)
+			return -ENOMEM;
+
+		/* Turn the stream on in the subdevices directly connected */
+		if (vimc_pipeline_s_stream(&vsca->vsd.sd.entity, 1)) {
+			vfree(vsca->src_frame);
+			vsca->src_frame = NULL;
+			return -EINVAL;
+		}
+	} else {
+		if (!vsca->src_frame)
+			return -EINVAL;
+		vfree(vsca->src_frame);
+		vsca->src_frame = NULL;
+		vimc_pipeline_s_stream(&vsca->vsd.sd.entity, 0);
+	}
+
+	return 0;
+}
+
+struct v4l2_subdev_video_ops vimc_sca_video_ops = {
+	.s_stream = vimc_sca_s_stream,
+};
+
+static const struct v4l2_subdev_ops vimc_sca_ops = {
+	.pad = &vimc_sca_pad_ops,
+	.video = &vimc_sca_video_ops,
+};
+
+static void vimc_sca_fill_pix(u8 *const ptr,
+			      const u8 *const pixel,
+			      const unsigned int bpp)
+{
+	unsigned int i;
+
+	/* copy the pixel to the pointer */
+	for (i = 0; i < bpp; i++)
+		ptr[i] = pixel[i];
+}
+
+static void vimc_sca_scale_pix(const struct vimc_sca_device *const vsca,
+			       const unsigned int lin, const unsigned int col,
+			       const u8 *const sink_frame)
+{
+	unsigned int i, j, index;
+	const u8 *pixel;
+
+	/* Point to the pixel value in position (lin, col) in the sink frame */
+	index = VIMC_FRAME_INDEX(lin, col,
+				 vsca->sink_mbus_fmt.width,
+				 vsca->bpp);
+	pixel = &sink_frame[index];
+
+	dev_dbg(vsca->vsd.dev,
+		"sca: %s: --- scale_pix sink pos %dx%d, index %d ---\n",
+		vsca->vsd.sd.name, lin, col, index);
+
+	/* point to the place we are going to put the first pixel
+	 * in the scaled src frame */
+	index = VIMC_FRAME_INDEX(lin * vsca->mult, col * vsca->mult,
+				 vsca->src_width, vsca->bpp);
+
+	dev_dbg(vsca->vsd.dev, "sca: %s: scale_pix src pos %dx%d, index %d\n",
+		vsca->vsd.sd.name, lin * vsca->mult, col * vsca->mult, index);
+
+	/* Repeat this pixel mult times */
+	for (i = 0; i < vsca->mult; i++) {
+		/* Iterate though each beginning of a
+		 * pixel repetition in a line */
+		for (j = 0; j < vsca->mult * vsca->bpp; j += vsca->bpp) {
+			dev_dbg(vsca->vsd.dev,
+				"sca: %s: sca: scale_pix src pos %d\n",
+				vsca->vsd.sd.name, index + j);
+
+			/* copy the pixel to the position index + j */
+			vimc_sca_fill_pix(&vsca->src_frame[index + j],
+					  pixel, vsca->bpp);
+		}
+
+		/* move the index to the next line */
+		index += vsca->src_line_size;
+	}
+}
+
+static void vimc_sca_fill_src_frame(const struct vimc_sca_device *const

vsca,

drivers/media/platform/vimc/vimc-scaler.c new file +92 -0

+				    const u8 *const sink_frame)
+{
+	unsigned int i, j;
+
+	/* Scale each pixel from the original sink frame */
+	/* TODO: implement scale down, only scale up is supported for now */
+	for (i = 0; i < vsca->sink_mbus_fmt.height; i++)
+		for (j = 0; j < vsca->sink_mbus_fmt.width; j++)
+			vimc_sca_scale_pix(vsca, i, j, sink_frame);
+}
+
+static void vimc_sca_process_frame(struct vimc_ent_device *ved,
+				   struct media_pad *sink,
+				   const void *sink_frame)
+{
+	unsigned int i;
+	struct vimc_sca_device *vsca = container_of(ved, struct vimc_sca_device,
+						    vsd.ved);
+
+	/* If the stream in this node is not active, just return */
+	if (!vsca->src_frame)
+		return;
+
+	vimc_sca_fill_src_frame(vsca, sink_frame);
+
+	/* Propagate the frame thought all source pads */
+	for (i = 0; i < vsca->vsd.sd.entity.num_pads; i++) {
+		struct media_pad *pad = &vsca->vsd.sd.entity.pads[i];
+
+		if (pad->flags & MEDIA_PAD_FL_SOURCE)
+			vimc_propagate_frame(vsca->vsd.dev,
+					     pad, vsca->src_frame);
+	}
+};
+
+static void vimc_sca_destroy(struct vimc_ent_device *ved)
+{
+	struct vimc_sca_device *vsca = container_of(ved, struct vimc_sca_device,
+						    vsd.ved);
+
+	vimc_ent_sd_cleanup(&vsca->vsd);
+}
+
+struct vimc_ent_device *vimc_sca_create(struct v4l2_device *v4l2_dev,
+					const char *const name,
+					u16 num_pads,
+					const unsigned long *pads_flag)
+{
+	int ret;
+	struct vimc_sca_device *vsca;
+	struct vimc_ent_subdevice *vsd;
+
+	vsd = vimc_ent_sd_init(sizeof(struct vimc_sca_device),
+			       v4l2_dev, name, num_pads, pads_flag,
+			       &vimc_sca_ops, vimc_sca_destroy);
+	if (IS_ERR(vsd))
+		return (struct vimc_ent_device *)vsd;
+
+	vsca = container_of(vsd, struct vimc_sca_device, vsd);
+
+	/* Set the default active frame format (this is hardcoded for now) */
+	vsca->sink_mbus_fmt.width = 640;
+	vsca->sink_mbus_fmt.height = 480;
+	vsca->sink_mbus_fmt.code = MEDIA_BUS_FMT_RGB888_1X24;
+	vsca->sink_mbus_fmt.field = V4L2_FIELD_NONE;
+	vsca->sink_mbus_fmt.colorspace = V4L2_COLORSPACE_SRGB;
+	vsca->sink_mbus_fmt.quantization = V4L2_QUANTIZATION_FULL_RANGE;
+	vsca->sink_mbus_fmt.xfer_func = V4L2_XFER_FUNC_SRGB;
+
+	/* Set the scaler multiplier factor */
+	vsca->mult = VIMC_SCA_MULTIPLIER;
+
+	/* Calculate the width and the height of the src frame */
+	vsca->src_width = vsca->sink_mbus_fmt.width * vsca->mult;
+	vsca->src_height = vsca->sink_mbus_fmt.height * vsca->mult;
+
+	/* Set the process frame callback */
+	vsca->vsd.ved.process_frame = vimc_sca_process_frame;
+
+	/* Register the subdev with the v4l2 and the media framework */
+	ret = v4l2_device_register_subdev(vsca->vsd.v4l2_dev, &vsca->vsd.sd);
+	if (ret) {
+		dev_err(vsca->vsd.dev,
+			"subdev register failed (err=%d)\n", ret);
+
+		vimc_ent_sd_cleanup(vsd);
+
+		return ERR_PTR(ret);
+	}
+
+	return &vsca->vsd.ved;
+}

(quoted diff) +0 -0

b/drivers/media/platform/vimc/vimc-scaler.h new file mode 100644 index 0000000..863278f

drivers/media/platform/vimc/vimc-scaler.h new file +28 -0

@@ -0,0 +1,28 @@
+/*
+ * vimc-scaler.h Virtual Media Controller Driver
+ *
+ * Copyright (C) 2015 Helen Fornazier <[email protected]>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that 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.
+ *
+ */
+
+#ifndef _VIMC_SCALER_H_
+#define _VIMC_SCALER_H_
+
+#include "vimc-core.h"
+
+struct vimc_ent_device *vimc_sca_create(struct v4l2_device *v4l2_dev,
+					const char *const name,
+					u16 num_pads,
+					const unsigned long *pads_flag);
+
+#endif

Implement scaler and integrated with the core

Signed-off-by Helen Fornazier <[email protected]>

---
 drivers/media/platform/vimc/Makefile      |   3 +-
 drivers/media/platform/vimc/vimc-core.c   |   6 +-
 drivers/media/platform/vimc/vimc-scaler.c | 321 ++++++++++++++++++++++++++++++
 drivers/media/platform/vimc/vimc-scaler.h |  28 +++
 4 files changed, 356 insertions(+), 2 deletions(-)
 create mode 100644 drivers/media/platform/vimc/vimc-scaler.c
 create mode 100644 drivers/media/platform/vimc/vimc-scaler.h

drivers/media/platform/vimc/Makefile +2 -1

index a6708f9..f13a594 100644
@@ -1,3 +1,4 @@
-vimc-objs := vimc-core.o vimc-capture.o vimc-debayer.o vimc-sensor.o
+vimc-objs := vimc-core.o vimc-capture.o vimc-debayer.o vimc-scaler.o \
+		vimc-sensor.o
 
 obj-$(CONFIG_VIDEO_VIMC) += vimc.o

drivers/media/platform/vimc/vimc-core.c +5 -1

index 373ea9c..8342732 100644
@@ -25,6 +25,7 @@
 #include "vimc-capture.h"
 #include "vimc-core.h"
 #include "vimc-debayer.h"
+#include "vimc-scaler.h"
 #include "vimc-sensor.h"
 
 #define VIMC_PDEV_NAME "vimc"

@@ -557,9 +558,12 @@ static int vimc_device_register(struct vimc_device *vimc)
 			create_func = vimc_deb_create;
 			break;
 
+		case VIMC_ENT_NODE_SCALER:
+			create_func = vimc_sca_create;
+			break;
+
 		/* TODO: Instantiate the specific topology node */
 		case VIMC_ENT_NODE_INPUT:
-		case VIMC_ENT_NODE_SCALER:
 		default:
 			/* TODO: remove this when all the entities specific
 			 * code are implemented */

drivers/media/platform/vimc/vimc-scaler.c new file +321 -0

new file mode 100644
index 0000000..ea26930
@@ -0,0 +1,321 @@
+/*
+ * vimc-scaler.c Virtual Media Controller Driver
+ *
+ * Copyright (C) 2015 Helen Fornazier <[email protected]>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that 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 <linux/freezer.h>
+#include <linux/vmalloc.h>
+#include <linux/v4l2-mediabus.h>
+#include <media/v4l2-subdev.h>
+
+#include "vimc-scaler.h"
+
+/* TODO: add this as a parameter of this module */
+#define VIMC_SCA_MULTIPLIER 3
+
+struct vimc_sca_device {
+	struct vimc_ent_subdevice vsd;
+	unsigned int mult;
+	/* The active format */
+	struct v4l2_mbus_framefmt sink_mbus_fmt;
+	unsigned int src_width;
+	unsigned int src_height;
+	/* Values calculated when the stream starts */
+	u8 *src_frame;
+	unsigned int src_frame_size;
+	unsigned int src_line_size;
+	unsigned int bpp;
+};
+
+static int vimc_sca_enum_mbus_code(struct v4l2_subdev *sd,
+				   struct v4l2_subdev_pad_config *cfg,
+				   struct v4l2_subdev_mbus_code_enum *code)
+{
+	struct vimc_sca_device *vsca = v4l2_get_subdevdata(sd);
+
+	/* Check if it is a valid pad */
+	if (code->pad >= vsca->vsd.sd.entity.num_pads)
+		return -EINVAL;
+
+	code->code = vsca->sink_mbus_fmt.code;
+
+	return 0;
+}
+
+static int vimc_sca_enum_frame_size(struct v4l2_subdev *sd,
+				    struct v4l2_subdev_pad_config *cfg,
+				    struct v4l2_subdev_frame_size_enum *fse)
+{
+	struct vimc_sca_device *vsca = v4l2_get_subdevdata(sd);
+	struct media_pad *pad;
+
+	/* Check if it is a valid pad */
+	if (fse->pad >= vsca->vsd.sd.entity.num_pads)
+		return -EINVAL;
+
+	/* TODO: Add support to other formats sizes */
+
+	pad = &vsca->vsd.sd.entity.pads[fse->pad];
+	if ((pad->flags & MEDIA_PAD_FL_SOURCE)) {
+		fse->min_width = vsca->src_width;
+		fse->max_width = vsca->src_width;
+		fse->min_height = vsca->src_height;
+		fse->max_height = vsca->src_height;
+	} else if ((pad->flags & MEDIA_PAD_FL_SINK)) {
+		fse->min_width = vsca->sink_mbus_fmt.width;
+		fse->max_width = vsca->sink_mbus_fmt.width;
+		fse->min_height = vsca->sink_mbus_fmt.height;
+		fse->max_height = vsca->sink_mbus_fmt.height;
+	} else
+		return -EINVAL;
+
+	return 0;
+}
+
+static int vimc_sca_get_fmt(struct v4l2_subdev *sd,
+			    struct v4l2_subdev_pad_config *cfg,
+			    struct v4l2_subdev_format *format)
+{
+	struct vimc_sca_device *vsca = v4l2_get_subdevdata(sd);
+	struct media_pad *pad;
+
+	/* Check if it is a valid pad */
+	if (format->pad >= vsca->vsd.sd.entity.num_pads)
+		return -EINVAL;
+
+	pad = &vsca->vsd.sd.entity.pads[format->pad];
+	if ((pad->flags & MEDIA_PAD_FL_SOURCE)) {
+		format->format = vsca->sink_mbus_fmt;
+		format->format.width = vsca->src_width;
+		format->format.height = vsca->src_height;
+	} else if ((pad->flags & MEDIA_PAD_FL_SINK))
+		format->format = vsca->sink_mbus_fmt;
+	else
+		return -EINVAL;
+
+	return 0;
+}
+
+static const struct v4l2_subdev_pad_ops vimc_sca_pad_ops = {
+	.enum_mbus_code		= vimc_sca_enum_mbus_code,
+	.enum_frame_size	= vimc_sca_enum_frame_size,
+	.get_fmt		= vimc_sca_get_fmt,
+	/* TODO: Add support to other formats */
+	.set_fmt		= vimc_sca_get_fmt,
+};
+
+static int vimc_sca_s_stream(struct v4l2_subdev *sd, int enable)
+{
+	struct vimc_sca_device *vsca = v4l2_get_subdevdata(sd);
+
+	if (enable) {
+		const struct vimc_pix_map *vpix;
+
+		if (vsca->src_frame)
+			return -EINVAL;
+
+		/* Save the bytes per pixel of the sink */
+		vpix = vimc_pix_map_by_code(vsca->sink_mbus_fmt.code);
+		/* This should never be NULL, as we won't allow any format
+		 * other then the ones in the vimc_pix_map_list table */
+		BUG_ON(!vpix);
+		vsca->bpp = vpix->bpp;
+
+		/* Calculate the width in bytes of the src frame */
+		vsca->src_line_size = vsca->src_width * vsca->bpp;
+
+		/* Calculate the frame size of the source pad */
+		vsca->src_frame_size = vsca->src_line_size * vsca->src_height;
+
+		/* Allocate the frame buffer. Use vmalloc to be able to
+		 * allocate a large amount of memory*/
+		vsca->src_frame = vmalloc(vsca->src_frame_size);
+		if (!vsca->src_frame)
+			return -ENOMEM;
+
+		/* Turn the stream on in the subdevices directly connected */
+		if (vimc_pipeline_s_stream(&vsca->vsd.sd.entity, 1)) {
+			vfree(vsca->src_frame);
+			vsca->src_frame = NULL;
+			return -EINVAL;
+		}
+	} else {
+		if (!vsca->src_frame)
+			return -EINVAL;
+		vfree(vsca->src_frame);
+		vsca->src_frame = NULL;
+		vimc_pipeline_s_stream(&vsca->vsd.sd.entity, 0);
+	}
+
+	return 0;
+}
+
+struct v4l2_subdev_video_ops vimc_sca_video_ops = {
+	.s_stream = vimc_sca_s_stream,
+};
+
+static const struct v4l2_subdev_ops vimc_sca_ops = {
+	.pad = &vimc_sca_pad_ops,
+	.video = &vimc_sca_video_ops,
+};
+
+static void vimc_sca_fill_pix(u8 *const ptr,
+			      const u8 *const pixel,
+			      const unsigned int bpp)
+{
+	unsigned int i;
+
+	/* copy the pixel to the pointer */
+	for (i = 0; i < bpp; i++)
+		ptr[i] = pixel[i];
+}
+
+static void vimc_sca_scale_pix(const struct vimc_sca_device *const vsca,
+			       const unsigned int lin, const unsigned int col,
+			       const u8 *const sink_frame)
+{
+	unsigned int i, j, index;
+	const u8 *pixel;
+
+	/* Point to the pixel value in position (lin, col) in the sink frame */
+	index = VIMC_FRAME_INDEX(lin, col,
+				 vsca->sink_mbus_fmt.width,
+				 vsca->bpp);
+	pixel = &sink_frame[index];
+
+	dev_dbg(vsca->vsd.dev,
+		"sca: %s: --- scale_pix sink pos %dx%d, index %d ---\n",
+		vsca->vsd.sd.name, lin, col, index);
+
+	/* point to the place we are going to put the first pixel
+	 * in the scaled src frame */
+	index = VIMC_FRAME_INDEX(lin * vsca->mult, col * vsca->mult,
+				 vsca->src_width, vsca->bpp);
+
+	dev_dbg(vsca->vsd.dev, "sca: %s: scale_pix src pos %dx%d, index %d\n",
+		vsca->vsd.sd.name, lin * vsca->mult, col * vsca->mult, index);
+
+	/* Repeat this pixel mult times */
+	for (i = 0; i < vsca->mult; i++) {
+		/* Iterate though each beginning of a
+		 * pixel repetition in a line */
+		for (j = 0; j < vsca->mult * vsca->bpp; j += vsca->bpp) {
+			dev_dbg(vsca->vsd.dev,
+				"sca: %s: sca: scale_pix src pos %d\n",
+				vsca->vsd.sd.name, index + j);
+
+			/* copy the pixel to the position index + j */
+			vimc_sca_fill_pix(&vsca->src_frame[index + j],
+					  pixel, vsca->bpp);
+		}
+
+		/* move the index to the next line */
+		index += vsca->src_line_size;
+	}
+}
+
+static void vimc_sca_fill_src_frame(const struct vimc_sca_device *const vsca,
+				    const u8 *const sink_frame)
+{
+	unsigned int i, j;
+
+	/* Scale each pixel from the original sink frame */
+	/* TODO: implement scale down, only scale up is supported for now */
+	for (i = 0; i < vsca->sink_mbus_fmt.height; i++)
+		for (j = 0; j < vsca->sink_mbus_fmt.width; j++)
+			vimc_sca_scale_pix(vsca, i, j, sink_frame);
+}
+
+static void vimc_sca_process_frame(struct vimc_ent_device *ved,
+				   struct media_pad *sink,
+				   const void *sink_frame)
+{
+	unsigned int i;
+	struct vimc_sca_device *vsca = container_of(ved, struct vimc_sca_device,
+						    vsd.ved);
+
+	/* If the stream in this node is not active, just return */
+	if (!vsca->src_frame)
+		return;
+
+	vimc_sca_fill_src_frame(vsca, sink_frame);
+
+	/* Propagate the frame thought all source pads */
+	for (i = 0; i < vsca->vsd.sd.entity.num_pads; i++) {
+		struct media_pad *pad = &vsca->vsd.sd.entity.pads[i];
+
+		if (pad->flags & MEDIA_PAD_FL_SOURCE)
+			vimc_propagate_frame(vsca->vsd.dev,
+					     pad, vsca->src_frame);
+	}
+};
+
+static void vimc_sca_destroy(struct vimc_ent_device *ved)
+{
+	struct vimc_sca_device *vsca = container_of(ved, struct vimc_sca_device,
+						    vsd.ved);
+
+	vimc_ent_sd_cleanup(&vsca->vsd);
+}
+
+struct vimc_ent_device *vimc_sca_create(struct v4l2_device *v4l2_dev,
+					const char *const name,
+					u16 num_pads,
+					const unsigned long *pads_flag)
+{
+	int ret;
+	struct vimc_sca_device *vsca;
+	struct vimc_ent_subdevice *vsd;
+
+	vsd = vimc_ent_sd_init(sizeof(struct vimc_sca_device),
+			       v4l2_dev, name, num_pads, pads_flag,
+			       &vimc_sca_ops, vimc_sca_destroy);
+	if (IS_ERR(vsd))
+		return (struct vimc_ent_device *)vsd;
+
+	vsca = container_of(vsd, struct vimc_sca_device, vsd);
+
+	/* Set the default active frame format (this is hardcoded for now) */
+	vsca->sink_mbus_fmt.width = 640;
+	vsca->sink_mbus_fmt.height = 480;
+	vsca->sink_mbus_fmt.code = MEDIA_BUS_FMT_RGB888_1X24;
+	vsca->sink_mbus_fmt.field = V4L2_FIELD_NONE;
+	vsca->sink_mbus_fmt.colorspace = V4L2_COLORSPACE_SRGB;
+	vsca->sink_mbus_fmt.quantization = V4L2_QUANTIZATION_FULL_RANGE;
+	vsca->sink_mbus_fmt.xfer_func = V4L2_XFER_FUNC_SRGB;
+
+	/* Set the scaler multiplier factor */
+	vsca->mult = VIMC_SCA_MULTIPLIER;
+
+	/* Calculate the width and the height of the src frame */
+	vsca->src_width = vsca->sink_mbus_fmt.width * vsca->mult;
+	vsca->src_height = vsca->sink_mbus_fmt.height * vsca->mult;
+
+	/* Set the process frame callback */
+	vsca->vsd.ved.process_frame = vimc_sca_process_frame;
+
+	/* Register the subdev with the v4l2 and the media framework */
+	ret = v4l2_device_register_subdev(vsca->vsd.v4l2_dev, &vsca->vsd.sd);
+	if (ret) {
+		dev_err(vsca->vsd.dev,
+			"subdev register failed (err=%d)\n", ret);
+
+		vimc_ent_sd_cleanup(vsd);
+
+		return ERR_PTR(ret);
+	}
+
+	return &vsca->vsd.ved;
+}

drivers/media/platform/vimc/vimc-scaler.h new file +28 -0

new file mode 100644
index 0000000..863278f
@@ -0,0 +1,28 @@
+/*
+ * vimc-scaler.h Virtual Media Controller Driver
+ *
+ * Copyright (C) 2015 Helen Fornazier <[email protected]>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that 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.
+ *
+ */
+
+#ifndef _VIMC_SCALER_H_
+#define _VIMC_SCALER_H_
+
+#include "vimc-core.h"
+
+struct vimc_ent_device *vimc_sca_create(struct v4l2_device *v4l2_dev,
+					const char *const name,
+					u16 num_pads,
+					const unsigned long *pads_flag);
+
+#endif

Implement set format in the topology nodes capture, debayer, sensor and scaler
Allow user space to change the frame size and the pixel format

Signed-off-by Helen Fornazier <[email protected]>

---
 drivers/media/platform/vimc/vimc-capture.c | 56 ++++++++++++++++++++-
 drivers/media/platform/vimc/vimc-core.c    | 81 +++++++++++++++++----------
 drivers/media/platform/vimc/vimc-core.h    |  6 +++
 drivers/media/platform/vimc/vimc-debayer.c | 36 ++++++++++++-
 drivers/media/platform/vimc/vimc-scaler.c  | 45 ++++++++++++++++-
 drivers/media/platform/vimc/vimc-sensor.c  | 33 +++++++++++-
 6 files changed, 222 insertions(+), 35 deletions(-)

(quoted diff) +0 -0

b/drivers/media/platform/vimc/vimc-capture.c index 7d21966..3b92a35 100644

drivers/media/platform/vimc/vimc-capture.c +1 -0

@@ -102,6 +102,59 @@ static int vimc_cap_g_fmt_vid_cap(struct file *file,
 void *priv, return 0;
 }
 
+static int vimc_cap_s_fmt_vid_cap(struct file *file, void *priv,

drivers/media/platform/vimc/vimc-capture.c +28 -0

+	if (f->fmt.pix.width)
+		vcap->format.width = f->fmt.pix.width;
+	else
+		f->fmt.pix.width = vcap->format.width;
+	if (f->fmt.pix.height)
+		vcap->format.height = f->fmt.pix.height;
+	else
+		f->fmt.pix.height = vcap->format.height;
+
+	/* Don't accept a pixelformat that is not on the table */
+	vpix = vimc_pix_map_by_pixelformat(f->fmt.pix.pixelformat);
+	if (vpix)
+		vcap->format.pixelformat = f->fmt.pix.pixelformat;
+	else {
+		f->fmt.pix.pixelformat = vcap->format.pixelformat;
+		vpix = vimc_pix_map_by_pixelformat(f->fmt.pix.pixelformat);
+	}
+
+	vcap->format.field = f->fmt.pix.field;
+
+	/* Check if bytesperline has the minimum size */
+	if (f->fmt.pix.bytesperline >= vcap->format.width * vpix->bpp)
+		vcap->format.bytesperline = f->fmt.pix.bytesperline;
+	else
+		f->fmt.pix.bytesperline = vcap->format.bytesperline;
+
+	/* Set the size of the image and the flags */
+	f->fmt.pix.sizeimage = vcap->format.width *

drivers/media/platform/vimc/vimc-capture.c +0 -0

 	.vidioc_try_fmt_vid_cap = vimc_cap_g_fmt_vid_cap,
 	.vidioc_enum_fmt_vid_cap = vimc_cap_enum_fmt_vid_cap,
 

(quoted diff) +0 -0

b/drivers/media/platform/vimc/vimc-core.c index 8342732..bf2148a 100644

drivers/media/platform/vimc/vimc-core.c +20 -17

@@ -39,10 +39,11 @@
 	.flags = link_flags,					\
 }
 
-#define VIMC_PIX_MAP(_code, _bpp, _pixelformat) {	\
-	.code = _code,					\
-	.pixelformat = _pixelformat,			\
-	.bpp = _bpp,					\
+#define VIMC_PIX_MAP(_code, _bpp, _pixelformat, _bayer) {	\
+	.code = _code,						\
+	.pixelformat = _pixelformat,				\
+	.bpp = _bpp,						\
+	.bayer = _bayer,					\
 }
 
 struct vimc_device {

@@ -216,36 +217,36 @@ const struct vimc_pix_map vimc_pix_map_list[] = {
 	/* TODO: add all missing formats */
 
 	/* RGB formats */
-	VIMC_PIX_MAP(MEDIA_BUS_FMT_BGR888_1X24, 3, V4L2_PIX_FMT_BGR24),
-	VIMC_PIX_MAP(MEDIA_BUS_FMT_RGB888_1X24, 3, V4L2_PIX_FMT_RGB24),
-	VIMC_PIX_MAP(MEDIA_BUS_FMT_ARGB8888_1X32, 4, V4L2_PIX_FMT_ARGB32),
+	VIMC_PIX_MAP(MEDIA_BUS_FMT_BGR888_1X24, 3, V4L2_PIX_FMT_BGR24, false),
+	VIMC_PIX_MAP(MEDIA_BUS_FMT_RGB888_1X24, 3, V4L2_PIX_FMT_RGB24, false),
+	VIMC_PIX_MAP(MEDIA_BUS_FMT_ARGB8888_1X32, 4, V4L2_PIX_FMT_ARGB32, false),
 
 	/* Bayer formats */
-	VIMC_PIX_MAP(MEDIA_BUS_FMT_SBGGR8_1X8, 1, V4L2_PIX_FMT_SBGGR8),
-	VIMC_PIX_MAP(MEDIA_BUS_FMT_SGBRG8_1X8, 1, V4L2_PIX_FMT_SGBRG8),
-	VIMC_PIX_MAP(MEDIA_BUS_FMT_SGRBG8_1X8, 1, V4L2_PIX_FMT_SGRBG8),
-	VIMC_PIX_MAP(MEDIA_BUS_FMT_SRGGB8_1X8, 1, V4L2_PIX_FMT_SRGGB8),
-	VIMC_PIX_MAP(MEDIA_BUS_FMT_SBGGR10_1X10, 2, V4L2_PIX_FMT_SBGGR10),
-	VIMC_PIX_MAP(MEDIA_BUS_FMT_SGBRG10_1X10, 2, V4L2_PIX_FMT_SGBRG10),
-	VIMC_PIX_MAP(MEDIA_BUS_FMT_SGRBG10_1X10, 2, V4L2_PIX_FMT_SGRBG10),
-	VIMC_PIX_MAP(MEDIA_BUS_FMT_SRGGB10_1X10, 2, V4L2_PIX_FMT_SRGGB10),
+	VIMC_PIX_MAP(MEDIA_BUS_FMT_SBGGR8_1X8, 1, V4L2_PIX_FMT_SBGGR8, true),
+	VIMC_PIX_MAP(MEDIA_BUS_FMT_SGBRG8_1X8, 1, V4L2_PIX_FMT_SGBRG8, true),
+	VIMC_PIX_MAP(MEDIA_BUS_FMT_SGRBG8_1X8, 1, V4L2_PIX_FMT_SGRBG8, true),
+	VIMC_PIX_MAP(MEDIA_BUS_FMT_SRGGB8_1X8, 1, V4L2_PIX_FMT_SRGGB8, true),
+	VIMC_PIX_MAP(MEDIA_BUS_FMT_SBGGR10_1X10, 2, V4L2_PIX_FMT_SBGGR10, true),
+	VIMC_PIX_MAP(MEDIA_BUS_FMT_SGBRG10_1X10, 2, V4L2_PIX_FMT_SGBRG10, true),
+	VIMC_PIX_MAP(MEDIA_BUS_FMT_SGRBG10_1X10, 2, V4L2_PIX_FMT_SGRBG10, true),
+	VIMC_PIX_MAP(MEDIA_BUS_FMT_SRGGB10_1X10, 2, V4L2_PIX_FMT_SRGGB10, true),
 	/* 10bit raw bayer a-law compressed to 8 bits */
-	VIMC_PIX_MAP(MEDIA_BUS_FMT_SBGGR10_ALAW8_1X8, 1,
 V4L2_PIX_FMT_SBGGR10ALAW8), -	VIMC_PIX_MAP(MEDIA_BUS_FMT_SGBRG10_ALAW8_1X8,
 1, V4L2_PIX_FMT_SGBRG10ALAW8),
-	VIMC_PIX_MAP(MEDIA_BUS_FMT_SGRBG10_ALAW8_1X8, 1,
 V4L2_PIX_FMT_SGRBG10ALAW8), -	VIMC_PIX_MAP(MEDIA_BUS_FMT_SRGGB10_ALAW8_1X8,
 1, V4L2_PIX_FMT_SRGGB10ALAW8),
+	VIMC_PIX_MAP(MEDIA_BUS_FMT_SBGGR10_ALAW8_1X8, 1,
 V4L2_PIX_FMT_SBGGR10ALAW8, true),
+	VIMC_PIX_MAP(MEDIA_BUS_FMT_SGBRG10_ALAW8_1X8, 1,
 V4L2_PIX_FMT_SGBRG10ALAW8, true),
+	VIMC_PIX_MAP(MEDIA_BUS_FMT_SGRBG10_ALAW8_1X8, 1,
 V4L2_PIX_FMT_SGRBG10ALAW8, true),
+	VIMC_PIX_MAP(MEDIA_BUS_FMT_SRGGB10_ALAW8_1X8, 1,

V4L2_PIX_FMT_SRGGB10ALAW8, true), /* 10bit raw bayer DPCM compressed to 8 bits */

drivers/media/platform/vimc/vimc-core.c +0 -1

-	VIMC_PIX_MAP(MEDIA_BUS_FMT_SBGGR10_DPCM8_1X8, 1,

V4L2_PIX_FMT_SBGGR10DPCM8), - VIMC_PIX_MAP(MEDIA_BUS_FMT_SGBRG10_DPCM8_1X8,
1, V4L2_PIX_FMT_SGBRG10DPCM8),

drivers/media/platform/vimc/vimc-core.c +0 -1

-	VIMC_PIX_MAP(MEDIA_BUS_FMT_SGRBG10_DPCM8_1X8, 1,

V4L2_PIX_FMT_SGRBG10DPCM8), - VIMC_PIX_MAP(MEDIA_BUS_FMT_SRGGB10_DPCM8_1X8,
1, V4L2_PIX_FMT_SRGGB10DPCM8), - VIMC_PIX_MAP(MEDIA_BUS_FMT_SBGGR12_1X12,
2, V4L2_PIX_FMT_SBGGR12), - VIMC_PIX_MAP(MEDIA_BUS_FMT_SGBRG12_1X12, 2,
V4L2_PIX_FMT_SGBRG12), - VIMC_PIX_MAP(MEDIA_BUS_FMT_SGRBG12_1X12, 2,
V4L2_PIX_FMT_SGRBG12), - VIMC_PIX_MAP(MEDIA_BUS_FMT_SRGGB12_1X12, 2,
V4L2_PIX_FMT_SRGGB12), + VIMC_PIX_MAP(MEDIA_BUS_FMT_SBGGR10_DPCM8_1X8, 1,
V4L2_PIX_FMT_SBGGR10DPCM8, true),

drivers/media/platform/vimc/vimc-core.c +1 -0

+	VIMC_PIX_MAP(MEDIA_BUS_FMT_SGBRG10_DPCM8_1X8, 1,

V4L2_PIX_FMT_SGBRG10DPCM8, true),

drivers/media/platform/vimc/vimc-core.c +1 -0

+	VIMC_PIX_MAP(MEDIA_BUS_FMT_SGRBG10_DPCM8_1X8, 1,

V4L2_PIX_FMT_SGRBG10DPCM8, true),

drivers/media/platform/vimc/vimc-core.c +1 -0

+	VIMC_PIX_MAP(MEDIA_BUS_FMT_SRGGB10_DPCM8_1X8, 1,

V4L2_PIX_FMT_SRGGB10DPCM8, true),

drivers/media/platform/vimc/vimc-core.c +5 -1

+	VIMC_PIX_MAP(MEDIA_BUS_FMT_SBGGR12_1X12, 2, V4L2_PIX_FMT_SBGGR12, true),
+	VIMC_PIX_MAP(MEDIA_BUS_FMT_SGBRG12_1X12, 2, V4L2_PIX_FMT_SGBRG12, true),
+	VIMC_PIX_MAP(MEDIA_BUS_FMT_SGRBG12_1X12, 2, V4L2_PIX_FMT_SGRBG12, true),
+	VIMC_PIX_MAP(MEDIA_BUS_FMT_SRGGB12_1X12, 2, V4L2_PIX_FMT_SRGGB12, true),
 
 	/* End */
-	{0, 0, 0}
+	{0, 0, 0, 0}
 };
 
 const struct vimc_pix_map *vimc_pix_map_by_code(u32 code)

drivers/media/platform/vimc/vimc-core.c +24 -0

+void vimc_ent_sd_set_fsize(struct v4l2_mbus_framefmt *active_fmt,
+			   struct v4l2_subdev_pad_config *cfg,
+			   struct v4l2_subdev_format *format)
+{
+	/* Accept all non-zero width and height sizes */
+	if (format->format.width)
+		active_fmt->width = format->format.width;
+	else
+		format->format.width = active_fmt->width;
+	if (format->format.height)
+		active_fmt->height = format->format.height;
+	else
+		format->format.height = active_fmt->height;
+
+	active_fmt->field = format->format.field;
+
+	/* We don't support changing the colorspace for now */
+	/* TODO: add support for others */
+	format->format.colorspace = active_fmt->colorspace;
+	format->format.ycbcr_enc = active_fmt->ycbcr_enc;
+	format->format.quantization = active_fmt->quantization;
+	format->format.xfer_func = active_fmt->xfer_func;
+}
+
 /* TODO: remove this function when all the
  * entities specific code are implemented */
 static void vimc_raw_destroy(struct vimc_ent_device *ved)

(quoted diff) +0 -0

b/drivers/media/platform/vimc/vimc-core.h index 892341a..311be04 100644

drivers/media/platform/vimc/vimc-core.h +1 -0

@@ -28,6 +28,7 @@ struct vimc_pix_map {
 	unsigned int code;
 	unsigned int bpp;
 	u32 pixelformat;
+	bool bayer;
 };
 extern const struct vimc_pix_map vimc_pix_map_list[];
 

drivers/media/platform/vimc/vimc-core.h +4 -0

+void vimc_ent_sd_set_fsize(struct v4l2_mbus_framefmt *active_fmt,
+			   struct v4l2_subdev_pad_config *cfg,
+			   struct v4l2_subdev_format *format);
+
 /* Helper function to call the s_stream of the subdevice
  * directly connected with entity*/
 int vimc_pipeline_s_stream(struct media_entity *entity, int enable);

drivers/media/platform/vimc/vimc-sensor.c +1 -2

 	.get_fmt		= vimc_sen_get_fmt,
-	/* TODO: Add support to other formats */
-	.set_fmt		= vimc_sen_get_fmt,
+	.set_fmt		= vimc_sen_set_fmt,
 };
 
 static int vimc_thread_sen(void *data)

The test pattern generator will be used by other drivers as the virtual media controller (vimc)

Signed-off-by Helen Fornazier <[email protected]>

---
 drivers/media/platform/Kconfig                  |    2 +
 drivers/media/platform/Makefile                 |    1 +
 drivers/media/platform/tpg/Kconfig              |    5 +
 drivers/media/platform/tpg/Makefile             |    3 +
 drivers/media/platform/tpg/tpg-colors.c         | 1181 ++++++++++++
 drivers/media/platform/tpg/tpg-core.c           | 2211 ++++++++++++++++++++
 drivers/media/platform/vivid/Kconfig            |    1 +
 drivers/media/platform/vivid/Makefile           |    2 +-
 drivers/media/platform/vivid/vivid-core.h       |    2 +-
 drivers/media/platform/vivid/vivid-tpg-colors.c | 1182 ------------
 drivers/media/platform/vivid/vivid-tpg-colors.h |   68 -
 drivers/media/platform/vivid/vivid-tpg.c        | 2191 --------------------
 drivers/media/platform/vivid/vivid-tpg.h        |  596 ------
 include/media/tpg-colors.h                      |   68 +
 include/media/tpg.h                             |  595 ++++++
 15 files changed, 4069 insertions(+), 4039 deletions(-)
 create mode 100644 drivers/media/platform/tpg/Kconfig
 create mode 100644 drivers/media/platform/tpg/Makefile
 create mode 100644 drivers/media/platform/tpg/tpg-colors.c
 create mode 100644 drivers/media/platform/tpg/tpg-core.c
 delete mode 100644 drivers/media/platform/vivid/vivid-tpg-colors.c
 delete mode 100644 drivers/media/platform/vivid/vivid-tpg-colors.h
 delete mode 100644 drivers/media/platform/vivid/vivid-tpg.c
 delete mode 100644 drivers/media/platform/vivid/vivid-tpg.h
 create mode 100644 include/media/tpg-colors.h
 create mode 100644 include/media/tpg.h

include/media/tpg.h new file +4 -0

new file mode 100644
index 0000000..6dc79fb
@@ -0,0 +1,595 @@
+/*
+ * tpg.h - Test Pattern Generator
+ *
+ * Copyright 2014 Cisco Systems, Inc. and/or its affiliates. All rights

reserved.
+ *
+ * This program is free software; you may redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; version 2 of the License.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
+ * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
+ * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */

* This patch series add to the vimc driver video processing units ad a debayer and a scaler.
* The test pattern generator from vivid driver was exported as a module, as it is used by the vimc driver as well.
* The debayer transforms the bayer format image received in its sink pad to a bayer format by avaraging the pixels within a mean window
* The scaler only scales up the image for now.
* The ioctls to configure the format in the pads were implemented to allow testing the pipe from the user space

The patch series is based on 'vimc/review/video-pipe' branch, it goes on top of the patch named "[media] vimc: Virtual Media Controller core, capture and sensor" and is available at
https://github.com/helen-fornazier/opw-staging vimc/review/vpu

Helen Fornazier (7):
[media] tpg: Export the tpg code from vivid as a module

[media] vimc: sen: Integrate the tpg on the sensor [media] vimc: Add vimc_ent_sd_init/cleanup helper functions [media] vimc: Add vimc_pipeline_s_stream in the core [media] vimc: deb: Add debayer filter
[media] vimc: sca: Add scaler subdevice
[media] vimc: Implement set format in the nodes

 drivers/media/platform/Kconfig                  |    2 +
 drivers/media/platform/Makefile                 |    1 +
 drivers/media/platform/tpg/Kconfig              |    5 +
 drivers/media/platform/tpg/Makefile             |    3 +
 drivers/media/platform/tpg/tpg-colors.c         | 1181 ++++++++++++
 drivers/media/platform/tpg/tpg-core.c           | 2211 +++++++++++++++++++++++
 drivers/media/platform/vimc/Kconfig             |    1 +
 drivers/media/platform/vimc/Makefile            |    3 +-
 drivers/media/platform/vimc/vimc-capture.c      |   88 +-
 drivers/media/platform/vimc/vimc-core.c         |  196 +-
 drivers/media/platform/vimc/vimc-core.h         |   29 +
 drivers/media/platform/vimc/vimc-debayer.c      |  503 ++++++
 drivers/media/platform/vimc/vimc-debayer.h      |   28 +
 drivers/media/platform/vimc/vimc-scaler.c       |  362 ++++
 drivers/media/platform/vimc/vimc-scaler.h       |   28 +
 drivers/media/platform/vimc/vimc-sensor.c       |  175 +-
 drivers/media/platform/vivid/Kconfig            |    1 +
 drivers/media/platform/vivid/Makefile           |    2 +-
 drivers/media/platform/vivid/vivid-core.h       |    2 +-
 drivers/media/platform/vivid/vivid-tpg-colors.c | 1182 ------------
 drivers/media/platform/vivid/vivid-tpg-colors.h |   68 -
 drivers/media/platform/vivid/vivid-tpg.c        | 2191 ----------------------
 drivers/media/platform/vivid/vivid-tpg.h        |  596 ------
 include/media/tpg-colors.h                      |   68 +
 include/media/tpg.h                             |  595 ++++++
 25 files changed, 5345 insertions(+), 4176 deletions(-)
 create mode 100644 drivers/media/platform/tpg/Kconfig
 create mode 100644 drivers/media/platform/tpg/Makefile
 create mode 100644 drivers/media/platform/tpg/tpg-colors.c
 create mode 100644 drivers/media/platform/tpg/tpg-core.c
 create mode 100644 drivers/media/platform/vimc/vimc-debayer.c
 create mode 100644 drivers/media/platform/vimc/vimc-debayer.h
 create mode 100644 drivers/media/platform/vimc/vimc-scaler.c
 create mode 100644 drivers/media/platform/vimc/vimc-scaler.h
 delete mode 100644 drivers/media/platform/vivid/vivid-tpg-colors.c
 delete mode 100644 drivers/media/platform/vivid/vivid-tpg-colors.h
 delete mode 100644 drivers/media/platform/vivid/vivid-tpg.c
 delete mode 100644 drivers/media/platform/vivid/vivid-tpg.h
 create mode 100644 include/media/tpg-colors.h
 create mode 100644 include/media/tpg.h

Initialize the test pattern generator on the sensor Generate a colored bar image instead of a grey one

Signed-off-by Helen Koike <[email protected]>

---

Changes in v2:
[media] vimc: sen: Integrate the tpg on the sensor
- Fix include location
- Select V4L2_TPG in Kconfig
- configure tpg on streamon only
- rm BUG_ON
- coding style

---
 drivers/media/platform/vimc/Kconfig       |  1 +
 drivers/media/platform/vimc/vimc-sensor.c | 43 +++++++++++++++++++++++++++++--
 2 files changed, 42 insertions(+), 2 deletions(-)

drivers/media/platform/vimc/Kconfig +1 -0

index dd285fa..df124d4 100644
@@ -2,6 +2,7 @@ config VIDEO_VIMC
 	tristate "Virtual Media Controller Driver (VIMC)"
 	depends on VIDEO_DEV && VIDEO_V4L2 && VIDEO_V4L2_SUBDEV_API
 	select VIDEOBUF2_VMALLOC
+	select VIDEO_V4L2_TPG
 	default n
 	---help---
 	  Skeleton driver for Virtual Media Controller

drivers/media/platform/vimc/vimc-sensor.c +10 -0

index 591f6a4..9154322 100644
@@ -20,12 +20,16 @@
 #include <linux/v4l2-mediabus.h>
 #include <linux/vmalloc.h>
 #include <media/v4l2-subdev.h>
+#include <media/v4l2-tpg.h>
 
 #include "vimc-sensor.h"
 
+#define VIMC_SEN_FRAME_MAX_WIDTH 4096
+
 struct vimc_sen_device {
 	struct vimc_ent_device ved;
 	struct v4l2_subdev sd;
+	struct tpg_data tpg;
 	struct task_struct *kthread_sen;
 	u8 *frame;
 	/* The active format */

@@ -84,6 +88,28 @@ static int vimc_sen_get_fmt(struct v4l2_subdev *sd,
 	return 0;
 }
 
+static void vimc_sen_tpg_s_format(struct vimc_sen_device *vsen)
+{
+	const struct vimc_pix_map *vpix =
+				vimc_pix_map_by_code(vsen->mbus_format.code);
+
+	tpg_reset_source(&vsen->tpg, vsen->mbus_format.width,

drivers/media/platform/vimc/vimc-sensor.c +6 -0

+	tpg_s_colorspace(&vsen->tpg, vsen->mbus_format.colorspace);
+	tpg_s_ycbcr_enc(&vsen->tpg, vsen->mbus_format.ycbcr_enc);
+	tpg_s_quantization(&vsen->tpg, vsen->mbus_format.quantization);
+	tpg_s_xfer_func(&vsen->tpg, vsen->mbus_format.xfer_func);
+}
+
 static const struct v4l2_subdev_pad_ops vimc_sen_pad_ops = {
 	.enum_mbus_code		= vimc_sen_enum_mbus_code,
 	.enum_frame_size	= vimc_sen_enum_frame_size,

drivers/media/platform/vimc/vimc-sensor.c +11 -1

 		/* Send the frame to all source pads */
 		for (i = 0; i < vsen->sd.entity.num_pads; i++)

@@ -159,6 +185,9 @@ static int vimc_sen_s_stream(struct v4l2_subdev *sd, int enable)
 			vsen->frame = NULL;
 			return PTR_ERR(vsen->kthread_sen);
 		}
+
+		/* configure the test pattern generator */
+		vimc_sen_tpg_s_format(vsen);
 	} else {
 		if (!vsen->kthread_sen)
 			return -EINVAL;

@@ -189,6 +218,7 @@ static void vimc_sen_destroy(struct vimc_ent_device *ved)
 	struct vimc_sen_device *vsen =
 				container_of(ved, struct vimc_sen_device, ved);
 
+	tpg_free(&vsen->tpg);
 	v4l2_device_unregister_subdev(&vsen->sd);
 	media_entity_cleanup(ved->ent);
 	kfree(vsen);

@@ -254,17 +284,26 @@ struct vimc_ent_device *vimc_sen_create(struct v4l2_device *v4l2_dev,
 	vsen->mbus_format.quantization = V4L2_QUANTIZATION_FULL_RANGE;
 	vsen->mbus_format.xfer_func = V4L2_XFER_FUNC_SRGB;
 
+	/* Initialize the test pattern generator */
+	tpg_init(&vsen->tpg, vsen->mbus_format.width,
+		 vsen->mbus_format.height);
+	ret = tpg_alloc(&vsen->tpg, VIMC_SEN_FRAME_MAX_WIDTH);
+	if (ret)
+		goto err_clean_m_ent;
+
 	/* Register the subdev with the v4l2 and the media framework */
 	ret = v4l2_device_register_subdev(v4l2_dev, &vsen->sd);
 	if (ret) {
 		dev_err(vsen->sd.v4l2_dev->dev,
 			"%s: subdev register failed (err=%d)\n",
 			vsen->sd.name, ret);
-		goto err_clean_m_ent;