// SPDX-License-Identifier: GPL-2.0 /* * Thunderbolt XDomain discovery protocol support * * Copyright (C) 2017, Intel Corporation * Authors: Michael Jamet <[email protected]> * Mika Westerberg <[email protected]> */ #include <linux/device.h> #include <linux/delay.h> #include <linux/kmod.h> #include <linux/module.h> #include <linux/pm_runtime.h> #include <linux/prandom.h> #include <linux/string_helpers.h> #include <linux/utsname.h> #include <linux/uuid.h> #include <linux/workqueue.h> #include "tb.h" #define XDOMAIN_SHORT_TIMEOUT … #define XDOMAIN_DEFAULT_TIMEOUT … #define XDOMAIN_BONDING_TIMEOUT … #define XDOMAIN_RETRIES … #define XDOMAIN_DEFAULT_MAX_HOPID … enum { … }; static const char * const state_names[] = …; struct xdomain_request_work { … }; static bool tb_xdomain_enabled = …; module_param_named(xdomain, tb_xdomain_enabled, bool, 0444); MODULE_PARM_DESC(…) …; /* * Serializes access to the properties and protocol handlers below. If * you need to take both this lock and the struct tb_xdomain lock, take * this one first. */ static DEFINE_MUTEX(xdomain_lock); /* Properties exposed to the remote domains */ static struct tb_property_dir *xdomain_property_dir; static u32 xdomain_property_block_gen; /* Additional protocol handlers */ static LIST_HEAD(protocol_handlers); /* UUID for XDomain discovery protocol: b638d70e-42ff-40bb-97c2-90e2c0b2ff07 */ static const uuid_t tb_xdp_uuid = …; bool tb_is_xdomain_enabled(void) { … } static bool tb_xdomain_match(const struct tb_cfg_request *req, const struct ctl_pkg *pkg) { … } static bool tb_xdomain_copy(struct tb_cfg_request *req, const struct ctl_pkg *pkg) { … } static void response_ready(void *data) { … } static int __tb_xdomain_response(struct tb_ctl *ctl, const void *response, size_t size, enum tb_cfg_pkg_type type) { … } /** * tb_xdomain_response() - Send a XDomain response message * @xd: XDomain to send the message * @response: Response to send * @size: Size of the response * @type: PDF type of the response * * This can be used to send a XDomain response message to the other * domain. No response for the message is expected. * * Return: %0 in case of success and negative errno in case of failure */ int tb_xdomain_response(struct tb_xdomain *xd, const void *response, size_t size, enum tb_cfg_pkg_type type) { … } EXPORT_SYMBOL_GPL(…); static int __tb_xdomain_request(struct tb_ctl *ctl, const void *request, size_t request_size, enum tb_cfg_pkg_type request_type, void *response, size_t response_size, enum tb_cfg_pkg_type response_type, unsigned int timeout_msec) { … } /** * tb_xdomain_request() - Send a XDomain request * @xd: XDomain to send the request * @request: Request to send * @request_size: Size of the request in bytes * @request_type: PDF type of the request * @response: Response is copied here * @response_size: Expected size of the response in bytes * @response_type: Expected PDF type of the response * @timeout_msec: Timeout in milliseconds to wait for the response * * This function can be used to send XDomain control channel messages to * the other domain. The function waits until the response is received * or when timeout triggers. Whichever comes first. * * Return: %0 in case of success and negative errno in case of failure */ int tb_xdomain_request(struct tb_xdomain *xd, const void *request, size_t request_size, enum tb_cfg_pkg_type request_type, void *response, size_t response_size, enum tb_cfg_pkg_type response_type, unsigned int timeout_msec) { … } EXPORT_SYMBOL_GPL(…); static inline void tb_xdp_fill_header(struct tb_xdp_header *hdr, u64 route, u8 sequence, enum tb_xdp_type type, size_t size) { … } static int tb_xdp_handle_error(const struct tb_xdp_error_response *res) { … } static int tb_xdp_uuid_request(struct tb_ctl *ctl, u64 route, int retry, uuid_t *uuid, u64 *remote_route) { … } static int tb_xdp_uuid_response(struct tb_ctl *ctl, u64 route, u8 sequence, const uuid_t *uuid) { … } static int tb_xdp_error_response(struct tb_ctl *ctl, u64 route, u8 sequence, enum tb_xdp_error error) { … } static int tb_xdp_properties_request(struct tb_ctl *ctl, u64 route, const uuid_t *src_uuid, const uuid_t *dst_uuid, int retry, u32 **block, u32 *generation) { … } static int tb_xdp_properties_response(struct tb *tb, struct tb_ctl *ctl, struct tb_xdomain *xd, u8 sequence, const struct tb_xdp_properties *req) { … } static int tb_xdp_properties_changed_request(struct tb_ctl *ctl, u64 route, int retry, const uuid_t *uuid) { … } static int tb_xdp_properties_changed_response(struct tb_ctl *ctl, u64 route, u8 sequence) { … } static int tb_xdp_link_state_status_request(struct tb_ctl *ctl, u64 route, u8 sequence, u8 *slw, u8 *tlw, u8 *sls, u8 *tls) { … } static int tb_xdp_link_state_status_response(struct tb *tb, struct tb_ctl *ctl, struct tb_xdomain *xd, u8 sequence) { … } static int tb_xdp_link_state_change_request(struct tb_ctl *ctl, u64 route, u8 sequence, u8 tlw, u8 tls) { … } static int tb_xdp_link_state_change_response(struct tb_ctl *ctl, u64 route, u8 sequence, u32 status) { … } /** * tb_register_protocol_handler() - Register protocol handler * @handler: Handler to register * * This allows XDomain service drivers to hook into incoming XDomain * messages. After this function is called the service driver needs to * be able to handle calls to callback whenever a package with the * registered protocol is received. */ int tb_register_protocol_handler(struct tb_protocol_handler *handler) { … } EXPORT_SYMBOL_GPL(…); /** * tb_unregister_protocol_handler() - Unregister protocol handler * @handler: Handler to unregister * * Removes the previously registered protocol handler. */ void tb_unregister_protocol_handler(struct tb_protocol_handler *handler) { … } EXPORT_SYMBOL_GPL(…); static void update_property_block(struct tb_xdomain *xd) { … } static void start_handshake(struct tb_xdomain *xd) { … } /* Can be called from state_work */ static void __stop_handshake(struct tb_xdomain *xd) { … } static void stop_handshake(struct tb_xdomain *xd) { … } static void tb_xdp_handle_request(struct work_struct *work) { … } static bool tb_xdp_schedule_request(struct tb *tb, const struct tb_xdp_header *hdr, size_t size) { … } /** * tb_register_service_driver() - Register XDomain service driver * @drv: Driver to register * * Registers new service driver from @drv to the bus. */ int tb_register_service_driver(struct tb_service_driver *drv) { … } EXPORT_SYMBOL_GPL(…); /** * tb_unregister_service_driver() - Unregister XDomain service driver * @drv: Driver to unregister * * Unregisters XDomain service driver from the bus. */ void tb_unregister_service_driver(struct tb_service_driver *drv) { … } EXPORT_SYMBOL_GPL(…); static ssize_t key_show(struct device *dev, struct device_attribute *attr, char *buf) { … } static DEVICE_ATTR_RO(key); static int get_modalias(const struct tb_service *svc, char *buf, size_t size) { … } static ssize_t modalias_show(struct device *dev, struct device_attribute *attr, char *buf) { … } static DEVICE_ATTR_RO(modalias); static ssize_t prtcid_show(struct device *dev, struct device_attribute *attr, char *buf) { … } static DEVICE_ATTR_RO(prtcid); static ssize_t prtcvers_show(struct device *dev, struct device_attribute *attr, char *buf) { … } static DEVICE_ATTR_RO(prtcvers); static ssize_t prtcrevs_show(struct device *dev, struct device_attribute *attr, char *buf) { … } static DEVICE_ATTR_RO(prtcrevs); static ssize_t prtcstns_show(struct device *dev, struct device_attribute *attr, char *buf) { … } static DEVICE_ATTR_RO(prtcstns); static struct attribute *tb_service_attrs[] = …; static const struct attribute_group tb_service_attr_group = …; static const struct attribute_group *tb_service_attr_groups[] = …; static int tb_service_uevent(const struct device *dev, struct kobj_uevent_env *env) { … } static void tb_service_release(struct device *dev) { … } const struct device_type tb_service_type = …; EXPORT_SYMBOL_GPL(…); static int remove_missing_service(struct device *dev, void *data) { … } static int find_service(struct device *dev, void *data) { … } static int populate_service(struct tb_service *svc, struct tb_property *property) { … } static void enumerate_services(struct tb_xdomain *xd) { … } static int populate_properties(struct tb_xdomain *xd, struct tb_property_dir *dir) { … } static int tb_xdomain_update_link_attributes(struct tb_xdomain *xd) { … } static int tb_xdomain_get_uuid(struct tb_xdomain *xd) { … } static int tb_xdomain_get_link_status(struct tb_xdomain *xd) { … } static int tb_xdomain_link_state_change(struct tb_xdomain *xd, unsigned int width) { … } static int tb_xdomain_bond_lanes_uuid_high(struct tb_xdomain *xd) { … } static int tb_xdomain_get_properties(struct tb_xdomain *xd) { … } static void tb_xdomain_queue_uuid(struct tb_xdomain *xd) { … } static void tb_xdomain_queue_link_status(struct tb_xdomain *xd) { … } static void tb_xdomain_queue_link_status2(struct tb_xdomain *xd) { … } static void tb_xdomain_queue_bonding(struct tb_xdomain *xd) { … } static void tb_xdomain_queue_bonding_uuid_low(struct tb_xdomain *xd) { … } static void tb_xdomain_queue_properties(struct tb_xdomain *xd) { … } static void tb_xdomain_queue_properties_changed(struct tb_xdomain *xd) { … } static void tb_xdomain_failed(struct tb_xdomain *xd) { … } static void tb_xdomain_state_work(struct work_struct *work) { … } static void tb_xdomain_properties_changed(struct work_struct *work) { … } static ssize_t device_show(struct device *dev, struct device_attribute *attr, char *buf) { … } static DEVICE_ATTR_RO(device); static ssize_t device_name_show(struct device *dev, struct device_attribute *attr, char *buf) { … } static DEVICE_ATTR_RO(device_name); static ssize_t maxhopid_show(struct device *dev, struct device_attribute *attr, char *buf) { … } static DEVICE_ATTR_RO(maxhopid); static ssize_t vendor_show(struct device *dev, struct device_attribute *attr, char *buf) { … } static DEVICE_ATTR_RO(vendor); static ssize_t vendor_name_show(struct device *dev, struct device_attribute *attr, char *buf) { … } static DEVICE_ATTR_RO(vendor_name); static ssize_t unique_id_show(struct device *dev, struct device_attribute *attr, char *buf) { … } static DEVICE_ATTR_RO(unique_id); static ssize_t speed_show(struct device *dev, struct device_attribute *attr, char *buf) { … } static DEVICE_ATTR(rx_speed, 0444, speed_show, NULL); static DEVICE_ATTR(tx_speed, 0444, speed_show, NULL); static ssize_t rx_lanes_show(struct device *dev, struct device_attribute *attr, char *buf) { … } static DEVICE_ATTR(rx_lanes, 0444, rx_lanes_show, NULL); static ssize_t tx_lanes_show(struct device *dev, struct device_attribute *attr, char *buf) { … } static DEVICE_ATTR(tx_lanes, 0444, tx_lanes_show, NULL); static struct attribute *xdomain_attrs[] = …; static const struct attribute_group xdomain_attr_group = …; static const struct attribute_group *xdomain_attr_groups[] = …; static void tb_xdomain_release(struct device *dev) { … } static int __maybe_unused tb_xdomain_suspend(struct device *dev) { … } static int __maybe_unused tb_xdomain_resume(struct device *dev) { … } static const struct dev_pm_ops tb_xdomain_pm_ops = …; const struct device_type tb_xdomain_type = …; EXPORT_SYMBOL_GPL(…); static void tb_xdomain_link_init(struct tb_xdomain *xd, struct tb_port *down) { … } static void tb_xdomain_link_exit(struct tb_xdomain *xd) { … } /** * tb_xdomain_alloc() - Allocate new XDomain object * @tb: Domain where the XDomain belongs * @parent: Parent device (the switch through the connection to the * other domain is reached). * @route: Route string used to reach the other domain * @local_uuid: Our local domain UUID * @remote_uuid: UUID of the other domain (optional) * * Allocates new XDomain structure and returns pointer to that. The * object must be released by calling tb_xdomain_put(). */ struct tb_xdomain *tb_xdomain_alloc(struct tb *tb, struct device *parent, u64 route, const uuid_t *local_uuid, const uuid_t *remote_uuid) { … } /** * tb_xdomain_add() - Add XDomain to the bus * @xd: XDomain to add * * This function starts XDomain discovery protocol handshake and * eventually adds the XDomain to the bus. After calling this function * the caller needs to call tb_xdomain_remove() in order to remove and * release the object regardless whether the handshake succeeded or not. */ void tb_xdomain_add(struct tb_xdomain *xd) { … } static int unregister_service(struct device *dev, void *data) { … } /** * tb_xdomain_remove() - Remove XDomain from the bus * @xd: XDomain to remove * * This will stop all ongoing configuration work and remove the XDomain * along with any services from the bus. When the last reference to @xd * is released the object will be released as well. */ void tb_xdomain_remove(struct tb_xdomain *xd) { … } /** * tb_xdomain_lane_bonding_enable() - Enable lane bonding on XDomain * @xd: XDomain connection * * Lane bonding is disabled by default for XDomains. This function tries * to enable bonding by first enabling the port and waiting for the CL0 * state. * * Return: %0 in case of success and negative errno in case of error. */ int tb_xdomain_lane_bonding_enable(struct tb_xdomain *xd) { … } EXPORT_SYMBOL_GPL(…); /** * tb_xdomain_lane_bonding_disable() - Disable lane bonding * @xd: XDomain connection * * Lane bonding is disabled by default for XDomains. If bonding has been * enabled, this function can be used to disable it. */ void tb_xdomain_lane_bonding_disable(struct tb_xdomain *xd) { … } EXPORT_SYMBOL_GPL(…); /** * tb_xdomain_alloc_in_hopid() - Allocate input HopID for tunneling * @xd: XDomain connection * @hopid: Preferred HopID or %-1 for next available * * Returns allocated HopID or negative errno. Specifically returns * %-ENOSPC if there are no more available HopIDs. Returned HopID is * guaranteed to be within range supported by the input lane adapter. * Call tb_xdomain_release_in_hopid() to release the allocated HopID. */ int tb_xdomain_alloc_in_hopid(struct tb_xdomain *xd, int hopid) { … } EXPORT_SYMBOL_GPL(…); /** * tb_xdomain_alloc_out_hopid() - Allocate output HopID for tunneling * @xd: XDomain connection * @hopid: Preferred HopID or %-1 for next available * * Returns allocated HopID or negative errno. Specifically returns * %-ENOSPC if there are no more available HopIDs. Returned HopID is * guaranteed to be within range supported by the output lane adapter. * Call tb_xdomain_release_in_hopid() to release the allocated HopID. */ int tb_xdomain_alloc_out_hopid(struct tb_xdomain *xd, int hopid) { … } EXPORT_SYMBOL_GPL(…); /** * tb_xdomain_release_in_hopid() - Release input HopID * @xd: XDomain connection * @hopid: HopID to release */ void tb_xdomain_release_in_hopid(struct tb_xdomain *xd, int hopid) { … } EXPORT_SYMBOL_GPL(…); /** * tb_xdomain_release_out_hopid() - Release output HopID * @xd: XDomain connection * @hopid: HopID to release */ void tb_xdomain_release_out_hopid(struct tb_xdomain *xd, int hopid) { … } EXPORT_SYMBOL_GPL(…); /** * tb_xdomain_enable_paths() - Enable DMA paths for XDomain connection * @xd: XDomain connection * @transmit_path: HopID we are using to send out packets * @transmit_ring: DMA ring used to send out packets * @receive_path: HopID the other end is using to send packets to us * @receive_ring: DMA ring used to receive packets from @receive_path * * The function enables DMA paths accordingly so that after successful * return the caller can send and receive packets using high-speed DMA * path. If a transmit or receive path is not needed, pass %-1 for those * parameters. * * Return: %0 in case of success and negative errno in case of error */ int tb_xdomain_enable_paths(struct tb_xdomain *xd, int transmit_path, int transmit_ring, int receive_path, int receive_ring) { … } EXPORT_SYMBOL_GPL(…); /** * tb_xdomain_disable_paths() - Disable DMA paths for XDomain connection * @xd: XDomain connection * @transmit_path: HopID we are using to send out packets * @transmit_ring: DMA ring used to send out packets * @receive_path: HopID the other end is using to send packets to us * @receive_ring: DMA ring used to receive packets from @receive_path * * This does the opposite of tb_xdomain_enable_paths(). After call to * this the caller is not expected to use the rings anymore. Passing %-1 * as path/ring parameter means don't care. Normally the callers should * pass the same values here as they do when paths are enabled. * * Return: %0 in case of success and negative errno in case of error */ int tb_xdomain_disable_paths(struct tb_xdomain *xd, int transmit_path, int transmit_ring, int receive_path, int receive_ring) { … } EXPORT_SYMBOL_GPL(…); struct tb_xdomain_lookup { … }; static struct tb_xdomain *switch_find_xdomain(struct tb_switch *sw, const struct tb_xdomain_lookup *lookup) { … } /** * tb_xdomain_find_by_uuid() - Find an XDomain by UUID * @tb: Domain where the XDomain belongs to * @uuid: UUID to look for * * Finds XDomain by walking through the Thunderbolt topology below @tb. * The returned XDomain will have its reference count increased so the * caller needs to call tb_xdomain_put() when it is done with the * object. * * This will find all XDomains including the ones that are not yet added * to the bus (handshake is still in progress). * * The caller needs to hold @tb->lock. */ struct tb_xdomain *tb_xdomain_find_by_uuid(struct tb *tb, const uuid_t *uuid) { … } EXPORT_SYMBOL_GPL(…); /** * tb_xdomain_find_by_link_depth() - Find an XDomain by link and depth * @tb: Domain where the XDomain belongs to * @link: Root switch link number * @depth: Depth in the link * * Finds XDomain by walking through the Thunderbolt topology below @tb. * The returned XDomain will have its reference count increased so the * caller needs to call tb_xdomain_put() when it is done with the * object. * * This will find all XDomains including the ones that are not yet added * to the bus (handshake is still in progress). * * The caller needs to hold @tb->lock. */ struct tb_xdomain *tb_xdomain_find_by_link_depth(struct tb *tb, u8 link, u8 depth) { … } /** * tb_xdomain_find_by_route() - Find an XDomain by route string * @tb: Domain where the XDomain belongs to * @route: XDomain route string * * Finds XDomain by walking through the Thunderbolt topology below @tb. * The returned XDomain will have its reference count increased so the * caller needs to call tb_xdomain_put() when it is done with the * object. * * This will find all XDomains including the ones that are not yet added * to the bus (handshake is still in progress). * * The caller needs to hold @tb->lock. */ struct tb_xdomain *tb_xdomain_find_by_route(struct tb *tb, u64 route) { … } EXPORT_SYMBOL_GPL(…); bool tb_xdomain_handle_request(struct tb *tb, enum tb_cfg_pkg_type type, const void *buf, size_t size) { … } static int update_xdomain(struct device *dev, void *data) { … } static void update_all_xdomains(void) { … } static bool remove_directory(const char *key, const struct tb_property_dir *dir) { … } /** * tb_register_property_dir() - Register property directory to the host * @key: Key (name) of the directory to add * @dir: Directory to add * * Service drivers can use this function to add new property directory * to the host available properties. The other connected hosts are * notified so they can re-read properties of this host if they are * interested. * * Return: %0 on success and negative errno on failure */ int tb_register_property_dir(const char *key, struct tb_property_dir *dir) { … } EXPORT_SYMBOL_GPL(…); /** * tb_unregister_property_dir() - Removes property directory from host * @key: Key (name) of the directory * @dir: Directory to remove * * This will remove the existing directory from this host and notify the * connected hosts about the change. */ void tb_unregister_property_dir(const char *key, struct tb_property_dir *dir) { … } EXPORT_SYMBOL_GPL(…); int tb_xdomain_init(void) { … } void tb_xdomain_exit(void) { … }
Codebase Browser
linux