// SPDX-License-Identifier: GPL-2.0-only
/*
 * Copyright (C) 2007, 2008, 2009 Siemens AG
 */

#include <linux/slab.h>
#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/device.h>

#include <net/cfg802154.h>
#include <net/rtnetlink.h>

#include "ieee802154.h"
#include "nl802154.h"
#include "sysfs.h"
#include "core.h"

/* name for sysfs, %d is appended */
#define PHY_NAME "phy"

/* RCU-protected (and RTNL for writers) */
LIST_HEAD(cfg802154_rdev_list);
int cfg802154_rdev_list_generation;

struct wpan_phy *wpan_phy_find(const char *str)
{
        struct device *dev;

        if (WARN_ON(!str))
                return NULL;

        dev = class_find_device_by_name(&wpan_phy_class, str);
        if (!dev)
                return NULL;

        return container_of(dev, struct wpan_phy, dev);
}
EXPORT_SYMBOL(wpan_phy_find);

struct wpan_phy_iter_data {
        int (*fn)(struct wpan_phy *phy, void *data);
        void *data;
};

static int wpan_phy_iter(struct device *dev, void *_data)
{
        struct wpan_phy_iter_data *wpid = _data;
        struct wpan_phy *phy = container_of(dev, struct wpan_phy, dev);

        return wpid->fn(phy, wpid->data);
}

int wpan_phy_for_each(int (*fn)(struct wpan_phy *phy, void *data),
                      void *data)
{
        struct wpan_phy_iter_data wpid = {
                .fn = fn,
                .data = data,
        };

        return class_for_each_device(&wpan_phy_class, NULL,
                        &wpid, wpan_phy_iter);
}
EXPORT_SYMBOL(wpan_phy_for_each);

struct cfg802154_registered_device *
cfg802154_rdev_by_wpan_phy_idx(int wpan_phy_idx)
{
        struct cfg802154_registered_device *result = NULL, *rdev;

        ASSERT_RTNL();

        list_for_each_entry(rdev, &cfg802154_rdev_list, list) {
                if (rdev->wpan_phy_idx == wpan_phy_idx) {
                        result = rdev;
                        break;
                }
        }

        return result;
}

struct wpan_phy *wpan_phy_idx_to_wpan_phy(int wpan_phy_idx)
{
        struct cfg802154_registered_device *rdev;

        ASSERT_RTNL();

        rdev = cfg802154_rdev_by_wpan_phy_idx(wpan_phy_idx);
        if (!rdev)
                return NULL;
        return &rdev->wpan_phy;
}

struct wpan_phy *
wpan_phy_new(const struct cfg802154_ops *ops, size_t priv_size)
{
        static atomic_t wpan_phy_counter = ATOMIC_INIT(0);
        struct cfg802154_registered_device *rdev;
        size_t alloc_size;

        alloc_size = sizeof(*rdev) + priv_size;
        rdev = kzalloc(alloc_size, GFP_KERNEL);
        if (!rdev)
                return NULL;

        rdev->ops = ops;

        rdev->wpan_phy_idx = atomic_inc_return(&wpan_phy_counter);

        if (unlikely(rdev->wpan_phy_idx < 0)) {
                /* ugh, wrapped! */
                atomic_dec(&wpan_phy_counter);
                kfree(rdev);
                return NULL;
        }

        /* atomic_inc_return makes it start at 1, make it start at 0 */
        rdev->wpan_phy_idx--;

        INIT_LIST_HEAD(&rdev->wpan_dev_list);
        device_initialize(&rdev->wpan_phy.dev);
        dev_set_name(&rdev->wpan_phy.dev, PHY_NAME "%d", rdev->wpan_phy_idx);

        rdev->wpan_phy.dev.class = &wpan_phy_class;
        rdev->wpan_phy.dev.platform_data = rdev;

        wpan_phy_net_set(&rdev->wpan_phy, &init_net);

        init_waitqueue_head(&rdev->dev_wait);
        init_waitqueue_head(&rdev->wpan_phy.sync_txq);

        spin_lock_init(&rdev->wpan_phy.queue_lock);

        return &rdev->wpan_phy;
}
EXPORT_SYMBOL(wpan_phy_new);

int wpan_phy_register(struct wpan_phy *phy)
{
        struct cfg802154_registered_device *rdev = wpan_phy_to_rdev(phy);
        int ret;

        rtnl_lock();
        ret = device_add(&phy->dev);
        if (ret) {
                rtnl_unlock();
                return ret;
        }

        list_add_rcu(&rdev->list, &cfg802154_rdev_list);
        cfg802154_rdev_list_generation++;

        /* TODO phy registered lock */
        rtnl_unlock();

        /* TODO nl802154 phy notify */

        return 0;
}
EXPORT_SYMBOL(wpan_phy_register);

void wpan_phy_unregister(struct wpan_phy *phy)
{
        struct cfg802154_registered_device *rdev = wpan_phy_to_rdev(phy);

        wait_event(rdev->dev_wait, ({
                int __count;
                rtnl_lock();
                __count = rdev->opencount;
                rtnl_unlock();
                __count == 0; }));

        rtnl_lock();
        /* TODO nl802154 phy notify */
        /* TODO phy registered lock */

        WARN_ON(!list_empty(&rdev->wpan_dev_list));

        /* First remove the hardware from everywhere, this makes
         * it impossible to find from userspace.
         */
        list_del_rcu(&rdev->list);
        synchronize_rcu();

        cfg802154_rdev_list_generation++;

        device_del(&phy->dev);

        rtnl_unlock();
}
EXPORT_SYMBOL(wpan_phy_unregister);

void wpan_phy_free(struct wpan_phy *phy)
{
        put_device(&phy->dev);
}
EXPORT_SYMBOL(wpan_phy_free);

static void cfg802154_free_peer_structures(struct wpan_dev *wpan_dev)
{
        struct ieee802154_pan_device *child, *tmp;

        mutex_lock(&wpan_dev->association_lock);

        kfree(wpan_dev->parent);
        wpan_dev->parent = NULL;

        list_for_each_entry_safe(child, tmp, &wpan_dev->children, node) {
                list_del(&child->node);
                kfree(child);
        }

        wpan_dev->nchildren = 0;

        mutex_unlock(&wpan_dev->association_lock);
}

int cfg802154_switch_netns(struct cfg802154_registered_device *rdev,
                           struct net *net)
{
        struct wpan_dev *wpan_dev;
        int err = 0;

        list_for_each_entry(wpan_dev, &rdev->wpan_dev_list, list) {
                if (!wpan_dev->netdev)
                        continue;
                wpan_dev->netdev->netns_immutable = false;
                err = dev_change_net_namespace(wpan_dev->netdev, net, "wpan%d");
                if (err)
                        break;
                wpan_dev->netdev->netns_immutable = true;
        }

        if (err) {
                /* failed -- clean up to old netns */
                net = wpan_phy_net(&rdev->wpan_phy);

                list_for_each_entry_continue_reverse(wpan_dev,
                                                     &rdev->wpan_dev_list,
                                                     list) {
                        if (!wpan_dev->netdev)
                                continue;
                        wpan_dev->netdev->netns_immutable = false;
                        err = dev_change_net_namespace(wpan_dev->netdev, net,
                                                       "wpan%d");
                        WARN_ON(err);
                        wpan_dev->netdev->netns_immutable = true;
                }

                return err;
        }

        wpan_phy_net_set(&rdev->wpan_phy, net);

        err = device_rename(&rdev->wpan_phy.dev, dev_name(&rdev->wpan_phy.dev));
        WARN_ON(err);

        return 0;
}

void cfg802154_dev_free(struct cfg802154_registered_device *rdev)
{
        kfree(rdev);
}

static void
cfg802154_update_iface_num(struct cfg802154_registered_device *rdev,
                           int iftype, int num)
{
        ASSERT_RTNL();

        rdev->num_running_ifaces += num;
}

static int cfg802154_netdev_notifier_call(struct notifier_block *nb,
                                          unsigned long state, void *ptr)
{
        struct net_device *dev = netdev_notifier_info_to_dev(ptr);
        struct wpan_dev *wpan_dev = dev->ieee802154_ptr;
        struct cfg802154_registered_device *rdev;

        if (!wpan_dev)
                return NOTIFY_DONE;

        rdev = wpan_phy_to_rdev(wpan_dev->wpan_phy);

        /* TODO WARN_ON unspec type */

        switch (state) {
                /* TODO NETDEV_DEVTYPE */
        case NETDEV_REGISTER:
                dev->netns_immutable = true;
                wpan_dev->identifier = ++rdev->wpan_dev_id;
                list_add_rcu(&wpan_dev->list, &rdev->wpan_dev_list);
                rdev->devlist_generation++;
                mutex_init(&wpan_dev->association_lock);
                INIT_LIST_HEAD(&wpan_dev->children);
                wpan_dev->max_associations = SZ_16K;

                wpan_dev->netdev = dev;
                break;
        case NETDEV_DOWN:
                cfg802154_update_iface_num(rdev, wpan_dev->iftype, -1);

                rdev->opencount--;
                wake_up(&rdev->dev_wait);
                break;
        case NETDEV_UP:
                cfg802154_update_iface_num(rdev, wpan_dev->iftype, 1);

                rdev->opencount++;
                break;
        case NETDEV_UNREGISTER:
                cfg802154_free_peer_structures(wpan_dev);

                /* It is possible to get NETDEV_UNREGISTER
                 * multiple times. To detect that, check
                 * that the interface is still on the list
                 * of registered interfaces, and only then
                 * remove and clean it up.
                 */
                if (!list_empty(&wpan_dev->list)) {
                        list_del_rcu(&wpan_dev->list);
                        rdev->devlist_generation++;
                }
                /* synchronize (so that we won't find this netdev
                 * from other code any more) and then clear the list
                 * head so that the above code can safely check for
                 * !list_empty() to avoid double-cleanup.
                 */
                synchronize_rcu();
                INIT_LIST_HEAD(&wpan_dev->list);
                break;
        default:
                return NOTIFY_DONE;
        }

        return NOTIFY_OK;
}

static struct notifier_block cfg802154_netdev_notifier = {
        .notifier_call = cfg802154_netdev_notifier_call,
};

static void __net_exit cfg802154_pernet_exit(struct net *net)
{
        struct cfg802154_registered_device *rdev;

        rtnl_lock();
        list_for_each_entry(rdev, &cfg802154_rdev_list, list) {
                if (net_eq(wpan_phy_net(&rdev->wpan_phy), net))
                        WARN_ON(cfg802154_switch_netns(rdev, &init_net));
        }
        rtnl_unlock();
}

static struct pernet_operations cfg802154_pernet_ops = {
        .exit = cfg802154_pernet_exit,
};

static int __init wpan_phy_class_init(void)
{
        int rc;

        rc = register_pernet_device(&cfg802154_pernet_ops);
        if (rc)
                goto err;

        rc = wpan_phy_sysfs_init();
        if (rc)
                goto err_sysfs;

        rc = register_netdevice_notifier(&cfg802154_netdev_notifier);
        if (rc)
                goto err_nl;

        rc = ieee802154_nl_init();
        if (rc)
                goto err_notifier;

        rc = nl802154_init();
        if (rc)
                goto err_ieee802154_nl;

        return 0;

err_ieee802154_nl:
        ieee802154_nl_exit();

err_notifier:
        unregister_netdevice_notifier(&cfg802154_netdev_notifier);
err_nl:
        wpan_phy_sysfs_exit();
err_sysfs:
        unregister_pernet_device(&cfg802154_pernet_ops);
err:
        return rc;
}
subsys_initcall(wpan_phy_class_init);

static void __exit wpan_phy_class_exit(void)
{
        nl802154_exit();
        ieee802154_nl_exit();
        unregister_netdevice_notifier(&cfg802154_netdev_notifier);
        wpan_phy_sysfs_exit();
        unregister_pernet_device(&cfg802154_pernet_ops);
}
module_exit(wpan_phy_class_exit);

MODULE_LICENSE("GPL v2");
MODULE_DESCRIPTION("IEEE 802.15.4 configuration interface");
MODULE_AUTHOR("Dmitry Eremin-Solenikov");