forked from Qortal/Brooklyn
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
840 lines
22 KiB
840 lines
22 KiB
// SPDX-License-Identifier: GPL-2.0-only |
|
/* |
|
* Copyright (C) 2010 Texas Instruments Inc |
|
*/ |
|
#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 |
|
* |
|
* @cfg: ptr to vpbe cfg |
|
* @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_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; |
|
unsigned 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, |
|
int output_index) |
|
{ |
|
struct vpbe_config *cfg = vpbe_dev->cfg; |
|
struct vpbe_enc_mode_info var; |
|
int curr_output = output_index; |
|
int i; |
|
|
|
if (!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 (!mode_info) |
|
return -EINVAL; |
|
|
|
*mode_info = vpbe_dev->current_timings; |
|
|
|
return 0; |
|
} |
|
|
|
/* 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.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; |
|
struct venc_platform_data *venc_device = vpbe_dev->venc_device; |
|
int enc_out_index; |
|
int sd_index; |
|
int ret; |
|
|
|
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 unlock; |
|
} |
|
|
|
ret = venc_device->setup_if_config(cfg->outputs[index].if_params); |
|
if (ret) |
|
goto unlock; |
|
} |
|
|
|
/* 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 unlock; |
|
|
|
/* |
|
* It is assumed that venc or external 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, index); |
|
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; |
|
} |
|
unlock: |
|
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 i; |
|
|
|
for (i = 0; i < cfg->num_outputs; i++) { |
|
if (!strcmp(def_output, |
|
cfg->outputs[i].output.name)) { |
|
int ret = vpbe_set_output(vpbe_dev, i); |
|
|
|
if (!ret) |
|
vpbe_dev->current_out_index = i; |
|
return ret; |
|
} |
|
} |
|
return 0; |
|
} |
|
|
|
/** |
|
* 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_timings - Set the given preset timings in the encoder |
|
* |
|
* Sets the timings if supported by the current encoder. Return the status. |
|
* 0 - success & -EINVAL on error |
|
*/ |
|
static int vpbe_s_dv_timings(struct vpbe_device *vpbe_dev, |
|
struct v4l2_dv_timings *dv_timings) |
|
{ |
|
struct vpbe_config *cfg = vpbe_dev->cfg; |
|
int out_index = vpbe_dev->current_out_index; |
|
struct vpbe_output *output = &cfg->outputs[out_index]; |
|
int sd_index = vpbe_dev->current_sd_index; |
|
int ret, i; |
|
|
|
|
|
if (!(cfg->outputs[out_index].output.capabilities & |
|
V4L2_OUT_CAP_DV_TIMINGS)) |
|
return -ENODATA; |
|
|
|
for (i = 0; i < output->num_modes; i++) { |
|
if (output->modes[i].timings_type == VPBE_ENC_DV_TIMINGS && |
|
!memcmp(&output->modes[i].dv_timings, |
|
dv_timings, sizeof(*dv_timings))) |
|
break; |
|
} |
|
if (i >= output->num_modes) |
|
return -EINVAL; |
|
vpbe_dev->current_timings = output->modes[i]; |
|
mutex_lock(&vpbe_dev->lock); |
|
|
|
ret = v4l2_subdev_call(vpbe_dev->encoders[sd_index], video, |
|
s_dv_timings, dv_timings); |
|
if (!ret && vpbe_dev->amp) { |
|
/* Call amplifier subdevice */ |
|
ret = v4l2_subdev_call(vpbe_dev->amp, video, |
|
s_dv_timings, dv_timings); |
|
} |
|
/* 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_timings - Get the timings in the current encoder |
|
* |
|
* Get the timings in the current encoder. Return the status. 0 - success |
|
* -EINVAL on error |
|
*/ |
|
static int vpbe_g_dv_timings(struct vpbe_device *vpbe_dev, |
|
struct v4l2_dv_timings *dv_timings) |
|
{ |
|
struct vpbe_config *cfg = vpbe_dev->cfg; |
|
int out_index = vpbe_dev->current_out_index; |
|
|
|
if (!(cfg->outputs[out_index].output.capabilities & |
|
V4L2_OUT_CAP_DV_TIMINGS)) |
|
return -ENODATA; |
|
|
|
if (vpbe_dev->current_timings.timings_type & |
|
VPBE_ENC_DV_TIMINGS) { |
|
*dv_timings = vpbe_dev->current_timings.dv_timings; |
|
return 0; |
|
} |
|
|
|
return -EINVAL; |
|
} |
|
|
|
/* |
|
* vpbe_enum_dv_timings - Enumerate the dv timings in the current encoder |
|
* |
|
* Get the timings in the current encoder. Return the status. 0 - success |
|
* -EINVAL on error |
|
*/ |
|
static int vpbe_enum_dv_timings(struct vpbe_device *vpbe_dev, |
|
struct v4l2_enum_dv_timings *timings) |
|
{ |
|
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_DV_TIMINGS)) |
|
return -ENODATA; |
|
|
|
for (i = 0; i < output->num_modes; i++) { |
|
if (output->modes[i].timings_type == VPBE_ENC_DV_TIMINGS) { |
|
if (j == timings->index) |
|
break; |
|
j++; |
|
} |
|
} |
|
|
|
if (i == output->num_modes) |
|
return -EINVAL; |
|
timings->timings = output->modes[i].dv_timings; |
|
return 0; |
|
} |
|
|
|
/* |
|
* 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 -ENODATA; |
|
|
|
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; |
|
struct vpbe_config *cfg = vpbe_dev->cfg; |
|
int out_index = vpbe_dev->current_out_index; |
|
|
|
if (!(cfg->outputs[out_index].output.capabilities & V4L2_OUT_CAP_STD)) |
|
return -ENODATA; |
|
|
|
if (cur_timings->timings_type & VPBE_ENC_STD) { |
|
*std_id = cur_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_timings dv_timings; |
|
struct osd_state *osd_device; |
|
int out_index = vpbe_dev->current_out_index; |
|
int i; |
|
|
|
if (!mode_info || !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->std_id); |
|
if (preset_mode->timings_type & |
|
VPBE_ENC_DV_TIMINGS) { |
|
dv_timings = |
|
preset_mode->dv_timings; |
|
return vpbe_s_dv_timings(vpbe_dev, &dv_timings); |
|
} |
|
} |
|
} |
|
|
|
/* Only custom timing should reach here */ |
|
if (!preset_mode) |
|
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 0; |
|
} |
|
|
|
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 (strstr(pdev->name, "vpbe-osd")) |
|
vpbe_dev->osd_device = platform_get_drvdata(pdev); |
|
if (strstr(pdev->name, "vpbe-venc")) |
|
vpbe_dev->venc_device = dev_get_platdata(&pdev->dev); |
|
|
|
return 0; |
|
} |
|
|
|
/** |
|
* vpbe_initialize() - Initialize the vpbe display controller |
|
* @dev: Master and slave device ptr |
|
* @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 amp_config_info *amp_info; |
|
struct v4l2_subdev **enc_subdev; |
|
struct osd_state *osd_device; |
|
struct i2c_adapter *i2c_adap; |
|
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 (!vpbe_dev || !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 fail_mutex_unlock; |
|
} |
|
if (clk_prepare_enable(vpbe_dev->dac_clk)) { |
|
ret = -ENODEV; |
|
clk_put(vpbe_dev->dac_clk); |
|
goto fail_mutex_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 fail_clk_put; |
|
} |
|
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) { |
|
ret = err; |
|
goto fail_dev_unregister; |
|
} |
|
|
|
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) { |
|
v4l2_err(&vpbe_dev->v4l2_dev, |
|
"vpbe unable to init venc sub device\n"); |
|
ret = -ENODEV; |
|
goto fail_dev_unregister; |
|
} |
|
/* initialize osd device */ |
|
osd_device = vpbe_dev->osd_device; |
|
if (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"); |
|
ret = -ENOMEM; |
|
goto fail_dev_unregister; |
|
} |
|
} |
|
|
|
/* |
|
* 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_array(num_encoders, |
|
sizeof(*vpbe_dev->encoders), |
|
GFP_KERNEL); |
|
if (!vpbe_dev->encoders) { |
|
ret = -ENOMEM; |
|
goto fail_dev_unregister; |
|
} |
|
|
|
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 fail_kfree_encoders; |
|
} |
|
} else |
|
v4l2_warn(&vpbe_dev->v4l2_dev, "non-i2c encoders currently not supported"); |
|
} |
|
/* Add amplifier subdevice for dm365 */ |
|
if ((strcmp(vpbe_dev->cfg->module_name, "dm365-vpbe-display") == 0) && |
|
vpbe_dev->cfg->amp) { |
|
amp_info = vpbe_dev->cfg->amp; |
|
if (amp_info->is_i2c) { |
|
vpbe_dev->amp = v4l2_i2c_new_subdev_board( |
|
&vpbe_dev->v4l2_dev, i2c_adap, |
|
&_info->board_info, NULL); |
|
if (!vpbe_dev->amp) { |
|
v4l2_err(&vpbe_dev->v4l2_dev, |
|
"amplifier %s failed to register", |
|
amp_info->module_name); |
|
ret = -ENODEV; |
|
goto fail_kfree_encoders; |
|
} |
|
v4l2_info(&vpbe_dev->v4l2_dev, |
|
"v4l2 sub device %s registered\n", |
|
amp_info->module_name); |
|
} else { |
|
vpbe_dev->amp = NULL; |
|
v4l2_warn(&vpbe_dev->v4l2_dev, "non-i2c amplifiers currently not supported"); |
|
} |
|
} else { |
|
vpbe_dev->amp = NULL; |
|
} |
|
|
|
/* set the current encoder and output to that of venc by default */ |
|
vpbe_dev->current_sd_index = 0; |
|
vpbe_dev->current_out_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); |
|
goto fail_kfree_amp; |
|
} |
|
|
|
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); |
|
goto fail_kfree_amp; |
|
} |
|
vpbe_dev->initialized = 1; |
|
/* TBD handling of bootargs for default output and mode */ |
|
return 0; |
|
|
|
fail_kfree_amp: |
|
mutex_lock(&vpbe_dev->lock); |
|
kfree(vpbe_dev->amp); |
|
fail_kfree_encoders: |
|
kfree(vpbe_dev->encoders); |
|
fail_dev_unregister: |
|
v4l2_device_unregister(&vpbe_dev->v4l2_dev); |
|
fail_clk_put: |
|
if (strcmp(vpbe_dev->cfg->module_name, "dm644x-vpbe-display") != 0) { |
|
clk_disable_unprepare(vpbe_dev->dac_clk); |
|
clk_put(vpbe_dev->dac_clk); |
|
} |
|
fail_mutex_unlock: |
|
mutex_unlock(&vpbe_dev->lock); |
|
return ret; |
|
} |
|
|
|
/** |
|
* vpbe_deinitialize() - de-initialize the vpbe display controller |
|
* @dev: Master and slave device ptr |
|
* @vpbe_dev: vpbe 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_disable_unprepare(vpbe_dev->dac_clk); |
|
clk_put(vpbe_dev->dac_clk); |
|
} |
|
|
|
kfree(vpbe_dev->amp); |
|
kfree(vpbe_dev->encoders); |
|
vpbe_dev->initialized = 0; |
|
/* disable vpss clocks */ |
|
vpss_enable_clock(VPSS_VPBE_CLOCK, 0); |
|
} |
|
|
|
static const struct vpbe_device_ops vpbe_dev_ops = { |
|
.enum_outputs = vpbe_enum_outputs, |
|
.set_output = vpbe_set_output, |
|
.get_output = vpbe_get_output, |
|
.s_dv_timings = vpbe_s_dv_timings, |
|
.g_dv_timings = vpbe_g_dv_timings, |
|
.enum_dv_timings = vpbe_enum_dv_timings, |
|
.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 int vpbe_probe(struct platform_device *pdev) |
|
{ |
|
struct vpbe_device *vpbe_dev; |
|
struct vpbe_config *cfg; |
|
|
|
if (!pdev->dev.platform_data) { |
|
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 -EINVAL; |
|
} |
|
|
|
vpbe_dev = kzalloc(sizeof(*vpbe_dev), GFP_KERNEL); |
|
if (!vpbe_dev) |
|
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 { |
|
kfree(vpbe_dev); |
|
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", |
|
}, |
|
.probe = vpbe_probe, |
|
.remove = vpbe_remove, |
|
}; |
|
|
|
module_platform_driver(vpbe_driver);
|
|
|