Author | Tokens | Token Proportion | Commits | Commit Proportion |
---|---|---|---|---|
Manjunath Hadli | 3170 | 90.16% | 2 | 7.14% |
Hans Verkuil | 126 | 3.58% | 2 | 7.14% |
Lad Prabhakar | 87 | 2.47% | 3 | 10.71% |
SF Markus Elfring | 33 | 0.94% | 8 | 28.57% |
Alexey Khoroshilov | 23 | 0.65% | 1 | 3.57% |
Murali Karicheri | 19 | 0.54% | 1 | 3.57% |
Mauro Carvalho Chehab | 18 | 0.51% | 3 | 10.71% |
Peter Senna Tschudin | 12 | 0.34% | 1 | 3.57% |
Wei Yongjun | 8 | 0.23% | 1 | 3.57% |
Julia Lawall | 8 | 0.23% | 2 | 7.14% |
Sudip Mukherjee | 7 | 0.20% | 1 | 3.57% |
Thomas Gleixner | 2 | 0.06% | 1 | 3.57% |
Axel Lin | 2 | 0.06% | 1 | 3.57% |
Dan Carpenter | 1 | 0.03% | 1 | 3.57% |
Total | 3516 | 28 |
// 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"); err = -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);
Information contained on this website is for historical information purposes only and does not indicate or represent copyright ownership.
Created with Cregit http://github.com/cregit/cregit
Version 2.0-RC1