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

Commit 66715cdc authored by Manjunath Hadli's avatar Manjunath Hadli Committed by Mauro Carvalho Chehab
Browse files

[media] davinci vpbe: VPBE display driver 



This patch implements the core functionality of the display driver,
mainly controlling the VENC and other encoders, and acting as
the one point interface for the main V4L2 driver. This implements
the core of each of the V4L2 IOCTLs.

Signed-off-by: default avatarManjunath Hadli <manjunath.hadli@ti.com>
Acked-by: default avatarMuralidharan Karicheri <m-karicheri2@ti.com>
Acked-by: default avatarHans Verkuil <hverkuil@xs4all.nl>
Signed-off-by: default avatarMauro Carvalho Chehab <mchehab@redhat.com>
parent a2c25b44

drivers/media/video/davinci/vpbe.c

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

 * Copyright (C) 2010 Texas Instruments Inc

 *

 * This program is free software; you can redistribute it and/or modify

 * it under the terms of the GNU General Public License as published by

 * the Free Software Foundation version 2.

 *

 * This program is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

 * GNU General Public License for more details.

 *

 * You should have received a copy of the GNU General Public License

 * along with this program; if not, write to the Free Software

 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA

 */

#include <linux/kernel.h>

#include <linux/init.h>

#include <linux/module.h>

#include <linux/errno.h>

#include <linux/fs.h>

#include <linux/string.h>

#include <linux/wait.h>

#include <linux/time.h>

#include <linux/platform_device.h>

#include <linux/io.h>

#include <linux/slab.h>

#include <linux/clk.h>

#include <linux/err.h>



#include <media/v4l2-device.h>

#include <media/davinci/vpbe_types.h>

#include <media/davinci/vpbe.h>

#include <media/davinci/vpss.h>

#include <media/davinci/vpbe_venc.h>



#define VPBE_DEFAULT_OUTPUT	"Composite"

#define VPBE_DEFAULT_MODE	"ntsc"



static char *def_output = VPBE_DEFAULT_OUTPUT;

static char *def_mode = VPBE_DEFAULT_MODE;

static int debug;



module_param(def_output, charp, S_IRUGO);

module_param(def_mode, charp, S_IRUGO);

module_param(debug, int, 0644);



MODULE_PARM_DESC(def_output, "vpbe output name (default:Composite)");

MODULE_PARM_DESC(def_mode, "vpbe output mode name (default:ntsc");

MODULE_PARM_DESC(debug, "Debug level 0-1");



MODULE_DESCRIPTION("TI DMXXX VPBE Display controller");

MODULE_LICENSE("GPL");

MODULE_AUTHOR("Texas Instruments");



/**

 * vpbe_current_encoder_info - Get config info for current encoder

 * @vpbe_dev - vpbe device ptr

 *

 * Return ptr to current encoder config info

 */

static struct encoder_config_info*

vpbe_current_encoder_info(struct vpbe_device *vpbe_dev)

{

	struct vpbe_config *cfg = vpbe_dev->cfg;

	int index = vpbe_dev->current_sd_index;



	return ((index == 0) ? &cfg->venc :

				&cfg->ext_encoders[index-1]);

}



/**

 * vpbe_find_encoder_sd_index - Given a name find encoder sd index

 *

 * @vpbe_config - ptr to vpbe cfg

 * @output_index - index used by application

 *

 * Return sd index of the encoder

 */

static int vpbe_find_encoder_sd_index(struct vpbe_config *cfg,

			     int index)

{

	char *encoder_name = cfg->outputs[index].subdev_name;

	int i;



	/* Venc is always first	*/

	if (!strcmp(encoder_name, cfg->venc.module_name))

		return 0;



	for (i = 0; i < cfg->num_ext_encoders; i++) {

		if (!strcmp(encoder_name,

		     cfg->ext_encoders[i].module_name))

			return i+1;

	}



	return -EINVAL;

}



/**

 * vpbe_g_cropcap - Get crop capabilities of the display

 * @vpbe_dev - vpbe device ptr

 * @cropcap - cropcap is a ptr to struct v4l2_cropcap

 *

 * Update the crop capabilities in crop cap for current

 * mode

 */

static int vpbe_g_cropcap(struct vpbe_device *vpbe_dev,

			  struct v4l2_cropcap *cropcap)

{

	if (NULL == cropcap)

		return -EINVAL;

	cropcap->bounds.left = 0;

	cropcap->bounds.top = 0;

	cropcap->bounds.width = vpbe_dev->current_timings.xres;

	cropcap->bounds.height = vpbe_dev->current_timings.yres;

	cropcap->defrect = cropcap->bounds;



	return 0;

}



/**

 * vpbe_enum_outputs - enumerate outputs

 * @vpbe_dev - vpbe device ptr

 * @output - ptr to v4l2_output structure

 *

 * Enumerates the outputs available at the vpbe display

 * returns the status, -EINVAL if end of output list

 */

static int vpbe_enum_outputs(struct vpbe_device *vpbe_dev,

			     struct v4l2_output *output)

{

	struct vpbe_config *cfg = vpbe_dev->cfg;

	int temp_index = output->index;



	if (temp_index >= cfg->num_outputs)

		return -EINVAL;



	*output = cfg->outputs[temp_index].output;

	output->index = temp_index;



	return 0;

}



static int vpbe_get_mode_info(struct vpbe_device *vpbe_dev, char *mode)

{

	struct vpbe_config *cfg = vpbe_dev->cfg;

	struct vpbe_enc_mode_info var;

	int curr_output = vpbe_dev->current_out_index;

	int i;



	if (NULL == mode)

		return -EINVAL;



	for (i = 0; i < cfg->outputs[curr_output].num_modes; i++) {

		var = cfg->outputs[curr_output].modes[i];

		if (!strcmp(mode, var.name)) {

			vpbe_dev->current_timings = var;

			return 0;

		}

	}



	return -EINVAL;

}



static int vpbe_get_current_mode_info(struct vpbe_device *vpbe_dev,

				      struct vpbe_enc_mode_info *mode_info)

{

	if (NULL == mode_info)

		return -EINVAL;



	*mode_info = vpbe_dev->current_timings;



	return 0;

}



static int vpbe_get_dv_preset_info(struct vpbe_device *vpbe_dev,

				   unsigned int dv_preset)

{

	struct vpbe_config *cfg = vpbe_dev->cfg;

	struct vpbe_enc_mode_info var;

	int curr_output = vpbe_dev->current_out_index;

	int i;



	for (i = 0; i < vpbe_dev->cfg->outputs[curr_output].num_modes; i++) {

		var = cfg->outputs[curr_output].modes[i];

		if ((var.timings_type & VPBE_ENC_DV_PRESET) &&

		  (var.timings.dv_preset == dv_preset)) {

			vpbe_dev->current_timings = var;

			return 0;

		}

	}



	return -EINVAL;

}



/* Get std by std id */

static int vpbe_get_std_info(struct vpbe_device *vpbe_dev,

			     v4l2_std_id std_id)

{

	struct vpbe_config *cfg = vpbe_dev->cfg;

	struct vpbe_enc_mode_info var;

	int curr_output = vpbe_dev->current_out_index;

	int i;



	for (i = 0; i < vpbe_dev->cfg->outputs[curr_output].num_modes; i++) {

		var = cfg->outputs[curr_output].modes[i];

		if ((var.timings_type & VPBE_ENC_STD) &&

		  (var.timings.std_id & std_id)) {

			vpbe_dev->current_timings = var;

			return 0;

		}

	}



	return -EINVAL;

}



static int vpbe_get_std_info_by_name(struct vpbe_device *vpbe_dev,

				char *std_name)

{

	struct vpbe_config *cfg = vpbe_dev->cfg;

	struct vpbe_enc_mode_info var;

	int curr_output = vpbe_dev->current_out_index;

	int i;



	for (i = 0; i < vpbe_dev->cfg->outputs[curr_output].num_modes; i++) {

		var = cfg->outputs[curr_output].modes[i];

		if (!strcmp(var.name, std_name)) {

			vpbe_dev->current_timings = var;

			return 0;

		}

	}



	return -EINVAL;

}



/**

 * vpbe_set_output - Set output

 * @vpbe_dev - vpbe device ptr

 * @index - index of output

 *

 * Set vpbe output to the output specified by the index

 */

static int vpbe_set_output(struct vpbe_device *vpbe_dev, int index)

{

	struct encoder_config_info *curr_enc_info =

			vpbe_current_encoder_info(vpbe_dev);

	struct vpbe_config *cfg = vpbe_dev->cfg;

	int enc_out_index;

	int sd_index;

	int ret = 0;



	if (index >= cfg->num_outputs)

		return -EINVAL;



	mutex_lock(&vpbe_dev->lock);



	sd_index = vpbe_dev->current_sd_index;

	enc_out_index = cfg->outputs[index].output.index;

	/*

	 * Currently we switch the encoder based on output selected

	 * by the application. If media controller is implemented later

	 * there is will be an API added to setup_link between venc

	 * and external encoder. So in that case below comparison always

	 * match and encoder will not be switched. But if application

	 * chose not to use media controller, then this provides current

	 * way of switching encoder at the venc output.

	 */

	if (strcmp(curr_enc_info->module_name,

		   cfg->outputs[index].subdev_name)) {

		/* Need to switch the encoder at the output */

		sd_index = vpbe_find_encoder_sd_index(cfg, index);

		if (sd_index < 0) {

			ret = -EINVAL;

			goto out;

		}



		if (ret)

			goto out;

	}



	/* Set output at the encoder */

	ret = v4l2_subdev_call(vpbe_dev->encoders[sd_index], video,

				       s_routing, 0, enc_out_index, 0);

	if (ret)

		goto out;



	/*

	 * It is assumed that venc or extenal encoder will set a default

	 * mode in the sub device. For external encoder or LCD pannel output,

	 * we also need to set up the lcd port for the required mode. So setup

	 * the lcd port for the default mode that is configured in the board

	 * arch/arm/mach-davinci/board-dm355-evm.setup file for the external

	 * encoder.

	 */

	ret = vpbe_get_mode_info(vpbe_dev,

				 cfg->outputs[index].default_mode);

	if (!ret) {

		struct osd_state *osd_device = vpbe_dev->osd_device;



		osd_device->ops.set_left_margin(osd_device,

			vpbe_dev->current_timings.left_margin);

		osd_device->ops.set_top_margin(osd_device,

		vpbe_dev->current_timings.upper_margin);

		vpbe_dev->current_sd_index = sd_index;

		vpbe_dev->current_out_index = index;

	}

out:

	mutex_unlock(&vpbe_dev->lock);

	return ret;

}



static int vpbe_set_default_output(struct vpbe_device *vpbe_dev)

{

	struct vpbe_config *cfg = vpbe_dev->cfg;

	int ret = 0;

	int i;



	for (i = 0; i < cfg->num_outputs; i++) {

		if (!strcmp(def_output,

			    cfg->outputs[i].output.name)) {

			ret = vpbe_set_output(vpbe_dev, i);

			if (!ret)

				vpbe_dev->current_out_index = i;

			return ret;

		}

	}

	return ret;

}



/**

 * vpbe_get_output - Get output

 * @vpbe_dev - vpbe device ptr

 *

 * return current vpbe output to the the index

 */

static unsigned int vpbe_get_output(struct vpbe_device *vpbe_dev)

{

	return vpbe_dev->current_out_index;

}



/**

 * vpbe_s_dv_preset - Set the given preset timings in the encoder

 *

 * Sets the preset if supported by the current encoder. Return the status.

 * 0 - success & -EINVAL on error

 */

static int vpbe_s_dv_preset(struct vpbe_device *vpbe_dev,

		     struct v4l2_dv_preset *dv_preset)

{

	struct vpbe_config *cfg = vpbe_dev->cfg;

	int out_index = vpbe_dev->current_out_index;

	int sd_index = vpbe_dev->current_sd_index;

	int ret;





	if (!(cfg->outputs[out_index].output.capabilities &

	    V4L2_OUT_CAP_PRESETS))

		return -EINVAL;



	ret = vpbe_get_dv_preset_info(vpbe_dev, dv_preset->preset);



	if (ret)

		return ret;



	mutex_lock(&vpbe_dev->lock);





	ret = v4l2_subdev_call(vpbe_dev->encoders[sd_index], video,

					s_dv_preset, dv_preset);

	/* set the lcd controller output for the given mode */

	if (!ret) {

		struct osd_state *osd_device = vpbe_dev->osd_device;



		osd_device->ops.set_left_margin(osd_device,

		vpbe_dev->current_timings.left_margin);

		osd_device->ops.set_top_margin(osd_device,

		vpbe_dev->current_timings.upper_margin);

	}

	mutex_unlock(&vpbe_dev->lock);



	return ret;

}



/**

 * vpbe_g_dv_preset - Get the preset in the current encoder

 *

 * Get the preset in the current encoder. Return the status. 0 - success

 * -EINVAL on error

 */

static int vpbe_g_dv_preset(struct vpbe_device *vpbe_dev,

		     struct v4l2_dv_preset *dv_preset)

{

	if (vpbe_dev->current_timings.timings_type &

	  VPBE_ENC_DV_PRESET) {

		dv_preset->preset = vpbe_dev->current_timings.timings.dv_preset;

		return 0;

	}



	return -EINVAL;

}



/**

 * vpbe_enum_dv_presets - Enumerate the dv presets in the current encoder

 *

 * Get the preset in the current encoder. Return the status. 0 - success

 * -EINVAL on error

 */

static int vpbe_enum_dv_presets(struct vpbe_device *vpbe_dev,

			 struct v4l2_dv_enum_preset *preset_info)

{

	struct vpbe_config *cfg = vpbe_dev->cfg;

	int out_index = vpbe_dev->current_out_index;

	struct vpbe_output *output = &cfg->outputs[out_index];

	int j = 0;

	int i;



	if (!(output->output.capabilities & V4L2_OUT_CAP_PRESETS))

		return -EINVAL;



	for (i = 0; i < output->num_modes; i++) {

		if (output->modes[i].timings_type == VPBE_ENC_DV_PRESET) {

			if (j == preset_info->index)

				break;

			j++;

		}

	}



	if (i == output->num_modes)

		return -EINVAL;



	return v4l_fill_dv_preset_info(output->modes[i].timings.dv_preset,

					preset_info);

}



/**

 * vpbe_s_std - Set the given standard in the encoder

 *

 * Sets the standard if supported by the current encoder. Return the status.

 * 0 - success & -EINVAL on error

 */

static int vpbe_s_std(struct vpbe_device *vpbe_dev, v4l2_std_id *std_id)

{

	struct vpbe_config *cfg = vpbe_dev->cfg;

	int out_index = vpbe_dev->current_out_index;

	int sd_index = vpbe_dev->current_sd_index;

	int ret;



	if (!(cfg->outputs[out_index].output.capabilities &

		V4L2_OUT_CAP_STD))

		return -EINVAL;



	ret = vpbe_get_std_info(vpbe_dev, *std_id);

	if (ret)

		return ret;



	mutex_lock(&vpbe_dev->lock);



	ret = v4l2_subdev_call(vpbe_dev->encoders[sd_index], video,

			       s_std_output, *std_id);

	/* set the lcd controller output for the given mode */

	if (!ret) {

		struct osd_state *osd_device = vpbe_dev->osd_device;



		osd_device->ops.set_left_margin(osd_device,

		vpbe_dev->current_timings.left_margin);

		osd_device->ops.set_top_margin(osd_device,

		vpbe_dev->current_timings.upper_margin);

	}

	mutex_unlock(&vpbe_dev->lock);



	return ret;

}



/**

 * vpbe_g_std - Get the standard in the current encoder

 *

 * Get the standard in the current encoder. Return the status. 0 - success

 * -EINVAL on error

 */

static int vpbe_g_std(struct vpbe_device *vpbe_dev, v4l2_std_id *std_id)

{

	struct vpbe_enc_mode_info cur_timings = vpbe_dev->current_timings;



	if (cur_timings.timings_type & VPBE_ENC_STD) {

		*std_id = cur_timings.timings.std_id;

		return 0;

	}



	return -EINVAL;

}



/**

 * vpbe_set_mode - Set mode in the current encoder using mode info

 *

 * Use the mode string to decide what timings to set in the encoder

 * This is typically useful when fbset command is used to change the current

 * timings by specifying a string to indicate the timings.

 */

static int vpbe_set_mode(struct vpbe_device *vpbe_dev,

			 struct vpbe_enc_mode_info *mode_info)

{

	struct vpbe_enc_mode_info *preset_mode = NULL;

	struct vpbe_config *cfg = vpbe_dev->cfg;

	struct v4l2_dv_preset dv_preset;

	struct osd_state *osd_device;

	int out_index = vpbe_dev->current_out_index;

	int ret = 0;

	int i;



	if ((NULL == mode_info) || (NULL == mode_info->name))

		return -EINVAL;



	for (i = 0; i < cfg->outputs[out_index].num_modes; i++) {

		if (!strcmp(mode_info->name,

		     cfg->outputs[out_index].modes[i].name)) {

			preset_mode = &cfg->outputs[out_index].modes[i];

			/*

			 * it may be one of the 3 timings type. Check and

			 * invoke right API

			 */

			if (preset_mode->timings_type & VPBE_ENC_STD)

				return vpbe_s_std(vpbe_dev,

						 &preset_mode->timings.std_id);

			if (preset_mode->timings_type & VPBE_ENC_DV_PRESET) {

				dv_preset.preset =

					preset_mode->timings.dv_preset;

				return vpbe_s_dv_preset(vpbe_dev, &dv_preset);

			}

		}

	}



	/* Only custom timing should reach here */

	if (preset_mode == NULL)

		return -EINVAL;



	mutex_lock(&vpbe_dev->lock);



	osd_device = vpbe_dev->osd_device;

	vpbe_dev->current_timings = *preset_mode;

	osd_device->ops.set_left_margin(osd_device,

		vpbe_dev->current_timings.left_margin);

	osd_device->ops.set_top_margin(osd_device,

		vpbe_dev->current_timings.upper_margin);



	mutex_unlock(&vpbe_dev->lock);



	return ret;

}



static int vpbe_set_default_mode(struct vpbe_device *vpbe_dev)

{

	int ret;



	ret = vpbe_get_std_info_by_name(vpbe_dev, def_mode);

	if (ret)

		return ret;



	/* set the default mode in the encoder */

	return vpbe_set_mode(vpbe_dev, &vpbe_dev->current_timings);

}



static int platform_device_get(struct device *dev, void *data)

{

	struct platform_device *pdev = to_platform_device(dev);

	struct vpbe_device *vpbe_dev = data;



	if (strcmp("vpbe-osd", pdev->name) == 0)

		vpbe_dev->osd_device = platform_get_drvdata(pdev);



	return 0;

}



/**

 * vpbe_initialize() - Initialize the vpbe display controller

 * @vpbe_dev - vpbe device ptr

 *

 * Master frame buffer device drivers calls this to initialize vpbe

 * display controller. This will then registers v4l2 device and the sub

 * devices and sets a current encoder sub device for display. v4l2 display

 * device driver is the master and frame buffer display device driver is

 * the slave. Frame buffer display driver checks the initialized during

 * probe and exit if not initialized. Returns status.

 */

static int vpbe_initialize(struct device *dev, struct vpbe_device *vpbe_dev)

{

	struct encoder_config_info *enc_info;

	struct v4l2_subdev **enc_subdev;

	struct osd_state *osd_device;

	struct i2c_adapter *i2c_adap;

	int output_index;

	int num_encoders;

	int ret = 0;

	int err;

	int i;



	/*

	 * v4l2 abd FBDev frame buffer devices will get the vpbe_dev pointer

	 * from the platform device by iteration of platform drivers and

	 * matching with device name

	 */

	if (NULL == vpbe_dev || NULL == dev) {

		printk(KERN_ERR "Null device pointers.\n");

		return -ENODEV;

	}



	if (vpbe_dev->initialized)

		return 0;



	mutex_lock(&vpbe_dev->lock);



	if (strcmp(vpbe_dev->cfg->module_name, "dm644x-vpbe-display") != 0) {

		/* We have dac clock available for platform */

		vpbe_dev->dac_clk = clk_get(vpbe_dev->pdev, "vpss_dac");

		if (IS_ERR(vpbe_dev->dac_clk)) {

			ret =  PTR_ERR(vpbe_dev->dac_clk);

			goto vpbe_unlock;

		}

		if (clk_enable(vpbe_dev->dac_clk)) {

			ret =  -ENODEV;

			goto vpbe_unlock;

		}

	}



	/* first enable vpss clocks */

	vpss_enable_clock(VPSS_VPBE_CLOCK, 1);



	/* First register a v4l2 device */

	ret = v4l2_device_register(dev, &vpbe_dev->v4l2_dev);

	if (ret) {

		v4l2_err(dev->driver,

			"Unable to register v4l2 device.\n");

		goto vpbe_fail_clock;

	}

	v4l2_info(&vpbe_dev->v4l2_dev, "vpbe v4l2 device registered\n");



	err = bus_for_each_dev(&platform_bus_type, NULL, vpbe_dev,

			       platform_device_get);

	if (err < 0)

		return err;



	vpbe_dev->venc = venc_sub_dev_init(&vpbe_dev->v4l2_dev,

					   vpbe_dev->cfg->venc.module_name);

	/* register venc sub device */

	if (vpbe_dev->venc == NULL) {

		v4l2_err(&vpbe_dev->v4l2_dev,

			"vpbe unable to init venc sub device\n");

		ret = -ENODEV;

		goto vpbe_fail_v4l2_device;

	}

	/* initialize osd device */

	osd_device = vpbe_dev->osd_device;



	if (NULL != osd_device->ops.initialize) {

		err = osd_device->ops.initialize(osd_device);

		if (err) {

			v4l2_err(&vpbe_dev->v4l2_dev,

				 "unable to initialize the OSD device");

			err = -ENOMEM;

			goto vpbe_fail_v4l2_device;

		}

	}



	/*

	 * Register any external encoders that are configured. At index 0 we

	 * store venc sd index.

	 */

	num_encoders = vpbe_dev->cfg->num_ext_encoders + 1;

	vpbe_dev->encoders = kmalloc(

				sizeof(struct v4l2_subdev *)*num_encoders,

				GFP_KERNEL);

	if (NULL == vpbe_dev->encoders) {

		v4l2_err(&vpbe_dev->v4l2_dev,

			"unable to allocate memory for encoders sub devices");

		ret = -ENOMEM;

		goto vpbe_fail_v4l2_device;

	}



	i2c_adap = i2c_get_adapter(vpbe_dev->cfg->i2c_adapter_id);

	for (i = 0; i < (vpbe_dev->cfg->num_ext_encoders + 1); i++) {

		if (i == 0) {

			/* venc is at index 0 */

			enc_subdev = &vpbe_dev->encoders[i];

			*enc_subdev = vpbe_dev->venc;

			continue;

		}

		enc_info = &vpbe_dev->cfg->ext_encoders[i];

		if (enc_info->is_i2c) {

			enc_subdev = &vpbe_dev->encoders[i];

			*enc_subdev = v4l2_i2c_new_subdev_board(

						&vpbe_dev->v4l2_dev, i2c_adap,

						&enc_info->board_info, NULL);

			if (*enc_subdev)

				v4l2_info(&vpbe_dev->v4l2_dev,

					  "v4l2 sub device %s registered\n",

					  enc_info->module_name);

			else {

				v4l2_err(&vpbe_dev->v4l2_dev, "encoder %s"

					 " failed to register",

					 enc_info->module_name);

				ret = -ENODEV;

				goto vpbe_fail_sd_register;

			}

		} else

			v4l2_warn(&vpbe_dev->v4l2_dev, "non-i2c encoders"

				 " currently not supported");

	}



	/* set the current encoder and output to that of venc by default */

	vpbe_dev->current_sd_index = 0;

	vpbe_dev->current_out_index = 0;

	output_index = 0;



	mutex_unlock(&vpbe_dev->lock);



	printk(KERN_NOTICE "Setting default output to %s\n", def_output);

	ret = vpbe_set_default_output(vpbe_dev);

	if (ret) {

		v4l2_err(&vpbe_dev->v4l2_dev, "Failed to set default output %s",

			 def_output);

		return ret;

	}



	printk(KERN_NOTICE "Setting default mode to %s\n", def_mode);

	ret = vpbe_set_default_mode(vpbe_dev);

	if (ret) {

		v4l2_err(&vpbe_dev->v4l2_dev, "Failed to set default mode %s",

			 def_mode);

		return ret;

	}

	vpbe_dev->initialized = 1;

	/* TBD handling of bootargs for default output and mode */

	return 0;



vpbe_fail_sd_register:

	kfree(vpbe_dev->encoders);

vpbe_fail_v4l2_device:

	v4l2_device_unregister(&vpbe_dev->v4l2_dev);

vpbe_fail_clock:

	if (strcmp(vpbe_dev->cfg->module_name, "dm644x-vpbe-display") != 0)

		clk_put(vpbe_dev->dac_clk);

vpbe_unlock:

	mutex_unlock(&vpbe_dev->lock);

	return ret;

}



/**

 * vpbe_deinitialize() - de-initialize the vpbe display controller

 * @dev - Master and slave device ptr

 *

 * vpbe_master and slave frame buffer devices calls this to de-initialize

 * the display controller. It is called when master and slave device

 * driver modules are removed and no longer requires the display controller.

 */

static void vpbe_deinitialize(struct device *dev, struct vpbe_device *vpbe_dev)

{

	v4l2_device_unregister(&vpbe_dev->v4l2_dev);

	if (strcmp(vpbe_dev->cfg->module_name, "dm644x-vpbe-display") != 0)

		clk_put(vpbe_dev->dac_clk);



	kfree(vpbe_dev->encoders);

	vpbe_dev->initialized = 0;

	/* disable vpss clocks */

	vpss_enable_clock(VPSS_VPBE_CLOCK, 0);

}



static struct vpbe_device_ops vpbe_dev_ops = {

	.g_cropcap = vpbe_g_cropcap,

	.enum_outputs = vpbe_enum_outputs,

	.set_output = vpbe_set_output,

	.get_output = vpbe_get_output,

	.s_dv_preset = vpbe_s_dv_preset,

	.g_dv_preset = vpbe_g_dv_preset,

	.enum_dv_presets = vpbe_enum_dv_presets,

	.s_std = vpbe_s_std,

	.g_std = vpbe_g_std,

	.initialize = vpbe_initialize,

	.deinitialize = vpbe_deinitialize,

	.get_mode_info = vpbe_get_current_mode_info,

	.set_mode = vpbe_set_mode,

};



static __devinit int vpbe_probe(struct platform_device *pdev)

{

	struct vpbe_device *vpbe_dev;

	struct vpbe_config *cfg;

	int ret = -EINVAL;



	if (pdev->dev.platform_data == NULL) {

		v4l2_err(pdev->dev.driver, "No platform data\n");

		return -ENODEV;

	}

	cfg = pdev->dev.platform_data;



	if (!cfg->module_name[0] ||

	    !cfg->osd.module_name[0] ||

	    !cfg->venc.module_name[0]) {

		v4l2_err(pdev->dev.driver, "vpbe display module names not"

			 " defined\n");

		return ret;

	}



	vpbe_dev = kzalloc(sizeof(*vpbe_dev), GFP_KERNEL);

	if (vpbe_dev == NULL) {

		v4l2_err(pdev->dev.driver, "Unable to allocate memory"

			 " for vpbe_device\n");

		return -ENOMEM;

	}

	vpbe_dev->cfg = cfg;

	vpbe_dev->ops = vpbe_dev_ops;

	vpbe_dev->pdev = &pdev->dev;



	if (cfg->outputs->num_modes > 0)

		vpbe_dev->current_timings = vpbe_dev->cfg->outputs[0].modes[0];

	else

		return -ENODEV;



	/* set the driver data in platform device */

	platform_set_drvdata(pdev, vpbe_dev);

	mutex_init(&vpbe_dev->lock);



	return 0;

}



static int vpbe_remove(struct platform_device *device)

{

	struct vpbe_device *vpbe_dev = platform_get_drvdata(device);



	kfree(vpbe_dev);



	return 0;

}



static struct platform_driver vpbe_driver = {

	.driver	= {

		.name	= "vpbe_controller",

		.owner	= THIS_MODULE,

	},

	.probe = vpbe_probe,

	.remove = vpbe_remove,

};



/**

 * vpbe_init: initialize the vpbe driver

 *

 * This function registers device and driver to the kernel

 */

static __init int vpbe_init(void)

{

	return platform_driver_register(&vpbe_driver);

}



/**

 * vpbe_cleanup : cleanup function for vpbe driver

 *

 * This will un-registers the device and driver to the kernel

 */

static void vpbe_cleanup(void)

{

	platform_driver_unregister(&vpbe_driver);

}



/* Function for module initialization and cleanup */

module_init(vpbe_init);

module_exit(vpbe_cleanup);

include/media/davinci/vpbe.h

0 → 100644
+184 −0

File added.

Preview size limit exceeded, changes collapsed.