Re: [PATCH 3/3] s5p-tv: add drivers for TV on Samsung S5P platform

[Tomasz Stanislawski <t.stanislaws@samsung.com>]

Hans Verkuil wrote:
> On Wednesday, June 08, 2011 14:03:31 Tomasz Stanislawski wrote:
>
> And now the mixer review...
>   
I'll separate patches. What is the proposed order of drivers?
>   
>> Add drivers for TV outputs on Samsung platforms from S5P family.
>> - HDMIPHY - auxiliary I2C driver need by TV driver
>> - HDMI    - generation and control of streaming by HDMI output
>> - SDO     - streaming analog TV by Composite connector
>> - MIXER   - merging images from three layers and passing result to the output
>>
>> Interface:
>> - 3 video nodes with output queues
>> - support for multi plane API
>> - each nodes has up to 2 outputs (HDMI and SDO)
>> - outputs are controlled by S_STD and S_DV_PRESET ioctls
>>
>> Drivers are using:
>> - v4l2 framework
>> - videobuf2
>> - videobuf2-dma-contig as memory allocator
>> - runtime PM
>>
>> Signed-off-by: Tomasz Stanislawski <t.stanislaws@samsung.com>
>> Signed-off-by: Kyungmin Park <kyungmin.park@samsung.com>
>> Reviewed-by: Marek Szyprowski <m.szyprowski@samsung.com>
>> Reviewed-by: Sylwester Nawrocki <s.nawrocki@samsung.com>
>> ---
>> diff --git a/drivers/media/video/s5p-tv/mixer.h b/drivers/media/video/s5p-tv/mixer.h
>> new file mode 100644
>> index 0000000..6176b0a
>> --- /dev/null
>> +++ b/drivers/media/video/s5p-tv/mixer.h
>> @@ -0,0 +1,368 @@
>> +/*
>> + * Samsung TV Mixer driver
>> + *
>> + * Copyright (c) 2010-2011 Samsung Electronics Co., Ltd.
>> + *
>> + * Tomasz Stanislawski, <t.stanislaws@samsung.com>
>> + *
>> + * 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 Foundiation. either version 2 of the License,
>> + * or (at your option) any later version
>> + */
>> +
>> +#ifndef SAMSUNG_MIXER_H
>> +#define SAMSUNG_MIXER_H
>> +
>> +#if CONFIG_VIDEO_SAMSUNG_S5P_MIXER_LOG_LEVEL >= 7
>> +	#define DEBUG
>> +#endif
>> +
>> +#include <linux/fb.h>
>> +#include <linux/kernel.h>
>> +#include <linux/spinlock.h>
>> +#include <linux/wait.h>
>> +#include <media/v4l2-device.h>
>> +#include <media/videobuf2-core.h>
>> +
>> +#include "regs-mixer.h"
>> +
>> +/** maximum number of output interfaces */
>> +#define MXR_MAX_OUTPUTS 2
>> +/** maximum number of input interfaces (layers) */
>> +#define MXR_MAX_LAYERS 3
>> +#define MXR_DRIVER_NAME "s5p-mixer"
>> +/** maximal number of planes for every layer */
>> +#define MXR_MAX_PLANES	2
>> +
>> +#define MXR_ENABLE 1
>> +#define MXR_DISABLE 0
>> +
>> +/** description of a macroblock for packed formats */
>> +struct mxr_block {
>> +	/** vertical number of pixels in macroblock */
>> +	unsigned int width;
>> +	/** horizontal number of pixels in macroblock */
>> +	unsigned int height;
>> +	/** size of block in bytes */
>> +	unsigned int size;
>> +};
>> +
>> +/** description of supported format */
>> +struct mxr_format {
>> +	/** format name/mnemonic */
>> +	char *name;
>>     
>
> const?
>
>   
>> +	/** fourcc identifier */
>> +	u32 fourcc;
>> +	/** number of planes in image data */
>> +	int num_planes;
>> +	/** description of block for each plane */
>> +	struct mxr_block plane[MXR_MAX_PLANES];
>> +	/** number of subframes in image data */
>> +	int num_subframes;
>> +	/** specifies to which subframe belong given plane */
>> +	int plane2subframe[MXR_MAX_PLANES];
>> +	/** internal code, driver dependant */
>> +	unsigned long cookie;
>> +};
>> +
>> +/** description of crop configuration for image */
>> +struct mxr_crop {
>> +	/** width of layer in pixels */
>> +	unsigned int full_width;
>> +	/** height of layer in pixels */
>> +	unsigned int full_height;
>> +	/** horizontal offset of first pixel to be displayed */
>> +	unsigned int x_offset;
>> +	/** vertical offset of first pixel to be displayed */
>> +	unsigned int y_offset;
>> +	/** width of displayed data in pixels */
>> +	unsigned int width;
>> +	/** height of displayed data in pixels */
>> +	unsigned int height;
>> +	/** indicate which fields are present in buffer */
>> +	unsigned int field;
>> +};
>> +
>> +/** description of transformation from source to destination image */
>> +struct mxr_geometry {
>> +	/** cropping for source image */
>> +	struct mxr_crop src;
>> +	/** cropping for destination image */
>> +	struct mxr_crop dst;
>> +	/** layer-dependant description of horizontal scaling */
>> +	unsigned int x_ratio;
>> +	/** layer-dependant description of vertical scaling */
>> +	unsigned int y_ratio;
>> +};
>> +
>> +/** instance of a buffer */
>> +struct mxr_buffer {
>> +	/** common v4l buffer stuff -- must be first */
>> +	struct vb2_buffer	vb;
>> +	/** node for layer's lists */
>> +	struct list_head	list;
>> +};
>> +
>> +
>> +/** internal states of layer */
>> +enum mxr_layer_state {
>> +	/** layers is not shown */
>> +	MXR_LAYER_IDLE = 0,
>> +	/** state between STREAMON and hardware start */
>> +	MXR_LAYER_STREAMING_START,
>> +	/** layer is shown */
>> +	MXR_LAYER_STREAMING,
>> +	/** state before STREAMOFF is finished */
>> +	MXR_LAYER_STREAMING_FINISH,
>> +};
>> +
>> +/** forward declarations */
>> +struct mxr_device;
>> +struct mxr_layer;
>> +
>> +/** callback for layers operation */
>> +struct mxr_layer_ops {
>> +	/* TODO: try to port it to subdev API */
>> +	/** handler for resource release function */
>> +	void (*release)(struct mxr_layer *);
>> +	/** setting buffer to HW */
>> +	void (*buffer_set)(struct mxr_layer *, struct mxr_buffer *);
>> +	/** setting format and geometry in HW */
>> +	void (*format_set)(struct mxr_layer *);
>> +	/** streaming stop/start */
>> +	void (*stream_set)(struct mxr_layer *, int);
>> +	/** adjusting geometry */
>> +	void (*fix_geometry)(struct mxr_layer *);
>> +};
>> +
>> +/** layer instance, a single window and content displayed on output */
>> +struct mxr_layer {
>> +	/** parent mixer device */
>> +	struct mxr_device *mdev;
>> +	/** layer index (unique identifier) */
>> +	int idx;
>> +	/** callbacks for layer methods */
>> +	struct mxr_layer_ops ops;
>> +	/** format array */
>> +	const struct mxr_format **fmt_array;
>> +	/** size of format array */
>> +	unsigned long fmt_array_size;
>> +
>> +	/** lock for protection of list and state fields */
>> +	spinlock_t enq_slock;
>> +	/** list for enqueued buffers */
>> +	struct list_head enq_list;
>> +	/** buffer currently owned by hardware in temporary registers */
>> +	struct mxr_buffer *update_buf;
>> +	/** buffer currently owned by hardware in shadow registers */
>> +	struct mxr_buffer *shadow_buf;
>> +	/** state of layer IDLE/STREAMING */
>> +	enum mxr_layer_state state;
>> +
>> +	/** mutex for protection of fields below */
>> +	struct mutex mutex;
>> +	/** use count */
>> +	int n_user;
>> +	/** handler for video node */
>> +	struct video_device vfd;
>> +	/** queue for output buffers */
>> +	struct vb2_queue vb_queue;
>> +	/** current image format */
>> +	const struct mxr_format *fmt;
>> +	/** current geometry of image */
>> +	struct mxr_geometry geo;
>> +};
>> +
>> +/** description of mixers output interface */
>> +struct mxr_output {
>> +	/** name of output */
>> +	char name[32];
>> +	/** output subdev */
>> +	struct v4l2_subdev *sd;
>> +	/** cookie used for configuration of registers */
>> +	int cookie;
>> +};
>> +
>> +/** specify source of output subdevs */
>> +struct mxr_output_conf {
>> +	/** name of output (connector) */
>> +	char *output_name;
>> +	/** name of module that generates output subdev */
>> +	char *module_name;
>> +	/** cookie need for mixer HW */
>> +	int cookie;
>> +};
>> +
>> +struct clk;
>> +struct regulator;
>> +
>> +/** auxiliary resources used my mixer */
>> +struct mxr_resources {
>> +	/** interrupt index */
>> +	int irq;
>> +	/** pointer to Mixer registers */
>> +	void __iomem *mxr_regs;
>> +	/** pointer to Video Processor registers */
>> +	void __iomem *vp_regs;
>> +	/** other resources, should used under mxr_device.mutex */
>> +	struct clk *mixer;
>> +	struct clk *vp;
>> +	struct clk *sclk_mixer;
>> +	struct clk *sclk_hdmi;
>> +	struct clk *sclk_dac;
>> +};
>> +
>> +/* event flags used  */
>> +enum mxr_devide_flags {
>> +	MXR_EVENT_VSYNC = 0,
>> +};
>> +
>> +/** drivers instance */
>> +struct mxr_device {
>> +	/** master device */
>> +	struct device *dev;
>> +	/** state of each layer */
>> +	struct mxr_layer *layer[MXR_MAX_LAYERS];
>> +	/** state of each output */
>> +	struct mxr_output *output[MXR_MAX_OUTPUTS];
>> +	/** number of registered outputs */
>> +	int output_cnt;
>> +
>> +	/* video resources */
>> +
>> +	/** V4L2 device */
>> +	struct v4l2_device v4l2_dev;
>> +	/** context of allocator */
>> +	void *alloc_ctx;
>> +	/** event wait queue */
>> +	wait_queue_head_t event_queue;
>> +	/** state flags */
>> +	unsigned long event_flags;
>> +
>> +	/** spinlock for protection of registers */
>> +	spinlock_t reg_slock;
>> +
>> +	/** mutex for protection of fields below */
>> +	struct mutex mutex;
>> +	/** number of entities depndant on output configuration */
>> +	int n_output;
>> +	/** number of users that do streaming */
>> +	int n_streamer;
>> +	/** index of current output */
>> +	int current_output;
>> +	/** auxiliary resources used my mixer */
>> +	struct mxr_resources res;
>> +};
>> +
>> +/** transform device structure into mixer device */
>> +static inline struct mxr_device *to_mdev(struct device *dev)
>> +{
>> +	struct v4l2_device *vdev = dev_get_drvdata(dev);
>> +	return container_of(vdev, struct mxr_device, v4l2_dev);
>> +}
>> +
>> +/** get current output data, should be called under mdev's mutex */
>> +static inline struct mxr_output *to_output(struct mxr_device *mdev)
>> +{
>> +	return mdev->output[mdev->current_output];
>> +}
>> +
>> +/** get current output subdev, should be called under mdev's mutex */
>> +static inline struct v4l2_subdev *to_outsd(struct mxr_device *mdev)
>> +{
>> +	struct mxr_output *out = to_output(mdev);
>> +	return out ? out->sd : NULL;
>> +}
>> +
>> +/** forward declaration for mixer platform data */
>> +struct mxr_platform_data;
>> +
>> +/** acquiring common video resources */
>> +int __devinit mxr_acquire_video(struct mxr_device *mdev,
>> +	struct mxr_output_conf *output_cont, int output_count);
>> +
>> +/** releasing common video resources */
>> +void __devexit mxr_release_video(struct mxr_device *mdev);
>> +
>> +struct mxr_layer *mxr_graph_layer_create(struct mxr_device *mdev, int idx);
>> +struct mxr_layer *mxr_vp_layer_create(struct mxr_device *mdev, int idx);
>> +struct mxr_layer *mxr_base_layer_create(struct mxr_device *mdev,
>> +	int idx, char *name, struct mxr_layer_ops *ops);
>> +
>> +void mxr_base_layer_release(struct mxr_layer *layer);
>> +void mxr_layer_release(struct mxr_layer *layer);
>> +
>> +int mxr_base_layer_register(struct mxr_layer *layer);
>> +void mxr_base_layer_unregister(struct mxr_layer *layer);
>> +
>> +unsigned long mxr_get_plane_size(const struct mxr_block *blk,
>> +	unsigned int width, unsigned int height);
>> +
>> +/** adds new consumer for mixer's power */
>> +int __must_check mxr_power_get(struct mxr_device *mdev);
>> +/** removes consumer for mixer's power */
>> +void mxr_power_put(struct mxr_device *mdev);
>> +/** add new client for output configuration */
>> +void mxr_output_get(struct mxr_device *mdev);
>> +/** removes new client for output configuration */
>> +void mxr_output_put(struct mxr_device *mdev);
>> +/** add new client for streaming */
>> +void mxr_streamer_get(struct mxr_device *mdev);
>> +/** removes new client for streaming */
>> +void mxr_streamer_put(struct mxr_device *mdev);
>> +/** returns format of data delivared to current output */
>> +void mxr_get_mbus_fmt(struct mxr_device *mdev,
>> +	struct v4l2_mbus_framefmt *mbus_fmt);
>> +
>> +/* Debug */
>> +
>> +#if CONFIG_VIDEO_SAMSUNG_S5P_MIXER_LOG_LEVEL >= 3
>> +	#define mxr_err(mdev, fmt, ...)  dev_err(mdev->dev, fmt, ##__VA_ARGS__)
>> +#else
>> +	#define mxr_err(mdev, fmt, ...)  do { (void) mdev; } while (0)
>> +#endif
>> +
>> +#if CONFIG_VIDEO_SAMSUNG_S5P_MIXER_LOG_LEVEL >= 4
>> +	#define mxr_warn(mdev, fmt, ...) dev_warn(mdev->dev, fmt, ##__VA_ARGS__)
>> +#else
>> +	#define mxr_warn(mdev, fmt, ...)  do { (void) mdev; } while (0)
>> +#endif
>> +
>> +#if CONFIG_VIDEO_SAMSUNG_S5P_MIXER_LOG_LEVEL >= 6
>> +	#define mxr_info(mdev, fmt, ...) dev_info(mdev->dev, fmt, ##__VA_ARGS__)
>> +#else
>> +	#define mxr_info(mdev, fmt, ...)  do {(void) mdev; } while (0)
>> +#endif
>> +
>> +#if CONFIG_VIDEO_SAMSUNG_S5P_MIXER_LOG_LEVEL >= 7
>> +	#define mxr_dbg(mdev, fmt, ...)  dev_dbg(mdev->dev, fmt, ##__VA_ARGS__)
>> +#else
>> +	#define mxr_dbg(mdev, fmt, ...)  do { (void) mdev; } while (0)
>> +#endif
>> +
>> +/* accessing Mixer's and Video Processor's registers */
>> +
>> +void mxr_vsync_set_update(struct mxr_device *mdev, int en);
>> +void mxr_reg_reset(struct mxr_device *mdev);
>> +irqreturn_t mxr_irq_handler(int irq, void *dev_data);
>> +void mxr_reg_s_output(struct mxr_device *mdev, int cookie);
>> +void mxr_reg_streamon(struct mxr_device *mdev);
>> +void mxr_reg_streamoff(struct mxr_device *mdev);
>> +int mxr_reg_wait4vsync(struct mxr_device *mdev);
>> +void mxr_reg_set_mbus_fmt(struct mxr_device *mdev,
>> +	struct v4l2_mbus_framefmt *fmt);
>> +void mxr_reg_graph_layer_stream(struct mxr_device *mdev, int idx, int en);
>> +void mxr_reg_graph_buffer(struct mxr_device *mdev, int idx, dma_addr_t addr);
>> +void mxr_reg_graph_format(struct mxr_device *mdev, int idx,
>> +	const struct mxr_format *fmt, const struct mxr_geometry *geo);
>> +
>> +void mxr_reg_vp_layer_stream(struct mxr_device *mdev, int en);
>> +void mxr_reg_vp_buffer(struct mxr_device *mdev,
>> +	dma_addr_t luma_addr[2], dma_addr_t chroma_addr[2]);
>> +void mxr_reg_vp_format(struct mxr_device *mdev,
>> +	const struct mxr_format *fmt, const struct mxr_geometry *geo);
>> +void mxr_reg_dump(struct mxr_device *mdev);
>> +
>> +#endif /* SAMSUNG_MIXER_H */
>> +
>> diff --git a/drivers/media/video/s5p-tv/mixer_drv.c b/drivers/media/video/s5p-tv/mixer_drv.c
>> new file mode 100644
>> index 0000000..5dca57b
>> --- /dev/null
>> +++ b/drivers/media/video/s5p-tv/mixer_drv.c
>> @@ -0,0 +1,494 @@
>> +/*
>> + * Samsung TV Mixer driver
>> + *
>> + * Copyright (c) 2010-2011 Samsung Electronics Co., Ltd.
>> + *
>> + * Tomasz Stanislawski, <t.stanislaws@samsung.com>
>> + *
>> + * 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 Foundiation. either version 2 of the License,
>> + * or (at your option) any later version
>> + */
>> +
>> +#include "mixer.h"
>> +
>> +#include <linux/module.h>
>> +#include <linux/platform_device.h>
>> +#include <linux/io.h>
>> +#include <linux/interrupt.h>
>> +#include <linux/irq.h>
>> +#include <linux/fb.h>
>> +#include <linux/delay.h>
>> +#include <linux/pm_runtime.h>
>> +#include <linux/clk.h>
>> +
>> +MODULE_AUTHOR("Tomasz Stanislawski, <t.stanislaws@samsung.com>");
>> +MODULE_DESCRIPTION("Samsung MIXER");
>> +MODULE_LICENSE("GPL");
>> +
>> +/* --------- DRIVER PARAMETERS ---------- */
>> +
>> +static struct mxr_output_conf mxr_output_conf[] = {
>> +	{
>> +		.output_name = "S5P HDMI connector",
>> +		.module_name = "s5p-hdmi",
>> +		.cookie = 1,
>> +	},
>> +	{
>> +		.output_name = "S5P SDO connector",
>> +		.module_name = "s5p-sdo",
>> +		.cookie = 0,
>> +	},
>> +};
>> +
>> +/* --------- DRIVER INITIALIZATION ---------- */
>> +
>> +static struct platform_driver mxr_driver __refdata;
>> +
>> +static int __init mxr_init(void)
>> +{
>> +	int i, ret;
>> +	static const char banner[] __initdata = KERN_INFO
>> +		"Samsung TV Mixer driver, "
>> +		"(c) 2010-2011 Samsung Electronics Co., Ltd.\n";
>> +	printk(banner);
>> +
>> +	/* Loading auxiliary modules */
>> +	for (i = 0; i < ARRAY_SIZE(mxr_output_conf); ++i)
>> +		request_module(mxr_output_conf[i].module_name);
>> +
>> +	ret = platform_driver_register(&mxr_driver);
>> +	if (ret != 0) {
>> +		printk(KERN_ERR "registration of MIXER driver failed\n");
>> +		return -ENXIO;
>> +	}
>> +
>> +	return 0;
>> +}
>> +module_init(mxr_init);
>> +
>> +static void __exit mxr_exit(void)
>> +{
>> +	platform_driver_unregister(&mxr_driver);
>> +}
>> +module_exit(mxr_exit);
>> +
>> +static int __devinit mxr_acquire_resources(struct mxr_device *mdev,
>> +	struct platform_device *pdev);
>> +
>> +static void mxr_release_resources(struct mxr_device *mdev);
>> +
>> +static int __devinit mxr_acquire_layers(struct mxr_device *mdev,
>> +	struct mxr_platform_data *pdata);
>> +
>> +static void mxr_release_layers(struct mxr_device *mxr_dev);
>> +
>> +static int __devinit mxr_probe(struct platform_device *pdev)
>> +{
>> +	struct device *dev = &pdev->dev;
>> +	struct mxr_platform_data *pdata = dev->platform_data;
>> +	struct mxr_device *mdev;
>> +	int ret;
>> +
>> +	/* mdev does not exist yet so no mxr_dbg is used */
>> +	dev_info(dev, "probe start\n");
>> +
>> +	mdev = kzalloc(sizeof *mdev, GFP_KERNEL);
>> +	if (!mdev) {
>> +		mxr_err(mdev, "not enough memory.\n");
>> +		ret = -ENOMEM;
>> +		goto fail;
>> +	}
>> +
>> +	/* setup pointer to master device */
>> +	mdev->dev = dev;
>> +
>> +	mutex_init(&mdev->mutex);
>> +	spin_lock_init(&mdev->reg_slock);
>> +	init_waitqueue_head(&mdev->event_queue);
>> +
>> +	/* acquire resources: regs, irqs, clocks, regulators */
>> +	ret = mxr_acquire_resources(mdev, pdev);
>> +	if (ret)
>> +		goto fail_mem;
>> +
>> +	/* configure resources for video output */
>> +	ret = mxr_acquire_video(mdev, mxr_output_conf,
>> +		ARRAY_SIZE(mxr_output_conf));
>> +	if (ret)
>> +		goto fail_resources;
>> +
>> +	/* configure layers */
>> +	ret = mxr_acquire_layers(mdev, pdata);
>> +	if (ret)
>> +		goto fail_video;
>> +
>> +	pm_runtime_enable(dev);
>> +
>> +	mxr_info(mdev, "probe successful\n");
>> +	return 0;
>> +
>> +fail_video:
>> +	mxr_release_video(mdev);
>> +
>> +fail_resources:
>> +	mxr_release_resources(mdev);
>> +
>> +fail_mem:
>> +	kfree(mdev);
>> +
>> +fail:
>> +	dev_info(dev, "probe failed\n");
>> +	return ret;
>> +}
>> +
>> +static int __devexit mxr_remove(struct platform_device *pdev)
>> +{
>> +	struct device *dev = &pdev->dev;
>> +	struct mxr_device *mdev = to_mdev(dev);
>> +
>> +	pm_runtime_disable(dev);
>> +
>> +	mxr_release_layers(mdev);
>> +	mxr_release_video(mdev);
>> +	mxr_release_resources(mdev);
>> +
>> +	kfree(mdev);
>> +
>> +	dev_info(dev, "remove sucessful\n");
>> +	return 0;
>> +}
>> +
>> +static int mxr_runtime_resume(struct device *dev)
>> +{
>> +	struct mxr_device *mdev = to_mdev(dev);
>> +	struct mxr_resources *res = &mdev->res;
>> +
>> +	mxr_dbg(mdev, "resume - start\n");
>> +	mutex_lock(&mdev->mutex);
>> +	/* turn clocks on */
>> +	clk_enable(res->mixer);
>> +	clk_enable(res->vp);
>> +	clk_enable(res->sclk_mixer);
>> +	mxr_dbg(mdev, "resume - finished\n");
>> +
>> +	mutex_unlock(&mdev->mutex);
>> +	return 0;
>> +}
>> +
>> +static int mxr_runtime_suspend(struct device *dev)
>> +{
>> +	struct mxr_device *mdev = to_mdev(dev);
>> +	struct mxr_resources *res = &mdev->res;
>> +	mxr_dbg(mdev, "suspend - start\n");
>> +	mutex_lock(&mdev->mutex);
>> +	/* turn clocks off */
>> +	clk_disable(res->sclk_mixer);
>> +	clk_disable(res->vp);
>> +	clk_disable(res->mixer);
>> +	mutex_unlock(&mdev->mutex);
>> +	mxr_dbg(mdev, "suspend - finished\n");
>> +	return 0;
>> +}
>> +
>> +static const struct dev_pm_ops mxr_pm_ops = {
>> +	.runtime_suspend = mxr_runtime_suspend,
>> +	.runtime_resume	 = mxr_runtime_resume,
>> +};
>> +
>> +static struct platform_driver mxr_driver __refdata = {
>> +	.probe = mxr_probe,
>> +	.remove = __devexit_p(mxr_remove),
>> +	.driver = {
>> +		.name = MXR_DRIVER_NAME,
>> +		.owner = THIS_MODULE,
>> +		.pm = &mxr_pm_ops,
>> +	}
>> +};
>> +
>> +static int __devinit mxr_acquire_plat_resources(struct mxr_device *mdev,
>> +	struct platform_device *pdev)
>> +{
>> +	struct resource *res;
>> +	int ret;
>> +
>> +	res = platform_get_resource_byname(pdev, IORESOURCE_MEM, "mxr");
>> +	if (res == NULL) {
>> +		mxr_err(mdev, "get memory resource failed.\n");
>> +		ret = -ENXIO;
>> +		goto fail;
>> +	}
>> +
>> +	mdev->res.mxr_regs = ioremap(res->start, resource_size(res));
>> +	if (mdev->res.mxr_regs == NULL) {
>> +		mxr_err(mdev, "register mapping failed.\n");
>> +		ret = -ENXIO;
>> +		goto fail;
>> +	}
>> +
>> +	res = platform_get_resource_byname(pdev, IORESOURCE_MEM, "vp");
>> +	if (res == NULL) {
>> +		mxr_err(mdev, "get memory resource failed.\n");
>> +		ret = -ENXIO;
>> +		goto fail_mxr_regs;
>> +	}
>> +
>> +	mdev->res.vp_regs = ioremap(res->start, resource_size(res));
>> +	if (mdev->res.vp_regs == NULL) {
>> +		mxr_err(mdev, "register mapping failed.\n");
>> +		ret = -ENXIO;
>> +		goto fail_mxr_regs;
>> +	}
>> +
>> +	res = platform_get_resource_byname(pdev, IORESOURCE_IRQ, "irq");
>> +	if (res == NULL) {
>> +		mxr_err(mdev, "get interrupt resource failed.\n");
>> +		ret = -ENXIO;
>> +		goto fail_vp_regs;
>> +	}
>> +
>> +	ret = request_irq(res->start, mxr_irq_handler, 0, "s5p-mixer", mdev);
>> +	if (ret) {
>> +		mxr_err(mdev, "request interrupt failed.\n");
>> +		goto fail_vp_regs;
>> +	}
>> +	mdev->res.irq = res->start;
>> +
>> +	return 0;
>> +
>> +fail_vp_regs:
>> +	iounmap(mdev->res.vp_regs);
>> +
>> +fail_mxr_regs:
>> +	iounmap(mdev->res.mxr_regs);
>> +
>> +fail:
>> +	return ret;
>> +}
>> +
>> +static void mxr_release_plat_resources(struct mxr_device *mdev)
>> +{
>> +	free_irq(mdev->res.irq, mdev);
>> +	iounmap(mdev->res.vp_regs);
>> +	iounmap(mdev->res.mxr_regs);
>> +}
>> +
>> +static void mxr_release_clocks(struct mxr_device *mdev)
>> +{
>> +	struct mxr_resources *res = &mdev->res;
>> +
>> +	if (!IS_ERR_OR_NULL(res->sclk_dac))
>> +		clk_put(res->sclk_dac);
>> +	if (!IS_ERR_OR_NULL(res->sclk_hdmi))
>> +		clk_put(res->sclk_hdmi);
>> +	if (!IS_ERR_OR_NULL(res->sclk_mixer))
>> +		clk_put(res->sclk_mixer);
>> +	if (!IS_ERR_OR_NULL(res->vp))
>> +		clk_put(res->vp);
>> +	if (!IS_ERR_OR_NULL(res->mixer))
>> +		clk_put(res->mixer);
>> +}
>> +
>> +static int mxr_acquire_clocks(struct mxr_device *mdev)
>> +{
>> +	struct mxr_resources *res = &mdev->res;
>> +	struct device *dev = mdev->dev;
>> +
>> +	res->mixer = clk_get(dev, "mixer");
>> +	if (IS_ERR_OR_NULL(res->mixer)) {
>> +		mxr_err(mdev, "failed to get clock 'mixer'\n");
>> +		goto fail;
>> +	}
>> +	res->vp = clk_get(dev, "vp");
>> +	if (IS_ERR_OR_NULL(res->vp)) {
>> +		mxr_err(mdev, "failed to get clock 'vp'\n");
>> +		goto fail;
>> +	}
>> +	res->sclk_mixer = clk_get(dev, "sclk_mixer");
>> +	if (IS_ERR_OR_NULL(res->sclk_mixer)) {
>> +		mxr_err(mdev, "failed to get clock 'sclk_mixer'\n");
>> +		goto fail;
>> +	}
>> +	res->sclk_hdmi = clk_get(dev, "sclk_hdmi");
>> +	if (IS_ERR_OR_NULL(res->sclk_hdmi)) {
>> +		mxr_err(mdev, "failed to get clock 'sclk_hdmi'\n");
>> +		goto fail;
>> +	}
>> +	res->sclk_dac = clk_get(dev, "sclk_dac");
>> +	if (IS_ERR_OR_NULL(res->sclk_dac)) {
>> +		mxr_err(mdev, "failed to get clock 'sclk_dac'\n");
>> +		goto fail;
>> +	}
>> +
>> +	return 0;
>> +fail:
>> +	mxr_release_clocks(mdev);
>> +	return -ENODEV;
>> +}
>> +
>> +static int __devinit mxr_acquire_resources(struct mxr_device *mdev,
>> +	struct platform_device *pdev)
>> +{
>> +	int ret;
>> +	ret = mxr_acquire_plat_resources(mdev, pdev);
>> +
>> +	if (ret)
>> +		goto fail;
>> +
>> +	ret = mxr_acquire_clocks(mdev);
>> +	if (ret)
>> +		goto fail_plat;
>> +
>> +	mxr_info(mdev, "resources acquired\n");
>> +	return 0;
>> +
>> +fail_plat:
>> +	mxr_release_plat_resources(mdev);
>> +fail:
>> +	mxr_err(mdev, "resources acquire failed\n");
>> +	return ret;
>> +}
>> +
>> +static void mxr_release_resources(struct mxr_device *mdev)
>> +{
>> +	mxr_release_clocks(mdev);
>> +	mxr_release_plat_resources(mdev);
>> +	memset(&mdev->res, 0, sizeof mdev->res);
>> +}
>> +
>> +static int __devinit mxr_acquire_layers(struct mxr_device *mdev,
>> +	struct mxr_platform_data *pdata)
>> +{
>> +	mdev->layer[0] = mxr_graph_layer_create(mdev, 0);
>> +	mdev->layer[1] = mxr_graph_layer_create(mdev, 1);
>> +	mdev->layer[2] = mxr_vp_layer_create(mdev, 0);
>> +
>> +	if (!mdev->layer[0] || !mdev->layer[1] || !mdev->layer[2]) {
>> +		mxr_err(mdev, "failed to acquire layers\n");
>> +		goto fail;
>> +	}
>> +
>> +	return 0;
>> +
>> +fail:
>> +	mxr_release_layers(mdev);
>> +	return -ENODEV;
>> +}
>> +
>> +static void mxr_release_layers(struct mxr_device *mdev)
>> +{
>> +	int i;
>> +
>> +	for (i = 0; i < ARRAY_SIZE(mdev->layer); ++i)
>> +		if (mdev->layer[i])
>> +			mxr_layer_release(mdev->layer[i]);
>> +}
>> +
>> +int mxr_power_get(struct mxr_device *mdev)
>> +{
>> +	int ret = pm_runtime_get_sync(mdev->dev);
>> +
>> +	/* returning 1 means that power is already enabled,
>> +	 * so zero success be returned */
>> +	if (IS_ERR_VALUE(ret))
>> +		return ret;
>> +	return 0;
>> +}
>> +
>> +void mxr_power_put(struct mxr_device *mdev)
>> +{
>> +	pm_runtime_put_sync(mdev->dev);
>> +}
>> +
>> +void mxr_get_mbus_fmt(struct mxr_device *mdev,
>> +	struct v4l2_mbus_framefmt *mbus_fmt)
>> +{
>> +	struct v4l2_subdev *sd;
>> +	int ret;
>> +
>> +	mutex_lock(&mdev->mutex);
>> +	sd = to_outsd(mdev);
>> +	ret = v4l2_subdev_call(sd, video, g_mbus_fmt, mbus_fmt);
>> +	WARN(ret, "failed to get mbus_fmt for output %s\n", sd->name);
>> +	mutex_unlock(&mdev->mutex);
>> +}
>> +
>> +void mxr_streamer_get(struct mxr_device *mdev)
>> +{
>> +	mutex_lock(&mdev->mutex);
>> +	++mdev->n_streamer;
>> +	mxr_dbg(mdev, "%s(%d)\n", __func__, mdev->n_streamer);
>> +	if (mdev->n_streamer == 1) {
>> +		struct v4l2_subdev *sd = to_outsd(mdev);
>> +		struct v4l2_mbus_framefmt mbus_fmt;
>> +		struct mxr_resources *res = &mdev->res;
>> +		int ret;
>> +
>> +		ret = v4l2_subdev_call(sd, video, g_mbus_fmt, &mbus_fmt);
>> +		WARN(ret, "failed to get mbus_fmt for output %s\n", sd->name);
>> +		ret = v4l2_subdev_call(sd, video, s_stream, 1);
>> +		WARN(ret, "starting stream failed for output %s\n", sd->name);
>> +		if (to_output(mdev)->cookie == 0)
>> +			clk_set_parent(res->sclk_mixer, res->sclk_dac);
>> +		else
>> +			clk_set_parent(res->sclk_mixer, res->sclk_hdmi);
>> +		/* apply default configuration */
>> +		mxr_reg_reset(mdev);
>> +		mxr_reg_set_mbus_fmt(mdev, &mbus_fmt);
>> +		mxr_reg_s_output(mdev, to_output(mdev)->cookie);
>> +		mxr_reg_streamon(mdev);
>> +		ret = mxr_reg_wait4vsync(mdev);
>> +		WARN(ret, "failed to get vsync (%d) from output\n", ret);
>> +	}
>> +	mutex_unlock(&mdev->mutex);
>> +	mxr_reg_dump(mdev);
>> +	/* FIXME: what to do when streaming fails? */
>> +}
>> +
>> +void mxr_streamer_put(struct mxr_device *mdev)
>> +{
>> +	mutex_lock(&mdev->mutex);
>> +	--mdev->n_streamer;
>> +	mxr_dbg(mdev, "%s(%d)\n", __func__, mdev->n_streamer);
>> +	if (mdev->n_streamer == 0) {
>> +		int ret;
>> +		struct v4l2_subdev *sd = to_outsd(mdev);
>> +
>> +		mxr_reg_streamoff(mdev);
>> +		/* vsync applies Mixer setup */
>> +		ret = mxr_reg_wait4vsync(mdev);
>> +		WARN(ret, "failed to get vsync (%d) from output\n", ret);
>> +		ret = v4l2_subdev_call(sd, video, s_stream, 0);
>> +		WARN(ret, "stopping stream failed for output %s\n", sd->name);
>> +	}
>> +	WARN(mdev->n_streamer < 0, "negative number of streamers (%d)\n",
>> +		mdev->n_streamer);
>> +	mutex_unlock(&mdev->mutex);
>> +	mxr_reg_dump(mdev);
>> +}
>> +
>> +void mxr_output_get(struct mxr_device *mdev)
>> +{
>> +	mutex_lock(&mdev->mutex);
>> +	++mdev->n_output;
>> +	mxr_dbg(mdev, "%s(%d)\n", __func__, mdev->n_output);
>> +	/* turn on auxliary driver */
>>     
>
> typo: auxiliary
>
>   
>> +	if (mdev->n_output == 1)
>> +		v4l2_subdev_call(to_outsd(mdev), core, s_power, 1);
>> +	mutex_unlock(&mdev->mutex);
>> +}
>> +
>> +void mxr_output_put(struct mxr_device *mdev)
>> +{
>> +	mutex_lock(&mdev->mutex);
>> +	--mdev->n_output;
>> +	mxr_dbg(mdev, "%s(%d)\n", __func__, mdev->n_output);
>> +	/* turn on auxliary driver */
>>     
>
> same typo.
>
>   
>> +	if (mdev->n_output == 0)
>> +		v4l2_subdev_call(to_outsd(mdev), core, s_power, 0);
>> +	WARN(mdev->n_output < 0, "negative number of output users (%d)\n",
>> +		mdev->n_output);
>> +	mutex_unlock(&mdev->mutex);
>> +}
>> +
>> diff --git a/drivers/media/video/s5p-tv/mixer_grp_layer.c b/drivers/media/video/s5p-tv/mixer_grp_layer.c
>> new file mode 100644
>> index 0000000..8c14531
>> --- /dev/null
>> +++ b/drivers/media/video/s5p-tv/mixer_grp_layer.c
>> @@ -0,0 +1,181 @@
>> +/*
>> + * Samsung TV Mixer driver
>> + *
>> + * Copyright (c) 2010-2011 Samsung Electronics Co., Ltd.
>> + *
>> + * Tomasz Stanislawski, <t.stanislaws@samsung.com>
>> + *
>> + * 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 Foundiation. either version 2 of the License,
>> + * or (at your option) any later version
>> + */
>> +
>> +#include "mixer.h"
>> +
>> +#include <media/videobuf2-dma-contig.h>
>> +
>> +/* FORMAT DEFINITIONS */
>> +
>> +static const struct mxr_format mxr_fb_fmt_rgb565 = {
>> +	.name = "RGB565",
>> +	.fourcc = V4L2_PIX_FMT_RGB565,
>> +	.num_planes = 1,
>> +	.plane = {
>> +		{ .width = 1, .height = 1, .size = 2 },
>> +	},
>> +	.num_subframes = 1,
>> +	.cookie = 4,
>> +};
>> +
>> +static const struct mxr_format mxr_fb_fmt_argb1555 = {
>> +	.name = "ARGB1555",
>> +	.num_planes = 1,
>> +	.fourcc = V4L2_PIX_FMT_RGB555,
>> +	.plane = {
>> +		{ .width = 1, .height = 1, .size = 2 },
>> +	},
>> +	.num_subframes = 1,
>> +	.cookie = 5,
>> +};
>> +
>> +static const struct mxr_format mxr_fb_fmt_argb4444 = {
>> +	.name = "ARGB4444",
>> +	.num_planes = 1,
>> +	.fourcc = V4L2_PIX_FMT_RGB444,
>> +	.plane = {
>> +		{ .width = 1, .height = 1, .size = 2 },
>> +	},
>> +	.num_subframes = 1,
>> +	.cookie = 6,
>> +};
>> +
>> +static const struct mxr_format mxr_fb_fmt_argb8888 = {
>> +	.name = "ARGB8888",
>> +	.fourcc = V4L2_PIX_FMT_BGR32,
>> +	.num_planes = 1,
>> +	.plane = {
>> +		{ .width = 1, .height = 1, .size = 4 },
>> +	},
>> +	.num_subframes = 1,
>> +	.cookie = 7,
>> +};
>> +
>> +static const struct mxr_format *mxr_graph_format[] = {
>> +	&mxr_fb_fmt_rgb565,
>> +	&mxr_fb_fmt_argb1555,
>> +	&mxr_fb_fmt_argb4444,
>> +	&mxr_fb_fmt_argb8888,
>> +};
>> +
>> +/* AUXILIARY CALLBACKS */
>> +
>> +static void mxr_graph_layer_release(struct mxr_layer *layer)
>> +{
>> +	mxr_base_layer_unregister(layer);
>> +	mxr_base_layer_release(layer);
>> +}
>> +
>> +static void mxr_graph_buffer_set(struct mxr_layer *layer,
>> +	struct mxr_buffer *buf)
>> +{
>> +	dma_addr_t addr = 0;
>> +
>> +	if (buf)
>> +		addr = vb2_dma_contig_plane_paddr(&buf->vb, 0);
>> +	mxr_reg_graph_buffer(layer->mdev, layer->idx, addr);
>> +}
>> +
>> +static void mxr_graph_stream_set(struct mxr_layer *layer, int en)
>> +{
>> +	mxr_reg_graph_layer_stream(layer->mdev, layer->idx, en);
>> +}
>> +
>> +static void mxr_graph_format_set(struct mxr_layer *layer)
>> +{
>> +	mxr_reg_graph_format(layer->mdev, layer->idx,
>> +		layer->fmt, &layer->geo);
>> +}
>> +
>> +static void mxr_graph_fix_geometry(struct mxr_layer *layer)
>> +{
>> +	struct mxr_geometry *geo = &layer->geo;
>> +
>> +	/* limit to boundary size */
>> +	geo->src.full_width = clamp_val(geo->src.full_width, 1, 32767);
>> +	geo->src.full_height = clamp_val(geo->src.full_height, 1, 2047);
>> +	geo->src.width = clamp_val(geo->src.width, 1, geo->src.full_width);
>> +	geo->src.width = min(geo->src.width, 2047U);
>> +	/* not possible to crop of Y axis */
>> +	geo->src.y_offset = min(geo->src.y_offset, geo->src.full_height - 1);
>> +	geo->src.height = geo->src.full_height - geo->src.y_offset;
>> +	/* limitting offset */
>> +	geo->src.x_offset = min(geo->src.x_offset,
>> +		geo->src.full_width - geo->src.width);
>> +
>> +	/* setting position in output */
>> +	geo->dst.width = min(geo->dst.width, geo->dst.full_width);
>> +	geo->dst.height = min(geo->dst.height, geo->dst.full_height);
>> +
>> +	/* Mixer supports only 1x and 2x scaling */
>> +	if (geo->dst.width >= 2 * geo->src.width) {
>> +		geo->x_ratio = 1;
>> +		geo->dst.width = 2 * geo->src.width;
>> +	} else {
>> +		geo->x_ratio = 0;
>> +		geo->dst.width = geo->src.width;
>> +	}
>> +
>> +	if (geo->dst.height >= 2 * geo->src.height) {
>> +		geo->y_ratio = 1;
>> +		geo->dst.height = 2 * geo->src.height;
>> +	} else {
>> +		geo->y_ratio = 0;
>> +		geo->dst.height = geo->src.height;
>> +	}
>> +
>> +	geo->dst.x_offset = min(geo->dst.x_offset,
>> +		geo->dst.full_width - geo->dst.width);
>> +	geo->dst.y_offset = min(geo->dst.y_offset,
>> +		geo->dst.full_height - geo->dst.height);
>> +}
>> +
>> +/* PUBLIC API */
>> +
>> +struct mxr_layer *mxr_graph_layer_create(struct mxr_device *mdev, int idx)
>> +{
>> +	struct mxr_layer *layer;
>> +	int ret;
>> +	struct mxr_layer_ops ops = {
>> +		.release = mxr_graph_layer_release,
>> +		.buffer_set = mxr_graph_buffer_set,
>> +		.stream_set = mxr_graph_stream_set,
>> +		.format_set = mxr_graph_format_set,
>> +		.fix_geometry = mxr_graph_fix_geometry,
>> +	};
>> +	char name[32];
>> +
>> +	sprintf(name, "graph%d", idx);
>> +
>> +	layer = mxr_base_layer_create(mdev, idx, name, &ops);
>> +	if (layer == NULL) {
>> +		mxr_err(mdev, "failed to initialize layer(%d) base\n", idx);
>> +		goto fail;
>> +	}
>> +
>> +	layer->fmt_array = mxr_graph_format;
>> +	layer->fmt_array_size = ARRAY_SIZE(mxr_graph_format);
>> +
>> +	ret = mxr_base_layer_register(layer);
>> +	if (ret)
>> +		goto fail_layer;
>> +
>> +	return layer;
>> +
>> +fail_layer:
>> +	mxr_base_layer_release(layer);
>> +
>> +fail:
>> +	return NULL;
>> +}
>> +
>> diff --git a/drivers/media/video/s5p-tv/mixer_reg.c b/drivers/media/video/s5p-tv/mixer_reg.c
>> new file mode 100644
>> index 0000000..c60f85f8
>> --- /dev/null
>> +++ b/drivers/media/video/s5p-tv/mixer_reg.c
>> @@ -0,0 +1,540 @@
>> +/*
>> + * Samsung TV Mixer driver
>> + *
>> + * Copyright (c) 2010-2011 Samsung Electronics Co., Ltd.
>> + *
>> + * Tomasz Stanislawski, <t.stanislaws@samsung.com>
>> + *
>> + * 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 Foundiation. either version 2 of the License,
>> + * or (at your option) any later version
>> + */
>> +
>> +#include "mixer.h"
>> +#include "regs-mixer.h"
>> +#include "regs-vp.h"
>> +
>> +#include <linux/delay.h>
>> +
>> +/* Register access subroutines */
>> +
>> +static inline u32 vp_read(struct mxr_device *mdev, u32 reg_id)
>> +{
>> +	return readl(mdev->res.vp_regs + reg_id);
>> +}
>> +
>> +static inline void vp_write(struct mxr_device *mdev, u32 reg_id, u32 val)
>> +{
>> +	writel(val, mdev->res.vp_regs + reg_id);
>> +}
>> +
>> +static inline void vp_write_mask(struct mxr_device *mdev, u32 reg_id,
>> +	u32 val, u32 mask)
>> +{
>> +	u32 old = vp_read(mdev, reg_id);
>> +
>> +	val = (val & mask) | (old & ~mask);
>> +	writel(val, mdev->res.vp_regs + reg_id);
>> +}
>> +
>> +static inline u32 mxr_read(struct mxr_device *mdev, u32 reg_id)
>> +{
>> +	return readl(mdev->res.mxr_regs + reg_id);
>> +}
>> +
>> +static inline void mxr_write(struct mxr_device *mdev, u32 reg_id, u32 val)
>> +{
>> +	writel(val, mdev->res.mxr_regs + reg_id);
>> +}
>> +
>> +static inline void mxr_write_mask(struct mxr_device *mdev, u32 reg_id,
>> +	u32 val, u32 mask)
>> +{
>> +	u32 old = mxr_read(mdev, reg_id);
>> +
>> +	val = (val & mask) | (old & ~mask);
>> +	writel(val, mdev->res.mxr_regs + reg_id);
>> +}
>> +
>> +void mxr_vsync_set_update(struct mxr_device *mdev, int en)
>> +{
>> +	/* block update on vsync */
>> +	mxr_write_mask(mdev, MXR_STATUS, en ? MXR_STATUS_SYNC_ENABLE : 0,
>> +		MXR_STATUS_SYNC_ENABLE);
>> +	vp_write(mdev, VP_SHADOW_UPDATE, en ? VP_SHADOW_UPDATE_ENABLE : 0);
>> +}
>> +
>> +static void __mxr_reg_vp_reset(struct mxr_device *mdev)
>> +{
>> +	int tries = 100;
>> +
>> +	vp_write(mdev, VP_SRESET, VP_SRESET_PROCESSING);
>> +	for (tries = 100; tries; --tries) {
>> +		/* waiting until VP_SRESET_PROCESSING is 0 */
>> +		if (~vp_read(mdev, VP_SRESET) & VP_SRESET_PROCESSING)
>> +			break;
>> +		mdelay(10);
>> +	}
>> +	WARN(tries == 0, "failed to reset Video Processor\n");
>> +}
>> +
>> +static void mxr_reg_vp_default_filter(struct mxr_device *mdev);
>> +
>> +void mxr_reg_reset(struct mxr_device *mdev)
>> +{
>> +	unsigned long flags;
>> +	u32 val; /* value stored to register */
>> +
>> +	spin_lock_irqsave(&mdev->reg_slock, flags);
>> +	mxr_vsync_set_update(mdev, MXR_DISABLE);
>> +
>> +	/* set output in RGB888 mode */
>> +	mxr_write(mdev, MXR_CFG, MXR_CFG_OUT_YUV444);
>> +
>> +	/* 16 beat burst in DMA */
>> +	mxr_write_mask(mdev, MXR_STATUS, MXR_STATUS_16_BURST,
>> +		MXR_STATUS_BURST_MASK);
>> +
>> +	/* setting default layer priority: layer1 > video > layer0
>> +	 * because typical usage scenario would be
>> +	 * layer0 - framebuffer
>> +	 * video - video overlay
>> +	 * layer1 - OSD
>> +	 */
>> +	val  = MXR_LAYER_CFG_GRP0_VAL(1);
>> +	val |= MXR_LAYER_CFG_VP_VAL(2);
>> +	val |= MXR_LAYER_CFG_GRP1_VAL(3);
>> +	mxr_write(mdev, MXR_LAYER_CFG, val);
>> +
>> +	/* use dark gray background color */
>> +	mxr_write(mdev, MXR_BG_COLOR0, 0x808080);
>> +	mxr_write(mdev, MXR_BG_COLOR1, 0x808080);
>> +	mxr_write(mdev, MXR_BG_COLOR2, 0x808080);
>> +
>> +	/* setting graphical layers */
>> +
>> +	val  = MXR_GRP_CFG_COLOR_KEY_DISABLE; /* no blank key */
>> +	val |= MXR_GRP_CFG_BLEND_PRE_MUL; /* premul mode */
>> +	val |= MXR_GRP_CFG_ALPHA_VAL(0xff); /* non-transparent alpha */
>> +
>> +	/* the same configuration for both layers */
>> +	mxr_write(mdev, MXR_GRAPHIC_CFG(0), val);
>> +	mxr_write(mdev, MXR_GRAPHIC_CFG(1), val);
>> +
>> +	/* configuration of Video Processor Registers */
>> +	__mxr_reg_vp_reset(mdev);
>> +	mxr_reg_vp_default_filter(mdev);
>> +
>> +	/* enable all interrupts */
>> +	mxr_write_mask(mdev, MXR_INT_EN, ~0, MXR_INT_EN_ALL);
>> +
>> +	mxr_vsync_set_update(mdev, MXR_ENABLE);
>> +	spin_unlock_irqrestore(&mdev->reg_slock, flags);
>> +}
>> +
>> +void mxr_reg_graph_format(struct mxr_device *mdev, int idx,
>> +	const struct mxr_format *fmt, const struct mxr_geometry *geo)
>> +{
>> +	u32 val;
>> +	unsigned long flags;
>> +
>> +	spin_lock_irqsave(&mdev->reg_slock, flags);
>> +	mxr_vsync_set_update(mdev, MXR_DISABLE);
>> +
>> +	/* setup format */
>> +	mxr_write_mask(mdev, MXR_GRAPHIC_CFG(idx),
>> +		MXR_GRP_CFG_FORMAT_VAL(fmt->cookie), MXR_GRP_CFG_FORMAT_MASK);
>> +
>> +	/* setup geometry */
>> +	mxr_write(mdev, MXR_GRAPHIC_SPAN(idx), geo->src.full_width);
>> +	val  = MXR_GRP_WH_WIDTH(geo->src.width);
>> +	val |= MXR_GRP_WH_HEIGHT(geo->src.height);
>> +	val |= MXR_GRP_WH_H_SCALE(geo->x_ratio);
>> +	val |= MXR_GRP_WH_V_SCALE(geo->y_ratio);
>> +	mxr_write(mdev, MXR_GRAPHIC_WH(idx), val);
>> +
>> +	/* setup offsets in source image */
>> +	val  = MXR_GRP_SXY_SX(geo->src.x_offset);
>> +	val |= MXR_GRP_SXY_SY(geo->src.y_offset);
>> +	mxr_write(mdev, MXR_GRAPHIC_SXY(idx), val);
>> +
>> +	/* setup offsets in display image */
>> +	val  = MXR_GRP_DXY_DX(geo->dst.x_offset);
>> +	val |= MXR_GRP_DXY_DY(geo->dst.y_offset);
>> +	mxr_write(mdev, MXR_GRAPHIC_DXY(idx), val);
>> +
>> +	mxr_vsync_set_update(mdev, MXR_ENABLE);
>> +	spin_unlock_irqrestore(&mdev->reg_slock, flags);
>> +}
>> +
>> +void mxr_reg_vp_format(struct mxr_device *mdev,
>> +	const struct mxr_format *fmt, const struct mxr_geometry *geo)
>> +{
>> +	unsigned long flags;
>> +
>> +	spin_lock_irqsave(&mdev->reg_slock, flags);
>> +	mxr_vsync_set_update(mdev, MXR_DISABLE);
>> +
>> +	vp_write_mask(mdev, VP_MODE, fmt->cookie, VP_MODE_FMT_MASK);
>> +
>> +	/* setting size of input image */
>> +	vp_write(mdev, VP_IMG_SIZE_Y, VP_IMG_HSIZE(geo->src.full_width) |
>> +		VP_IMG_VSIZE(geo->src.full_height));
>> +	/* chroma height has to reduced by 2 to avoid chroma distorions */
>> +	vp_write(mdev, VP_IMG_SIZE_C, VP_IMG_HSIZE(geo->src.full_width) |
>> +		VP_IMG_VSIZE(geo->src.full_height / 2));
>> +
>> +	vp_write(mdev, VP_SRC_WIDTH, geo->src.width);
>> +	vp_write(mdev, VP_SRC_HEIGHT, geo->src.height);
>> +	vp_write(mdev, VP_SRC_H_POSITION,
>> +		VP_SRC_H_POSITION_VAL(geo->src.x_offset));
>> +	vp_write(mdev, VP_SRC_V_POSITION, geo->src.y_offset);
>> +
>> +	vp_write(mdev, VP_DST_WIDTH, geo->dst.width);
>> +	vp_write(mdev, VP_DST_H_POSITION, geo->dst.x_offset);
>> +	if (geo->dst.field == V4L2_FIELD_INTERLACED) {
>> +		vp_write(mdev, VP_DST_HEIGHT, geo->dst.height / 2);
>> +		vp_write(mdev, VP_DST_V_POSITION, geo->dst.y_offset / 2);
>> +	} else {
>> +		vp_write(mdev, VP_DST_HEIGHT, geo->dst.height);
>> +		vp_write(mdev, VP_DST_V_POSITION, geo->dst.y_offset);
>> +	}
>> +
>> +	vp_write(mdev, VP_H_RATIO, geo->x_ratio);
>> +	vp_write(mdev, VP_V_RATIO, geo->y_ratio);
>> +
>> +	vp_write(mdev, VP_ENDIAN_MODE, VP_ENDIAN_MODE_LITTLE);
>> +
>> +	mxr_vsync_set_update(mdev, MXR_ENABLE);
>> +	spin_unlock_irqrestore(&mdev->reg_slock, flags);
>> +
>> +}
>> +
>> +void mxr_reg_graph_buffer(struct mxr_device *mdev, int idx, dma_addr_t addr)
>> +{
>> +	u32 val = addr ? ~0 : 0;
>> +	unsigned long flags;
>> +
>> +	spin_lock_irqsave(&mdev->reg_slock, flags);
>> +	mxr_vsync_set_update(mdev, MXR_DISABLE);
>> +
>> +	if (idx == 0)
>> +		mxr_write_mask(mdev, MXR_CFG, val, MXR_CFG_GRP0_ENABLE);
>> +	else
>> +		mxr_write_mask(mdev, MXR_CFG, val, MXR_CFG_GRP1_ENABLE);
>> +	mxr_write(mdev, MXR_GRAPHIC_BASE(idx), addr);
>> +
>> +	mxr_vsync_set_update(mdev, MXR_ENABLE);
>> +	spin_unlock_irqrestore(&mdev->reg_slock, flags);
>> +}
>> +
>> +void mxr_reg_vp_buffer(struct mxr_device *mdev,
>> +	dma_addr_t luma_addr[2], dma_addr_t chroma_addr[2])
>> +{
>> +	u32 val = luma_addr[0] ? ~0 : 0;
>> +	unsigned long flags;
>> +
>> +	spin_lock_irqsave(&mdev->reg_slock, flags);
>> +	mxr_vsync_set_update(mdev, MXR_DISABLE);
>> +
>> +	mxr_write_mask(mdev, MXR_CFG, val, MXR_CFG_VP_ENABLE);
>> +	vp_write_mask(mdev, VP_ENABLE, val, VP_ENABLE_ON);
>> +	/* TODO: fix tiled mode */
>> +	vp_write(mdev, VP_TOP_Y_PTR, luma_addr[0]);
>> +	vp_write(mdev, VP_TOP_C_PTR, chroma_addr[0]);
>> +	vp_write(mdev, VP_BOT_Y_PTR, luma_addr[1]);
>> +	vp_write(mdev, VP_BOT_C_PTR, chroma_addr[1]);
>> +
>> +	mxr_vsync_set_update(mdev, MXR_ENABLE);
>> +	spin_unlock_irqrestore(&mdev->reg_slock, flags);
>> +}
>> +
>> +static void mxr_irq_layer_handle(struct mxr_layer *layer)
>> +{
>> +	struct list_head *head = &layer->enq_list;
>> +	struct mxr_buffer *done;
>> +
>> +	/* skip non-existing layer */
>> +	if (layer == NULL)
>> +		return;
>> +
>> +	spin_lock(&layer->enq_slock);
>> +	if (layer->state == MXR_LAYER_IDLE)
>> +		goto done;
>> +
>> +	done = layer->shadow_buf;
>> +	layer->shadow_buf = layer->update_buf;
>> +
>> +	if (list_empty(head)) {
>> +		if (layer->state != MXR_LAYER_STREAMING)
>> +			layer->update_buf = NULL;
>> +	} else {
>> +		struct mxr_buffer *next;
>> +		next = list_first_entry(head, struct mxr_buffer, list);
>> +		list_del(&next->list);
>> +		layer->update_buf = next;
>> +	}
>> +
>> +	layer->ops.buffer_set(layer, layer->update_buf);
>> +
>> +	if (done && done != layer->shadow_buf)
>> +		vb2_buffer_done(&done->vb, VB2_BUF_STATE_DONE);
>> +
>> +done:
>> +	spin_unlock(&layer->enq_slock);
>> +}
>> +
>> +irqreturn_t mxr_irq_handler(int irq, void *dev_data)
>> +{
>> +	struct mxr_device *mdev = dev_data;
>> +	u32 i, val;
>> +
>> +	spin_lock(&mdev->reg_slock);
>> +	val = mxr_read(mdev, MXR_INT_STATUS);
>> +
>> +	/* wake up process waiting for VSYNC */
>> +	if (val & MXR_INT_STATUS_VSYNC) {
>> +		set_bit(MXR_EVENT_VSYNC, &mdev->event_flags);
>> +		wake_up(&mdev->event_queue);
>> +	}
>> +
>> +	/* clear interrupts */
>> +	if (~val & MXR_INT_EN_VSYNC) {
>> +		/* vsync interrupt use different bit for read and clear */
>> +		val &= ~MXR_INT_EN_VSYNC;
>> +		val |= MXR_INT_CLEAR_VSYNC;
>> +	}
>> +	mxr_write(mdev, MXR_INT_STATUS, val);
>> +
>> +	spin_unlock(&mdev->reg_slock);
>> +	/* leave on non-vsync event */
>> +	if (~val & MXR_INT_CLEAR_VSYNC)
>> +		return IRQ_HANDLED;
>> +	for (i = 0; i < MXR_MAX_LAYERS; ++i)
>> +		mxr_irq_layer_handle(mdev->layer[i]);
>> +	return IRQ_HANDLED;
>> +}
>> +
>> +void mxr_reg_s_output(struct mxr_device *mdev, int cookie)
>> +{
>> +	u32 val;
>> +
>> +	val = cookie == 0 ? MXR_CFG_DST_SDO : MXR_CFG_DST_HDMI;
>> +	mxr_write_mask(mdev, MXR_CFG, val, MXR_CFG_DST_MASK);
>> +}
>> +
>> +void mxr_reg_streamon(struct mxr_device *mdev)
>> +{
>> +	unsigned long flags;
>> +
>> +	spin_lock_irqsave(&mdev->reg_slock, flags);
>> +	/* single write -> no need to block vsync update */
>> +
>> +	/* start MIXER */
>> +	mxr_write_mask(mdev, MXR_STATUS, ~0, MXR_STATUS_REG_RUN);
>> +
>> +	spin_unlock_irqrestore(&mdev->reg_slock, flags);
>> +}
>> +
>> +void mxr_reg_streamoff(struct mxr_device *mdev)
>> +{
>> +	unsigned long flags;
>> +
>> +	spin_lock_irqsave(&mdev->reg_slock, flags);
>> +	/* single write -> no need to block vsync update */
>> +
>> +	/* stop MIXER */
>> +	mxr_write_mask(mdev, MXR_STATUS, 0, MXR_STATUS_REG_RUN);
>> +
>> +	spin_unlock_irqrestore(&mdev->reg_slock, flags);
>> +}
>> +
>> +int mxr_reg_wait4vsync(struct mxr_device *mdev)
>> +{
>> +	int ret;
>> +
>> +	clear_bit(MXR_EVENT_VSYNC, &mdev->event_flags);
>> +	/* TODO: consider adding interruptible */
>> +	ret = wait_event_timeout(mdev->event_queue,
>> +		test_bit(MXR_EVENT_VSYNC, &mdev->event_flags),
>> +		msecs_to_jiffies(1000));
>> +	if (ret > 0)
>> +		return 0;
>> +	if (ret < 0)
>> +		return ret;
>> +	return -ETIME;
>> +}
>> +
>> +void mxr_reg_set_mbus_fmt(struct mxr_device *mdev,
>> +	struct v4l2_mbus_framefmt *fmt)
>> +{
>> +	u32 val = 0;
>> +	unsigned long flags;
>> +
>> +	spin_lock_irqsave(&mdev->reg_slock, flags);
>> +	mxr_vsync_set_update(mdev, MXR_DISABLE);
>> +
>> +	/* choosing between interlace and progressive mode */
>> +	if (fmt->field == V4L2_FIELD_INTERLACED)
>> +		val |= MXR_CFG_SCAN_INTERLACE;
>> +	else
>> +		val |= MXR_CFG_SCAN_PROGRASSIVE;
>> +
>> +	/* choosing between porper HD and SD mode */
>> +	if (fmt->height == 480)
>> +		val |= MXR_CFG_SCAN_NTSC | MXR_CFG_SCAN_SD;
>> +	else if (fmt->height == 576)
>> +		val |= MXR_CFG_SCAN_PAL | MXR_CFG_SCAN_SD;
>> +	else if (fmt->height == 720)
>> +		val |= MXR_CFG_SCAN_HD_720 | MXR_CFG_SCAN_HD;
>> +	else if (fmt->height == 1080)
>> +		val |= MXR_CFG_SCAN_HD_1080 | MXR_CFG_SCAN_HD;
>> +	else
>> +		WARN(1, "unrecognized mbus height %u!\n", fmt->height);
>> +
>> +	mxr_write_mask(mdev, MXR_CFG, val, MXR_CFG_SCAN_MASK);
>> +
>> +	val = (fmt->field == V4L2_FIELD_INTERLACED) ? ~0 : 0;
>> +	vp_write_mask(mdev, VP_MODE, val,
>> +		VP_MODE_LINE_SKIP | VP_MODE_FIELD_ID_AUTO_TOGGLING);
>> +
>> +	mxr_vsync_set_update(mdev, MXR_ENABLE);
>> +	spin_unlock_irqrestore(&mdev->reg_slock, flags);
>> +}
>> +
>> +void mxr_reg_graph_layer_stream(struct mxr_device *mdev, int idx, int en)
>> +{
>> +	/* no extra actions need to be done */
>> +}
>> +
>> +void mxr_reg_vp_layer_stream(struct mxr_device *mdev, int en)
>> +{
>> +	/* no extra actions need to be done */
>> +}
>> +
>> +static const u8 filter_y_horiz_tap8[] = {
>> +	0,	-1,	-1,	-1,	-1,	-1,	-1,	-1,
>> +	-1,	-1,	-1,	-1,	-1,	0,	0,	0,
>> +	0,	2,	4,	5,	6,	6,	6,	6,
>> +	6,	5,	5,	4,	3,	2,	1,	1,
>> +	0,	-6,	-12,	-16,	-18,	-20,	-21,	-20,
>> +	-20,	-18,	-16,	-13,	-10,	-8,	-5,	-2,
>> +	127,	126,	125,	121,	114,	107,	99,	89,
>> +	79,	68,	57,	46,	35,	25,	16,	8,
>> +};
>> +
>> +static const u8 filter_y_vert_tap4[] = {
>> +	0,	-3,	-6,	-8,	-8,	-8,	-8,	-7,
>> +	-6,	-5,	-4,	-3,	-2,	-1,	-1,	0,
>> +	127,	126,	124,	118,	111,	102,	92,	81,
>> +	70,	59,	48,	37,	27,	19,	11,	5,
>> +	0,	5,	11,	19,	27,	37,	48,	59,
>> +	70,	81,	92,	102,	111,	118,	124,	126,
>> +	0,	0,	-1,	-1,	-2,	-3,	-4,	-5,
>> +	-6,	-7,	-8,	-8,	-8,	-8,	-6,	-3,
>> +};
>> +
>> +static const u8 filter_cr_horiz_tap4[] = {
>> +	0,	-3,	-6,	-8,	-8,	-8,	-8,	-7,
>> +	-6,	-5,	-4,	-3,	-2,	-1,	-1,	0,
>> +	127,	126,	124,	118,	111,	102,	92,	81,
>> +	70,	59,	48,	37,	27,	19,	11,	5,
>> +};
>> +
>> +static inline void mxr_reg_vp_filter_set(struct mxr_device *mdev,
>> +	int reg_id, const u8 *data, unsigned int size)
>> +{
>> +	/* assure 4-byte align */
>> +	BUG_ON(size & 3);
>> +	for (; size; size -= 4, reg_id += 4, data += 4) {
>> +		u32 val = (data[0] << 24) |  (data[1] << 16) |
>> +			(data[2] << 8) | data[3];
>> +		vp_write(mdev, reg_id, val);
>> +	}
>> +}
>> +
>> +static void mxr_reg_vp_default_filter(struct mxr_device *mdev)
>> +{
>> +	mxr_reg_vp_filter_set(mdev, VP_POLY8_Y0_LL,
>> +		filter_y_horiz_tap8, sizeof filter_y_horiz_tap8);
>> +	mxr_reg_vp_filter_set(mdev, VP_POLY4_Y0_LL,
>> +		filter_y_vert_tap4, sizeof filter_y_vert_tap4);
>> +	mxr_reg_vp_filter_set(mdev, VP_POLY4_C0_LL,
>> +		filter_cr_horiz_tap4, sizeof filter_cr_horiz_tap4);
>> +}
>> +
>> +static void mxr_reg_mxr_dump(struct mxr_device *mdev)
>> +{
>> +#define DUMPREG(reg_id) \
>> +do { \
>> +	mxr_dbg(mdev, #reg_id " = %08x\n", \
>> +		(u32)readl(mdev->res.mxr_regs + reg_id)); \
>> +} while (0)
>> +
>> +	DUMPREG(MXR_STATUS);
>> +	DUMPREG(MXR_CFG);
>> +	DUMPREG(MXR_INT_EN);
>> +	DUMPREG(MXR_INT_STATUS);
>> +
>> +	DUMPREG(MXR_LAYER_CFG);
>> +	DUMPREG(MXR_VIDEO_CFG);
>> +
>> +	DUMPREG(MXR_GRAPHIC0_CFG);
>> +	DUMPREG(MXR_GRAPHIC0_BASE);
>> +	DUMPREG(MXR_GRAPHIC0_SPAN);
>> +	DUMPREG(MXR_GRAPHIC0_WH);
>> +	DUMPREG(MXR_GRAPHIC0_SXY);
>> +	DUMPREG(MXR_GRAPHIC0_DXY);
>> +
>> +	DUMPREG(MXR_GRAPHIC1_CFG);
>> +	DUMPREG(MXR_GRAPHIC1_BASE);
>> +	DUMPREG(MXR_GRAPHIC1_SPAN);
>> +	DUMPREG(MXR_GRAPHIC1_WH);
>> +	DUMPREG(MXR_GRAPHIC1_SXY);
>> +	DUMPREG(MXR_GRAPHIC1_DXY);
>> +#undef DUMPREG
>> +}
>> +
>> +static void mxr_reg_vp_dump(struct mxr_device *mdev)
>> +{
>> +#define DUMPREG(reg_id) \
>> +do { \
>> +	mxr_dbg(mdev, #reg_id " = %08x\n", \
>> +		(u32) readl(mdev->res.vp_regs + reg_id)); \
>> +} while (0)
>> +
>> +
>> +	DUMPREG(VP_ENABLE);
>> +	DUMPREG(VP_SRESET);
>> +	DUMPREG(VP_SHADOW_UPDATE);
>> +	DUMPREG(VP_FIELD_ID);
>> +	DUMPREG(VP_MODE);
>> +	DUMPREG(VP_IMG_SIZE_Y);
>> +	DUMPREG(VP_IMG_SIZE_C);
>> +	DUMPREG(VP_PER_RATE_CTRL);
>> +	DUMPREG(VP_TOP_Y_PTR);
>> +	DUMPREG(VP_BOT_Y_PTR);
>> +	DUMPREG(VP_TOP_C_PTR);
>> +	DUMPREG(VP_BOT_C_PTR);
>> +	DUMPREG(VP_ENDIAN_MODE);
>> +	DUMPREG(VP_SRC_H_POSITION);
>> +	DUMPREG(VP_SRC_V_POSITION);
>> +	DUMPREG(VP_SRC_WIDTH);
>> +	DUMPREG(VP_SRC_HEIGHT);
>> +	DUMPREG(VP_DST_H_POSITION);
>> +	DUMPREG(VP_DST_V_POSITION);
>> +	DUMPREG(VP_DST_WIDTH);
>> +	DUMPREG(VP_DST_HEIGHT);
>> +	DUMPREG(VP_H_RATIO);
>> +	DUMPREG(VP_V_RATIO);
>> +
>> +#undef DUMPREG
>> +}
>> +
>> +void mxr_reg_dump(struct mxr_device *mdev)
>> +{
>> +	mxr_reg_mxr_dump(mdev);
>> +	mxr_reg_vp_dump(mdev);
>> +}
>> +
>> diff --git a/drivers/media/video/s5p-tv/mixer_video.c b/drivers/media/video/s5p-tv/mixer_video.c
>> new file mode 100644
>> index 0000000..f4fc3e1
>> --- /dev/null
>> +++ b/drivers/media/video/s5p-tv/mixer_video.c
>> @@ -0,0 +1,956 @@
>> +/*
>> + * Samsung TV Mixer driver
>> + *
>> + * Copyright (c) 2010-2011 Samsung Electronics Co., Ltd.
>> + *
>> + * Tomasz Stanislawski, <t.stanislaws@samsung.com>
>> + *
>> + * 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 Foundiation. either version 2 of the License,
>> + * or (at your option) any later version
>> + */
>> +
>> +#include "mixer.h"
>> +
>> +#include <media/v4l2-ioctl.h>
>> +#include <linux/videodev2.h>
>> +#include <linux/mm.h>
>> +#include <linux/version.h>
>> +#include <linux/timer.h>
>> +#include <media/videobuf2-dma-contig.h>
>> +
>> +static int find_reg_callback(struct device *dev, void *p)
>> +{
>> +	struct v4l2_subdev **sd = p;
>> +
>> +	*sd = dev_get_drvdata(dev);
>>     
>
> Now I understand why the hdmi driver sets drvdata.
>
> I think that in the hdmi driver you should just pass a NULL pointer as struct
> device to v4l2_device_register. The only think you need to do is to initialize
> the 'name' field of v4l2_device before calling v4l2_device_register. Normally
> v4l2_device_register will derive the name from struct device, but when you
> pass a NULL pointer that no longer works.
>   
How to solve passing subdev to other driver? Any code example?
>   
>> +	/* non-zero value stops iteration */
>> +	return 1;
>> +}
>> +
>> +static struct v4l2_subdev *find_and_register_subdev(
>> +	struct mxr_device *mdev, char *module_name)
>> +{
>> +	struct device_driver *drv;
>> +	struct v4l2_subdev *sd = NULL;
>> +	int ret;
>> +
>> +	/* TODO: add waiting until probe is finished */
>> +	drv = driver_find(module_name, &platform_bus_type);
>> +	if (!drv) {
>> +		mxr_warn(mdev, "module %s is missing\n", module_name);
>> +		return NULL;
>> +	}
>> +	/* driver refcnt is increased, it is safe to iterate over devices */
>> +	ret = driver_for_each_device(drv, NULL, &sd, find_reg_callback);
>> +	/* ret == 0 means that find_reg_callback was never executed */
>> +	if (sd == NULL) {
>> +		mxr_warn(mdev, "module %s provides no subdev!\n", module_name);
>> +		goto done;
>> +	}
>> +	/* v4l2_device_register_subdev detects if sd is NULL */
>> +	ret = v4l2_device_register_subdev(&mdev->v4l2_dev, sd);
>> +	if (ret) {
>> +		mxr_warn(mdev, "failed to register subdev %s\n", sd->name);
>> +		sd = NULL;
>> +	}
>> +
>> +done:
>> +	put_driver(drv);
>> +	return sd;
>> +}
>> +
>> +int __devinit mxr_acquire_video(struct mxr_device *mdev,
>> +	struct mxr_output_conf *output_conf, int output_count)
>> +{
>> +	struct device *dev = mdev->dev;
>> +	struct v4l2_device *vdev = &mdev->v4l2_dev;
>>     
>
> Don't use 'vdev' for v4l2_device, it's confusing. I always use 'v4l2_dev'.
>
>   
>> +	int i;
>> +	int ret = 0;
>> +	struct v4l2_subdev *sd;
>> +
>> +	strlcpy(vdev->name, "s5p-tv", sizeof(vdev->name));
>> +	/* prepare context for V4L2 device */
>> +	ret = v4l2_device_register(dev, vdev);
>> +	if (ret) {
>> +		mxr_err(mdev, "could not register v4l2 device.\n");
>> +		goto fail;
>> +	}
>> +
>> +	mdev->alloc_ctx = vb2_dma_contig_init_ctx(mdev->dev);
>> +	if (IS_ERR_OR_NULL(mdev->alloc_ctx)) {
>> +		mxr_err(mdev, "could not acquire vb2 allocator\n");
>> +		goto fail_v4l2_dev;
>> +	}
>> +
>> +	/* registering outputs */
>> +	mdev->output_cnt = 0;
>> +	for (i = 0; i < output_count; ++i) {
>> +		struct mxr_output_conf *conf = &output_conf[i];
>> +		struct mxr_output *out;
>>     
>
> Add empty line between the declarations and the code.
>
>   
>> +		sd = find_and_register_subdev(mdev, conf->module_name);
>> +		/* trying to register next output */
>> +		if (sd == NULL)
>> +			continue;
>> +		out = kzalloc(sizeof *out, GFP_KERNEL);
>> +		if (out == NULL) {
>> +			mxr_err(mdev, "no memory for '%s'\n",
>> +				conf->output_name);
>> +			ret = -ENOMEM;
>> +			/* registered subdevs are removed in fail_v4l2_dev */
>> +			goto fail_output;
>> +		}
>> +		strlcpy(out->name, conf->output_name, sizeof(out->name));
>> +		out->sd = sd;
>> +		out->cookie = conf->cookie;
>> +		mdev->output[mdev->output_cnt++] = out;
>> +		mxr_info(mdev, "added output '%s' from module '%s'\n",
>> +			conf->output_name, conf->module_name);
>> +		/* checking if maximal number of outputs is reached */
>> +		if (mdev->output_cnt >= MXR_MAX_OUTPUTS)
>> +			break;
>> +	}
>> +
>> +	if (mdev->output_cnt == 0) {
>> +		mxr_err(mdev, "failed to register any output\n");
>> +		ret = -ENODEV;
>> +		/* skipping fail_output because there is nothing to free */
>> +		goto fail_vb2_allocator;
>> +	}
>> +
>> +	return 0;
>> +
>> +fail_output:
>> +	/* kfree is NULL-safe */
>> +	for (i = 0; i < mdev->output_cnt; ++i)
>> +		kfree(mdev->output[i]);
>> +	memset(mdev->output, 0, sizeof mdev->output);
>> +
>> +fail_vb2_allocator:
>> +	/* freeing allocator context */
>> +	vb2_dma_contig_cleanup_ctx(mdev->alloc_ctx);
>> +
>> +fail_v4l2_dev:
>> +	/* NOTE: automatically unregisteres all subdevs */
>> +	v4l2_device_unregister(vdev);
>> +
>> +fail:
>> +	return ret;
>> +}
>> +
>> +void __devexit mxr_release_video(struct mxr_device *mdev)
>> +{
>> +	int i;
>> +
>> +	/* kfree is NULL-safe */
>> +	for (i = 0; i < mdev->output_cnt; ++i)
>> +		kfree(mdev->output[i]);
>> +
>> +	vb2_dma_contig_cleanup_ctx(mdev->alloc_ctx);
>> +	v4l2_device_unregister(&mdev->v4l2_dev);
>> +}
>> +
>> +static int mxr_querycap(struct file *file, void *priv,
>> +	struct v4l2_capability *cap)
>> +{
>> +	struct mxr_layer *layer = video_drvdata(file);
>> +
>> +	mxr_dbg(layer->mdev, "%s:%d\n", __func__, __LINE__);
>> +
>> +	strlcpy(cap->driver, MXR_DRIVER_NAME, sizeof cap->driver);
>> +	strlcpy(cap->card, layer->vfd.name, sizeof cap->card);
>> +	sprintf(cap->bus_info, "%d", layer->idx);
>> +	cap->version = KERNEL_VERSION(0, 1, 0);
>> +	cap->capabilities = V4L2_CAP_STREAMING |
>> +		V4L2_CAP_VIDEO_OUTPUT | V4L2_CAP_VIDEO_OUTPUT_MPLANE;
>> +
>> +	return 0;
>> +}
>> +
>> +/* Geometry handling */
>> +static void mxr_layer_geo_fix(struct mxr_layer *layer)
>> +{
>> +	struct mxr_device *mdev = layer->mdev;
>> +	struct v4l2_mbus_framefmt mbus_fmt;
>> +
>> +	/* TODO: add some dirty flag to avoid unneccessary adjustments */
>> +	mxr_get_mbus_fmt(mdev, &mbus_fmt);
>> +	layer->geo.dst.full_width = mbus_fmt.width;
>> +	layer->geo.dst.full_height = mbus_fmt.height;
>> +	layer->geo.dst.field = mbus_fmt.field;
>> +	layer->ops.fix_geometry(layer);
>> +}
>> +
>> +static void mxr_layer_default_geo(struct mxr_layer *layer)
>> +{
>> +	struct mxr_device *mdev = layer->mdev;
>> +	struct v4l2_mbus_framefmt mbus_fmt;
>> +
>> +	memset(&layer->geo, 0, sizeof layer->geo);
>> +
>> +	mxr_get_mbus_fmt(mdev, &mbus_fmt);
>> +
>> +	layer->geo.dst.full_width = mbus_fmt.width;
>> +	layer->geo.dst.full_height = mbus_fmt.height;
>> +	layer->geo.dst.width = layer->geo.dst.full_width;
>> +	layer->geo.dst.height = layer->geo.dst.full_height;
>> +	layer->geo.dst.field = mbus_fmt.field;
>> +
>> +	layer->geo.src.full_width = mbus_fmt.width;
>> +	layer->geo.src.full_height = mbus_fmt.height;
>> +	layer->geo.src.width = layer->geo.src.full_width;
>> +	layer->geo.src.height = layer->geo.src.full_height;
>> +
>> +	layer->ops.fix_geometry(layer);
>> +}
>> +
>> +static void mxr_geometry_dump(struct mxr_device *mdev, struct mxr_geometry *geo)
>> +{
>> +	mxr_dbg(mdev, "src.full_size = (%u, %u)\n",
>> +		geo->src.full_width, geo->src.full_height);
>> +	mxr_dbg(mdev, "src.size = (%u, %u)\n",
>> +		geo->src.width, geo->src.height);
>> +	mxr_dbg(mdev, "src.offset = (%u, %u)\n",
>> +		geo->src.x_offset, geo->src.y_offset);
>> +	mxr_dbg(mdev, "dst.full_size = (%u, %u)\n",
>> +		geo->dst.full_width, geo->dst.full_height);
>> +	mxr_dbg(mdev, "dst.size = (%u, %u)\n",
>> +		geo->dst.width, geo->dst.height);
>> +	mxr_dbg(mdev, "dst.offset = (%u, %u)\n",
>> +		geo->dst.x_offset, geo->dst.y_offset);
>> +	mxr_dbg(mdev, "ratio = (%u, %u)\n",
>> +		geo->x_ratio, geo->y_ratio);
>> +}
>> +
>> +
>> +static const struct mxr_format *find_format_by_fourcc(
>> +	struct mxr_layer *layer, unsigned long fourcc);
>> +static const struct mxr_format *find_format_by_index(
>> +	struct mxr_layer *layer, unsigned long index);
>> +
>> +static int mxr_enum_fmt(struct file *file, void  *priv,
>> +	struct v4l2_fmtdesc *f)
>> +{
>> +	struct mxr_layer *layer = video_drvdata(file);
>> +	struct mxr_device *mdev = layer->mdev;
>> +	const struct mxr_format *fmt;
>> +
>> +	mxr_dbg(mdev, "%s\n", __func__);
>> +	fmt = find_format_by_index(layer, f->index);
>> +	if (fmt == NULL)
>> +		return -EINVAL;
>> +
>> +	strlcpy(f->description, fmt->name, sizeof(f->description));
>> +	f->pixelformat = fmt->fourcc;
>> +
>> +	return 0;
>> +}
>> +
>> +static int mxr_s_fmt(struct file *file, void *priv,
>> +	struct v4l2_format *f)
>> +{
>> +	struct mxr_layer *layer = video_drvdata(file);
>> +	const struct mxr_format *fmt;
>> +	struct v4l2_pix_format_mplane *pix;
>> +	struct mxr_device *mdev = layer->mdev;
>> +	struct mxr_geometry *geo = &layer->geo;
>> +	int i;
>> +
>> +	mxr_dbg(mdev, "%s:%d\n", __func__, __LINE__);
>> +
>> +	pix = &f->fmt.pix_mp;
>> +	fmt = find_format_by_fourcc(layer, pix->pixelformat);
>> +	if (fmt == NULL) {
>> +		mxr_warn(mdev, "not recognized fourcc: %08x\n",
>> +			pix->pixelformat);
>> +		return -EINVAL;
>> +	}
>> +	layer->fmt = fmt;
>> +	geo->src.full_width = pix->width;
>> +	geo->src.width = pix->width;
>> +	geo->src.full_height = pix->height;
>> +	geo->src.height = pix->height;
>> +	/* assure consistency of geometry */
>> +	mxr_layer_geo_fix(layer);
>> +
>> +	for (i = 0; i < fmt->num_subframes; ++i) {
>> +		unsigned int n_pixel = fmt->plane[i].height *
>> +			fmt->plane[i].width;
>> +		pix->plane_fmt[i].bytesperline = geo->src.full_width *
>> +			fmt->plane[i].size / n_pixel;
>> +	}
>> +	mxr_dbg(mdev, "width=%u height=%u bpp=%u span=%u\n",
>> +		geo->src.width, geo->src.height,
>> +		pix->plane_fmt[0].bytesperline, geo->src.full_width);
>> +	return 0;
>> +}
>> +
>> +static int mxr_g_fmt(struct file *file, void *priv,
>> +			     struct v4l2_format *f)
>> +{
>> +	struct mxr_layer *layer = video_drvdata(file);
>> +
>> +	mxr_dbg(layer->mdev, "%s:%d\n", __func__, __LINE__);
>> +
>> +	f->fmt.pix.width	= layer->geo.src.full_width;
>> +	f->fmt.pix.height	= layer->geo.src.full_height;
>> +	f->fmt.pix.field	= V4L2_FIELD_NONE;
>> +	f->fmt.pix.pixelformat	= layer->fmt->fourcc;
>>     
>
> Colorspace is not set. The subdev drivers should set the colorspace and that
> should be passed in here.
>
>   
Which one should be used for formats in vp_layer and grp_layer?
>> +
>> +	return 0;
>> +}
>> +
>> +static inline struct mxr_crop *choose_crop_by_type(struct mxr_geometry *geo,
>> +	enum v4l2_buf_type type)
>> +{
>> +	switch (type) {
>> +	case V4L2_BUF_TYPE_VIDEO_OUTPUT:
>> +	case V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE:
>> +		return &geo->dst;
>> +	case V4L2_BUF_TYPE_VIDEO_OVERLAY:
>> +		return &geo->src;
>>     
>
> Hmm, this is the only place where I see overlay. It's not set in QUERYCAP either.
> And I suspect this is supposed to be OUTPUT_OVERLAY anyway since OVERLAY is for
> capture.
>
>   
Usage of OVERLAY is workaround for a lack of S_COMPOSE. This is 
described in RFC.
>> +	default:
>> +		return NULL;
>> +	}
>> +}
>> +
>> +static int mxr_g_crop(struct file *file, void *fh, struct v4l2_crop *a)
>> +{
>> +	struct mxr_layer *layer = video_drvdata(file);
>> +	struct mxr_crop *crop;
>> +
>> +	mxr_dbg(layer->mdev, "%s:%d\n", __func__, __LINE__);
>> +	crop = choose_crop_by_type(&layer->geo, a->type);
>> +	if (crop == NULL)
>> +		return -EINVAL;
>> +	mxr_layer_geo_fix(layer);
>> +	a->c.left = crop->x_offset;
>> +	a->c.top = crop->y_offset;
>> +	a->c.width = crop->width;
>> +	a->c.height = crop->height;
>> +	return 0;
>> +}
>> +
>> +static int mxr_s_crop(struct file *file, void *fh, struct v4l2_crop *a)
>> +{
>> +	struct mxr_layer *layer = video_drvdata(file);
>> +	struct mxr_crop *crop;
>> +
>> +	mxr_dbg(layer->mdev, "%s:%d\n", __func__, __LINE__);
>> +	crop = choose_crop_by_type(&layer->geo, a->type);
>> +	if (crop == NULL)
>> +		return -EINVAL;
>> +	crop->x_offset = a->c.left;
>> +	crop->y_offset = a->c.top;
>> +	crop->width = a->c.width;
>> +	crop->height = a->c.height;
>> +	mxr_layer_geo_fix(layer);
>>     
>
> No check for out-of-bounds rectangle.
>   
Fix geometry will bound it.
>   
>> +	return 0;
>> +}
>> +
>> +static int mxr_cropcap(struct file *file, void *fh, struct v4l2_cropcap *a)
>> +{
>> +	struct mxr_layer *layer = video_drvdata(file);
>> +	struct mxr_crop *crop;
>> +
>> +	mxr_dbg(layer->mdev, "%s:%d\n", __func__, __LINE__);
>> +	crop = choose_crop_by_type(&layer->geo, a->type);
>> +	if (crop == NULL)
>> +		return -EINVAL;
>> +	mxr_layer_geo_fix(layer);
>> +	a->bounds.left = 0;
>> +	a->bounds.top = 0;
>> +	a->bounds.width = crop->full_width;
>> +	a->bounds.top = crop->full_height;
>> +	a->defrect = a->bounds;
>>     
>
> Please set pixelaspect to 1x1.
>   
ok
>   
>> +	return 0;
>> +}
>> +
>> +static int mxr_enum_dv_presets(struct file *file, void *fh,
>> +	struct v4l2_dv_enum_preset *preset)
>> +{
>> +	struct mxr_layer *layer = video_drvdata(file);
>> +	struct mxr_device *mdev = layer->mdev;
>> +	int ret;
>> +
>> +	/* lock protects from changing sd_out */
>> +	mutex_lock(&mdev->mutex);
>> +	ret = v4l2_subdev_call(to_outsd(mdev), video, enum_dv_presets, preset);
>> +	mutex_unlock(&mdev->mutex);
>> +
>> +	return ret ? -EINVAL : 0;
>> +}
>> +
>> +static int mxr_s_dv_preset(struct file *file, void *fh,
>> +	struct v4l2_dv_preset *preset)
>> +{
>> +	struct mxr_layer *layer = video_drvdata(file);
>> +	struct mxr_device *mdev = layer->mdev;
>> +	int ret;
>> +
>> +	/* lock protects from changing sd_out */
>> +	mutex_lock(&mdev->mutex);
>> +
>> +	/* preset change cannot be done while there is an entity
>> +	 * dependant on output configuration
>> +	 */
>> +	if (mdev->n_output == 0)
>> +		ret = v4l2_subdev_call(to_outsd(mdev), video, s_dv_preset,
>> +			preset);
>> +	else
>> +		ret = -EBUSY;
>>     
>
> EBUSY or EINVAL? I think EINVAL is better as this ioctl is simply not supported
> for that input. EBUSY means that you can change it, but not now since streaming
> is in progress.
>
>   
EBUSY in this case means that there is a layer that depends on current 
setting of output. Therefore configuration of output cannot change.
>> +
>> +	mutex_unlock(&mdev->mutex);
>> +
>> +	return ret;
>> +}
>> +
>> +static int mxr_g_dv_preset(struct file *file, void *fh,
>> +	struct v4l2_dv_preset *preset)
>> +{
>> +	struct mxr_layer *layer = video_drvdata(file);
>> +	struct mxr_device *mdev = layer->mdev;
>> +	int ret;
>> +
>> +	/* lock protects from changing sd_out */
>>     
>
> Needs a check against n_output as well.
>   
Probably I use query_dv_preset wrong. Output is always somehow 
configured no matter is some layer is using it or not.
Therefore there is no reference checking.
>   
>> +	mutex_lock(&mdev->mutex);
>> +	ret = v4l2_subdev_call(to_outsd(mdev), video, query_dv_preset, preset);
>> +	mutex_unlock(&mdev->mutex);
>> +
>> +	return ret;
>> +}
>> +
>> +static int mxr_s_std(struct file *file, void *fh, v4l2_std_id *norm)
>> +{
>> +	struct mxr_layer *layer = video_drvdata(file);
>> +	struct mxr_device *mdev = layer->mdev;
>> +	int ret;
>> +
>> +	/* lock protects from changing sd_out */
>> +	mutex_lock(&mdev->mutex);
>> +
>> +	/* standard change cannot be done while there is an entity
>> +	 * dependant on output configuration
>> +	 */
>> +	if (mdev->n_output == 0)
>> +		ret = v4l2_subdev_call(to_outsd(mdev), video, s_std_output,
>> +			*norm);
>> +	else
>> +		ret = -EBUSY;
>>     
>
> -EINVAL
>
>   
>> +
>> +	mutex_unlock(&mdev->mutex);
>> +
>> +	return ret;
>> +}
>> +
>> +static int mxr_enum_output(struct file *file, void *fh, struct v4l2_output *a)
>> +{
>> +	struct mxr_layer *layer = video_drvdata(file);
>> +	struct mxr_device *mdev = layer->mdev;
>> +	struct mxr_output *out;
>> +	struct v4l2_subdev *sd;
>> +
>> +	if (a->index >= mdev->output_cnt)
>> +		return -EINVAL;
>> +	out = mdev->output[a->index];
>> +	BUG_ON(out == NULL);
>> +	sd = out->sd;
>> +	strlcpy(a->name, out->name, sizeof(a->name));
>>     
>
> The names for the outputs are currently hardcoded in mxr_output_conf if I
> understand it correctly.
>
> I think that you should consider obtaining this from board code via platform data.
>
> These names should refer to labels on the final product. You don't know those
> names in this driver (or for that matter whether any of the outputs are actually
> hooked up to a physical connector!). Let the board designer decide which, if any,
> outputs are used and how they are labeled.
>
>   
Ok.. I tried to avoid using platform data. I prefer driver variants.
>> +
>> +	/* try to obtain supported tv norms */
>> +	v4l2_subdev_call(sd, video, g_tvnorms, &a->std);
>> +	a->capabilities = 0;
>> +	if (sd->ops->video && sd->ops->video->s_dv_preset)
>> +		a->capabilities |= V4L2_OUT_CAP_PRESETS;
>> +	if (sd->ops->video && sd->ops->video->s_std_output)
>> +		a->capabilities |= V4L2_OUT_CAP_STD;
>>     
>
> Hmm, what to use for a->type? V4L2_OUTPUT_TYPE_ANALOG is the only reasonable
> option today. I think we should introduce an alias for this: V4L2_OUTPUT_TYPE_DISPLAY
> or something like that that is less 'analog' minded. I don't think that a
> TYPE_DIGITAL makes much sense in practice.
>   
Oops.. my mistake. I forgot to set this field.
>   
>> +
>> +	return 0;
>> +}
>> +
>> +static int mxr_s_output(struct file *file, void *fh, unsigned int i)
>> +{
>> +	struct video_device *vfd = video_devdata(file);
>> +	struct mxr_layer *layer = video_drvdata(file);
>> +	struct mxr_device *mdev = layer->mdev;
>> +	int ret = 0;
>> +
>> +	if (i >= mdev->output_cnt || mdev->output[i] == NULL)
>> +		return -EINVAL;
>> +
>> +	mutex_lock(&mdev->mutex);
>> +	if (mdev->n_output > 0) {
>> +		ret = -EBUSY;
>> +		goto done;
>> +	}
>> +	mdev->current_output = i;
>> +	mxr_info(mdev, "tvnorms = %08llx\n", vfd->tvnorms);
>> +	vfd->tvnorms = 0;
>> +	v4l2_subdev_call(to_outsd(mdev), video, g_tvnorms, &vfd->tvnorms);
>> +	mxr_info(mdev, "new tvnorms = %08llx\n", vfd->tvnorms);
>>     
>
> Why mxr_info? I'd use mxr_dbg.
>
> Normal usage should not result in kernel messages unless explicitly enabled.
>
>   
ok
>> +
>> +done:
>> +	mutex_unlock(&mdev->mutex);
>> +	return ret;
>> +}
>> +
>> +static int mxr_reqbufs(struct file *file, void *priv,
>> +			  struct v4l2_requestbuffers *p)
>> +{
>> +	struct mxr_layer *layer = video_drvdata(file);
>> +
>> +	mxr_dbg(layer->mdev, "%s:%d\n", __func__, __LINE__);
>> +	return vb2_reqbufs(&layer->vb_queue, p);
>> +}
>> +
>> +static int mxr_querybuf(struct file *file, void *priv, struct v4l2_buffer *p)
>> +{
>> +	struct mxr_layer *layer = video_drvdata(file);
>> +
>> +	mxr_dbg(layer->mdev, "%s:%d\n", __func__, __LINE__);
>> +	return vb2_querybuf(&layer->vb_queue, p);
>> +}
>> +
>> +static int mxr_qbuf(struct file *file, void *priv, struct v4l2_buffer *p)
>> +{
>> +	struct mxr_layer *layer = video_drvdata(file);
>> +
>> +	mxr_dbg(layer->mdev, "%s:%d(%d)\n", __func__, __LINE__, p->index);
>> +	return vb2_qbuf(&layer->vb_queue, p);
>> +}
>> +
>> +static int mxr_dqbuf(struct file *file, void *priv, struct v4l2_buffer *p)
>> +{
>> +	struct mxr_layer *layer = video_drvdata(file);
>> +
>> +	mxr_dbg(layer->mdev, "%s:%d\n", __func__, __LINE__);
>> +	return vb2_dqbuf(&layer->vb_queue, p, file->f_flags & O_NONBLOCK);
>> +}
>> +
>> +static int mxr_streamon(struct file *file, void *priv, enum v4l2_buf_type i)
>> +{
>> +	struct mxr_layer *layer = video_drvdata(file);
>> +
>> +	mxr_dbg(layer->mdev, "%s:%d\n", __func__, __LINE__);
>> +	return vb2_streamon(&layer->vb_queue, i);
>> +}
>> +
>> +static int mxr_streamoff(struct file *file, void *priv, enum v4l2_buf_type i)
>> +{
>> +	struct mxr_layer *layer = video_drvdata(file);
>> +
>> +	mxr_dbg(layer->mdev, "%s:%d\n", __func__, __LINE__);
>> +	return vb2_streamoff(&layer->vb_queue, i);
>> +}
>> +
>> +static const struct v4l2_ioctl_ops mxr_ioctl_ops = {
>> +	.vidioc_querycap = mxr_querycap,
>> +	/* format handling */
>> +	.vidioc_enum_fmt_vid_out = mxr_enum_fmt,
>> +	.vidioc_s_fmt_vid_out_mplane = mxr_s_fmt,
>> +	.vidioc_g_fmt_vid_out_mplane = mxr_g_fmt,
>> +	/* buffer control */
>> +	.vidioc_reqbufs = mxr_reqbufs,
>> +	.vidioc_querybuf = mxr_querybuf,
>> +	.vidioc_qbuf = mxr_qbuf,
>> +	.vidioc_dqbuf = mxr_dqbuf,
>> +	/* Streaming control */
>> +	.vidioc_streamon = mxr_streamon,
>> +	.vidioc_streamoff = mxr_streamoff,
>> +	/* Preset functions */
>> +	.vidioc_enum_dv_presets = mxr_enum_dv_presets,
>> +	.vidioc_s_dv_preset = mxr_s_dv_preset,
>> +	.vidioc_g_dv_preset = mxr_g_dv_preset,
>> +	/* analog TV standard functions */
>> +	.vidioc_s_std = mxr_s_std,
>> +	/* Output handling */
>> +	.vidioc_enum_output = mxr_enum_output,
>> +	.vidioc_s_output = mxr_s_output,
>> +	/* Crop ioctls */
>> +	.vidioc_g_crop = mxr_g_crop,
>> +	.vidioc_s_crop = mxr_s_crop,
>> +	.vidioc_cropcap = mxr_cropcap,
>> +};
>> +
>> +static int mxr_video_open(struct file *file)
>> +{
>> +	struct mxr_layer *layer = video_drvdata(file);
>> +	struct mxr_device *mdev = layer->mdev;
>> +	int ret = 0;
>> +
>> +	mxr_dbg(mdev, "%s:%d\n", __func__, __LINE__);
>> +	/* assure device probe is finished */
>> +	wait_for_device_probe();
>> +	/* lock layer->mutex is already taken by video_device */
>> +	/* leaving if layer is already initialized */
>> +	if (++layer->n_user > 1)
>> +		return 0;
>> +
>> +	/* FIXME: should power be enabled on open? */
>> +	ret = mxr_power_get(mdev);
>> +	if (ret) {
>> +		mxr_err(mdev, "power on failed\n");
>> +		goto fail_n_user;
>> +	}
>> +
>> +	ret = vb2_queue_init(&layer->vb_queue);
>> +	if (ret != 0) {
>> +		mxr_err(mdev, "failed to initialize vb2 queue\n");
>> +		goto fail_power;
>> +	}
>> +	/* set default format, first on the list */
>> +	layer->fmt = layer->fmt_array[0];
>> +	/* setup default geometry */
>> +	mxr_layer_default_geo(layer);
>> +
>> +	return 0;
>> +
>> +fail_power:
>> +	mxr_power_put(mdev);
>> +
>> +fail_n_user:
>> +	--layer->n_user;
>> +
>> +	return ret;
>> +}
>> +
>> +static unsigned int
>> +mxr_video_poll(struct file *file, struct poll_table_struct *wait)
>> +{
>> +	struct mxr_layer *layer = video_drvdata(file);
>> +
>> +	mxr_dbg(layer->mdev, "%s:%d\n", __func__, __LINE__);
>> +
>> +	return vb2_poll(&layer->vb_queue, file, wait);
>> +}
>> +
>> +static int mxr_video_mmap(struct file *file, struct vm_area_struct *vma)
>> +{
>> +	struct mxr_layer *layer = video_drvdata(file);
>> +
>> +	mxr_dbg(layer->mdev, "%s:%d\n", __func__, __LINE__);
>> +
>> +	return vb2_mmap(&layer->vb_queue, vma);
>> +}
>> +
>> +static int mxr_video_release(struct file *file)
>> +{
>> +	struct mxr_layer *layer = video_drvdata(file);
>> +
>> +	mxr_dbg(layer->mdev, "%s:%d\n", __func__, __LINE__);
>> +	if (--layer->n_user == 0) {
>> +		vb2_queue_release(&layer->vb_queue);
>> +		mxr_power_put(layer->mdev);
>> +	}
>> +	return 0;
>> +}
>>     
>
> I recommend that you start using v4l2_fh_open and v4l2_fh_release together with
> v4l2_fh_is_singular. The first two functions will allow you to easily implement
> G/S_PRIORITY and be ready for control and HDMI events. The v4l2_fh_is_singular()
> call allows you to get rid of n_user. You can take a look at vivi.c to see how
> this is done.
>
> I also recommend you run the v4l2-compliance test app from v4l-utils against
> this driver. It's not a full coverage, but what it tests it does test well.
>
>   
ok
>> +
>> +static const struct v4l2_file_operations mxr_fops = {
>> +	.owner = THIS_MODULE,
>> +	.open = mxr_video_open,
>> +	.poll = mxr_video_poll,
>> +	.mmap = mxr_video_mmap,
>> +	.release = mxr_video_release,
>> +	.unlocked_ioctl = video_ioctl2,
>> +};
>> +
>> +static unsigned int divup(unsigned int divident, unsigned int divisor)
>> +{
>> +	return (divident + divisor - 1) / divisor;
>> +}
>> +
>> +unsigned long mxr_get_plane_size(const struct mxr_block *blk,
>> +	unsigned int width, unsigned int height)
>> +{
>> +	unsigned int bl_width = divup(width, blk->width);
>> +	unsigned int bl_height = divup(height, blk->height);
>> +
>> +	return bl_width * bl_height * blk->size;
>> +}
>> +
>> +static int queue_setup(struct vb2_queue *vq, unsigned int *nbuffers,
>> +	unsigned int *nplanes, unsigned long sizes[],
>> +	void *alloc_ctxs[])
>> +{
>> +	struct mxr_layer *layer = vb2_get_drv_priv(vq);
>> +	const struct mxr_format *fmt = layer->fmt;
>> +	int i;
>> +	struct mxr_device *mdev = layer->mdev;
>> +
>> +	mxr_dbg(mdev, "%s\n", __func__);
>> +	/* checking if format was configured */
>> +	if (fmt == NULL)
>> +		return -EINVAL;
>> +	mxr_dbg(mdev, "fmt = %s\n", fmt->name);
>> +
>> +	*nplanes = fmt->num_subframes;
>> +	for (i = 0; i < fmt->num_subframes; ++i) {
>> +		alloc_ctxs[i] = layer->mdev->alloc_ctx;
>> +		sizes[i] = 0;
>> +	}
>> +
>> +	for (i = 0; i < fmt->num_planes; ++i) {
>> +		int frame_idx = fmt->plane2subframe[i];
>> +		const struct mxr_block *blk = &fmt->plane[i];
>> +		unsigned long plane_size;
>>     
>
> Add empty line.
>
>   
>> +		plane_size = mxr_get_plane_size(blk, layer->geo.src.full_width,
>> +			layer->geo.src.full_height);
>> +		sizes[frame_idx] += plane_size;
>> +		mxr_dbg(mdev, "plane_size[%d] = %08lx\n", i, plane_size);
>> +	}
>> +	for (i = 0; i < fmt->num_subframes; ++i) {
>> +		sizes[i] = PAGE_ALIGN(sizes[i]);
>> +		mxr_dbg(mdev, "size[%d] = %08lx\n", i, sizes[i]);
>> +	}
>> +
>> +	if (*nbuffers == 0)
>> +		*nbuffers = 1;
>> +
>> +	return 0;
>> +}
>> +
>> +static void buf_queue(struct vb2_buffer *vb)
>> +{
>> +	struct mxr_buffer *buffer = container_of(vb, struct mxr_buffer, vb);
>> +	struct mxr_layer *layer = vb2_get_drv_priv(vb->vb2_queue);
>> +	struct mxr_device *mdev = layer->mdev;
>> +	unsigned long flags;
>> +	int must_start = 0;
>> +
>> +	spin_lock_irqsave(&layer->enq_slock, flags);
>> +	if (layer->state == MXR_LAYER_STREAMING_START) {
>> +		layer->state = MXR_LAYER_STREAMING;
>> +		must_start = 1;
>> +	}
>> +	list_add_tail(&buffer->list, &layer->enq_list);
>> +	spin_unlock_irqrestore(&layer->enq_slock, flags);
>> +	if (must_start) {
>> +		layer->ops.stream_set(layer, MXR_ENABLE);
>> +		mxr_streamer_get(mdev);
>> +	}
>> +
>> +	mxr_dbg(mdev, "queuing buffer\n");
>> +}
>> +
>> +static void wait_lock(struct vb2_queue *vq)
>> +{
>> +	struct mxr_layer *layer = vb2_get_drv_priv(vq);
>> +
>> +	mxr_dbg(layer->mdev, "%s\n", __func__);
>> +	mutex_lock(&layer->mutex);
>> +}
>> +
>> +static void wait_unlock(struct vb2_queue *vq)
>> +{
>> +	struct mxr_layer *layer = vb2_get_drv_priv(vq);
>> +
>> +	mxr_dbg(layer->mdev, "%s\n", __func__);
>> +	mutex_unlock(&layer->mutex);
>> +}
>> +
>> +static int start_streaming(struct vb2_queue *vq)
>> +{
>> +	struct mxr_layer *layer = vb2_get_drv_priv(vq);
>> +	struct mxr_device *mdev = layer->mdev;
>> +	unsigned long flags;
>> +
>> +	mxr_dbg(mdev, "%s\n", __func__);
>> +	/* block any changes in output configuration */
>> +	mxr_output_get(mdev);
>> +
>> +	/* update layers geometry */
>> +	mxr_layer_geo_fix(layer);
>> +	mxr_geometry_dump(mdev, &layer->geo);
>> +
>> +	layer->ops.format_set(layer);
>> +	/* enabling layer in hardware */
>> +	spin_lock_irqsave(&layer->enq_slock, flags);
>> +	layer->state = MXR_LAYER_STREAMING_START;
>> +	spin_unlock_irqrestore(&layer->enq_slock, flags);
>> +
>> +	return 0;
>> +}
>> +
>> +static void mxr_watchdog(unsigned long arg)
>> +{
>> +	struct mxr_layer *layer = (struct mxr_layer *) arg;
>> +	struct mxr_device *mdev = layer->mdev;
>> +	unsigned long flags;
>> +
>> +	mxr_err(mdev, "watchdog fired for layer %s\n", layer->vfd.name);
>> +
>> +	spin_lock_irqsave(&layer->enq_slock, flags);
>> +
>> +	if (layer->update_buf == layer->shadow_buf)
>> +		layer->update_buf = NULL;
>> +	if (layer->update_buf) {
>> +		vb2_buffer_done(&layer->update_buf->vb, VB2_BUF_STATE_ERROR);
>> +		layer->update_buf = NULL;
>> +	}
>> +	if (layer->shadow_buf) {
>> +		vb2_buffer_done(&layer->shadow_buf->vb, VB2_BUF_STATE_ERROR);
>> +		layer->shadow_buf = NULL;
>> +	}
>> +	spin_unlock_irqrestore(&layer->enq_slock, flags);
>> +}
>> +
>> +static int stop_streaming(struct vb2_queue *vq)
>> +{
>> +	struct mxr_layer *layer = vb2_get_drv_priv(vq);
>> +	struct mxr_device *mdev = layer->mdev;
>> +	unsigned long flags;
>> +	struct timer_list watchdog;
>> +	struct mxr_buffer *buf, *buf_tmp;
>> +
>> +	mxr_dbg(mdev, "%s\n", __func__);
>> +
>> +	spin_lock_irqsave(&layer->enq_slock, flags);
>> +
>> +	/* reset list */
>> +	layer->state = MXR_LAYER_STREAMING_FINISH;
>> +
>> +	/* set all buffer to be done */
>> +	list_for_each_entry_safe(buf, buf_tmp, &layer->enq_list, list) {
>> +		list_del(&buf->list);
>> +		vb2_buffer_done(&buf->vb, VB2_BUF_STATE_ERROR);
>> +	}
>> +
>> +	spin_unlock_irqrestore(&layer->enq_slock, flags);
>> +
>> +	/* give 1 seconds to complete to complete last buffers */
>> +	setup_timer_on_stack(&watchdog, mxr_watchdog,
>> +		(unsigned long)layer);
>> +	mod_timer(&watchdog, jiffies + msecs_to_jiffies(1000));
>> +
>> +	/* wait until all buffers are goes to done state */
>> +	vb2_wait_for_all_buffers(vq);
>> +
>> +	/* stop timer if all synchronization is done */
>> +	del_timer_sync(&watchdog);
>> +	destroy_timer_on_stack(&watchdog);
>> +
>> +	/* stopping hardware */
>> +	spin_lock_irqsave(&layer->enq_slock, flags);
>> +	layer->state = MXR_LAYER_IDLE;
>> +	spin_unlock_irqrestore(&layer->enq_slock, flags);
>> +
>> +	/* disabling layer in hardware */
>> +	layer->ops.stream_set(layer, MXR_DISABLE);
>> +	/* remove one streamer */
>> +	mxr_streamer_put(mdev);
>> +	/* allow changes in output configuration */
>> +	mxr_output_put(mdev);
>> +	return 0;
>> +}
>> +
>> +static struct vb2_ops mxr_video_qops = {
>> +	.queue_setup = queue_setup,
>> +	.buf_queue = buf_queue,
>> +	.wait_prepare = wait_unlock,
>> +	.wait_finish = wait_lock,
>> +	.start_streaming = start_streaming,
>> +	.stop_streaming = stop_streaming,
>> +};
>> +
>> +/* FIXME: itry to put this functions to mxr_base_layer_create */
>> +int mxr_base_layer_register(struct mxr_layer *layer)
>> +{
>> +	struct mxr_device *mdev = layer->mdev;
>> +	int ret;
>> +
>> +	ret = video_register_device(&layer->vfd, VFL_TYPE_GRABBER, -1);
>> +	if (ret)
>> +		mxr_err(mdev, "failed to register video device\n");
>> +	else
>> +		mxr_info(mdev, "registered layer %s as /dev/video%d\n",
>> +			layer->vfd.name, layer->vfd.num);
>> +	return ret;
>> +}
>> +
>> +void mxr_base_layer_unregister(struct mxr_layer *layer)
>> +{
>> +	video_unregister_device(&layer->vfd);
>> +}
>> +
>> +void mxr_layer_release(struct mxr_layer *layer)
>> +{
>> +	if (layer->ops.release)
>> +		layer->ops.release(layer);
>> +}
>> +
>> +void mxr_base_layer_release(struct mxr_layer *layer)
>> +{
>> +	kfree(layer);
>> +}
>> +
>> +static void mxr_vfd_release(struct video_device *vdev)
>> +{
>> +	printk(KERN_INFO "video device release\n");
>> +}
>> +
>> +struct mxr_layer *mxr_base_layer_create(struct mxr_device *mdev,
>> +	int idx, char *name, struct mxr_layer_ops *ops)
>> +{
>> +	struct mxr_layer *layer;
>> +
>> +	layer = kzalloc(sizeof *layer, GFP_KERNEL);
>> +	if (layer == NULL) {
>> +		mxr_err(mdev, "not enough memory for layer.\n");
>> +		goto fail;
>> +	}
>> +
>> +	layer->mdev = mdev;
>> +	layer->idx = idx;
>> +	layer->ops = *ops;
>> +
>> +	spin_lock_init(&layer->enq_slock);
>> +	INIT_LIST_HEAD(&layer->enq_list);
>> +	mutex_init(&layer->mutex);
>> +
>> +	layer->vfd = (struct video_device) {
>> +		.minor = -1,
>> +		.release = mxr_vfd_release,
>> +		.fops = &mxr_fops,
>> +		.ioctl_ops = &mxr_ioctl_ops,
>> +	};
>> +	strlcpy(layer->vfd.name, name, sizeof(layer->vfd.name));
>> +
>> +	video_set_drvdata(&layer->vfd, layer);
>> +	layer->vfd.lock = &layer->mutex;
>> +	layer->vfd.v4l2_dev = &mdev->v4l2_dev;
>> +
>> +	layer->vb_queue = (struct vb2_queue) {
>> +		.type = V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE,
>> +		.io_modes = VB2_MMAP | VB2_USERPTR,
>> +		.drv_priv = layer,
>> +		.buf_struct_size = sizeof(struct mxr_buffer),
>> +		.ops = &mxr_video_qops,
>> +		.mem_ops = &vb2_dma_contig_memops,
>> +	};
>> +
>> +	return layer;
>> +
>> +fail:
>> +	return NULL;
>> +}
>> +
>> +static const struct mxr_format *find_format_by_fourcc(
>> +	struct mxr_layer *layer, unsigned long fourcc)
>> +{
>> +	int i;
>> +
>> +	for (i = 0; i < layer->fmt_array_size; ++i)
>> +		if (layer->fmt_array[i]->fourcc == fourcc)
>> +			return layer->fmt_array[i];
>> +	return NULL;
>> +}
>> +
>> +static const struct mxr_format *find_format_by_index(
>> +	struct mxr_layer *layer, unsigned long index)
>> +{
>> +	if (index >= layer->fmt_array_size)
>> +		return NULL;
>> +	return layer->fmt_array[index];
>> +}
>> +
>> diff --git a/drivers/media/video/s5p-tv/mixer_vp_layer.c b/drivers/media/video/s5p-tv/mixer_vp_layer.c
>> new file mode 100644
>> index 0000000..88b457e
>> --- /dev/null
>> +++ b/drivers/media/video/s5p-tv/mixer_vp_layer.c
>> @@ -0,0 +1,207 @@
>> +/*
>> + * Samsung TV Mixer driver
>> + *
>> + * Copyright (c) 2010-2011 Samsung Electronics Co., Ltd.
>> + *
>> + * Tomasz Stanislawski, <t.stanislaws@samsung.com>
>> + *
>> + * 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 Foundiation. either version 2 of the License,
>> + * or (at your option) any later version
>> + */
>> +
>> +#include "mixer.h"
>> +
>> +#include "regs-vp.h"
>> +
>> +#include <media/videobuf2-dma-contig.h>
>> +
>> +/* FORMAT DEFINITIONS */
>> +static const struct mxr_format mxr_fmt_nv12 = {
>> +	.name = "NV12",
>> +	.fourcc = V4L2_PIX_FMT_NV12,
>> +	.num_planes = 2,
>> +	.plane = {
>> +		{ .width = 1, .height = 1, .size = 1 },
>> +		{ .width = 2, .height = 2, .size = 2 },
>> +	},
>> +	.num_subframes = 1,
>> +	.cookie = VP_MODE_NV12 | VP_MODE_MEM_LINEAR,
>> +};
>> +
>> +static const struct mxr_format mxr_fmt_nv21 = {
>> +	.name = "NV21",
>> +	.fourcc = V4L2_PIX_FMT_NV21,
>> +	.num_planes = 2,
>> +	.plane = {
>> +		{ .width = 1, .height = 1, .size = 1 },
>> +		{ .width = 2, .height = 2, .size = 2 },
>> +	},
>> +	.num_subframes = 1,
>> +	.cookie = VP_MODE_NV21 | VP_MODE_MEM_LINEAR,
>> +};
>> +
>> +static const struct mxr_format mxr_fmt_nv12m = {
>> +	.name = "NV12 (mplane)",
>> +	.fourcc = V4L2_PIX_FMT_NV12M,
>> +	.num_planes = 2,
>> +	.plane = {
>> +		{ .width = 1, .height = 1, .size = 1 },
>> +		{ .width = 2, .height = 2, .size = 2 },
>> +	},
>> +	.num_subframes = 2,
>> +	.plane2subframe = {0, 1},
>> +	.cookie = VP_MODE_NV12 | VP_MODE_MEM_LINEAR,
>> +};
>> +
>> +static const struct mxr_format mxr_fmt_nv12mt = {
>> +	.name = "NV12 tiled (mplane)",
>> +	.fourcc = V4L2_PIX_FMT_NV12MT,
>> +	.num_planes = 2,
>> +	.plane = {
>> +		{ .width = 128, .height = 32, .size = 4096 },
>> +		{ .width = 128, .height = 32, .size = 2048 },
>> +	},
>> +	.num_subframes = 2,
>> +	.plane2subframe = {0, 1},
>> +	.cookie = VP_MODE_NV12 | VP_MODE_MEM_TILED,
>> +};
>> +
>> +static const struct mxr_format *mxr_video_format[] = {
>> +	&mxr_fmt_nv12,
>> +	&mxr_fmt_nv21,
>> +	&mxr_fmt_nv12m,
>> +	&mxr_fmt_nv12mt,
>> +};
>> +
>> +/* AUXILIARY CALLBACKS */
>> +
>> +static void mxr_vp_layer_release(struct mxr_layer *layer)
>> +{
>> +	mxr_base_layer_unregister(layer);
>> +	mxr_base_layer_release(layer);
>> +}
>> +
>> +static void mxr_vp_buffer_set(struct mxr_layer *layer,
>> +	struct mxr_buffer *buf)
>> +{
>> +	dma_addr_t luma_addr[2] = {0, 0};
>> +	dma_addr_t chroma_addr[2] = {0, 0};
>> +
>> +	if (buf == NULL) {
>> +		mxr_reg_vp_buffer(layer->mdev, luma_addr, chroma_addr);
>> +		return;
>> +	}
>> +	luma_addr[0] = vb2_dma_contig_plane_paddr(&buf->vb, 0);
>> +	if (layer->fmt->num_subframes == 2) {
>> +		chroma_addr[0] = vb2_dma_contig_plane_paddr(&buf->vb, 1);
>> +	} else {
>> +		/* FIXME: mxr_get_plane_size compute integer division,
>> +		 * which is slow and should not be performed in interrupt */
>> +		chroma_addr[0] = luma_addr[0] + mxr_get_plane_size(
>> +			&layer->fmt->plane[0], layer->geo.src.full_width,
>> +			layer->geo.src.full_height);
>> +	}
>> +	if (layer->fmt->cookie & VP_MODE_MEM_TILED) {
>> +		luma_addr[1] = luma_addr[0] + 0x40;
>> +		chroma_addr[1] = chroma_addr[0] + 0x40;
>> +	} else {
>> +		luma_addr[1] = luma_addr[0] + layer->geo.src.full_width;
>> +		chroma_addr[1] = chroma_addr[0];
>> +	}
>> +	mxr_reg_vp_buffer(layer->mdev, luma_addr, chroma_addr);
>> +}
>> +
>> +static void mxr_vp_stream_set(struct mxr_layer *layer, int en)
>> +{
>> +	mxr_reg_vp_layer_stream(layer->mdev, en);
>> +}
>> +
>> +static void mxr_vp_format_set(struct mxr_layer *layer)
>> +{
>> +	mxr_reg_vp_format(layer->mdev, layer->fmt, &layer->geo);
>> +}
>> +
>> +static void mxr_vp_fix_geometry(struct mxr_layer *layer)
>> +{
>> +	struct mxr_geometry *geo = &layer->geo;
>> +
>> +	/* align horizontal size to 8 pixels */
>> +	geo->src.full_width = ALIGN(geo->src.full_width, 8);
>> +	/* limit to boundary size */
>> +	geo->src.full_width = clamp_val(geo->src.full_width, 8, 8192);
>> +	geo->src.full_height = clamp_val(geo->src.full_height, 1, 8192);
>> +	geo->src.width = clamp_val(geo->src.width, 32, geo->src.full_width);
>> +	geo->src.width = min(geo->src.width, 2047U);
>> +	geo->src.height = clamp_val(geo->src.height, 4, geo->src.full_height);
>> +	geo->src.height = min(geo->src.height, 2047U);
>> +
>> +	/* setting size of output window */
>> +	geo->dst.width = clamp_val(geo->dst.width, 8, geo->dst.full_width);
>> +	geo->dst.height = clamp_val(geo->dst.height, 1, geo->dst.full_height);
>> +
>> +	/* ensure that scaling is in range 1/4x to 16x */
>> +	if (geo->src.width >= 4 * geo->dst.width)
>> +		geo->src.width = 4 * geo->dst.width;
>> +	if (geo->dst.width >= 16 * geo->src.width)
>> +		geo->dst.width = 16 * geo->src.width;
>> +	if (geo->src.height >= 4 * geo->dst.height)
>> +		geo->src.height = 4 * geo->dst.height;
>> +	if (geo->dst.height >= 16 * geo->src.height)
>> +		geo->dst.height = 16 * geo->src.height;
>> +
>> +	/* setting scaling ratio */
>> +	geo->x_ratio = (geo->src.width << 16) / geo->dst.width;
>> +	geo->y_ratio = (geo->src.height << 16) / geo->dst.height;
>> +
>> +	/* adjust offsets */
>> +	geo->src.x_offset = min(geo->src.x_offset,
>> +		geo->src.full_width - geo->src.width);
>> +	geo->src.y_offset = min(geo->src.y_offset,
>> +		geo->src.full_height - geo->src.height);
>> +	geo->dst.x_offset = min(geo->dst.x_offset,
>> +		geo->dst.full_width - geo->dst.width);
>> +	geo->dst.y_offset = min(geo->dst.y_offset,
>> +		geo->dst.full_height - geo->dst.height);
>> +}
>> +
>> +/* PUBLIC API */
>> +
>> +struct mxr_layer *mxr_vp_layer_create(struct mxr_device *mdev, int idx)
>> +{
>> +	struct mxr_layer *layer;
>> +	int ret;
>> +	struct mxr_layer_ops ops = {
>> +		.release = mxr_vp_layer_release,
>> +		.buffer_set = mxr_vp_buffer_set,
>> +		.stream_set = mxr_vp_stream_set,
>> +		.format_set = mxr_vp_format_set,
>> +		.fix_geometry = mxr_vp_fix_geometry,
>> +	};
>> +	char name[32];
>> +
>> +	sprintf(name, "video%d", idx);
>> +
>> +	layer = mxr_base_layer_create(mdev, idx, name, &ops);
>> +	if (layer == NULL) {
>> +		mxr_err(mdev, "failed to initialize layer(%d) base\n", idx);
>> +		goto fail;
>> +	}
>> +
>> +	layer->fmt_array = mxr_video_format;
>> +	layer->fmt_array_size = ARRAY_SIZE(mxr_video_format);
>> +
>> +	ret = mxr_base_layer_register(layer);
>> +	if (ret)
>> +		goto fail_layer;
>> +
>> +	return layer;
>> +
>> +fail_layer:
>> +	mxr_base_layer_release(layer);
>> +
>> +fail:
>> +	return NULL;
>> +}
>> +
>>     
>
> Regards,
>
> 	Hans
>
>