// SPDX-License-Identifier: GPL-2.0 /* * Interconnect framework core driver * * Copyright (c) 2017-2019, Linaro Ltd. * Author: Georgi Djakov <[email protected]> */ #include <linux/debugfs.h> #include <linux/device.h> #include <linux/idr.h> #include <linux/init.h> #include <linux/interconnect.h> #include <linux/interconnect-provider.h> #include <linux/list.h> #include <linux/mutex.h> #include <linux/slab.h> #include <linux/of.h> #include <linux/overflow.h> #include "internal.h" #define CREATE_TRACE_POINTS #include "trace.h" static DEFINE_IDR(icc_idr); static LIST_HEAD(icc_providers); static int providers_count; static bool synced_state; static DEFINE_MUTEX(icc_lock); static DEFINE_MUTEX(icc_bw_lock); static struct dentry *icc_debugfs_dir; static void icc_summary_show_one(struct seq_file *s, struct icc_node *n) { … } static int icc_summary_show(struct seq_file *s, void *data) { … } DEFINE_SHOW_ATTRIBUTE(…); static void icc_graph_show_link(struct seq_file *s, int level, struct icc_node *n, struct icc_node *m) { … } static void icc_graph_show_node(struct seq_file *s, struct icc_node *n) { … } static int icc_graph_show(struct seq_file *s, void *data) { … } DEFINE_SHOW_ATTRIBUTE(…); static struct icc_node *node_find(const int id) { … } static struct icc_node *node_find_by_name(const char *name) { … } static struct icc_path *path_init(struct device *dev, struct icc_node *dst, ssize_t num_nodes) { … } static struct icc_path *path_find(struct device *dev, struct icc_node *src, struct icc_node *dst) { … } /* * We want the path to honor all bandwidth requests, so the average and peak * bandwidth requirements from each consumer are aggregated at each node. * The aggregation is platform specific, so each platform can customize it by * implementing its own aggregate() function. */ static int aggregate_requests(struct icc_node *node) { … } static int apply_constraints(struct icc_path *path) { … } int icc_std_aggregate(struct icc_node *node, u32 tag, u32 avg_bw, u32 peak_bw, u32 *agg_avg, u32 *agg_peak) { … } EXPORT_SYMBOL_GPL(…); /* of_icc_xlate_onecell() - Translate function using a single index. * @spec: OF phandle args to map into an interconnect node. * @data: private data (pointer to struct icc_onecell_data) * * This is a generic translate function that can be used to model simple * interconnect providers that have one device tree node and provide * multiple interconnect nodes. A single cell is used as an index into * an array of icc nodes specified in the icc_onecell_data struct when * registering the provider. */ struct icc_node *of_icc_xlate_onecell(const struct of_phandle_args *spec, void *data) { … } EXPORT_SYMBOL_GPL(…); /** * of_icc_get_from_provider() - Look-up interconnect node * @spec: OF phandle args to use for look-up * * Looks for interconnect provider under the node specified by @spec and if * found, uses xlate function of the provider to map phandle args to node. * * Returns a valid pointer to struct icc_node_data on success or ERR_PTR() * on failure. */ struct icc_node_data *of_icc_get_from_provider(const struct of_phandle_args *spec) { … } EXPORT_SYMBOL_GPL(…); static void devm_icc_release(struct device *dev, void *res) { … } struct icc_path *devm_of_icc_get(struct device *dev, const char *name) { … } EXPORT_SYMBOL_GPL(…); /** * of_icc_get_by_index() - get a path handle from a DT node based on index * @dev: device pointer for the consumer device * @idx: interconnect path index * * This function will search for a path between two endpoints and return an * icc_path handle on success. Use icc_put() to release constraints when they * are not needed anymore. * If the interconnect API is disabled, NULL is returned and the consumer * drivers will still build. Drivers are free to handle this specifically, * but they don't have to. * * Return: icc_path pointer on success or ERR_PTR() on error. NULL is returned * when the API is disabled or the "interconnects" DT property is missing. */ struct icc_path *of_icc_get_by_index(struct device *dev, int idx) { … } EXPORT_SYMBOL_GPL(…); /** * of_icc_get() - get a path handle from a DT node based on name * @dev: device pointer for the consumer device * @name: interconnect path name * * This function will search for a path between two endpoints and return an * icc_path handle on success. Use icc_put() to release constraints when they * are not needed anymore. * If the interconnect API is disabled, NULL is returned and the consumer * drivers will still build. Drivers are free to handle this specifically, * but they don't have to. * * Return: icc_path pointer on success or ERR_PTR() on error. NULL is returned * when the API is disabled or the "interconnects" DT property is missing. */ struct icc_path *of_icc_get(struct device *dev, const char *name) { … } EXPORT_SYMBOL_GPL(…); /** * icc_get() - get a path handle between two endpoints * @dev: device pointer for the consumer device * @src: source node name * @dst: destination node name * * This function will search for a path between two endpoints and return an * icc_path handle on success. Use icc_put() to release constraints when they * are not needed anymore. * * Return: icc_path pointer on success or ERR_PTR() on error. NULL is returned * when the API is disabled. */ struct icc_path *icc_get(struct device *dev, const char *src, const char *dst) { … } /** * icc_set_tag() - set an optional tag on a path * @path: the path we want to tag * @tag: the tag value * * This function allows consumers to append a tag to the requests associated * with a path, so that a different aggregation could be done based on this tag. */ void icc_set_tag(struct icc_path *path, u32 tag) { … } EXPORT_SYMBOL_GPL(…); /** * icc_get_name() - Get name of the icc path * @path: interconnect path * * This function is used by an interconnect consumer to get the name of the icc * path. * * Returns a valid pointer on success, or NULL otherwise. */ const char *icc_get_name(struct icc_path *path) { … } EXPORT_SYMBOL_GPL(…); /** * icc_set_bw() - set bandwidth constraints on an interconnect path * @path: interconnect path * @avg_bw: average bandwidth in kilobytes per second * @peak_bw: peak bandwidth in kilobytes per second * * This function is used by an interconnect consumer to express its own needs * in terms of bandwidth for a previously requested path between two endpoints. * The requests are aggregated and each node is updated accordingly. The entire * path is locked by a mutex to ensure that the set() is completed. * The @path can be NULL when the "interconnects" DT properties is missing, * which will mean that no constraints will be set. * * Returns 0 on success, or an appropriate error code otherwise. */ int icc_set_bw(struct icc_path *path, u32 avg_bw, u32 peak_bw) { … } EXPORT_SYMBOL_GPL(…); static int __icc_enable(struct icc_path *path, bool enable) { … } int icc_enable(struct icc_path *path) { … } EXPORT_SYMBOL_GPL(…); int icc_disable(struct icc_path *path) { … } EXPORT_SYMBOL_GPL(…); /** * icc_put() - release the reference to the icc_path * @path: interconnect path * * Use this function to release the constraints on a path when the path is * no longer needed. The constraints will be re-aggregated. */ void icc_put(struct icc_path *path) { … } EXPORT_SYMBOL_GPL(…); static struct icc_node *icc_node_create_nolock(int id) { … } /** * icc_node_create() - create a node * @id: node id * * Return: icc_node pointer on success, or ERR_PTR() on error */ struct icc_node *icc_node_create(int id) { … } EXPORT_SYMBOL_GPL(…); /** * icc_node_destroy() - destroy a node * @id: node id */ void icc_node_destroy(int id) { … } EXPORT_SYMBOL_GPL(…); /** * icc_link_create() - create a link between two nodes * @node: source node id * @dst_id: destination node id * * Create a link between two nodes. The nodes might belong to different * interconnect providers and the @dst_id node might not exist (if the * provider driver has not probed yet). So just create the @dst_id node * and when the actual provider driver is probed, the rest of the node * data is filled. * * Return: 0 on success, or an error code otherwise */ int icc_link_create(struct icc_node *node, const int dst_id) { … } EXPORT_SYMBOL_GPL(…); /** * icc_node_add() - add interconnect node to interconnect provider * @node: pointer to the interconnect node * @provider: pointer to the interconnect provider */ void icc_node_add(struct icc_node *node, struct icc_provider *provider) { … } EXPORT_SYMBOL_GPL(…); /** * icc_node_del() - delete interconnect node from interconnect provider * @node: pointer to the interconnect node */ void icc_node_del(struct icc_node *node) { … } EXPORT_SYMBOL_GPL(…); /** * icc_nodes_remove() - remove all previously added nodes from provider * @provider: the interconnect provider we are removing nodes from * * Return: 0 on success, or an error code otherwise */ int icc_nodes_remove(struct icc_provider *provider) { … } EXPORT_SYMBOL_GPL(…); /** * icc_provider_init() - initialize a new interconnect provider * @provider: the interconnect provider to initialize * * Must be called before adding nodes to the provider. */ void icc_provider_init(struct icc_provider *provider) { … } EXPORT_SYMBOL_GPL(…); /** * icc_provider_register() - register a new interconnect provider * @provider: the interconnect provider to register * * Return: 0 on success, or an error code otherwise */ int icc_provider_register(struct icc_provider *provider) { … } EXPORT_SYMBOL_GPL(…); /** * icc_provider_deregister() - deregister an interconnect provider * @provider: the interconnect provider to deregister */ void icc_provider_deregister(struct icc_provider *provider) { … } EXPORT_SYMBOL_GPL(…); static const struct of_device_id __maybe_unused ignore_list[] = …; static int of_count_icc_providers(struct device_node *np) { … } void icc_sync_state(struct device *dev) { … } EXPORT_SYMBOL_GPL(…); static int __init icc_init(void) { … } device_initcall(icc_init);
Codebase Browser
linux