git.sur5r.net Git - u-boot/blob - drivers/video/bridge/video-bridge-uclass.c

   1 /*
   2  * Copyright (C) 2015 Google, Inc
   3  * Written by Simon Glass <sjg@chromium.org>
   4  *
   5  * SPDX-License-Identifier:     GPL-2.0+
   6  */
   7
   8 #include <common.h>
   9 #include <dm.h>
  10 #include <errno.h>
  11 #include <video_bridge.h>
  12
  13 int video_bridge_set_backlight(struct udevice *dev, int percent)
  14 {
  15         struct video_bridge_ops *ops = video_bridge_get_ops(dev);
  16
  17         if (!ops->set_backlight)
  18                 return -ENOSYS;
  19
  20         return ops->set_backlight(dev, percent);
  21 }
  22
  23 int video_bridge_attach(struct udevice *dev)
  24 {
  25         struct video_bridge_ops *ops = video_bridge_get_ops(dev);
  26
  27         if (!ops->attach)
  28                 return -ENOSYS;
  29
  30         return ops->attach(dev);
  31 }
  32
  33 int video_bridge_check_attached(struct udevice *dev)
  34 {
  35         struct video_bridge_priv *uc_priv = dev_get_uclass_priv(dev);
  36         struct video_bridge_ops *ops = video_bridge_get_ops(dev);
  37         int ret;
  38
  39         if (!ops->check_attached) {
  40                 ret = dm_gpio_get_value(&uc_priv->hotplug);
  41
  42                 return ret > 0 ? 0 : ret == 0 ? -ENOTCONN : ret;
  43         }
  44
  45         return ops->check_attached(dev);
  46 }
  47
  48 static int video_bridge_pre_probe(struct udevice *dev)
  49 {
  50         struct video_bridge_priv *uc_priv = dev_get_uclass_priv(dev);
  51         int ret;
  52
  53         debug("%s\n", __func__);
  54         ret = gpio_request_by_name(dev, "sleep-gpios", 0,
  55                                    &uc_priv->sleep, GPIOD_IS_OUT);
  56         if (ret) {
  57                 debug("%s: Could not decode sleep-gpios (%d)\n", __func__, ret);
  58                 return ret;
  59         }
  60         ret = dm_gpio_set_pull(&uc_priv->sleep, GPIO_PULL_NONE);
  61         if (ret) {
  62                 debug("%s: Could not set sleep pull value\n", __func__);
  63                 return ret;
  64         }
  65         ret = gpio_request_by_name(dev, "reset-gpios", 0, &uc_priv->reset,
  66                                    GPIOD_IS_OUT);
  67         if (ret) {
  68                 debug("%s: Could not decode reset-gpios (%d)\n", __func__, ret);
  69                 return ret;
  70         }
  71         ret = dm_gpio_set_pull(&uc_priv->reset, GPIO_PULL_NONE);
  72         if (ret) {
  73                 debug("%s: Could not set reset pull value\n", __func__);
  74                 return ret;
  75         }
  76         ret = gpio_request_by_name(dev, "hotplug-gpios", 0, &uc_priv->hotplug,
  77                                    GPIOD_IS_IN);
  78         if (ret && ret != -ENOENT) {
  79                 debug("%s: Could not decode hotplug (%d)\n", __func__, ret);
  80                 return ret;
  81         }
  82
  83         return 0;
  84 }
  85
  86 int video_bridge_set_active(struct udevice *dev, bool active)
  87 {
  88         struct video_bridge_priv *uc_priv = dev_get_uclass_priv(dev);
  89         int ret;
  90
  91         debug("%s: %d\n", __func__, active);
  92         ret = dm_gpio_set_value(&uc_priv->sleep, !active);
  93         if (ret)
  94                 return ret;
  95         if (active) {
  96                 ret = dm_gpio_set_value(&uc_priv->reset, true);
  97                 if (ret)
  98                         return ret;
  99                 udelay(10);
 100                 ret = dm_gpio_set_value(&uc_priv->reset, false);
 101         }
 102
 103         return ret;
 104 }
 105
 106 UCLASS_DRIVER(video_bridge) = {
 107         .id             = UCLASS_VIDEO_BRIDGE,
 108         .name           = "video_bridge",
 109         .per_device_auto_alloc_size     = sizeof(struct video_bridge_priv),
 110         .pre_probe      = video_bridge_pre_probe,
 111 };