// SPDX-License-Identifier: GPL-2.0
/*
 * Bus for USB Type-C Alternate Modes
 *
 * Copyright (C) 2018 Intel Corporation
 * Author: Heikki Krogerus <heikki.krogerus@linux.intel.com>
 */

#include <linux/usb/pd_vdo.h>

#include "bus.h"

static inline int
typec_altmode_set_mux(struct altmode *alt, unsigned long conf, void *data)
{
        struct typec_mux_state state;

        if (!alt->mux)
                return 0;

        state.alt = &alt->adev;
        state.mode = conf;
        state.data = data;

        return alt->mux->set(alt->mux, &state);
}

static int typec_altmode_set_state(struct typec_altmode *adev,
                                   unsigned long conf, void *data)
{
        bool is_port = is_typec_port(adev->dev.parent);
        struct altmode *port_altmode;

        port_altmode = is_port ? to_altmode(adev) : to_altmode(adev)->partner;

        return typec_altmode_set_mux(port_altmode, conf, data);
}

/* -------------------------------------------------------------------------- */
/* Common API */

/**
 * typec_altmode_notify - Communication between the OS and alternate mode driver
 * @adev: Handle to the alternate mode
 * @conf: Alternate mode specific configuration value
 * @data: Alternate mode specific data
 *
 * The primary purpose for this function is to allow the alternate mode drivers
 * to tell which pin configuration has been negotiated with the partner. That
 * information will then be used for example to configure the muxes.
 * Communication to the other direction is also possible, and low level device
 * drivers can also send notifications to the alternate mode drivers. The actual
 * communication will be specific for every SVID.
 */
int typec_altmode_notify(struct typec_altmode *adev,
                         unsigned long conf, void *data)
{
        bool is_port;
        struct altmode *altmode;
        struct altmode *partner;
        int ret;

        if (!adev)
                return 0;

        altmode = to_altmode(adev);

        if (!altmode->partner)
                return -ENODEV;

        is_port = is_typec_port(adev->dev.parent);
        partner = altmode->partner;

        ret = typec_altmode_set_mux(is_port ? altmode : partner, conf, data);
        if (ret)
                return ret;

        if (partner->adev.ops && partner->adev.ops->notify)
                return partner->adev.ops->notify(&partner->adev, conf, data);

        return 0;
}
EXPORT_SYMBOL_GPL(typec_altmode_notify);

/**
 * typec_altmode_enter - Enter Mode
 * @adev: The alternate mode
 * @vdo: VDO for the Enter Mode command
 *
 * The alternate mode drivers use this function to enter mode. The port drivers
 * use this to inform the alternate mode drivers that the partner has initiated
 * Enter Mode command. If the alternate mode does not require VDO, @vdo must be
 * NULL.
 */
int typec_altmode_enter(struct typec_altmode *adev, u32 *vdo)
{
        struct altmode *partner = to_altmode(adev)->partner;
        struct typec_altmode *pdev = &partner->adev;
        int ret;

        if (!adev || adev->active)
                return 0;

        if (!pdev->ops || !pdev->ops->enter)
                return -EOPNOTSUPP;

        if (is_typec_port(pdev->dev.parent) && !pdev->active)
                return -EPERM;

        /* Moving to USB Safe State */
        ret = typec_altmode_set_state(adev, TYPEC_STATE_SAFE, NULL);
        if (ret)
                return ret;

        /* Enter Mode */
        return pdev->ops->enter(pdev, vdo);
}
EXPORT_SYMBOL_GPL(typec_altmode_enter);

/**
 * typec_altmode_exit - Exit Mode
 * @adev: The alternate mode
 *
 * The partner of @adev has initiated Exit Mode command.
 */
int typec_altmode_exit(struct typec_altmode *adev)
{
        struct altmode *partner = to_altmode(adev)->partner;
        struct typec_altmode *pdev = &partner->adev;
        int ret;

        if (!adev || !adev->active)
                return 0;

        if (!pdev->ops || !pdev->ops->enter)
                return -EOPNOTSUPP;

        /* Moving to USB Safe State */
        ret = typec_altmode_set_state(adev, TYPEC_STATE_SAFE, NULL);
        if (ret)
                return ret;

        /* Exit Mode command */
        return pdev->ops->exit(pdev);
}
EXPORT_SYMBOL_GPL(typec_altmode_exit);

/**
 * typec_altmode_attention - Attention command
 * @adev: The alternate mode
 * @vdo: VDO for the Attention command
 *
 * Notifies the partner of @adev about Attention command.
 */
void typec_altmode_attention(struct typec_altmode *adev, u32 vdo)
{
        struct typec_altmode *pdev = &to_altmode(adev)->partner->adev;

        if (pdev->ops && pdev->ops->attention)
                pdev->ops->attention(pdev, vdo);
}
EXPORT_SYMBOL_GPL(typec_altmode_attention);

/**
 * typec_altmode_vdm - Send Vendor Defined Messages (VDM) to the partner
 * @adev: Alternate mode handle
 * @header: VDM Header
 * @vdo: Array of Vendor Defined Data Objects
 * @count: Number of Data Objects
 *
 * The alternate mode drivers use this function for SVID specific communication
 * with the partner. The port drivers use it to deliver the Structured VDMs
 * received from the partners to the alternate mode drivers.
 */
int typec_altmode_vdm(struct typec_altmode *adev,
                      const u32 header, const u32 *vdo, int count)
{
        struct typec_altmode *pdev;
        struct altmode *altmode;

        if (!adev)
                return 0;

        altmode = to_altmode(adev);

        if (!altmode->partner)
                return -ENODEV;

        pdev = &altmode->partner->adev;

        if (!pdev->ops || !pdev->ops->vdm)
                return -EOPNOTSUPP;

        return pdev->ops->vdm(pdev, header, vdo, count);
}
EXPORT_SYMBOL_GPL(typec_altmode_vdm);

const struct typec_altmode *
typec_altmode_get_partner(struct typec_altmode *adev)
{
        if (!adev || !to_altmode(adev)->partner)
                return NULL;

        return &to_altmode(adev)->partner->adev;
}
EXPORT_SYMBOL_GPL(typec_altmode_get_partner);

/* -------------------------------------------------------------------------- */
/* API for the alternate mode drivers */

/**
 * typec_altmode_get_plug - Find cable plug alternate mode
 * @adev: Handle to partner alternate mode
 * @index: Cable plug index
 *
 * Increment reference count for cable plug alternate mode device. Returns
 * handle to the cable plug alternate mode, or NULL if none is found.
 */
struct typec_altmode *typec_altmode_get_plug(struct typec_altmode *adev,
                                             enum typec_plug_index index)
{
        struct altmode *port = to_altmode(adev)->partner;

        if (port->plug[index]) {
                get_device(&port->plug[index]->adev.dev);
                return &port->plug[index]->adev;
        }

        return NULL;
}
EXPORT_SYMBOL_GPL(typec_altmode_get_plug);

/**
 * typec_altmode_put_plug - Decrement cable plug alternate mode reference count
 * @plug: Handle to the cable plug alternate mode
 */
void typec_altmode_put_plug(struct typec_altmode *plug)
{
        if (plug)
                put_device(&plug->dev);
}
EXPORT_SYMBOL_GPL(typec_altmode_put_plug);

int __typec_altmode_register_driver(struct typec_altmode_driver *drv,
                                    struct module *module)
{
        if (!drv->probe)
                return -EINVAL;

        drv->driver.owner = module;
        drv->driver.bus = &typec_bus;

        return driver_register(&drv->driver);
}
EXPORT_SYMBOL_GPL(__typec_altmode_register_driver);

void typec_altmode_unregister_driver(struct typec_altmode_driver *drv)
{
        driver_unregister(&drv->driver);
}
EXPORT_SYMBOL_GPL(typec_altmode_unregister_driver);

/* -------------------------------------------------------------------------- */
/* API for the port drivers */

/**
 * typec_match_altmode - Match SVID and mode to an array of alternate modes
 * @altmodes: Array of alternate modes
 * @n: Number of elements in the array, or -1 for NULL terminated arrays
 * @svid: Standard or Vendor ID to match with
 * @mode: Mode to match with
 *
 * Return pointer to an alternate mode with SVID matching @svid, or NULL when no
 * match is found.
 */
struct typec_altmode *typec_match_altmode(struct typec_altmode **altmodes,
                                          size_t n, u16 svid, u8 mode)
{
        int i;

        for (i = 0; i < n; i++) {
                if (!altmodes[i])
                        break;
                if (altmodes[i]->svid == svid && altmodes[i]->mode == mode)
                        return altmodes[i];
        }

        return NULL;
}
EXPORT_SYMBOL_GPL(typec_match_altmode);

/* -------------------------------------------------------------------------- */

static ssize_t
description_show(struct device *dev, struct device_attribute *attr, char *buf)
{
        struct typec_altmode *alt = to_typec_altmode(dev);

        return sprintf(buf, "%s\n", alt->desc ? alt->desc : "");
}
static DEVICE_ATTR_RO(description);

static struct attribute *typec_attrs[] = {
        &dev_attr_description.attr,
        NULL
};
ATTRIBUTE_GROUPS(typec);

static int typec_match(struct device *dev, struct device_driver *driver)
{
        struct typec_altmode_driver *drv = to_altmode_driver(driver);
        struct typec_altmode *altmode = to_typec_altmode(dev);
        const struct typec_device_id *id;

        for (id = drv->id_table; id->svid; id++)
                if (id->svid == altmode->svid &&
                    (id->mode == TYPEC_ANY_MODE || id->mode == altmode->mode))
                        return 1;
        return 0;
}

static int typec_uevent(struct device *dev, struct kobj_uevent_env *env)
{
        struct typec_altmode *altmode = to_typec_altmode(dev);

        if (add_uevent_var(env, "SVID=%04X", altmode->svid))
                return -ENOMEM;

        if (add_uevent_var(env, "MODE=%u", altmode->mode))
                return -ENOMEM;

        return add_uevent_var(env, "MODALIAS=typec:id%04Xm%02X",
                              altmode->svid, altmode->mode);
}

static int typec_altmode_create_links(struct altmode *alt)
{
        struct device *port_dev = &alt->partner->adev.dev;
        struct device *dev = &alt->adev.dev;
        int err;

        err = sysfs_create_link(&dev->kobj, &port_dev->kobj, "port");
        if (err)
                return err;

        err = sysfs_create_link(&port_dev->kobj, &dev->kobj, "partner");
        if (err)
                sysfs_remove_link(&dev->kobj, "port");

        return err;
}

static void typec_altmode_remove_links(struct altmode *alt)
{
        sysfs_remove_link(&alt->partner->adev.dev.kobj, "partner");
        sysfs_remove_link(&alt->adev.dev.kobj, "port");
}

static int typec_probe(struct device *dev)
{
        struct typec_altmode_driver *drv = to_altmode_driver(dev->driver);
        struct typec_altmode *adev = to_typec_altmode(dev);
        struct altmode *altmode = to_altmode(adev);
        int ret;

        /* Fail if the port does not support the alternate mode */
        if (!altmode->partner)
                return -ENODEV;

        ret = typec_altmode_create_links(altmode);
        if (ret) {
                dev_warn(dev, "failed to create symlinks\n");
                return ret;
        }

        ret = drv->probe(adev);
        if (ret)
                typec_altmode_remove_links(altmode);

        return ret;
}

static int typec_remove(struct device *dev)
{
        struct typec_altmode_driver *drv = to_altmode_driver(dev->driver);
        struct typec_altmode *adev = to_typec_altmode(dev);
        struct altmode *altmode = to_altmode(adev);

        typec_altmode_remove_links(altmode);

        if (drv->remove)
                drv->remove(to_typec_altmode(dev));

        if (adev->active) {
                WARN_ON(typec_altmode_set_state(adev, TYPEC_STATE_SAFE, NULL));
                typec_altmode_update_active(adev, false);
        }

        adev->desc = NULL;
        adev->ops = NULL;

        return 0;
}

struct bus_type typec_bus = {
        .name = "typec",
        .dev_groups = typec_groups,
        .match = typec_match,
        .uevent = typec_uevent,
        .probe = typec_probe,
        .remove = typec_remove,
};