static int __exit tpd_remove(struct platform_device *pdev) { struct panel_drv_data *ddata = platform_get_drvdata(pdev); struct omap_dss_device *dssdev = &ddata->dssdev; struct omap_dss_device *in = ddata->in; tpd_uninit_pins(pdev); unregister_pm_notifier(&hdmi_i2c2_hack_pm_notif_block); hdmi_i2c2_hack_suspend_mcasp(); omapdss_unregister_output(&ddata->dssdev); WARN_ON(omapdss_device_is_enabled(dssdev)); if (omapdss_device_is_enabled(dssdev)) tpd_disable(dssdev); WARN_ON(omapdss_device_is_connected(dssdev)); if (omapdss_device_is_connected(dssdev)) tpd_disconnect(dssdev, dssdev->dst); omap_dss_put_device(in); return 0; }
static int omap_connect_dssdevs(void) { int r; struct omap_dss_device *dssdev = NULL; bool no_displays = true; for_each_dss_dev(dssdev) { r = dssdev->driver->connect(dssdev); if (r == -EPROBE_DEFER) { omap_dss_put_device(dssdev); goto cleanup; } else if (r) { dev_warn(dssdev->dev, "could not connect display: %s\n", dssdev->name); } else { no_displays = false; } } if (no_displays) return -EPROBE_DEFER; return 0; cleanup: /* * if we are deferring probe, we disconnect the devices we previously * connected */ omap_disconnect_dssdevs(); return r; }
static int __devexit omap_hdmi_remove(struct platform_device *pdev) { omap_dss_put_device(hdmi.dssdev); blocking_notifier_chain_unregister(&hdmi.dssdev->state_notifiers, &hdmi.notifier); snd_soc_unregister_dai(&pdev->dev); return 0; }
static int tfp410_probe(struct platform_device *pdev) { struct panel_drv_data *ddata; struct omap_dss_device *dssdev; int r; ddata = devm_kzalloc(&pdev->dev, sizeof(*ddata), GFP_KERNEL); if (!ddata) return -ENOMEM; platform_set_drvdata(pdev, ddata); if (dev_get_platdata(&pdev->dev)) { r = tfp410_probe_pdata(pdev); if (r) return r; } else if (pdev->dev.of_node) { r = tfp410_probe_of(pdev); if (r) return r; } else { return -ENODEV; } if (gpio_is_valid(ddata->pd_gpio)) { r = devm_gpio_request_one(&pdev->dev, ddata->pd_gpio, GPIOF_OUT_INIT_LOW, "tfp410 PD"); if (r) { dev_err(&pdev->dev, "Failed to request PD GPIO %d\n", ddata->pd_gpio); goto err_gpio; } } dssdev = &ddata->dssdev; dssdev->ops.dvi = &tfp410_dvi_ops; dssdev->dev = &pdev->dev; dssdev->type = OMAP_DISPLAY_TYPE_DPI; dssdev->output_type = OMAP_DISPLAY_TYPE_DVI; dssdev->owner = THIS_MODULE; dssdev->phy.dpi.data_lines = ddata->data_lines; dssdev->port_num = 1; r = omapdss_register_output(dssdev); if (r) { dev_err(&pdev->dev, "Failed to register output\n"); goto err_reg; } return 0; err_reg: err_gpio: omap_dss_put_device(ddata->in); return r; }
static void omap_connector_destroy(struct drm_connector *connector) { struct omap_connector *omap_connector = to_omap_connector(connector); struct omap_dss_device *dssdev = omap_connector->dssdev; DBG("%s", omap_connector->dssdev->name); drm_connector_unregister(connector); drm_connector_cleanup(connector); kfree(omap_connector); omap_dss_put_device(dssdev); }
static int opa362_probe(struct platform_device *pdev) { struct device_node *node = pdev->dev.of_node; struct panel_drv_data *ddata; struct omap_dss_device *dssdev, *in; struct gpio_desc *gpio; int r; dev_dbg(&pdev->dev, "probe\n"); if (node == NULL) { dev_err(&pdev->dev, "Unable to find device tree\n"); return -EINVAL; } ddata = devm_kzalloc(&pdev->dev, sizeof(*ddata), GFP_KERNEL); if (!ddata) return -ENOMEM; platform_set_drvdata(pdev, ddata); gpio = devm_gpiod_get_optional(&pdev->dev, "enable", GPIOD_OUT_LOW); if (IS_ERR(gpio)) return PTR_ERR(gpio); ddata->enable_gpio = gpio; in = omapdss_of_find_source_for_first_ep(node); if (IS_ERR(in)) { dev_err(&pdev->dev, "failed to find video source\n"); return PTR_ERR(in); } ddata->in = in; dssdev = &ddata->dssdev; dssdev->ops.atv = &opa362_atv_ops; dssdev->dev = &pdev->dev; dssdev->type = OMAP_DISPLAY_TYPE_VENC; dssdev->output_type = OMAP_DISPLAY_TYPE_VENC; dssdev->owner = THIS_MODULE; r = omapdss_register_output(dssdev); if (r) { dev_err(&pdev->dev, "Failed to register output\n"); goto err_reg; } return 0; err_reg: omap_dss_put_device(ddata->in); return r; }
static int panel_dpi_probe(struct platform_device *pdev) { struct panel_drv_data *ddata; struct omap_dss_device *dssdev; int r; ddata = devm_kzalloc(&pdev->dev, sizeof(*ddata), GFP_KERNEL); if (ddata == NULL) return -ENOMEM; platform_set_drvdata(pdev, ddata); if (dev_get_platdata(&pdev->dev)) { r = panel_dpi_probe_pdata(pdev); if (r) return r; } else if (pdev->dev.of_node) { r = panel_dpi_probe_of(pdev); if (r) return r; } else { return -ENODEV; } if (gpio_is_valid(ddata->backlight_gpio)) { r = devm_gpio_request_one(&pdev->dev, ddata->backlight_gpio, GPIOF_OUT_INIT_LOW, "panel backlight"); if (r) goto err_gpio; } dssdev = &ddata->dssdev; dssdev->dev = &pdev->dev; dssdev->driver = &panel_dpi_ops; dssdev->type = OMAP_DISPLAY_TYPE_DPI; dssdev->owner = THIS_MODULE; dssdev->panel.vm = ddata->vm; dssdev->phy.dpi.data_lines = ddata->data_lines; r = omapdss_register_display(dssdev); if (r) { dev_err(&pdev->dev, "Failed to register panel\n"); goto err_reg; } return 0; err_reg: err_gpio: omap_dss_put_device(ddata->in); return r; }
static int hdmic_probe(struct platform_device *pdev) { struct panel_drv_data *ddata; struct omap_dss_device *dssdev; int r; ddata = devm_kzalloc(&pdev->dev, sizeof(*ddata), GFP_KERNEL); if (!ddata) return -ENOMEM; platform_set_drvdata(pdev, ddata); ddata->dev = &pdev->dev; if (dev_get_platdata(&pdev->dev)) { r = hdmic_probe_pdata(pdev); if (r) return r; } else if (pdev->dev.of_node) { r = hdmic_probe_of(pdev); if (r) return r; } else { return -ENODEV; } if (gpio_is_valid(ddata->hpd_gpio)) { r = devm_gpio_request_one(&pdev->dev, ddata->hpd_gpio, GPIOF_DIR_IN, "hdmi_hpd"); if (r) goto err_reg; } ddata->timings = hdmic_default_timings; dssdev = &ddata->dssdev; dssdev->driver = &hdmic_driver; dssdev->dev = &pdev->dev; dssdev->type = OMAP_DISPLAY_TYPE_HDMI; dssdev->owner = THIS_MODULE; dssdev->panel.timings = hdmic_default_timings; r = omapdss_register_display(dssdev); if (r) { dev_err(&pdev->dev, "Failed to register panel\n"); goto err_reg; } return 0; err_reg: omap_dss_put_device(ddata->in); return r; }
static void acx565akm_disconnect(struct omap_dss_device *dssdev) { struct panel_drv_data *ddata = to_panel_data(dssdev); struct omap_dss_device *in = ddata->in; if (!omapdss_device_is_connected(dssdev)) return; in->ops.sdi->disconnect(in, dssdev); omap_dss_put_device(in); ddata->in = NULL; }
static void omap_connector_destroy(struct drm_connector *connector) { struct omap_connector *omap_connector = to_omap_connector(connector); struct omap_dss_device *dssdev = omap_connector->dssdev; dssdev->driver->disable(dssdev); DBG("%s", omap_connector->dssdev->name); drm_sysfs_connector_remove(connector); drm_connector_cleanup(connector); kfree(omap_connector); omap_dss_put_device(dssdev); }
static int __exit hdmic_remove(struct platform_device *pdev) { struct panel_drv_data *ddata = platform_get_drvdata(pdev); struct omap_dss_device *dssdev = &ddata->dssdev; struct omap_dss_device *in = ddata->in; omapdss_unregister_display(&ddata->dssdev); hdmic_disable(dssdev); hdmic_disconnect(dssdev); omap_dss_put_device(in); return 0; }
static int tpo_td043_remove(struct spi_device *spi) { struct panel_drv_data *ddata = dev_get_drvdata(&spi->dev); struct omap_dss_device *dssdev = &ddata->dssdev; struct omap_dss_device *in = ddata->in; dev_dbg(&ddata->spi->dev, "%s\n", __func__); omapdss_unregister_display(dssdev); tpo_td043_disable(dssdev); tpo_td043_disconnect(dssdev); omap_dss_put_device(in); sysfs_remove_group(&spi->dev.kobj, &tpo_td043_attr_group); return 0; }
static int panel_dpi_probe_pdata(struct platform_device *pdev) { const struct panel_dpi_platform_data *pdata; struct panel_drv_data *ddata = platform_get_drvdata(pdev); struct omap_dss_device *dssdev, *in; struct videomode vm; int r; pdata = dev_get_platdata(&pdev->dev); in = omap_dss_find_output(pdata->source); if (in == NULL) { dev_err(&pdev->dev, "failed to find video source '%s'\n", pdata->source); return -EPROBE_DEFER; } ddata->in = in; ddata->data_lines = pdata->data_lines; videomode_from_timing(pdata->display_timing, &vm); videomode_to_omap_video_timings(&vm, &ddata->videomode); dssdev = &ddata->dssdev; dssdev->name = pdata->name; r = devm_gpio_request_one(&pdev->dev, pdata->enable_gpio, GPIOF_OUT_INIT_LOW, "panel enable"); if (r) goto err_gpio; ddata->enable_gpio = gpio_to_desc(pdata->enable_gpio); ddata->backlight_gpio = pdata->backlight_gpio; return 0; err_gpio: omap_dss_put_device(ddata->in); return r; }
static int acx565akm_remove(struct spi_device *spi) { struct panel_drv_data *ddata = dev_get_drvdata(&spi->dev); struct omap_dss_device *dssdev = &ddata->dssdev; struct omap_dss_device *in = ddata->in; dev_dbg(&ddata->spi->dev, "%s\n", __func__); sysfs_remove_group(&ddata->bl_dev->dev.kobj, &bldev_attr_group); backlight_device_unregister(ddata->bl_dev); omapdss_unregister_display(dssdev); acx565akm_disable(dssdev); acx565akm_disconnect(dssdev); omap_dss_put_device(in); return 0; }
static int __exit opa362_remove(struct platform_device *pdev) { struct panel_drv_data *ddata = platform_get_drvdata(pdev); struct omap_dss_device *dssdev = &ddata->dssdev; struct omap_dss_device *in = ddata->in; omapdss_unregister_output(&ddata->dssdev); WARN_ON(omapdss_device_is_enabled(dssdev)); if (omapdss_device_is_enabled(dssdev)) opa362_disable(dssdev); WARN_ON(omapdss_device_is_connected(dssdev)); if (omapdss_device_is_connected(dssdev)) opa362_disconnect(dssdev, dssdev->dst); omap_dss_put_device(in); return 0; }
int display_init_sysfs(struct platform_device *pdev) { struct omap_dss_device *dssdev = NULL; int r; for_each_dss_dev(dssdev) { r = kobject_init_and_add(&dssdev->kobj, &display_ktype, &pdev->dev.kobj, "%s", dssdev->alias); if (r) { DSSERR("failed to create sysfs files\n"); omap_dss_put_device(dssdev); goto err; } } return 0; err: display_uninit_sysfs(pdev); return r; }
static int close_display(struct omap_display_device *display) { int err; int i; /* TODO: Is it the same thing to close a virtual and single display? */ DBG_PRINT("Closing display '%s'", display->name); display->reference_count--; for (i = 0; i < display->overlay_managers_count; i++) omap_dss_put_device(display->overlay_managers[i]->device); if (display->flip_chain) { err = display->destroy_flip_chain(display); display->flip_chain = 0; if (err) WRN_PRINT("An error happened when destroying flip " "chain for '%s'", display->name); } return 0; }
static int acx565akm_connect(struct omap_dss_device *dssdev) { struct panel_drv_data *ddata = to_panel_data(dssdev); struct omap_dss_device *in; int r; if (omapdss_device_is_connected(dssdev)) return 0; in = omapdss_of_find_source_for_first_ep(dssdev->dev->of_node); if (IS_ERR(in)) { dev_err(dssdev->dev, "failed to find video source\n"); return PTR_ERR(in); } r = in->ops.sdi->connect(in, dssdev); if (r) { omap_dss_put_device(in); return r; } ddata->in = in; return 0; }
static int tpo_td043_probe(struct spi_device *spi) { struct panel_drv_data *ddata; struct omap_dss_device *dssdev; int r; dev_dbg(&spi->dev, "%s\n", __func__); spi->bits_per_word = 16; spi->mode = SPI_MODE_0; r = spi_setup(spi); if (r < 0) { dev_err(&spi->dev, "spi_setup failed: %d\n", r); return r; } ddata = devm_kzalloc(&spi->dev, sizeof(*ddata), GFP_KERNEL); if (ddata == NULL) return -ENOMEM; dev_set_drvdata(&spi->dev, ddata); ddata->spi = spi; if (!spi->dev.of_node) return -ENODEV; r = tpo_td043_probe_of(spi); if (r) return r; ddata->mode = TPO_R02_MODE_800x480; memcpy(ddata->gamma, tpo_td043_def_gamma, sizeof(ddata->gamma)); ddata->vcc_reg = devm_regulator_get(&spi->dev, "vcc"); if (IS_ERR(ddata->vcc_reg)) { dev_err(&spi->dev, "failed to get LCD VCC regulator\n"); r = PTR_ERR(ddata->vcc_reg); goto err_regulator; } if (gpio_is_valid(ddata->nreset_gpio)) { r = devm_gpio_request_one(&spi->dev, ddata->nreset_gpio, GPIOF_OUT_INIT_LOW, "lcd reset"); if (r < 0) { dev_err(&spi->dev, "couldn't request reset GPIO\n"); goto err_gpio_req; } } r = sysfs_create_group(&spi->dev.kobj, &tpo_td043_attr_group); if (r) { dev_err(&spi->dev, "failed to create sysfs files\n"); goto err_sysfs; } ddata->videomode = tpo_td043_timings; dssdev = &ddata->dssdev; dssdev->dev = &spi->dev; dssdev->driver = &tpo_td043_ops; dssdev->type = OMAP_DISPLAY_TYPE_DPI; dssdev->owner = THIS_MODULE; dssdev->panel.timings = ddata->videomode; r = omapdss_register_display(dssdev); if (r) { dev_err(&spi->dev, "Failed to register panel\n"); goto err_reg; } return 0; err_reg: sysfs_remove_group(&spi->dev.kobj, &tpo_td043_attr_group); err_sysfs: err_gpio_req: err_regulator: omap_dss_put_device(ddata->in); return r; }
static __devinit int omap_hdmi_probe(struct platform_device *pdev) { int ret; struct resource *hdmi_rsrc; struct omap_dss_device *dssdev = NULL; bool hdmi_dev_found = false; hdmi_rsrc = platform_get_resource(pdev, IORESOURCE_MEM, 0); if (!hdmi_rsrc) { dev_err(&pdev->dev, "Cannot obtain IORESOURCE_MEM HDMI\n"); return -ENODEV; } omap_hdmi_dai_dma_params.port_addr = hdmi_rsrc->start + OMAP_HDMI_AUDIO_DMA_PORT; hdmi_rsrc = platform_get_resource(pdev, IORESOURCE_DMA, 0); if (!hdmi_rsrc) { dev_err(&pdev->dev, "Cannot obtain IORESOURCE_DMA HDMI\n"); return -ENODEV; } hdmi.oh = omap_hwmod_lookup("dss_hdmi"); if (!hdmi.oh) { dev_err(&pdev->dev, "can't find omap_hwmod for hdmi\n"); return -ENODEV; } omap_hdmi_dai_dma_params.dma_req = hdmi_rsrc->start; /* * Find an HDMI device. In the future, registers all the HDMI devices * it finds and create a PCM for each. */ for_each_dss_dev(dssdev) { omap_dss_get_device(dssdev); if (!dssdev->driver) { omap_dss_put_device(dssdev); continue; } if (dssdev->type == OMAP_DISPLAY_TYPE_HDMI) { hdmi_dev_found = true; break; } } if (!hdmi_dev_found) { dev_err(&pdev->dev, "no driver for HDMI display found"); return -ENODEV; } hdmi.dssdev = dssdev; /* the supported rates and sample format depend on the cpu */ if (cpu_is_omap44xx()) { omap_hdmi_dai.playback.rates = OMAP4_HDMI_RATES; omap_hdmi_dai.playback.formats = OMAP4_HDMI_FORMATS; omap_hdmi_dai.playback.channels_max = 8; } else { /* OMAP5 */ omap_hdmi_dai.playback.rates = OMAP5_HDMI_RATES; omap_hdmi_dai.playback.formats = OMAP5_HDMI_FORMATS; #ifdef CONFIG_ARCH_OMAP5_ES1 omap_hdmi_dai.playback.channels_max = 2; #else omap_hdmi_dai.playback.channels_max = 8; #endif } ret = snd_soc_register_dai(&pdev->dev, &omap_hdmi_dai); hdmi.notifier.notifier_call = hdmi_audio_notifier_callback; blocking_notifier_chain_register(&hdmi.dssdev->state_notifiers, &hdmi.notifier); return ret; }
static int omap_modeset_init(struct drm_device *dev) { struct omap_drm_private *priv = dev->dev_private; struct omap_dss_device *dssdev = NULL; int num_ovls = dss_feat_get_num_ovls(); int num_mgrs = dss_feat_get_num_mgrs(); int num_crtcs; int i, id = 0; drm_mode_config_init(dev); omap_drm_irq_install(dev); /* * We usually don't want to create a CRTC for each manager, at least * not until we have a way to expose private planes to userspace. * Otherwise there would not be enough video pipes left for drm planes. * We use the num_crtc argument to limit the number of crtcs we create. */ num_crtcs = min3(num_crtc, num_mgrs, num_ovls); dssdev = NULL; for_each_dss_dev(dssdev) { struct drm_connector *connector; struct drm_encoder *encoder; enum omap_channel channel; struct omap_overlay_manager *mgr; if (!omapdss_device_is_connected(dssdev)) continue; encoder = omap_encoder_init(dev, dssdev); if (!encoder) { dev_err(dev->dev, "could not create encoder: %s\n", dssdev->name); return -ENOMEM; } connector = omap_connector_init(dev, get_connector_type(dssdev), dssdev, encoder); if (!connector) { dev_err(dev->dev, "could not create connector: %s\n", dssdev->name); return -ENOMEM; } BUG_ON(priv->num_encoders >= ARRAY_SIZE(priv->encoders)); BUG_ON(priv->num_connectors >= ARRAY_SIZE(priv->connectors)); priv->encoders[priv->num_encoders++] = encoder; priv->connectors[priv->num_connectors++] = connector; drm_mode_connector_attach_encoder(connector, encoder); /* * if we have reached the limit of the crtcs we are allowed to * create, let's not try to look for a crtc for this * panel/encoder and onwards, we will, of course, populate the * the possible_crtcs field for all the encoders with the final * set of crtcs we create */ if (id == num_crtcs) continue; /* * get the recommended DISPC channel for this encoder. For now, * we only try to get create a crtc out of the recommended, the * other possible channels to which the encoder can connect are * not considered. */ mgr = omapdss_find_mgr_from_display(dssdev); channel = mgr->id; /* * if this channel hasn't already been taken by a previously * allocated crtc, we create a new crtc for it */ if (!channel_used(dev, channel)) { struct drm_plane *plane; struct drm_crtc *crtc; plane = omap_plane_init(dev, id, true); crtc = omap_crtc_init(dev, plane, channel, id); BUG_ON(priv->num_crtcs >= ARRAY_SIZE(priv->crtcs)); priv->crtcs[id] = crtc; priv->num_crtcs++; priv->planes[id] = plane; priv->num_planes++; id++; } } /* * we have allocated crtcs according to the need of the panels/encoders, * adding more crtcs here if needed */ for (; id < num_crtcs; id++) { /* find a free manager for this crtc */ for (i = 0; i < num_mgrs; i++) { if (!channel_used(dev, i)) { struct drm_plane *plane; struct drm_crtc *crtc; plane = omap_plane_init(dev, id, true); crtc = omap_crtc_init(dev, plane, i, id); BUG_ON(priv->num_crtcs >= ARRAY_SIZE(priv->crtcs)); priv->crtcs[id] = crtc; priv->num_crtcs++; priv->planes[id] = plane; priv->num_planes++; break; } else { continue; } } if (i == num_mgrs) { /* this shouldn't really happen */ dev_err(dev->dev, "no managers left for crtc\n"); return -ENOMEM; } } /* * Create normal planes for the remaining overlays: */ for (; id < num_ovls; id++) { struct drm_plane *plane = omap_plane_init(dev, id, false); BUG_ON(priv->num_planes >= ARRAY_SIZE(priv->planes)); priv->planes[priv->num_planes++] = plane; } for (i = 0; i < priv->num_encoders; i++) { struct drm_encoder *encoder = priv->encoders[i]; struct omap_dss_device *dssdev = omap_encoder_get_dssdev(encoder); struct omap_dss_device *output; output = omapdss_find_output_from_display(dssdev); /* figure out which crtc's we can connect the encoder to: */ encoder->possible_crtcs = 0; for (id = 0; id < priv->num_crtcs; id++) { struct drm_crtc *crtc = priv->crtcs[id]; enum omap_channel crtc_channel; crtc_channel = omap_crtc_channel(crtc); if (output->dispc_channel == crtc_channel) { encoder->possible_crtcs |= (1 << id); break; } } omap_dss_put_device(output); } DBG("registered %d planes, %d crtcs, %d encoders and %d connectors\n", priv->num_planes, priv->num_crtcs, priv->num_encoders, priv->num_connectors); dev->mode_config.min_width = 32; dev->mode_config.min_height = 32; /* note: eventually will need some cpu_is_omapXYZ() type stuff here * to fill in these limits properly on different OMAP generations.. */ dev->mode_config.max_width = 2048; dev->mode_config.max_height = 2048; dev->mode_config.funcs = &omap_mode_config_funcs; return 0; }
static int tpd_probe(struct platform_device *pdev) { struct omap_dss_device *in, *dssdev; struct panel_drv_data *ddata; int r; ddata = devm_kzalloc(&pdev->dev, sizeof(*ddata), GFP_KERNEL); if (!ddata) return -ENOMEM; platform_set_drvdata(pdev, ddata); if (dev_get_platdata(&pdev->dev)) { r = tpd_probe_pdata(pdev); if (r) return r; } else if (pdev->dev.of_node) { r = tpd_probe_of(pdev); if (r) return r; } else { return -ENODEV; } /* * initialize the SEL_HDMI_I2C2 line going to the demux. Configure the * demux to select the I2C2 bus */ r = sel_hdmi_i2c2_init(&pdev->dev); if (r) return r; config_demux(&pdev->dev, SEL_I2C2); r = devm_gpio_request_one(&pdev->dev, ddata->ct_cp_hpd_gpio, GPIOF_OUT_INIT_LOW, "hdmi_ct_cp_hpd"); if (r) goto err_gpio; if (gpio_is_valid(ddata->ls_oe_gpio)) { r = devm_gpio_request_one(&pdev->dev, ddata->ls_oe_gpio, GPIOF_OUT_INIT_LOW, "hdmi_ls_oe"); if (r) goto err_gpio; } r = devm_gpio_request_one(&pdev->dev, ddata->hpd_gpio, GPIOF_DIR_IN, "hdmi_hpd"); if (r) goto err_gpio; /* * we see some low voltage glitches on the HPD_B line before it * stabalizes to around 5V. We see the effects of this glitch on the * HPD_A side, and hence on the gpio on DRA7x. The glitch is quite short * in duration, but it takes a while for the voltage to go down back to * 0 volts, we set a debounce value of 1 millisecond to prevent this, * the reason for the glitch not being taken care of by the TPD chip * needs to be investigated */ r = gpio_set_debounce(ddata->hpd_gpio, HPD_DEBOUNCE_TIME); if (r) goto err_debounce; dssdev = &ddata->dssdev; dssdev->ops.hdmi = &tpd_hdmi_ops; dssdev->dev = &pdev->dev; dssdev->type = OMAP_DISPLAY_TYPE_HDMI; dssdev->output_type = OMAP_DISPLAY_TYPE_HDMI; dssdev->owner = THIS_MODULE; dssdev->port_num = 1; in = ddata->in; r = omapdss_register_output(dssdev); if (r) { dev_err(&pdev->dev, "Failed to register output\n"); goto err_reg; } return 0; err_reg: err_debounce: err_gpio: omap_dss_put_device(ddata->in); return r; }
static int tpd_probe(struct platform_device *pdev) { struct omap_dss_device *in, *dssdev; struct panel_drv_data *ddata; int r; ddata = devm_kzalloc(&pdev->dev, sizeof(*ddata), GFP_KERNEL); if (!ddata) return -ENOMEM; platform_set_drvdata(pdev, ddata); init_completion(&ddata->hpd_completion); if (dev_get_platdata(&pdev->dev)) { r = tpd_probe_pdata(pdev); if (r) return r; } else if (pdev->dev.of_node) { r = tpd_probe_of(pdev); if (r) return r; } else { return -ENODEV; } r = devm_gpio_request_one(&pdev->dev, ddata->ct_cp_hpd_gpio, GPIOF_OUT_INIT_LOW, "hdmi_ct_cp_hpd"); if (r) goto err_gpio; if (gpio_is_valid(ddata->ls_oe_gpio)) { r = devm_gpio_request_one(&pdev->dev, ddata->ls_oe_gpio, GPIOF_OUT_INIT_LOW, "hdmi_ls_oe"); if (r) goto err_gpio; } r = devm_gpio_request_one(&pdev->dev, ddata->hpd_gpio, GPIOF_DIR_IN, "hdmi_hpd"); if (r) goto err_gpio; r = devm_request_threaded_irq(&pdev->dev, gpio_to_irq(ddata->hpd_gpio), NULL, tpd_hpd_irq_handler, IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING | IRQF_ONESHOT, "hpd", ddata); if (r) goto err_irq; dssdev = &ddata->dssdev; dssdev->ops.hdmi = &tpd_hdmi_ops; dssdev->dev = &pdev->dev; dssdev->type = OMAP_DISPLAY_TYPE_HDMI; dssdev->output_type = OMAP_DISPLAY_TYPE_HDMI; dssdev->owner = THIS_MODULE; in = ddata->in; r = omapdss_register_output(dssdev); if (r) { dev_err(&pdev->dev, "Failed to register output\n"); goto err_reg; } return 0; err_reg: err_irq: err_gpio: omap_dss_put_device(ddata->in); return r; }
static int acx565akm_probe(struct spi_device *spi) { struct panel_drv_data *ddata; struct omap_dss_device *dssdev; struct backlight_device *bldev; int max_brightness, brightness; struct backlight_properties props; int r; dev_dbg(&spi->dev, "%s\n", __func__); spi->mode = SPI_MODE_3; ddata = devm_kzalloc(&spi->dev, sizeof(*ddata), GFP_KERNEL); if (ddata == NULL) return -ENOMEM; dev_set_drvdata(&spi->dev, ddata); ddata->spi = spi; mutex_init(&ddata->mutex); if (dev_get_platdata(&spi->dev)) { r = acx565akm_probe_pdata(spi); if (r) return r; } else if (spi->dev.of_node) { r = acx565akm_probe_of(spi); if (r) return r; } else { dev_err(&spi->dev, "platform data missing!\n"); return -ENODEV; } if (gpio_is_valid(ddata->reset_gpio)) { r = devm_gpio_request_one(&spi->dev, ddata->reset_gpio, GPIOF_OUT_INIT_LOW, "lcd reset"); if (r) goto err_gpio; } if (gpio_is_valid(ddata->reset_gpio)) gpio_set_value(ddata->reset_gpio, 1); /* * After reset we have to wait 5 msec before the first * command can be sent. */ usleep_range(5000, 10000); ddata->enabled = panel_enabled(ddata); r = panel_detect(ddata); if (!ddata->enabled && gpio_is_valid(ddata->reset_gpio)) gpio_set_value(ddata->reset_gpio, 0); if (r) { dev_err(&spi->dev, "%s panel detect error\n", __func__); goto err_detect; } memset(&props, 0, sizeof(props)); props.fb_blank = FB_BLANK_UNBLANK; props.power = FB_BLANK_UNBLANK; props.type = BACKLIGHT_RAW; bldev = backlight_device_register("acx565akm", &ddata->spi->dev, ddata, &acx565akm_bl_ops, &props); ddata->bl_dev = bldev; if (ddata->has_cabc) { r = sysfs_create_group(&bldev->dev.kobj, &bldev_attr_group); if (r) { dev_err(&bldev->dev, "%s failed to create sysfs files\n", __func__); goto err_sysfs; } ddata->cabc_mode = get_hw_cabc_mode(ddata); } max_brightness = 255; if (ddata->has_bc) brightness = acx565akm_get_actual_brightness(ddata); else brightness = 0; bldev->props.max_brightness = max_brightness; bldev->props.brightness = brightness; acx565akm_bl_update_status(bldev); ddata->videomode = acx565akm_panel_timings; dssdev = &ddata->dssdev; dssdev->dev = &spi->dev; dssdev->driver = &acx565akm_ops; dssdev->type = OMAP_DISPLAY_TYPE_SDI; dssdev->owner = THIS_MODULE; dssdev->panel.timings = ddata->videomode; r = omapdss_register_display(dssdev); if (r) { dev_err(&spi->dev, "Failed to register panel\n"); goto err_reg; } return 0; err_reg: sysfs_remove_group(&bldev->dev.kobj, &bldev_attr_group); err_sysfs: backlight_device_unregister(bldev); err_detect: err_gpio: omap_dss_put_device(ddata->in); return r; }
static int tpd_probe(struct platform_device *pdev) { struct omap_dss_device *in, *dssdev; struct panel_drv_data *ddata; int r; struct gpio_desc *gpio; ddata = devm_kzalloc(&pdev->dev, sizeof(*ddata), GFP_KERNEL); if (!ddata) return -ENOMEM; platform_set_drvdata(pdev, ddata); if (!pdev->dev.of_node) return -ENODEV; r = tpd_probe_of(pdev); if (r) return r; gpio = devm_gpiod_get_index_optional(&pdev->dev, NULL, 0, GPIOD_OUT_LOW); if (IS_ERR(gpio)) { r = PTR_ERR(gpio); goto err_gpio; } ddata->ct_cp_hpd_gpio = gpio; gpio = devm_gpiod_get_index_optional(&pdev->dev, NULL, 1, GPIOD_OUT_LOW); if (IS_ERR(gpio)) { r = PTR_ERR(gpio); goto err_gpio; } ddata->ls_oe_gpio = gpio; gpio = devm_gpiod_get_index(&pdev->dev, NULL, 2, GPIOD_IN); if (IS_ERR(gpio)) { r = PTR_ERR(gpio); goto err_gpio; } ddata->hpd_gpio = gpio; dssdev = &ddata->dssdev; dssdev->ops.hdmi = &tpd_hdmi_ops; dssdev->dev = &pdev->dev; dssdev->type = OMAP_DISPLAY_TYPE_HDMI; dssdev->output_type = OMAP_DISPLAY_TYPE_HDMI; dssdev->owner = THIS_MODULE; dssdev->port_num = 1; in = ddata->in; r = omapdss_register_output(dssdev); if (r) { dev_err(&pdev->dev, "Failed to register output\n"); goto err_reg; } return 0; err_reg: err_gpio: omap_dss_put_device(ddata->in); return r; }