Source of gpio-uclass.c - uboot-phytec - PHYTEC BitBucket (Stash)

Ignore whitespace
Show whitespace characters
Hide e-diff
Unified diff
Side-by-side diff
Source viewDiff to previous
 
                   struct ofnode_phandle_args *args)
{
    struct dm_gpio_ops *ops = gpio_get_ops(desc->dev);
​
    if (ops->xlate)
        return ops->xlate(desc->dev, desc, args);
    else
        return gpio_xlate_offs_flags(desc->dev, desc, args);
}
​
#if defined(CONFIG_DM_GPIO_HOG)
#if defined(CONFIG_GPIO_HOG)
​
struct gpio_hog_priv {
    struct gpio_desc gpiod;
};
​
struct gpio_hog_data {
    int gpiod_flags;
    int value;
    u32 val[2];
};
Show more
        printf("%s: missing gpio-hog state.\n", __func__);
        return -EINVAL;
    }
    ret = dev_read_u32_array(dev, "gpios", plat->val, 2);
    if (ret) {
        printf("%s: wrong gpios property, 2 values needed %d\n",
               __func__, ret);
        return ret;
    }
    nodename = dev_read_string(dev, "line-name");
    if (!nodename)
        nodename = dev_read_name(dev);
    device_set_name(dev, nodename);
    if (nodename)
        device_set_name(dev, nodename);
​
    return 0;
}
​
static int gpio_hog_probe(struct udevice *dev)
{
    struct gpio_hog_data *plat = dev_get_platdata(dev);
    struct gpio_hog_priv *priv = dev_get_priv(dev);
    int ret;
​
    ret = gpio_dev_request_index(dev->parent, dev->name, "gpio-hog",
                     plat->val[0], plat->gpiod_flags,
                     plat->val[1], &priv->gpiod);
    if (ret < 0) {
        debug("%s: node %s could not get gpio.\n", __func__,
              dev->name);
        return ret;
    }
    dm_gpio_set_dir(&priv->gpiod);
    if (plat->gpiod_flags == GPIOD_IS_OUT)
        dm_gpio_set_value(&priv->gpiod, plat->value);
​
    if (plat->gpiod_flags == GPIOD_IS_OUT) {
        ret = dm_gpio_set_value(&priv->gpiod, plat->value);
        if (ret < 0) {
            debug("%s: node %s could not set gpio.\n", __func__,
                  dev->name);
            return ret;
        }
    }
​
    return 0;
}
​
int gpio_hog_probe_all(void)
{
    struct udevice *dev;
    int ret;
    int retval = 0;
​
    for (uclass_first_device(UCLASS_NOP, &dev);
         dev;
         uclass_find_next_device(&dev)) {
        if (dev->driver == DM_GET_DRIVER(gpio_hog)) {
            ret = device_probe(dev);
            if (ret)
                return ret;
            if (ret) {
                printf("Failed to probe device %s err: %d\n",
                       dev->name, ret);
                retval = ret;
            }
        }
    }
​
    return 0;
    return retval;
}
​
struct gpio_desc *gpio_hog_lookup_name(const char *name)
int gpio_hog_lookup_name(const char *name, struct gpio_desc **desc)
{
    struct udevice *dev;
​
    *desc = NULL;
    gpio_hog_probe_all();
    if (!uclass_get_device_by_name(UCLASS_NOP, name, &dev)) {
        struct gpio_hog_priv *priv = dev_get_priv(dev);
​
        return &priv->gpiod;
        *desc = &priv->gpiod;
        return 0;
    }
​
    return NULL;
    return -ENODEV;
}
​
U_BOOT_DRIVER(gpio_hog) = {
    .name   = "gpio_hog",
    .id = UCLASS_NOP,
    .ofdata_to_platdata = gpio_hog_ofdata_to_platdata,
    .probe = gpio_hog_probe,
    .priv_auto_alloc_size = sizeof(struct gpio_hog_priv),
    .platdata_auto_alloc_size = sizeof(struct gpio_hog_data),
};
#else
struct gpio_desc *gpio_hog_lookup_name(const char *name)
int gpio_hog_lookup_name(const char *name, struct gpio_desc **desc)
{
    return NULL;
    return 0;
}
#endif
​
int dm_gpio_request(struct gpio_desc *desc, const char *label)
{
    struct udevice *dev = desc->dev;
    struct gpio_dev_priv *uc_priv;
    char *str;
    int ret;
​
Show more
        if (ret < 0)
            return ret;
        else if (ret)
            vector |= bitmask;
        bitmask <<= 1;
    }
​
    return vector;
}
​
/**
 * gpio_request_tail: common work for requesting a gpio.
 *
 * ret:     return value from previous work in function which calls
 *      this function.
 *      This seems bogus (why calling this function instead not
 *      calling it and end caller function instead?).
 *      Because on error in caller function we want to set some
 *      default values in gpio desc and have a common error
 *      debug message, which provides this function.
 * nodename:    Name of node for which gpio gets requested
 *      used for gpio label name.
 * args:    pointer to output arguments structure
 * list_name:   Name of GPIO list
 *      used for gpio label name.
 * index:   gpio index in gpio list
 *      used for gpio label name.
 * desc:    pointer to gpio descriptor, filled from this
 *      function.
 * flags:   gpio flags to use.
 * add_index:   should index added to gpio label name
 * gpio_dev:    pointer to gpio device from which the gpio
 *      will be requested. If NULL try to get the
 *      gpio device with uclass_get_device_by_ofnode()
 *
 * return:  In error case this function sets default values in
 *      gpio descriptor, also emmits a debug message.
 *      On success it returns 0 else the error code from
 *      function calls, or the error code passed through
 *      ret to this function.
 *
 */
static int gpio_request_tail(int ret, const char *nodename,
                 struct ofnode_phandle_args *args,
                 const char *list_name, int index,
                 struct gpio_desc *desc, int flags,
                 bool add_index, struct udevice *dev)
                 bool add_index, struct udevice *gpio_dev)
{
    desc->dev = dev;
    desc->dev = gpio_dev;
    desc->offset = 0;
    desc->flags = 0;
    if (ret)
        goto err;
​
    if (!desc->dev) {
        ret = uclass_get_device_by_ofnode(UCLASS_GPIO, args->node,
                          &desc->dev);
        if (ret) {
            debug("%s: uclass_get_device_by_ofnode failed\n", __func__);
            debug("%s: uclass_get_device_by_ofnode failed\n",
                  __func__);
            goto err;
        }
    }
    ret = gpio_find_and_xlate(desc, args);
    if (ret) {
        debug("%s: gpio_find_and_xlate failed\n", __func__);
        goto err;
    }
    ret = dm_gpio_requestf(desc, add_index ? "%s.%s%d" : "%s.%s",
                   nodename, list_name, index);
Show more
    args.args_count = 2;
    args.args[0] = index;
    args.args[1] = dtflags;
​
    return gpio_request_tail(0, nodename, &args, list_name, index, desc,
                 flags, 0, dev);
}
​
static int gpio_post_bind(struct udevice *dev)
{
#if defined(CONFIG_DM_GPIO_HOG)
    struct udevice *child;
    ofnode node;
#endif
​
#if defined(CONFIG_NEEDS_MANUAL_RELOC)
    struct dm_gpio_ops *ops = (struct dm_gpio_ops *)device_get_ops(dev);
    static int reloc_done;
​
    if (!reloc_done) {
        if (ops->request)
            ops->request += gd->reloc_off;
        if (ops->free)
            ops->free += gd->reloc_off;
Show more
            ops->set_open_drain += gd->reloc_off;
        if (ops->get_function)
            ops->get_function += gd->reloc_off;
        if (ops->xlate)
            ops->xlate += gd->reloc_off;
​
        reloc_done++;
    }
#endif
​
#if defined(CONFIG_DM_GPIO_HOG)
    dev_for_each_subnode(node, dev) {
        if (ofnode_read_bool(node, "gpio-hog")) {
            const char *name = ofnode_get_name(node);
​
            device_bind_driver_to_node(dev, "gpio_hog", name,
                           node, &child);
    if (IS_ENABLED(CONFIG_GPIO_HOG)) {
        dev_for_each_subnode(node, dev) {
            if (ofnode_read_bool(node, "gpio-hog")) {
                const char *name = ofnode_get_name(node);
                int ret;
​
                ret = device_bind_driver_to_node(dev,
                                 "gpio_hog",
                                 name, node,
                                 &child);
                if (ret)
                    return ret;
            }
        }
    }
#endif
    return 0;
}
​
UCLASS_DRIVER(gpio) = {
    .id     = UCLASS_GPIO,
    .name       = "gpio",
    .flags      = DM_UC_FLAG_SEQ_ALIAS,
    .post_probe = gpio_post_probe,
    .post_bind  = gpio_post_bind,
    .pre_remove = gpio_pre_remove,