License cleanup: add SPDX GPL-2.0 license identifier to files with no license
Many source files in the tree are missing licensing information, which
makes it harder for compliance tools to determine the correct license.
By default all files without license information are under the default
license of the kernel, which is GPL version 2.
Update the files which contain no license information with the 'GPL-2.0'
SPDX license identifier. The SPDX identifier is a legally binding
shorthand, which can be used instead of the full boiler plate text.
This patch is based on work done by Thomas Gleixner and Kate Stewart and
Philippe Ombredanne.
How this work was done:
Patches were generated and checked against linux-4.14-rc6 for a subset of
the use cases:
- file had no licensing information it it.
- file was a */uapi/* one with no licensing information in it,
- file was a */uapi/* one with existing licensing information,
Further patches will be generated in subsequent months to fix up cases
where non-standard license headers were used, and references to license
had to be inferred by heuristics based on keywords.
The analysis to determine which SPDX License Identifier to be applied to
a file was done in a spreadsheet of side by side results from of the
output of two independent scanners (ScanCode & Windriver) producing SPDX
tag:value files created by Philippe Ombredanne. Philippe prepared the
base worksheet, and did an initial spot review of a few 1000 files.
The 4.13 kernel was the starting point of the analysis with 60,537 files
assessed. Kate Stewart did a file by file comparison of the scanner
results in the spreadsheet to determine which SPDX license identifier(s)
to be applied to the file. She confirmed any determination that was not
immediately clear with lawyers working with the Linux Foundation.
Criteria used to select files for SPDX license identifier tagging was:
- Files considered eligible had to be source code files.
- Make and config files were included as candidates if they contained >5
lines of source
- File already had some variant of a license header in it (even if <5
lines).
All documentation files were explicitly excluded.
The following heuristics were used to determine which SPDX license
identifiers to apply.
- when both scanners couldn't find any license traces, file was
considered to have no license information in it, and the top level
COPYING file license applied.
For non */uapi/* files that summary was:
SPDX license identifier # files
---------------------------------------------------|-------
GPL-2.0 11139
and resulted in the first patch in this series.
If that file was a */uapi/* path one, it was "GPL-2.0 WITH
Linux-syscall-note" otherwise it was "GPL-2.0". Results of that was:
SPDX license identifier # files
---------------------------------------------------|-------
GPL-2.0 WITH Linux-syscall-note 930
and resulted in the second patch in this series.
- if a file had some form of licensing information in it, and was one
of the */uapi/* ones, it was denoted with the Linux-syscall-note if
any GPL family license was found in the file or had no licensing in
it (per prior point). Results summary:
SPDX license identifier # files
---------------------------------------------------|------
GPL-2.0 WITH Linux-syscall-note 270
GPL-2.0+ WITH Linux-syscall-note 169
((GPL-2.0 WITH Linux-syscall-note) OR BSD-2-Clause) 21
((GPL-2.0 WITH Linux-syscall-note) OR BSD-3-Clause) 17
LGPL-2.1+ WITH Linux-syscall-note 15
GPL-1.0+ WITH Linux-syscall-note 14
((GPL-2.0+ WITH Linux-syscall-note) OR BSD-3-Clause) 5
LGPL-2.0+ WITH Linux-syscall-note 4
LGPL-2.1 WITH Linux-syscall-note 3
((GPL-2.0 WITH Linux-syscall-note) OR MIT) 3
((GPL-2.0 WITH Linux-syscall-note) AND MIT) 1
and that resulted in the third patch in this series.
- when the two scanners agreed on the detected license(s), that became
the concluded license(s).
- when there was disagreement between the two scanners (one detected a
license but the other didn't, or they both detected different
licenses) a manual inspection of the file occurred.
- In most cases a manual inspection of the information in the file
resulted in a clear resolution of the license that should apply (and
which scanner probably needed to revisit its heuristics).
- When it was not immediately clear, the license identifier was
confirmed with lawyers working with the Linux Foundation.
- If there was any question as to the appropriate license identifier,
the file was flagged for further research and to be revisited later
in time.
In total, over 70 hours of logged manual review was done on the
spreadsheet to determine the SPDX license identifiers to apply to the
source files by Kate, Philippe, Thomas and, in some cases, confirmation
by lawyers working with the Linux Foundation.
Kate also obtained a third independent scan of the 4.13 code base from
FOSSology, and compared selected files where the other two scanners
disagreed against that SPDX file, to see if there was new insights. The
Windriver scanner is based on an older version of FOSSology in part, so
they are related.
Thomas did random spot checks in about 500 files from the spreadsheets
for the uapi headers and agreed with SPDX license identifier in the
files he inspected. For the non-uapi files Thomas did random spot checks
in about 15000 files.
In initial set of patches against 4.14-rc6, 3 files were found to have
copy/paste license identifier errors, and have been fixed to reflect the
correct identifier.
Additionally Philippe spent 10 hours this week doing a detailed manual
inspection and review of the 12,461 patched files from the initial patch
version early this week with:
- a full scancode scan run, collecting the matched texts, detected
license ids and scores
- reviewing anything where there was a license detected (about 500+
files) to ensure that the applied SPDX license was correct
- reviewing anything where there was no detection but the patch license
was not GPL-2.0 WITH Linux-syscall-note to ensure that the applied
SPDX license was correct
This produced a worksheet with 20 files needing minor correction. This
worksheet was then exported into 3 different .csv files for the
different types of files to be modified.
These .csv files were then reviewed by Greg. Thomas wrote a script to
parse the csv files and add the proper SPDX tag to the file, in the
format that the file expected. This script was further refined by Greg
based on the output to detect more types of files automatically and to
distinguish between header and source .c files (which need different
comment types.) Finally Greg ran the script using the .csv files to
generate the patches.
Reviewed-by: Kate Stewart <kstewart@linuxfoundation.org>
Reviewed-by: Philippe Ombredanne <pombredanne@nexb.com>
Reviewed-by: Thomas Gleixner <tglx@linutronix.de>
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
2017-11-01 21:07:57 +07:00
|
|
|
/* SPDX-License-Identifier: GPL-2.0 */
|
2014-06-04 03:04:00 +07:00
|
|
|
/*
|
2018-10-01 16:31:22 +07:00
|
|
|
* Thunderbolt driver - bus logic (NHI independent)
|
2014-06-04 03:04:00 +07:00
|
|
|
*
|
|
|
|
* Copyright (c) 2014 Andreas Noever <andreas.noever@gmail.com>
|
2018-10-01 16:31:22 +07:00
|
|
|
* Copyright (C) 2018, Intel Corporation
|
2014-06-04 03:04:00 +07:00
|
|
|
*/
|
|
|
|
|
|
|
|
#ifndef TB_H_
|
|
|
|
#define TB_H_
|
|
|
|
|
2017-06-06 19:25:17 +07:00
|
|
|
#include <linux/nvmem-provider.h>
|
2014-06-04 03:04:02 +07:00
|
|
|
#include <linux/pci.h>
|
2017-10-02 17:38:34 +07:00
|
|
|
#include <linux/thunderbolt.h>
|
2017-06-06 19:25:01 +07:00
|
|
|
#include <linux/uuid.h>
|
2014-06-04 03:04:02 +07:00
|
|
|
|
|
|
|
#include "tb_regs.h"
|
2014-06-04 03:04:00 +07:00
|
|
|
#include "ctl.h"
|
2017-06-06 19:25:14 +07:00
|
|
|
#include "dma_port.h"
|
2014-06-04 03:04:00 +07:00
|
|
|
|
2017-06-06 19:25:17 +07:00
|
|
|
/**
|
|
|
|
* struct tb_switch_nvm - Structure holding switch NVM information
|
|
|
|
* @major: Major version number of the active NVM portion
|
|
|
|
* @minor: Minor version number of the active NVM portion
|
|
|
|
* @id: Identifier used with both NVM portions
|
|
|
|
* @active: Active portion NVMem device
|
|
|
|
* @non_active: Non-active portion NVMem device
|
|
|
|
* @buf: Buffer where the NVM image is stored before it is written to
|
|
|
|
* the actual NVM flash device
|
|
|
|
* @buf_data_size: Number of bytes actually consumed by the new NVM
|
|
|
|
* image
|
|
|
|
* @authenticating: The switch is authenticating the new NVM
|
|
|
|
*/
|
|
|
|
struct tb_switch_nvm {
|
|
|
|
u8 major;
|
|
|
|
u8 minor;
|
|
|
|
int id;
|
|
|
|
struct nvmem_device *active;
|
|
|
|
struct nvmem_device *non_active;
|
|
|
|
void *buf;
|
|
|
|
size_t buf_data_size;
|
|
|
|
bool authenticating;
|
|
|
|
};
|
|
|
|
|
2017-06-06 19:25:16 +07:00
|
|
|
#define TB_SWITCH_KEY_SIZE 32
|
2018-12-30 17:14:46 +07:00
|
|
|
#define TB_SWITCH_MAX_DEPTH 6
|
2019-12-17 19:33:40 +07:00
|
|
|
#define USB4_SWITCH_MAX_DEPTH 5
|
2017-06-06 19:25:16 +07:00
|
|
|
|
2019-12-17 19:33:43 +07:00
|
|
|
/**
|
|
|
|
* enum tb_switch_tmu_rate - TMU refresh rate
|
|
|
|
* @TB_SWITCH_TMU_RATE_OFF: %0 (Disable Time Sync handshake)
|
|
|
|
* @TB_SWITCH_TMU_RATE_HIFI: %16 us time interval between successive
|
|
|
|
* transmission of the Delay Request TSNOS
|
|
|
|
* (Time Sync Notification Ordered Set) on a Link
|
|
|
|
* @TB_SWITCH_TMU_RATE_NORMAL: %1 ms time interval between successive
|
|
|
|
* transmission of the Delay Request TSNOS on
|
|
|
|
* a Link
|
|
|
|
*/
|
|
|
|
enum tb_switch_tmu_rate {
|
|
|
|
TB_SWITCH_TMU_RATE_OFF = 0,
|
|
|
|
TB_SWITCH_TMU_RATE_HIFI = 16,
|
|
|
|
TB_SWITCH_TMU_RATE_NORMAL = 1000,
|
|
|
|
};
|
|
|
|
|
|
|
|
/**
|
|
|
|
* struct tb_switch_tmu - Structure holding switch TMU configuration
|
|
|
|
* @cap: Offset to the TMU capability (%0 if not found)
|
|
|
|
* @has_ucap: Does the switch support uni-directional mode
|
|
|
|
* @rate: TMU refresh rate related to upstream switch. In case of root
|
|
|
|
* switch this holds the domain rate.
|
|
|
|
* @unidirectional: Is the TMU in uni-directional or bi-directional mode
|
|
|
|
* related to upstream switch. Don't case for root switch.
|
|
|
|
*/
|
|
|
|
struct tb_switch_tmu {
|
|
|
|
int cap;
|
|
|
|
bool has_ucap;
|
|
|
|
enum tb_switch_tmu_rate rate;
|
|
|
|
bool unidirectional;
|
|
|
|
};
|
|
|
|
|
2014-06-04 03:04:02 +07:00
|
|
|
/**
|
|
|
|
* struct tb_switch - a thunderbolt switch
|
2017-06-06 19:25:01 +07:00
|
|
|
* @dev: Device for the switch
|
|
|
|
* @config: Switch configuration
|
|
|
|
* @ports: Ports in this switch
|
2017-06-06 19:25:14 +07:00
|
|
|
* @dma_port: If the switch has port supporting DMA configuration based
|
|
|
|
* mailbox this will hold the pointer to that (%NULL
|
2017-06-06 19:25:17 +07:00
|
|
|
* otherwise). If set it also means the switch has
|
|
|
|
* upgradeable NVM.
|
2019-12-17 19:33:43 +07:00
|
|
|
* @tmu: The switch TMU configuration
|
2017-06-06 19:25:01 +07:00
|
|
|
* @tb: Pointer to the domain the switch belongs to
|
|
|
|
* @uid: Unique ID of the switch
|
|
|
|
* @uuid: UUID of the switch (or %NULL if not supported)
|
|
|
|
* @vendor: Vendor ID of the switch
|
|
|
|
* @device: Device ID of the switch
|
2017-06-06 19:25:05 +07:00
|
|
|
* @vendor_name: Name of the vendor (or %NULL if not known)
|
|
|
|
* @device_name: Name of the device (or %NULL if not known)
|
2019-03-22 00:03:00 +07:00
|
|
|
* @link_speed: Speed of the link in Gb/s
|
|
|
|
* @link_width: Width of the link (1 or 2)
|
2017-06-06 19:25:13 +07:00
|
|
|
* @generation: Switch Thunderbolt generation
|
2017-06-06 19:25:01 +07:00
|
|
|
* @cap_plug_events: Offset to the plug events capability (%0 if not found)
|
2019-01-09 21:42:12 +07:00
|
|
|
* @cap_lc: Offset to the link controller capability (%0 if not found)
|
2017-06-06 19:25:01 +07:00
|
|
|
* @is_unplugged: The switch is going away
|
|
|
|
* @drom: DROM of the switch (%NULL if not found)
|
2017-06-06 19:25:17 +07:00
|
|
|
* @nvm: Pointer to the NVM if the switch has one (%NULL otherwise)
|
|
|
|
* @no_nvm_upgrade: Prevent NVM upgrade of this switch
|
|
|
|
* @safe_mode: The switch is in safe-mode
|
2018-01-22 17:50:09 +07:00
|
|
|
* @boot: Whether the switch was already authorized on boot or not
|
2018-07-25 15:48:39 +07:00
|
|
|
* @rpm: The switch supports runtime PM
|
2017-06-06 19:25:16 +07:00
|
|
|
* @authorized: Whether the switch is authorized by user or policy
|
|
|
|
* @security_level: Switch supported security level
|
|
|
|
* @key: Contains the key used to challenge the device or %NULL if not
|
|
|
|
* supported. Size of the key is %TB_SWITCH_KEY_SIZE.
|
|
|
|
* @connection_id: Connection ID used with ICM messaging
|
|
|
|
* @connection_key: Connection key used with ICM messaging
|
|
|
|
* @link: Root switch link this switch is connected (ICM only)
|
|
|
|
* @depth: Depth in the chain this switch is connected (ICM only)
|
2019-05-28 22:56:20 +07:00
|
|
|
* @rpm_complete: Completion used to wait for runtime resume to
|
|
|
|
* complete (ICM only)
|
2017-06-06 19:25:16 +07:00
|
|
|
*
|
|
|
|
* When the switch is being added or removed to the domain (other
|
2019-03-19 21:48:41 +07:00
|
|
|
* switches) you need to have domain lock held.
|
2014-06-04 03:04:02 +07:00
|
|
|
*/
|
|
|
|
struct tb_switch {
|
2017-06-06 19:25:01 +07:00
|
|
|
struct device dev;
|
2014-06-04 03:04:02 +07:00
|
|
|
struct tb_regs_switch_header config;
|
|
|
|
struct tb_port *ports;
|
2017-06-06 19:25:14 +07:00
|
|
|
struct tb_dma_port *dma_port;
|
2019-12-17 19:33:43 +07:00
|
|
|
struct tb_switch_tmu tmu;
|
2014-06-04 03:04:02 +07:00
|
|
|
struct tb *tb;
|
2014-06-04 03:04:11 +07:00
|
|
|
u64 uid;
|
2017-07-18 20:30:05 +07:00
|
|
|
uuid_t *uuid;
|
2017-06-06 19:25:01 +07:00
|
|
|
u16 vendor;
|
|
|
|
u16 device;
|
2017-06-06 19:25:05 +07:00
|
|
|
const char *vendor_name;
|
|
|
|
const char *device_name;
|
2019-03-22 00:03:00 +07:00
|
|
|
unsigned int link_speed;
|
|
|
|
unsigned int link_width;
|
2017-06-06 19:25:13 +07:00
|
|
|
unsigned int generation;
|
2017-06-06 19:25:01 +07:00
|
|
|
int cap_plug_events;
|
2019-01-09 21:42:12 +07:00
|
|
|
int cap_lc;
|
2017-06-06 19:25:01 +07:00
|
|
|
bool is_unplugged;
|
2014-06-13 04:11:46 +07:00
|
|
|
u8 *drom;
|
2017-06-06 19:25:17 +07:00
|
|
|
struct tb_switch_nvm *nvm;
|
|
|
|
bool no_nvm_upgrade;
|
|
|
|
bool safe_mode;
|
2018-01-22 17:50:09 +07:00
|
|
|
bool boot;
|
2018-07-25 15:48:39 +07:00
|
|
|
bool rpm;
|
2017-06-06 19:25:16 +07:00
|
|
|
unsigned int authorized;
|
|
|
|
enum tb_security_level security_level;
|
|
|
|
u8 *key;
|
|
|
|
u8 connection_id;
|
|
|
|
u8 connection_key;
|
|
|
|
u8 link;
|
|
|
|
u8 depth;
|
2019-05-28 22:56:20 +07:00
|
|
|
struct completion rpm_complete;
|
2014-06-04 03:04:02 +07:00
|
|
|
};
|
|
|
|
|
|
|
|
/**
|
|
|
|
* struct tb_port - a thunderbolt port, part of a tb_switch
|
2017-10-02 17:38:34 +07:00
|
|
|
* @config: Cached port configuration read from registers
|
|
|
|
* @sw: Switch the port belongs to
|
|
|
|
* @remote: Remote port (%NULL if not connected)
|
|
|
|
* @xdomain: Remote host (%NULL if not connected)
|
|
|
|
* @cap_phy: Offset, zero if not found
|
2019-12-17 19:33:43 +07:00
|
|
|
* @cap_tmu: Offset of the adapter specific TMU capability (%0 if not present)
|
2017-02-19 15:39:34 +07:00
|
|
|
* @cap_adap: Offset of the adapter specific capability (%0 if not present)
|
2019-12-17 19:33:40 +07:00
|
|
|
* @cap_usb4: Offset to the USB4 port capability (%0 if not present)
|
2017-10-02 17:38:34 +07:00
|
|
|
* @port: Port number on switch
|
|
|
|
* @disabled: Disabled by eeprom
|
2019-03-22 00:03:00 +07:00
|
|
|
* @bonded: true if the port is bonded (two lanes combined as one)
|
2017-10-02 17:38:34 +07:00
|
|
|
* @dual_link_port: If the switch is connected using two ports, points
|
|
|
|
* to the other port.
|
|
|
|
* @link_nr: Is this primary or secondary port on the dual_link.
|
2017-02-19 21:57:27 +07:00
|
|
|
* @in_hopids: Currently allocated input HopIDs
|
|
|
|
* @out_hopids: Currently allocated output HopIDs
|
2019-03-26 19:52:30 +07:00
|
|
|
* @list: Used to link ports to DP resources list
|
2014-06-04 03:04:02 +07:00
|
|
|
*/
|
|
|
|
struct tb_port {
|
|
|
|
struct tb_regs_port_header config;
|
|
|
|
struct tb_switch *sw;
|
2017-10-02 17:38:34 +07:00
|
|
|
struct tb_port *remote;
|
|
|
|
struct tb_xdomain *xdomain;
|
|
|
|
int cap_phy;
|
2019-12-17 19:33:43 +07:00
|
|
|
int cap_tmu;
|
2017-02-19 15:39:34 +07:00
|
|
|
int cap_adap;
|
2019-12-17 19:33:40 +07:00
|
|
|
int cap_usb4;
|
2017-10-02 17:38:34 +07:00
|
|
|
u8 port;
|
|
|
|
bool disabled;
|
2019-03-22 00:03:00 +07:00
|
|
|
bool bonded;
|
2014-06-13 04:11:46 +07:00
|
|
|
struct tb_port *dual_link_port;
|
|
|
|
u8 link_nr:1;
|
2017-02-19 21:57:27 +07:00
|
|
|
struct ida in_hopids;
|
|
|
|
struct ida out_hopids;
|
2019-03-26 19:52:30 +07:00
|
|
|
struct list_head list;
|
2014-06-04 03:04:02 +07:00
|
|
|
};
|
|
|
|
|
2014-06-04 03:04:07 +07:00
|
|
|
/**
|
|
|
|
* struct tb_path_hop - routing information for a tb_path
|
2017-02-20 03:11:41 +07:00
|
|
|
* @in_port: Ingress port of a switch
|
|
|
|
* @out_port: Egress port of a switch where the packet is routed out
|
|
|
|
* (must be on the same switch than @in_port)
|
|
|
|
* @in_hop_index: HopID where the path configuration entry is placed in
|
|
|
|
* the path config space of @in_port.
|
|
|
|
* @in_counter_index: Used counter index (not used in the driver
|
|
|
|
* currently, %-1 to disable)
|
|
|
|
* @next_hop_index: HopID of the packet when it is routed out from @out_port
|
2017-02-20 04:43:26 +07:00
|
|
|
* @initial_credits: Number of initial flow control credits allocated for
|
|
|
|
* the path
|
2014-06-04 03:04:07 +07:00
|
|
|
*
|
|
|
|
* Hop configuration is always done on the IN port of a switch.
|
|
|
|
* in_port and out_port have to be on the same switch. Packets arriving on
|
|
|
|
* in_port with "hop" = in_hop_index will get routed to through out_port. The
|
2017-02-20 03:11:41 +07:00
|
|
|
* next hop to take (on out_port->remote) is determined by
|
|
|
|
* next_hop_index. When routing packet to another switch (out->remote is
|
|
|
|
* set) the @next_hop_index must match the @in_hop_index of that next
|
|
|
|
* hop to make routing possible.
|
2014-06-04 03:04:07 +07:00
|
|
|
*
|
|
|
|
* in_counter_index is the index of a counter (in TB_CFG_COUNTERS) on the in
|
|
|
|
* port.
|
|
|
|
*/
|
|
|
|
struct tb_path_hop {
|
|
|
|
struct tb_port *in_port;
|
|
|
|
struct tb_port *out_port;
|
|
|
|
int in_hop_index;
|
2017-02-20 03:11:41 +07:00
|
|
|
int in_counter_index;
|
2014-06-04 03:04:07 +07:00
|
|
|
int next_hop_index;
|
2017-02-20 04:43:26 +07:00
|
|
|
unsigned int initial_credits;
|
2014-06-04 03:04:07 +07:00
|
|
|
};
|
|
|
|
|
|
|
|
/**
|
|
|
|
* enum tb_path_port - path options mask
|
2017-02-20 03:11:41 +07:00
|
|
|
* @TB_PATH_NONE: Do not activate on any hop on path
|
|
|
|
* @TB_PATH_SOURCE: Activate on the first hop (out of src)
|
|
|
|
* @TB_PATH_INTERNAL: Activate on the intermediate hops (not the first/last)
|
|
|
|
* @TB_PATH_DESTINATION: Activate on the last hop (into dst)
|
|
|
|
* @TB_PATH_ALL: Activate on all hops on the path
|
2014-06-04 03:04:07 +07:00
|
|
|
*/
|
|
|
|
enum tb_path_port {
|
|
|
|
TB_PATH_NONE = 0,
|
2017-02-20 03:11:41 +07:00
|
|
|
TB_PATH_SOURCE = 1,
|
|
|
|
TB_PATH_INTERNAL = 2,
|
|
|
|
TB_PATH_DESTINATION = 4,
|
2014-06-04 03:04:07 +07:00
|
|
|
TB_PATH_ALL = 7,
|
|
|
|
};
|
|
|
|
|
|
|
|
/**
|
|
|
|
* struct tb_path - a unidirectional path between two ports
|
2017-02-20 03:11:41 +07:00
|
|
|
* @tb: Pointer to the domain structure
|
|
|
|
* @name: Name of the path (used for debugging)
|
|
|
|
* @nfc_credits: Number of non flow controlled credits allocated for the path
|
|
|
|
* @ingress_shared_buffer: Shared buffering used for ingress ports on the path
|
|
|
|
* @egress_shared_buffer: Shared buffering used for egress ports on the path
|
|
|
|
* @ingress_fc_enable: Flow control for ingress ports on the path
|
|
|
|
* @egress_fc_enable: Flow control for egress ports on the path
|
|
|
|
* @priority: Priority group if the path
|
|
|
|
* @weight: Weight of the path inside the priority group
|
|
|
|
* @drop_packages: Drop packages from queue tail or head
|
|
|
|
* @activated: Is the path active
|
2018-09-28 20:35:32 +07:00
|
|
|
* @clear_fc: Clear all flow control from the path config space entries
|
|
|
|
* when deactivating this path
|
2017-02-20 03:11:41 +07:00
|
|
|
* @hops: Path hops
|
|
|
|
* @path_length: How many hops the path uses
|
2014-06-04 03:04:07 +07:00
|
|
|
*
|
2017-02-20 03:11:41 +07:00
|
|
|
* A path consists of a number of hops (see &struct tb_path_hop). To
|
|
|
|
* establish a PCIe tunnel two paths have to be created between the two
|
|
|
|
* PCIe ports.
|
2014-06-04 03:04:07 +07:00
|
|
|
*/
|
|
|
|
struct tb_path {
|
|
|
|
struct tb *tb;
|
2017-02-20 03:11:41 +07:00
|
|
|
const char *name;
|
|
|
|
int nfc_credits;
|
2014-06-04 03:04:07 +07:00
|
|
|
enum tb_path_port ingress_shared_buffer;
|
|
|
|
enum tb_path_port egress_shared_buffer;
|
|
|
|
enum tb_path_port ingress_fc_enable;
|
|
|
|
enum tb_path_port egress_fc_enable;
|
|
|
|
|
2019-04-25 01:34:13 +07:00
|
|
|
unsigned int priority:3;
|
2014-06-04 03:04:07 +07:00
|
|
|
int weight:4;
|
|
|
|
bool drop_packages;
|
|
|
|
bool activated;
|
2018-09-28 20:35:32 +07:00
|
|
|
bool clear_fc;
|
2014-06-04 03:04:07 +07:00
|
|
|
struct tb_path_hop *hops;
|
2017-02-20 03:11:41 +07:00
|
|
|
int path_length;
|
2014-06-04 03:04:07 +07:00
|
|
|
};
|
|
|
|
|
2017-02-19 21:57:27 +07:00
|
|
|
/* HopIDs 0-7 are reserved by the Thunderbolt protocol */
|
|
|
|
#define TB_PATH_MIN_HOPID 8
|
2017-02-20 04:43:26 +07:00
|
|
|
#define TB_PATH_MAX_HOPS 7
|
2017-02-19 21:57:27 +07:00
|
|
|
|
2017-06-06 19:25:00 +07:00
|
|
|
/**
|
|
|
|
* struct tb_cm_ops - Connection manager specific operations vector
|
2017-06-06 19:25:16 +07:00
|
|
|
* @driver_ready: Called right after control channel is started. Used by
|
|
|
|
* ICM to send driver ready message to the firmware.
|
2017-06-06 19:25:00 +07:00
|
|
|
* @start: Starts the domain
|
|
|
|
* @stop: Stops the domain
|
|
|
|
* @suspend_noirq: Connection manager specific suspend_noirq
|
|
|
|
* @resume_noirq: Connection manager specific resume_noirq
|
2017-06-06 19:25:16 +07:00
|
|
|
* @suspend: Connection manager specific suspend
|
|
|
|
* @complete: Connection manager specific complete
|
2018-07-25 15:48:39 +07:00
|
|
|
* @runtime_suspend: Connection manager specific runtime_suspend
|
|
|
|
* @runtime_resume: Connection manager specific runtime_resume
|
2019-05-28 22:56:20 +07:00
|
|
|
* @runtime_suspend_switch: Runtime suspend a switch
|
|
|
|
* @runtime_resume_switch: Runtime resume a switch
|
2017-06-06 19:25:09 +07:00
|
|
|
* @handle_event: Handle thunderbolt event
|
2018-01-21 17:08:04 +07:00
|
|
|
* @get_boot_acl: Get boot ACL list
|
|
|
|
* @set_boot_acl: Set boot ACL list
|
2017-06-06 19:25:16 +07:00
|
|
|
* @approve_switch: Approve switch
|
|
|
|
* @add_switch_key: Add key to switch
|
|
|
|
* @challenge_switch_key: Challenge switch using key
|
2017-06-06 19:25:17 +07:00
|
|
|
* @disconnect_pcie_paths: Disconnects PCIe paths before NVM update
|
2017-10-02 17:38:34 +07:00
|
|
|
* @approve_xdomain_paths: Approve (establish) XDomain DMA paths
|
|
|
|
* @disconnect_xdomain_paths: Disconnect XDomain DMA paths
|
2017-06-06 19:25:00 +07:00
|
|
|
*/
|
|
|
|
struct tb_cm_ops {
|
2017-06-06 19:25:16 +07:00
|
|
|
int (*driver_ready)(struct tb *tb);
|
2017-06-06 19:25:00 +07:00
|
|
|
int (*start)(struct tb *tb);
|
|
|
|
void (*stop)(struct tb *tb);
|
|
|
|
int (*suspend_noirq)(struct tb *tb);
|
|
|
|
int (*resume_noirq)(struct tb *tb);
|
2017-06-06 19:25:16 +07:00
|
|
|
int (*suspend)(struct tb *tb);
|
|
|
|
void (*complete)(struct tb *tb);
|
2018-07-25 15:48:39 +07:00
|
|
|
int (*runtime_suspend)(struct tb *tb);
|
|
|
|
int (*runtime_resume)(struct tb *tb);
|
2019-05-28 22:56:20 +07:00
|
|
|
int (*runtime_suspend_switch)(struct tb_switch *sw);
|
|
|
|
int (*runtime_resume_switch)(struct tb_switch *sw);
|
2017-06-06 19:25:09 +07:00
|
|
|
void (*handle_event)(struct tb *tb, enum tb_cfg_pkg_type,
|
|
|
|
const void *buf, size_t size);
|
2018-01-21 17:08:04 +07:00
|
|
|
int (*get_boot_acl)(struct tb *tb, uuid_t *uuids, size_t nuuids);
|
|
|
|
int (*set_boot_acl)(struct tb *tb, const uuid_t *uuids, size_t nuuids);
|
2017-06-06 19:25:16 +07:00
|
|
|
int (*approve_switch)(struct tb *tb, struct tb_switch *sw);
|
|
|
|
int (*add_switch_key)(struct tb *tb, struct tb_switch *sw);
|
|
|
|
int (*challenge_switch_key)(struct tb *tb, struct tb_switch *sw,
|
|
|
|
const u8 *challenge, u8 *response);
|
2017-06-06 19:25:17 +07:00
|
|
|
int (*disconnect_pcie_paths)(struct tb *tb);
|
2017-10-02 17:38:34 +07:00
|
|
|
int (*approve_xdomain_paths)(struct tb *tb, struct tb_xdomain *xd);
|
|
|
|
int (*disconnect_xdomain_paths)(struct tb *tb, struct tb_xdomain *xd);
|
2017-06-06 19:25:00 +07:00
|
|
|
};
|
2014-06-04 03:04:07 +07:00
|
|
|
|
2017-06-06 19:25:00 +07:00
|
|
|
static inline void *tb_priv(struct tb *tb)
|
|
|
|
{
|
|
|
|
return (void *)tb->privdata;
|
|
|
|
}
|
|
|
|
|
2018-07-25 15:48:39 +07:00
|
|
|
#define TB_AUTOSUSPEND_DELAY 15000 /* ms */
|
|
|
|
|
2014-06-04 03:04:02 +07:00
|
|
|
/* helper functions & macros */
|
|
|
|
|
|
|
|
/**
|
|
|
|
* tb_upstream_port() - return the upstream port of a switch
|
|
|
|
*
|
|
|
|
* Every switch has an upstream port (for the root switch it is the NHI).
|
|
|
|
*
|
|
|
|
* During switch alloc/init tb_upstream_port()->remote may be NULL, even for
|
|
|
|
* non root switches (on the NHI port remote is always NULL).
|
|
|
|
*
|
|
|
|
* Return: Returns the upstream port of the switch.
|
|
|
|
*/
|
|
|
|
static inline struct tb_port *tb_upstream_port(struct tb_switch *sw)
|
|
|
|
{
|
|
|
|
return &sw->ports[sw->config.upstream_port_number];
|
|
|
|
}
|
|
|
|
|
2019-03-07 20:26:45 +07:00
|
|
|
/**
|
|
|
|
* tb_is_upstream_port() - Is the port upstream facing
|
|
|
|
* @port: Port to check
|
|
|
|
*
|
|
|
|
* Returns true if @port is upstream facing port. In case of dual link
|
|
|
|
* ports both return true.
|
|
|
|
*/
|
|
|
|
static inline bool tb_is_upstream_port(const struct tb_port *port)
|
|
|
|
{
|
|
|
|
const struct tb_port *upstream_port = tb_upstream_port(port->sw);
|
|
|
|
return port == upstream_port || port->dual_link_port == upstream_port;
|
|
|
|
}
|
|
|
|
|
2019-03-07 00:23:38 +07:00
|
|
|
static inline u64 tb_route(const struct tb_switch *sw)
|
2014-06-04 03:04:02 +07:00
|
|
|
{
|
|
|
|
return ((u64) sw->config.route_hi) << 32 | sw->config.route_lo;
|
|
|
|
}
|
|
|
|
|
2017-06-06 19:25:16 +07:00
|
|
|
static inline struct tb_port *tb_port_at(u64 route, struct tb_switch *sw)
|
|
|
|
{
|
|
|
|
u8 port;
|
|
|
|
|
|
|
|
port = route >> (sw->config.depth * 8);
|
|
|
|
if (WARN_ON(port > sw->config.max_port_number))
|
|
|
|
return NULL;
|
|
|
|
return &sw->ports[port];
|
|
|
|
}
|
|
|
|
|
2019-03-07 20:26:45 +07:00
|
|
|
/**
|
|
|
|
* tb_port_has_remote() - Does the port have switch connected downstream
|
|
|
|
* @port: Port to check
|
|
|
|
*
|
|
|
|
* Returns true only when the port is primary port and has remote set.
|
|
|
|
*/
|
|
|
|
static inline bool tb_port_has_remote(const struct tb_port *port)
|
|
|
|
{
|
|
|
|
if (tb_is_upstream_port(port))
|
|
|
|
return false;
|
|
|
|
if (!port->remote)
|
|
|
|
return false;
|
|
|
|
if (port->dual_link_port && port->link_nr)
|
|
|
|
return false;
|
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2017-10-11 21:19:54 +07:00
|
|
|
static inline bool tb_port_is_null(const struct tb_port *port)
|
|
|
|
{
|
|
|
|
return port && port->port && port->config.type == TB_TYPE_PORT;
|
|
|
|
}
|
|
|
|
|
2018-12-31 02:34:08 +07:00
|
|
|
static inline bool tb_port_is_pcie_down(const struct tb_port *port)
|
|
|
|
{
|
|
|
|
return port && port->config.type == TB_TYPE_PCIE_DOWN;
|
|
|
|
}
|
|
|
|
|
2017-02-20 04:43:26 +07:00
|
|
|
static inline bool tb_port_is_pcie_up(const struct tb_port *port)
|
|
|
|
{
|
|
|
|
return port && port->config.type == TB_TYPE_PCIE_UP;
|
|
|
|
}
|
|
|
|
|
2018-09-17 20:30:49 +07:00
|
|
|
static inline bool tb_port_is_dpin(const struct tb_port *port)
|
|
|
|
{
|
|
|
|
return port && port->config.type == TB_TYPE_DP_HDMI_IN;
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline bool tb_port_is_dpout(const struct tb_port *port)
|
|
|
|
{
|
|
|
|
return port && port->config.type == TB_TYPE_DP_HDMI_OUT;
|
|
|
|
}
|
|
|
|
|
2019-12-17 19:33:44 +07:00
|
|
|
static inline bool tb_port_is_usb3_down(const struct tb_port *port)
|
|
|
|
{
|
|
|
|
return port && port->config.type == TB_TYPE_USB3_DOWN;
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline bool tb_port_is_usb3_up(const struct tb_port *port)
|
|
|
|
{
|
|
|
|
return port && port->config.type == TB_TYPE_USB3_UP;
|
|
|
|
}
|
|
|
|
|
2014-06-04 03:04:02 +07:00
|
|
|
static inline int tb_sw_read(struct tb_switch *sw, void *buffer,
|
|
|
|
enum tb_cfg_space space, u32 offset, u32 length)
|
|
|
|
{
|
2019-03-19 22:07:37 +07:00
|
|
|
if (sw->is_unplugged)
|
|
|
|
return -ENODEV;
|
2014-06-04 03:04:02 +07:00
|
|
|
return tb_cfg_read(sw->tb->ctl,
|
|
|
|
buffer,
|
|
|
|
tb_route(sw),
|
|
|
|
0,
|
|
|
|
space,
|
|
|
|
offset,
|
|
|
|
length);
|
|
|
|
}
|
|
|
|
|
2019-07-01 22:41:51 +07:00
|
|
|
static inline int tb_sw_write(struct tb_switch *sw, const void *buffer,
|
2014-06-04 03:04:02 +07:00
|
|
|
enum tb_cfg_space space, u32 offset, u32 length)
|
|
|
|
{
|
2019-03-19 22:07:37 +07:00
|
|
|
if (sw->is_unplugged)
|
|
|
|
return -ENODEV;
|
2014-06-04 03:04:02 +07:00
|
|
|
return tb_cfg_write(sw->tb->ctl,
|
|
|
|
buffer,
|
|
|
|
tb_route(sw),
|
|
|
|
0,
|
|
|
|
space,
|
|
|
|
offset,
|
|
|
|
length);
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline int tb_port_read(struct tb_port *port, void *buffer,
|
|
|
|
enum tb_cfg_space space, u32 offset, u32 length)
|
|
|
|
{
|
2019-03-19 22:07:37 +07:00
|
|
|
if (port->sw->is_unplugged)
|
|
|
|
return -ENODEV;
|
2014-06-04 03:04:02 +07:00
|
|
|
return tb_cfg_read(port->sw->tb->ctl,
|
|
|
|
buffer,
|
|
|
|
tb_route(port->sw),
|
|
|
|
port->port,
|
|
|
|
space,
|
|
|
|
offset,
|
|
|
|
length);
|
|
|
|
}
|
|
|
|
|
2017-06-06 19:24:53 +07:00
|
|
|
static inline int tb_port_write(struct tb_port *port, const void *buffer,
|
2014-06-04 03:04:02 +07:00
|
|
|
enum tb_cfg_space space, u32 offset, u32 length)
|
|
|
|
{
|
2019-03-19 22:07:37 +07:00
|
|
|
if (port->sw->is_unplugged)
|
|
|
|
return -ENODEV;
|
2014-06-04 03:04:02 +07:00
|
|
|
return tb_cfg_write(port->sw->tb->ctl,
|
|
|
|
buffer,
|
|
|
|
tb_route(port->sw),
|
|
|
|
port->port,
|
|
|
|
space,
|
|
|
|
offset,
|
|
|
|
length);
|
|
|
|
}
|
|
|
|
|
|
|
|
#define tb_err(tb, fmt, arg...) dev_err(&(tb)->nhi->pdev->dev, fmt, ## arg)
|
|
|
|
#define tb_WARN(tb, fmt, arg...) dev_WARN(&(tb)->nhi->pdev->dev, fmt, ## arg)
|
|
|
|
#define tb_warn(tb, fmt, arg...) dev_warn(&(tb)->nhi->pdev->dev, fmt, ## arg)
|
|
|
|
#define tb_info(tb, fmt, arg...) dev_info(&(tb)->nhi->pdev->dev, fmt, ## arg)
|
2018-10-01 16:31:19 +07:00
|
|
|
#define tb_dbg(tb, fmt, arg...) dev_dbg(&(tb)->nhi->pdev->dev, fmt, ## arg)
|
2014-06-04 03:04:02 +07:00
|
|
|
|
|
|
|
#define __TB_SW_PRINT(level, sw, fmt, arg...) \
|
|
|
|
do { \
|
2019-03-07 00:23:38 +07:00
|
|
|
const struct tb_switch *__sw = (sw); \
|
2014-06-04 03:04:02 +07:00
|
|
|
level(__sw->tb, "%llx: " fmt, \
|
|
|
|
tb_route(__sw), ## arg); \
|
|
|
|
} while (0)
|
|
|
|
#define tb_sw_WARN(sw, fmt, arg...) __TB_SW_PRINT(tb_WARN, sw, fmt, ##arg)
|
|
|
|
#define tb_sw_warn(sw, fmt, arg...) __TB_SW_PRINT(tb_warn, sw, fmt, ##arg)
|
|
|
|
#define tb_sw_info(sw, fmt, arg...) __TB_SW_PRINT(tb_info, sw, fmt, ##arg)
|
2018-10-01 16:31:19 +07:00
|
|
|
#define tb_sw_dbg(sw, fmt, arg...) __TB_SW_PRINT(tb_dbg, sw, fmt, ##arg)
|
2014-06-04 03:04:02 +07:00
|
|
|
|
|
|
|
#define __TB_PORT_PRINT(level, _port, fmt, arg...) \
|
|
|
|
do { \
|
2019-03-07 00:23:38 +07:00
|
|
|
const struct tb_port *__port = (_port); \
|
2014-06-04 03:04:02 +07:00
|
|
|
level(__port->sw->tb, "%llx:%x: " fmt, \
|
|
|
|
tb_route(__port->sw), __port->port, ## arg); \
|
|
|
|
} while (0)
|
|
|
|
#define tb_port_WARN(port, fmt, arg...) \
|
|
|
|
__TB_PORT_PRINT(tb_WARN, port, fmt, ##arg)
|
|
|
|
#define tb_port_warn(port, fmt, arg...) \
|
|
|
|
__TB_PORT_PRINT(tb_warn, port, fmt, ##arg)
|
|
|
|
#define tb_port_info(port, fmt, arg...) \
|
|
|
|
__TB_PORT_PRINT(tb_info, port, fmt, ##arg)
|
2018-10-01 16:31:19 +07:00
|
|
|
#define tb_port_dbg(port, fmt, arg...) \
|
|
|
|
__TB_PORT_PRINT(tb_dbg, port, fmt, ##arg)
|
2014-06-04 03:04:02 +07:00
|
|
|
|
2017-06-06 19:25:16 +07:00
|
|
|
struct tb *icm_probe(struct tb_nhi *nhi);
|
2017-06-06 19:25:00 +07:00
|
|
|
struct tb *tb_probe(struct tb_nhi *nhi);
|
|
|
|
|
|
|
|
extern struct device_type tb_domain_type;
|
2017-06-06 19:25:01 +07:00
|
|
|
extern struct device_type tb_switch_type;
|
2017-06-06 19:25:00 +07:00
|
|
|
|
|
|
|
int tb_domain_init(void);
|
|
|
|
void tb_domain_exit(void);
|
2017-06-06 19:25:17 +07:00
|
|
|
void tb_switch_exit(void);
|
2017-10-02 17:38:34 +07:00
|
|
|
int tb_xdomain_init(void);
|
|
|
|
void tb_xdomain_exit(void);
|
2014-06-04 03:04:02 +07:00
|
|
|
|
2017-06-06 19:25:00 +07:00
|
|
|
struct tb *tb_domain_alloc(struct tb_nhi *nhi, size_t privsize);
|
|
|
|
int tb_domain_add(struct tb *tb);
|
|
|
|
void tb_domain_remove(struct tb *tb);
|
|
|
|
int tb_domain_suspend_noirq(struct tb *tb);
|
|
|
|
int tb_domain_resume_noirq(struct tb *tb);
|
2017-06-06 19:25:16 +07:00
|
|
|
int tb_domain_suspend(struct tb *tb);
|
|
|
|
void tb_domain_complete(struct tb *tb);
|
2018-07-25 15:48:39 +07:00
|
|
|
int tb_domain_runtime_suspend(struct tb *tb);
|
|
|
|
int tb_domain_runtime_resume(struct tb *tb);
|
2017-06-06 19:25:16 +07:00
|
|
|
int tb_domain_approve_switch(struct tb *tb, struct tb_switch *sw);
|
|
|
|
int tb_domain_approve_switch_key(struct tb *tb, struct tb_switch *sw);
|
|
|
|
int tb_domain_challenge_switch_key(struct tb *tb, struct tb_switch *sw);
|
2017-06-06 19:25:17 +07:00
|
|
|
int tb_domain_disconnect_pcie_paths(struct tb *tb);
|
2017-10-02 17:38:34 +07:00
|
|
|
int tb_domain_approve_xdomain_paths(struct tb *tb, struct tb_xdomain *xd);
|
|
|
|
int tb_domain_disconnect_xdomain_paths(struct tb *tb, struct tb_xdomain *xd);
|
|
|
|
int tb_domain_disconnect_all_paths(struct tb *tb);
|
2017-06-06 19:25:00 +07:00
|
|
|
|
2018-10-22 18:47:01 +07:00
|
|
|
static inline struct tb *tb_domain_get(struct tb *tb)
|
|
|
|
{
|
|
|
|
if (tb)
|
|
|
|
get_device(&tb->dev);
|
|
|
|
return tb;
|
|
|
|
}
|
|
|
|
|
2017-06-06 19:25:00 +07:00
|
|
|
static inline void tb_domain_put(struct tb *tb)
|
|
|
|
{
|
|
|
|
put_device(&tb->dev);
|
|
|
|
}
|
2014-06-04 03:04:00 +07:00
|
|
|
|
2017-06-06 19:25:01 +07:00
|
|
|
struct tb_switch *tb_switch_alloc(struct tb *tb, struct device *parent,
|
|
|
|
u64 route);
|
2017-06-06 19:25:17 +07:00
|
|
|
struct tb_switch *tb_switch_alloc_safe_mode(struct tb *tb,
|
|
|
|
struct device *parent, u64 route);
|
2017-06-06 19:25:01 +07:00
|
|
|
int tb_switch_configure(struct tb_switch *sw);
|
|
|
|
int tb_switch_add(struct tb_switch *sw);
|
|
|
|
void tb_switch_remove(struct tb_switch *sw);
|
2014-06-04 03:04:12 +07:00
|
|
|
void tb_switch_suspend(struct tb_switch *sw);
|
|
|
|
int tb_switch_resume(struct tb_switch *sw);
|
|
|
|
int tb_switch_reset(struct tb *tb, u64 route);
|
2016-03-20 19:57:20 +07:00
|
|
|
void tb_sw_set_unplugged(struct tb_switch *sw);
|
2019-12-17 19:33:37 +07:00
|
|
|
struct tb_port *tb_switch_find_port(struct tb_switch *sw,
|
|
|
|
enum tb_port_type type);
|
2017-06-06 19:25:16 +07:00
|
|
|
struct tb_switch *tb_switch_find_by_link_depth(struct tb *tb, u8 link,
|
|
|
|
u8 depth);
|
2017-07-18 20:30:05 +07:00
|
|
|
struct tb_switch *tb_switch_find_by_uuid(struct tb *tb, const uuid_t *uuid);
|
2017-10-04 19:24:14 +07:00
|
|
|
struct tb_switch *tb_switch_find_by_route(struct tb *tb, u64 route);
|
2017-06-06 19:25:16 +07:00
|
|
|
|
2019-09-30 18:07:22 +07:00
|
|
|
/**
|
|
|
|
* tb_switch_for_each_port() - Iterate over each switch port
|
|
|
|
* @sw: Switch whose ports to iterate
|
|
|
|
* @p: Port used as iterator
|
|
|
|
*
|
|
|
|
* Iterates over each switch port skipping the control port (port %0).
|
|
|
|
*/
|
|
|
|
#define tb_switch_for_each_port(sw, p) \
|
|
|
|
for ((p) = &(sw)->ports[1]; \
|
|
|
|
(p) <= &(sw)->ports[(sw)->config.max_port_number]; (p)++)
|
|
|
|
|
2017-10-04 19:19:20 +07:00
|
|
|
static inline struct tb_switch *tb_switch_get(struct tb_switch *sw)
|
|
|
|
{
|
|
|
|
if (sw)
|
|
|
|
get_device(&sw->dev);
|
|
|
|
return sw;
|
|
|
|
}
|
|
|
|
|
2017-06-06 19:25:01 +07:00
|
|
|
static inline void tb_switch_put(struct tb_switch *sw)
|
|
|
|
{
|
|
|
|
put_device(&sw->dev);
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline bool tb_is_switch(const struct device *dev)
|
|
|
|
{
|
|
|
|
return dev->type == &tb_switch_type;
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline struct tb_switch *tb_to_switch(struct device *dev)
|
|
|
|
{
|
|
|
|
if (tb_is_switch(dev))
|
|
|
|
return container_of(dev, struct tb_switch, dev);
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2017-02-20 04:43:26 +07:00
|
|
|
static inline struct tb_switch *tb_switch_parent(struct tb_switch *sw)
|
|
|
|
{
|
|
|
|
return tb_to_switch(sw->dev.parent);
|
|
|
|
}
|
|
|
|
|
2019-10-08 20:42:47 +07:00
|
|
|
static inline bool tb_switch_is_light_ridge(const struct tb_switch *sw)
|
2019-01-08 23:55:09 +07:00
|
|
|
{
|
|
|
|
return sw->config.device_id == PCI_DEVICE_ID_INTEL_LIGHT_RIDGE;
|
|
|
|
}
|
|
|
|
|
2019-10-08 20:42:47 +07:00
|
|
|
static inline bool tb_switch_is_eagle_ridge(const struct tb_switch *sw)
|
2019-01-08 23:55:09 +07:00
|
|
|
{
|
|
|
|
return sw->config.device_id == PCI_DEVICE_ID_INTEL_EAGLE_RIDGE;
|
|
|
|
}
|
|
|
|
|
2019-10-08 20:42:47 +07:00
|
|
|
static inline bool tb_switch_is_cactus_ridge(const struct tb_switch *sw)
|
2018-12-31 02:34:08 +07:00
|
|
|
{
|
|
|
|
switch (sw->config.device_id) {
|
|
|
|
case PCI_DEVICE_ID_INTEL_CACTUS_RIDGE_2C:
|
|
|
|
case PCI_DEVICE_ID_INTEL_CACTUS_RIDGE_4C:
|
|
|
|
return true;
|
|
|
|
default:
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-10-08 20:42:47 +07:00
|
|
|
static inline bool tb_switch_is_falcon_ridge(const struct tb_switch *sw)
|
2018-12-31 02:34:08 +07:00
|
|
|
{
|
|
|
|
switch (sw->config.device_id) {
|
|
|
|
case PCI_DEVICE_ID_INTEL_FALCON_RIDGE_2C_BRIDGE:
|
|
|
|
case PCI_DEVICE_ID_INTEL_FALCON_RIDGE_4C_BRIDGE:
|
|
|
|
return true;
|
|
|
|
default:
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-03-22 20:16:53 +07:00
|
|
|
static inline bool tb_switch_is_alpine_ridge(const struct tb_switch *sw)
|
|
|
|
{
|
|
|
|
switch (sw->config.device_id) {
|
|
|
|
case PCI_DEVICE_ID_INTEL_ALPINE_RIDGE_2C_BRIDGE:
|
|
|
|
case PCI_DEVICE_ID_INTEL_ALPINE_RIDGE_LP_BRIDGE:
|
|
|
|
case PCI_DEVICE_ID_INTEL_ALPINE_RIDGE_C_4C_BRIDGE:
|
|
|
|
case PCI_DEVICE_ID_INTEL_ALPINE_RIDGE_C_2C_BRIDGE:
|
|
|
|
return true;
|
|
|
|
default:
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline bool tb_switch_is_titan_ridge(const struct tb_switch *sw)
|
|
|
|
{
|
|
|
|
switch (sw->config.device_id) {
|
|
|
|
case PCI_DEVICE_ID_INTEL_TITAN_RIDGE_2C_BRIDGE:
|
|
|
|
case PCI_DEVICE_ID_INTEL_TITAN_RIDGE_4C_BRIDGE:
|
|
|
|
case PCI_DEVICE_ID_INTEL_TITAN_RIDGE_DD_BRIDGE:
|
|
|
|
return true;
|
|
|
|
default:
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-12-17 19:33:40 +07:00
|
|
|
/**
|
|
|
|
* tb_switch_is_usb4() - Is the switch USB4 compliant
|
|
|
|
* @sw: Switch to check
|
|
|
|
*
|
|
|
|
* Returns true if the @sw is USB4 compliant router, false otherwise.
|
|
|
|
*/
|
|
|
|
static inline bool tb_switch_is_usb4(const struct tb_switch *sw)
|
|
|
|
{
|
|
|
|
return sw->config.thunderbolt_version == USB4_VERSION_1_0;
|
|
|
|
}
|
|
|
|
|
2019-06-25 19:10:01 +07:00
|
|
|
/**
|
|
|
|
* tb_switch_is_icm() - Is the switch handled by ICM firmware
|
|
|
|
* @sw: Switch to check
|
|
|
|
*
|
|
|
|
* In case there is a need to differentiate whether ICM firmware or SW CM
|
|
|
|
* is handling @sw this function can be called. It is valid to call this
|
|
|
|
* after tb_switch_alloc() and tb_switch_configure() has been called
|
|
|
|
* (latter only for SW CM case).
|
|
|
|
*/
|
|
|
|
static inline bool tb_switch_is_icm(const struct tb_switch *sw)
|
|
|
|
{
|
|
|
|
return !sw->config.enabled;
|
|
|
|
}
|
|
|
|
|
2019-03-22 00:03:00 +07:00
|
|
|
int tb_switch_lane_bonding_enable(struct tb_switch *sw);
|
|
|
|
void tb_switch_lane_bonding_disable(struct tb_switch *sw);
|
|
|
|
|
2019-03-26 19:52:30 +07:00
|
|
|
bool tb_switch_query_dp_resource(struct tb_switch *sw, struct tb_port *in);
|
|
|
|
int tb_switch_alloc_dp_resource(struct tb_switch *sw, struct tb_port *in);
|
|
|
|
void tb_switch_dealloc_dp_resource(struct tb_switch *sw, struct tb_port *in);
|
|
|
|
|
2019-12-17 19:33:43 +07:00
|
|
|
int tb_switch_tmu_init(struct tb_switch *sw);
|
|
|
|
int tb_switch_tmu_post_time(struct tb_switch *sw);
|
|
|
|
int tb_switch_tmu_disable(struct tb_switch *sw);
|
|
|
|
int tb_switch_tmu_enable(struct tb_switch *sw);
|
|
|
|
|
|
|
|
static inline bool tb_switch_tmu_is_enabled(const struct tb_switch *sw)
|
|
|
|
{
|
|
|
|
return sw->tmu.rate == TB_SWITCH_TMU_RATE_HIFI &&
|
|
|
|
!sw->tmu.unidirectional;
|
|
|
|
}
|
|
|
|
|
2014-06-04 03:04:05 +07:00
|
|
|
int tb_wait_for_port(struct tb_port *port, bool wait_if_unplugged);
|
2014-06-04 03:04:07 +07:00
|
|
|
int tb_port_add_nfc_credits(struct tb_port *port, int credits);
|
2018-09-28 20:35:32 +07:00
|
|
|
int tb_port_set_initial_credits(struct tb_port *port, u32 credits);
|
2014-06-04 03:04:07 +07:00
|
|
|
int tb_port_clear_counter(struct tb_port *port, int counter);
|
2019-12-17 19:33:40 +07:00
|
|
|
int tb_port_unlock(struct tb_port *port);
|
2017-02-19 21:57:27 +07:00
|
|
|
int tb_port_alloc_in_hopid(struct tb_port *port, int hopid, int max_hopid);
|
|
|
|
void tb_port_release_in_hopid(struct tb_port *port, int hopid);
|
|
|
|
int tb_port_alloc_out_hopid(struct tb_port *port, int hopid, int max_hopid);
|
|
|
|
void tb_port_release_out_hopid(struct tb_port *port, int hopid);
|
2017-02-20 02:51:30 +07:00
|
|
|
struct tb_port *tb_next_port_on_path(struct tb_port *start, struct tb_port *end,
|
|
|
|
struct tb_port *prev);
|
2014-06-04 03:04:05 +07:00
|
|
|
|
2017-06-06 19:24:58 +07:00
|
|
|
int tb_switch_find_vse_cap(struct tb_switch *sw, enum tb_switch_vse_cap vsec);
|
2019-12-17 19:33:42 +07:00
|
|
|
int tb_switch_find_cap(struct tb_switch *sw, enum tb_switch_cap cap);
|
2017-06-06 19:24:58 +07:00
|
|
|
int tb_port_find_cap(struct tb_port *port, enum tb_port_cap cap);
|
2017-10-12 20:45:50 +07:00
|
|
|
bool tb_port_is_enabled(struct tb_port *port);
|
2014-06-04 03:04:03 +07:00
|
|
|
|
2019-12-17 19:33:44 +07:00
|
|
|
bool tb_usb3_port_is_enabled(struct tb_port *port);
|
|
|
|
int tb_usb3_port_enable(struct tb_port *port, bool enable);
|
|
|
|
|
2017-02-20 04:43:26 +07:00
|
|
|
bool tb_pci_port_is_enabled(struct tb_port *port);
|
2017-02-19 18:48:29 +07:00
|
|
|
int tb_pci_port_enable(struct tb_port *port, bool enable);
|
|
|
|
|
2018-09-17 20:30:49 +07:00
|
|
|
int tb_dp_port_hpd_is_active(struct tb_port *port);
|
|
|
|
int tb_dp_port_hpd_clear(struct tb_port *port);
|
|
|
|
int tb_dp_port_set_hops(struct tb_port *port, unsigned int video,
|
|
|
|
unsigned int aux_tx, unsigned int aux_rx);
|
|
|
|
bool tb_dp_port_is_enabled(struct tb_port *port);
|
|
|
|
int tb_dp_port_enable(struct tb_port *port, bool enable);
|
|
|
|
|
2017-02-20 04:43:26 +07:00
|
|
|
struct tb_path *tb_path_discover(struct tb_port *src, int src_hopid,
|
|
|
|
struct tb_port *dst, int dst_hopid,
|
|
|
|
struct tb_port **last, const char *name);
|
2017-02-20 03:11:41 +07:00
|
|
|
struct tb_path *tb_path_alloc(struct tb *tb, struct tb_port *src, int src_hopid,
|
|
|
|
struct tb_port *dst, int dst_hopid, int link_nr,
|
|
|
|
const char *name);
|
2014-06-04 03:04:07 +07:00
|
|
|
void tb_path_free(struct tb_path *path);
|
|
|
|
int tb_path_activate(struct tb_path *path);
|
|
|
|
void tb_path_deactivate(struct tb_path *path);
|
|
|
|
bool tb_path_is_invalid(struct tb_path *path);
|
2019-03-26 20:03:48 +07:00
|
|
|
bool tb_path_switch_on_path(const struct tb_path *path,
|
|
|
|
const struct tb_switch *sw);
|
2014-06-04 03:04:07 +07:00
|
|
|
|
2014-06-13 04:11:46 +07:00
|
|
|
int tb_drom_read(struct tb_switch *sw);
|
|
|
|
int tb_drom_read_uid_only(struct tb_switch *sw, u64 *uid);
|
2014-06-04 03:04:11 +07:00
|
|
|
|
2019-01-09 21:42:12 +07:00
|
|
|
int tb_lc_read_uuid(struct tb_switch *sw, u32 *uuid);
|
2018-10-11 16:33:08 +07:00
|
|
|
int tb_lc_configure_link(struct tb_switch *sw);
|
|
|
|
void tb_lc_unconfigure_link(struct tb_switch *sw);
|
2019-01-09 22:25:43 +07:00
|
|
|
int tb_lc_set_sleep(struct tb_switch *sw);
|
2019-03-22 00:03:00 +07:00
|
|
|
bool tb_lc_lane_bonding_possible(struct tb_switch *sw);
|
2019-03-26 19:52:30 +07:00
|
|
|
bool tb_lc_dp_sink_query(struct tb_switch *sw, struct tb_port *in);
|
|
|
|
int tb_lc_dp_sink_alloc(struct tb_switch *sw, struct tb_port *in);
|
|
|
|
int tb_lc_dp_sink_dealloc(struct tb_switch *sw, struct tb_port *in);
|
2014-06-04 03:04:02 +07:00
|
|
|
|
|
|
|
static inline int tb_route_length(u64 route)
|
|
|
|
{
|
|
|
|
return (fls64(route) + TB_ROUTE_SHIFT - 1) / TB_ROUTE_SHIFT;
|
|
|
|
}
|
|
|
|
|
2014-06-04 03:04:05 +07:00
|
|
|
/**
|
|
|
|
* tb_downstream_route() - get route to downstream switch
|
|
|
|
*
|
|
|
|
* Port must not be the upstream port (otherwise a loop is created).
|
|
|
|
*
|
|
|
|
* Return: Returns a route to the switch behind @port.
|
|
|
|
*/
|
|
|
|
static inline u64 tb_downstream_route(struct tb_port *port)
|
|
|
|
{
|
|
|
|
return tb_route(port->sw)
|
|
|
|
| ((u64) port->port << (port->sw->config.depth * 8));
|
|
|
|
}
|
|
|
|
|
2017-10-02 17:38:34 +07:00
|
|
|
bool tb_xdomain_handle_request(struct tb *tb, enum tb_cfg_pkg_type type,
|
|
|
|
const void *buf, size_t size);
|
|
|
|
struct tb_xdomain *tb_xdomain_alloc(struct tb *tb, struct device *parent,
|
|
|
|
u64 route, const uuid_t *local_uuid,
|
|
|
|
const uuid_t *remote_uuid);
|
|
|
|
void tb_xdomain_add(struct tb_xdomain *xd);
|
|
|
|
void tb_xdomain_remove(struct tb_xdomain *xd);
|
|
|
|
struct tb_xdomain *tb_xdomain_find_by_link_depth(struct tb *tb, u8 link,
|
|
|
|
u8 depth);
|
|
|
|
|
2019-12-17 19:33:40 +07:00
|
|
|
int usb4_switch_setup(struct tb_switch *sw);
|
|
|
|
int usb4_switch_read_uid(struct tb_switch *sw, u64 *uid);
|
|
|
|
int usb4_switch_drom_read(struct tb_switch *sw, unsigned int address, void *buf,
|
|
|
|
size_t size);
|
|
|
|
int usb4_switch_configure_link(struct tb_switch *sw);
|
|
|
|
void usb4_switch_unconfigure_link(struct tb_switch *sw);
|
|
|
|
bool usb4_switch_lane_bonding_possible(struct tb_switch *sw);
|
|
|
|
int usb4_switch_set_sleep(struct tb_switch *sw);
|
|
|
|
int usb4_switch_nvm_sector_size(struct tb_switch *sw);
|
|
|
|
int usb4_switch_nvm_read(struct tb_switch *sw, unsigned int address, void *buf,
|
|
|
|
size_t size);
|
|
|
|
int usb4_switch_nvm_write(struct tb_switch *sw, unsigned int address,
|
|
|
|
const void *buf, size_t size);
|
|
|
|
int usb4_switch_nvm_authenticate(struct tb_switch *sw);
|
|
|
|
bool usb4_switch_query_dp_resource(struct tb_switch *sw, struct tb_port *in);
|
|
|
|
int usb4_switch_alloc_dp_resource(struct tb_switch *sw, struct tb_port *in);
|
|
|
|
int usb4_switch_dealloc_dp_resource(struct tb_switch *sw, struct tb_port *in);
|
|
|
|
struct tb_port *usb4_switch_map_pcie_down(struct tb_switch *sw,
|
|
|
|
const struct tb_port *port);
|
2019-12-17 19:33:44 +07:00
|
|
|
struct tb_port *usb4_switch_map_usb3_down(struct tb_switch *sw,
|
|
|
|
const struct tb_port *port);
|
2019-12-17 19:33:40 +07:00
|
|
|
|
|
|
|
int usb4_port_unlock(struct tb_port *port);
|
2014-06-04 03:04:00 +07:00
|
|
|
#endif
|