dpll_netlink.c | Explore in Territory

// SPDX-License-Identifier: GPL-2.0
/*
 * Generic netlink for DPLL management framework
 *
 *  Copyright (c) 2023 Meta Platforms, Inc. and affiliates
 *  Copyright (c) 2023 Intel and affiliates
 *
 */
#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/netdevice.h>
#include <net/genetlink.h>
#include "dpll_core.h"
#include "dpll_netlink.h"
#include "dpll_nl.h"
#include <uapi/linux/dpll.h>

#define ASSERT_NOT_NULL(ptr) …

#define xa_for_each_marked_start(xa, index, entry, filter, start) …

struct dpll_dump_ctx { … };

static struct dpll_dump_ctx *dpll_dump_context(struct netlink_callback *cb)
{ … }

static int
dpll_msg_add_dev_handle(struct sk_buff *msg, struct dpll_device *dpll)
{ … }

static int
dpll_msg_add_dev_parent_handle(struct sk_buff *msg, u32 id)
{ … }

/**
 * dpll_msg_add_pin_handle - attach pin handle attribute to a given message
 * @msg: pointer to sk_buff message to attach a pin handle
 * @pin: pin pointer
 *
 * Return:
 * * 0 - success
 * * -EMSGSIZE - no space in message to attach pin handle
 */
static int dpll_msg_add_pin_handle(struct sk_buff *msg, struct dpll_pin *pin)
{ … }

static struct dpll_pin *dpll_netdev_pin(const struct net_device *dev)
{ … }

/**
 * dpll_netdev_pin_handle_size - get size of pin handle attribute of a netdev
 * @dev: netdev from which to get the pin
 *
 * Return: byte size of pin handle attribute, or 0 if @dev has no pin.
 */
size_t dpll_netdev_pin_handle_size(const struct net_device *dev)
{ … }

int dpll_netdev_add_pin_handle(struct sk_buff *msg,
			       const struct net_device *dev)
{ … }

static int
dpll_msg_add_mode(struct sk_buff *msg, struct dpll_device *dpll,
		  struct netlink_ext_ack *extack)
{ … }

static int
dpll_msg_add_mode_supported(struct sk_buff *msg, struct dpll_device *dpll,
			    struct netlink_ext_ack *extack)
{ … }

static int
dpll_msg_add_lock_status(struct sk_buff *msg, struct dpll_device *dpll,
			 struct netlink_ext_ack *extack)
{ … }

static int
dpll_msg_add_temp(struct sk_buff *msg, struct dpll_device *dpll,
		  struct netlink_ext_ack *extack)
{ … }

static int
dpll_msg_add_pin_prio(struct sk_buff *msg, struct dpll_pin *pin,
		      struct dpll_pin_ref *ref,
		      struct netlink_ext_ack *extack)
{ … }

static int
dpll_msg_add_pin_on_dpll_state(struct sk_buff *msg, struct dpll_pin *pin,
			       struct dpll_pin_ref *ref,
			       struct netlink_ext_ack *extack)
{ … }

static int
dpll_msg_add_pin_direction(struct sk_buff *msg, struct dpll_pin *pin,
			   struct dpll_pin_ref *ref,
			   struct netlink_ext_ack *extack)
{ … }

static int
dpll_msg_add_pin_phase_adjust(struct sk_buff *msg, struct dpll_pin *pin,
			      struct dpll_pin_ref *ref,
			      struct netlink_ext_ack *extack)
{ … }

static int
dpll_msg_add_phase_offset(struct sk_buff *msg, struct dpll_pin *pin,
			  struct dpll_pin_ref *ref,
			  struct netlink_ext_ack *extack)
{ … }

static int dpll_msg_add_ffo(struct sk_buff *msg, struct dpll_pin *pin,
			    struct dpll_pin_ref *ref,
			    struct netlink_ext_ack *extack)
{ … }

static int
dpll_msg_add_pin_freq(struct sk_buff *msg, struct dpll_pin *pin,
		      struct dpll_pin_ref *ref, struct netlink_ext_ack *extack)
{ … }

static bool dpll_pin_is_freq_supported(struct dpll_pin *pin, u32 freq)
{ … }

static int
dpll_msg_add_pin_parents(struct sk_buff *msg, struct dpll_pin *pin,
			 struct dpll_pin_ref *dpll_ref,
			 struct netlink_ext_ack *extack)
{ … }

static int
dpll_msg_add_pin_dplls(struct sk_buff *msg, struct dpll_pin *pin,
		       struct netlink_ext_ack *extack)
{ … }

static int
dpll_cmd_pin_get_one(struct sk_buff *msg, struct dpll_pin *pin,
		     struct netlink_ext_ack *extack)
{ … }

static int
dpll_device_get_one(struct dpll_device *dpll, struct sk_buff *msg,
		    struct netlink_ext_ack *extack)
{ … }

static int
dpll_device_event_send(enum dpll_cmd event, struct dpll_device *dpll)
{ … }

int dpll_device_create_ntf(struct dpll_device *dpll)
{ … }

int dpll_device_delete_ntf(struct dpll_device *dpll)
{ … }

static int
__dpll_device_change_ntf(struct dpll_device *dpll)
{ … }

static bool dpll_pin_available(struct dpll_pin *pin)
{ … }

/**
 * dpll_device_change_ntf - notify that the dpll device has been changed
 * @dpll: registered dpll pointer
 *
 * Context: acquires and holds a dpll_lock.
 * Return: 0 if succeeds, error code otherwise.
 */
int dpll_device_change_ntf(struct dpll_device *dpll)
{ … }
EXPORT_SYMBOL_GPL(…);

static int
dpll_pin_event_send(enum dpll_cmd event, struct dpll_pin *pin)
{ … }

int dpll_pin_create_ntf(struct dpll_pin *pin)
{ … }

int dpll_pin_delete_ntf(struct dpll_pin *pin)
{ … }

static int __dpll_pin_change_ntf(struct dpll_pin *pin)
{ … }

/**
 * dpll_pin_change_ntf - notify that the pin has been changed
 * @pin: registered pin pointer
 *
 * Context: acquires and holds a dpll_lock.
 * Return: 0 if succeeds, error code otherwise.
 */
int dpll_pin_change_ntf(struct dpll_pin *pin)
{ … }
EXPORT_SYMBOL_GPL(…);

static int
dpll_pin_freq_set(struct dpll_pin *pin, struct nlattr *a,
		  struct netlink_ext_ack *extack)
{ … }

static int
dpll_pin_on_pin_state_set(struct dpll_pin *pin, u32 parent_idx,
			  enum dpll_pin_state state,
			  struct netlink_ext_ack *extack)
{ … }

static int
dpll_pin_state_set(struct dpll_device *dpll, struct dpll_pin *pin,
		   enum dpll_pin_state state,
		   struct netlink_ext_ack *extack)
{ … }

static int
dpll_pin_prio_set(struct dpll_device *dpll, struct dpll_pin *pin,
		  u32 prio, struct netlink_ext_ack *extack)
{ … }

static int
dpll_pin_direction_set(struct dpll_pin *pin, struct dpll_device *dpll,
		       enum dpll_pin_direction direction,
		       struct netlink_ext_ack *extack)
{ … }

static int
dpll_pin_phase_adj_set(struct dpll_pin *pin, struct nlattr *phase_adj_attr,
		       struct netlink_ext_ack *extack)
{ … }

static int
dpll_pin_parent_device_set(struct dpll_pin *pin, struct nlattr *parent_nest,
			   struct netlink_ext_ack *extack)
{ … }

static int
dpll_pin_parent_pin_set(struct dpll_pin *pin, struct nlattr *parent_nest,
			struct netlink_ext_ack *extack)
{ … }

static int
dpll_pin_set_from_nlattr(struct dpll_pin *pin, struct genl_info *info)
{ … }

static struct dpll_pin *
dpll_pin_find(u64 clock_id, struct nlattr *mod_name_attr,
	      enum dpll_pin_type type, struct nlattr *board_label,
	      struct nlattr *panel_label, struct nlattr *package_label,
	      struct netlink_ext_ack *extack)
{ … }

static struct dpll_pin *dpll_pin_find_from_nlattr(struct genl_info *info)
{ … }

int dpll_nl_pin_id_get_doit(struct sk_buff *skb, struct genl_info *info)
{ … }

int dpll_nl_pin_get_doit(struct sk_buff *skb, struct genl_info *info)
{ … }

int dpll_nl_pin_get_dumpit(struct sk_buff *skb, struct netlink_callback *cb)
{ … }

int dpll_nl_pin_set_doit(struct sk_buff *skb, struct genl_info *info)
{ … }

static struct dpll_device *
dpll_device_find(u64 clock_id, struct nlattr *mod_name_attr,
		 enum dpll_type type, struct netlink_ext_ack *extack)
{ … }

static struct dpll_device *
dpll_device_find_from_nlattr(struct genl_info *info)
{ … }

int dpll_nl_device_id_get_doit(struct sk_buff *skb, struct genl_info *info)
{ … }

int dpll_nl_device_get_doit(struct sk_buff *skb, struct genl_info *info)
{ … }

int dpll_nl_device_set_doit(struct sk_buff *skb, struct genl_info *info)
{ … }

int dpll_nl_device_get_dumpit(struct sk_buff *skb, struct netlink_callback *cb)
{ … }

int dpll_pre_doit(const struct genl_split_ops *ops, struct sk_buff *skb,
		  struct genl_info *info)
{ … }

void dpll_post_doit(const struct genl_split_ops *ops, struct sk_buff *skb,
		    struct genl_info *info)
{ … }

int
dpll_lock_doit(const struct genl_split_ops *ops, struct sk_buff *skb,
	       struct genl_info *info)
{ … }

void
dpll_unlock_doit(const struct genl_split_ops *ops, struct sk_buff *skb,
		 struct genl_info *info)
{ … }

int dpll_pin_pre_doit(const struct genl_split_ops *ops, struct sk_buff *skb,
		      struct genl_info *info)
{ … }

void dpll_pin_post_doit(const struct genl_split_ops *ops, struct sk_buff *skb,
			struct genl_info *info)
{ … }
linux/drivers/dpll/dpll_netlink.c
