Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit fef1c8d0 authored by Tomasz Stanislawski's avatar Tomasz Stanislawski Committed by Mauro Carvalho Chehab
Browse files

[media] v4l: s5p-tv: add TV Mixer driver for Samsung S5P platform 



Add driver for TV Mixer on Samsung platforms from S5P family.
Mixer is responsible for merging images from three layers and
passing result to the output.

Drivers are using:
- v4l2 framework
- videobuf2
- runtime PM

Signed-off-by: default avatarTomasz Stanislawski <t.stanislaws@samsung.com>
Signed-off-by: default avatarKyungmin Park <kyungmin.park@samsung.com>
Reviewed-by: default avatarMarek Szyprowski <m.szyprowski@samsung.com>
Reviewed-by: default avatarSylwester Nawrocki <s.nawrocki@samsung.com>
Reviewed-by: default avatarHans Verkuil <hverkuil@xs4all.nl>
Signed-off-by: default avatarMauro Carvalho Chehab <mchehab@redhat.com>
parent 9a498400

drivers/media/video/s5p-tv/Kconfig

+16 −0
Original line number Diff line number Diff line
@@ -57,4 +57,20 @@ config VIDEO_SAMSUNG_S5P_SDO 
	  subdev for use by other drivers. This driver requires

	  hdmiphy driver to work correctly.



config VIDEO_SAMSUNG_S5P_MIXER

	tristate "Samsung Mixer and Video Processor Driver"

	depends on VIDEO_DEV && VIDEO_V4L2

	depends on VIDEO_SAMSUNG_S5P_TV

	select VIDEOBUF2_DMA_CONTIG

	help

	  Say Y here if you want support for the Mixer in Samsung S5P SoCs.

	  This device produce image data to one of output interfaces.



config VIDEO_SAMSUNG_S5P_MIXER_DEBUG

	bool "Enable debug for Mixer Driver"

	depends on VIDEO_SAMSUNG_S5P_MIXER

	default n

	help

	  Enables debugging for Mixer driver.



endif # VIDEO_SAMSUNG_S5P_TV

drivers/media/video/s5p-tv/Makefile

+2 −0
Original line number Diff line number Diff line
@@ -12,4 +12,6 @@ obj-$(CONFIG_VIDEO_SAMSUNG_S5P_HDMI) += s5p-hdmi.o 
s5p-hdmi-y += hdmi_drv.o

obj-$(CONFIG_VIDEO_SAMSUNG_S5P_SDO) += s5p-sdo.o

s5p-sdo-y += sdo_drv.o

obj-$(CONFIG_VIDEO_SAMSUNG_S5P_MIXER) += s5p-mixer.o

s5p-mixer-y += mixer_drv.o mixer_video.o mixer_reg.o mixer_grp_layer.o mixer_vp_layer.o

drivers/media/video/s5p-tv/mixer.h

0 → 100644
+354 −0
Original line number Diff line number Diff line 
/*

 * 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



#ifdef CONFIG_VIDEO_SAMSUNG_S5P_MIXER_DEBUG

	#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 */

	const char *name;

	/** fourcc identifier */

	u32 fourcc;

	/** colorspace identifier */

	enum v4l2_colorspace colorspace;

	/** 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;

	/** 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 */



#define mxr_err(mdev, fmt, ...)  dev_err(mdev->dev, fmt, ##__VA_ARGS__)

#define mxr_warn(mdev, fmt, ...) dev_warn(mdev->dev, fmt, ##__VA_ARGS__)

#define mxr_info(mdev, fmt, ...) dev_info(mdev->dev, fmt, ##__VA_ARGS__)



#ifdef CONFIG_VIDEO_SAMSUNG_S5P_MIXER_DEBUG

	#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 */

drivers/media/video/s5p-tv/mixer_drv.c

0 → 100644
+487 −0
Original line number Diff line number Diff line 
/*

 * 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,

	},

};



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;



		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);

		mxr_reg_s_output(mdev, to_output(mdev)->cookie);



		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);



		mxr_reg_set_mbus_fmt(mdev, &mbus_fmt);

		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 auxiliary driver */

	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 auxiliary driver */

	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);

}



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);

}



/* --------- RESOURCE MANAGEMENT -------------*/



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 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]);

}



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;

}



/* ---------- POWER MANAGEMENT ----------- */



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);

	/* apply default configuration */

	mxr_reg_reset(mdev);

	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,

};



/* --------- DRIVER INITIALIZATION ---------- */



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 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 __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);

drivers/media/video/s5p-tv/mixer_grp_layer.c

0 → 100644
+185 −0

File added.

Preview size limit exceeded, changes collapsed.