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 17:07:57 +03:00
/* SPDX-License-Identifier: GPL-2.0 */
2014-06-04 00:04:00 +04:00
/*
2018-10-01 12:31:22 +03:00
* Thunderbolt driver - bus logic ( NHI independent )
2014-06-04 00:04:00 +04:00
*
* Copyright ( c ) 2014 Andreas Noever < andreas . noever @ gmail . com >
2018-10-01 12:31:22 +03:00
* Copyright ( C ) 2018 , Intel Corporation
2014-06-04 00:04:00 +04:00
*/
# ifndef TB_H_
# define TB_H_
2017-06-06 15:25:17 +03:00
# include <linux/nvmem-provider.h>
2014-06-04 00:04:02 +04:00
# include <linux/pci.h>
2017-10-02 13:38:34 +03:00
# include <linux/thunderbolt.h>
2017-06-06 15:25:01 +03:00
# include <linux/uuid.h>
2014-06-04 00:04:02 +04:00
# include "tb_regs.h"
2014-06-04 00:04:00 +04:00
# include "ctl.h"
2017-06-06 15:25:14 +03:00
# include "dma_port.h"
2014-06-04 00:04:00 +04:00
2017-06-06 15:25:17 +03: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 15:25:16 +03:00
# define TB_SWITCH_KEY_SIZE 32
2018-12-30 13:14:46 +03:00
# define TB_SWITCH_MAX_DEPTH 6
2017-06-06 15:25:16 +03:00
2014-06-04 00:04:02 +04:00
/**
* struct tb_switch - a thunderbolt switch
2017-06-06 15:25:01 +03:00
* @ dev : Device for the switch
* @ config : Switch configuration
* @ ports : Ports in this switch
2017-06-06 15:25:14 +03:00
* @ dma_port : If the switch has port supporting DMA configuration based
* mailbox this will hold the pointer to that ( % NULL
2017-06-06 15:25:17 +03:00
* otherwise ) . If set it also means the switch has
* upgradeable NVM .
2017-06-06 15:25:01 +03: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 15:25:05 +03:00
* @ vendor_name : Name of the vendor ( or % NULL if not known )
* @ device_name : Name of the device ( or % NULL if not known )
2017-06-06 15:25:13 +03:00
* @ generation : Switch Thunderbolt generation
2017-06-06 15:25:01 +03:00
* @ cap_plug_events : Offset to the plug events capability ( % 0 if not found )
2019-01-09 17:42:12 +03:00
* @ cap_lc : Offset to the link controller capability ( % 0 if not found )
2017-06-06 15:25:01 +03:00
* @ is_unplugged : The switch is going away
* @ drom : DROM of the switch ( % NULL if not found )
2017-06-06 15:25:17 +03: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 13:50:09 +03:00
* @ boot : Whether the switch was already authorized on boot or not
2018-07-25 11:48:39 +03:00
* @ rpm : The switch supports runtime PM
2017-06-06 15:25:16 +03: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 )
*
* When the switch is being added or removed to the domain ( other
2019-03-19 17:48:41 +03:00
* switches ) you need to have domain lock held .
2014-06-04 00:04:02 +04:00
*/
struct tb_switch {
2017-06-06 15:25:01 +03:00
struct device dev ;
2014-06-04 00:04:02 +04:00
struct tb_regs_switch_header config ;
struct tb_port * ports ;
2017-06-06 15:25:14 +03:00
struct tb_dma_port * dma_port ;
2014-06-04 00:04:02 +04:00
struct tb * tb ;
2014-06-04 00:04:11 +04:00
u64 uid ;
2017-07-18 16:30:05 +03:00
uuid_t * uuid ;
2017-06-06 15:25:01 +03:00
u16 vendor ;
u16 device ;
2017-06-06 15:25:05 +03:00
const char * vendor_name ;
const char * device_name ;
2017-06-06 15:25:13 +03:00
unsigned int generation ;
2017-06-06 15:25:01 +03:00
int cap_plug_events ;
2019-01-09 17:42:12 +03:00
int cap_lc ;
2017-06-06 15:25:01 +03:00
bool is_unplugged ;
2014-06-13 01:11:46 +04:00
u8 * drom ;
2017-06-06 15:25:17 +03:00
struct tb_switch_nvm * nvm ;
bool no_nvm_upgrade ;
bool safe_mode ;
2018-01-22 13:50:09 +03:00
bool boot ;
2018-07-25 11:48:39 +03:00
bool rpm ;
2017-06-06 15:25:16 +03:00
unsigned int authorized ;
enum tb_security_level security_level ;
u8 * key ;
u8 connection_id ;
u8 connection_key ;
u8 link ;
u8 depth ;
2014-06-04 00:04:02 +04:00
} ;
/**
* struct tb_port - a thunderbolt port , part of a tb_switch
2017-10-02 13:38:34 +03: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
2017-02-19 11:39:34 +03:00
* @ cap_adap : Offset of the adapter specific capability ( % 0 if not present )
2017-10-02 13:38:34 +03:00
* @ port : Port number on switch
* @ disabled : Disabled by eeprom
* @ 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 .
2014-06-04 00:04:02 +04:00
*/
struct tb_port {
struct tb_regs_port_header config ;
struct tb_switch * sw ;
2017-10-02 13:38:34 +03:00
struct tb_port * remote ;
struct tb_xdomain * xdomain ;
int cap_phy ;
2017-02-19 11:39:34 +03:00
int cap_adap ;
2017-10-02 13:38:34 +03:00
u8 port ;
bool disabled ;
2014-06-13 01:11:46 +04:00
struct tb_port * dual_link_port ;
u8 link_nr : 1 ;
2014-06-04 00:04:02 +04:00
} ;
2014-06-04 00:04:07 +04:00
/**
* struct tb_path_hop - routing information for a tb_path
*
* 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
* next hop to take ( on out_port - > remote ) is determined by next_hop_index .
*
* 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 ;
int in_counter_index ; /* write -1 to disable counters for this hop. */
int next_hop_index ;
} ;
/**
* enum tb_path_port - path options mask
*/
enum tb_path_port {
TB_PATH_NONE = 0 ,
TB_PATH_SOURCE = 1 , /* activate on the first hop (out of src) */
TB_PATH_INTERNAL = 2 , /* activate on other hops (not the first/last) */
TB_PATH_DESTINATION = 4 , /* activate on the last hop (into dst) */
TB_PATH_ALL = 7 ,
} ;
/**
* struct tb_path - a unidirectional path between two ports
*
* A path consists of a number of hops ( see tb_path_hop ) . To establish a PCIe
* tunnel two paths have to be created between the two PCIe ports .
*
*/
struct tb_path {
struct tb * tb ;
int nfc_credits ; /* non flow controlled credits */
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 ;
int priority : 3 ;
int weight : 4 ;
bool drop_packages ;
bool activated ;
struct tb_path_hop * hops ;
int path_length ; /* number of hops */
} ;
2017-06-06 15:25:00 +03:00
/**
* struct tb_cm_ops - Connection manager specific operations vector
2017-06-06 15:25:16 +03:00
* @ driver_ready : Called right after control channel is started . Used by
* ICM to send driver ready message to the firmware .
2017-06-06 15:25:00 +03: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 15:25:16 +03:00
* @ suspend : Connection manager specific suspend
* @ complete : Connection manager specific complete
2018-07-25 11:48:39 +03:00
* @ runtime_suspend : Connection manager specific runtime_suspend
* @ runtime_resume : Connection manager specific runtime_resume
2017-06-06 15:25:09 +03:00
* @ handle_event : Handle thunderbolt event
2018-01-21 13:08:04 +03:00
* @ get_boot_acl : Get boot ACL list
* @ set_boot_acl : Set boot ACL list
2017-06-06 15:25:16 +03:00
* @ approve_switch : Approve switch
* @ add_switch_key : Add key to switch
* @ challenge_switch_key : Challenge switch using key
2017-06-06 15:25:17 +03:00
* @ disconnect_pcie_paths : Disconnects PCIe paths before NVM update
2017-10-02 13:38:34 +03:00
* @ approve_xdomain_paths : Approve ( establish ) XDomain DMA paths
* @ disconnect_xdomain_paths : Disconnect XDomain DMA paths
2017-06-06 15:25:00 +03:00
*/
struct tb_cm_ops {
2017-06-06 15:25:16 +03:00
int ( * driver_ready ) ( struct tb * tb ) ;
2017-06-06 15:25:00 +03: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 15:25:16 +03:00
int ( * suspend ) ( struct tb * tb ) ;
void ( * complete ) ( struct tb * tb ) ;
2018-07-25 11:48:39 +03:00
int ( * runtime_suspend ) ( struct tb * tb ) ;
int ( * runtime_resume ) ( struct tb * tb ) ;
2017-06-06 15:25:09 +03:00
void ( * handle_event ) ( struct tb * tb , enum tb_cfg_pkg_type ,
const void * buf , size_t size ) ;
2018-01-21 13:08:04 +03: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 15:25:16 +03: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 15:25:17 +03:00
int ( * disconnect_pcie_paths ) ( struct tb * tb ) ;
2017-10-02 13:38:34 +03: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 15:25:00 +03:00
} ;
2014-06-04 00:04:07 +04:00
2017-06-06 15:25:00 +03:00
static inline void * tb_priv ( struct tb * tb )
{
return ( void * ) tb - > privdata ;
}
2018-07-25 11:48:39 +03:00
# define TB_AUTOSUSPEND_DELAY 15000 /* ms */
2014-06-04 00:04:02 +04: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 ] ;
}
static inline u64 tb_route ( struct tb_switch * sw )
{
return ( ( u64 ) sw - > config . route_hi ) < < 32 | sw - > config . route_lo ;
}
2017-06-06 15:25:16 +03: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 ] ;
}
2014-06-04 00:04:02 +04: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 18:07:37 +03:00
if ( sw - > is_unplugged )
return - ENODEV ;
2014-06-04 00:04:02 +04:00
return tb_cfg_read ( sw - > tb - > ctl ,
buffer ,
tb_route ( sw ) ,
0 ,
space ,
offset ,
length ) ;
}
static inline int tb_sw_write ( struct tb_switch * sw , void * buffer ,
enum tb_cfg_space space , u32 offset , u32 length )
{
2019-03-19 18:07:37 +03:00
if ( sw - > is_unplugged )
return - ENODEV ;
2014-06-04 00:04:02 +04: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 18:07:37 +03:00
if ( port - > sw - > is_unplugged )
return - ENODEV ;
2014-06-04 00:04:02 +04:00
return tb_cfg_read ( port - > sw - > tb - > ctl ,
buffer ,
tb_route ( port - > sw ) ,
port - > port ,
space ,
offset ,
length ) ;
}
2017-06-06 15:24:53 +03:00
static inline int tb_port_write ( struct tb_port * port , const void * buffer ,
2014-06-04 00:04:02 +04:00
enum tb_cfg_space space , u32 offset , u32 length )
{
2019-03-19 18:07:37 +03:00
if ( port - > sw - > is_unplugged )
return - ENODEV ;
2014-06-04 00:04:02 +04: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 12:31:19 +03:00
# define tb_dbg(tb, fmt, arg...) dev_dbg(&(tb)->nhi->pdev->dev, fmt, ## arg)
2014-06-04 00:04:02 +04:00
# define __TB_SW_PRINT(level, sw, fmt, arg...) \
do { \
struct tb_switch * __sw = ( sw ) ; \
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 12:31:19 +03:00
# define tb_sw_dbg(sw, fmt, arg...) __TB_SW_PRINT(tb_dbg, sw, fmt, ##arg)
2014-06-04 00:04:02 +04:00
# define __TB_PORT_PRINT(level, _port, fmt, arg...) \
do { \
struct tb_port * __port = ( _port ) ; \
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 12:31:19 +03:00
# define tb_port_dbg(port, fmt, arg...) \
__TB_PORT_PRINT ( tb_dbg , port , fmt , # # arg )
2014-06-04 00:04:02 +04:00
2017-06-06 15:25:16 +03:00
struct tb * icm_probe ( struct tb_nhi * nhi ) ;
2017-06-06 15:25:00 +03:00
struct tb * tb_probe ( struct tb_nhi * nhi ) ;
extern struct device_type tb_domain_type ;
2017-06-06 15:25:01 +03:00
extern struct device_type tb_switch_type ;
2017-06-06 15:25:00 +03:00
int tb_domain_init ( void ) ;
void tb_domain_exit ( void ) ;
2017-06-06 15:25:17 +03:00
void tb_switch_exit ( void ) ;
2017-10-02 13:38:34 +03:00
int tb_xdomain_init ( void ) ;
void tb_xdomain_exit ( void ) ;
2014-06-04 00:04:02 +04:00
2017-06-06 15:25:00 +03: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 15:25:16 +03:00
int tb_domain_suspend ( struct tb * tb ) ;
void tb_domain_complete ( struct tb * tb ) ;
2018-07-25 11:48:39 +03:00
int tb_domain_runtime_suspend ( struct tb * tb ) ;
int tb_domain_runtime_resume ( struct tb * tb ) ;
2017-06-06 15:25:16 +03: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 15:25:17 +03:00
int tb_domain_disconnect_pcie_paths ( struct tb * tb ) ;
2017-10-02 13:38:34 +03: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 15:25:00 +03:00
static inline void tb_domain_put ( struct tb * tb )
{
put_device ( & tb - > dev ) ;
}
2014-06-04 00:04:00 +04:00
2017-06-06 15:25:01 +03:00
struct tb_switch * tb_switch_alloc ( struct tb * tb , struct device * parent ,
u64 route ) ;
2017-06-06 15:25:17 +03:00
struct tb_switch * tb_switch_alloc_safe_mode ( struct tb * tb ,
struct device * parent , u64 route ) ;
2017-06-06 15:25:01 +03: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 00:04:12 +04: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 15:57:20 +03:00
void tb_sw_set_unplugged ( struct tb_switch * sw ) ;
2017-06-06 15:25:16 +03:00
struct tb_switch * tb_switch_find_by_link_depth ( struct tb * tb , u8 link ,
u8 depth ) ;
2017-07-18 16:30:05 +03:00
struct tb_switch * tb_switch_find_by_uuid ( struct tb * tb , const uuid_t * uuid ) ;
2017-10-04 15:24:14 +03:00
struct tb_switch * tb_switch_find_by_route ( struct tb * tb , u64 route ) ;
2017-06-06 15:25:16 +03:00
2017-10-04 15:19:20 +03:00
static inline struct tb_switch * tb_switch_get ( struct tb_switch * sw )
{
if ( sw )
get_device ( & sw - > dev ) ;
return sw ;
}
2017-06-06 15:25:01 +03: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 ;
}
2019-01-08 19:55:09 +03:00
static inline bool tb_switch_is_lr ( const struct tb_switch * sw )
{
return sw - > config . device_id = = PCI_DEVICE_ID_INTEL_LIGHT_RIDGE ;
}
static inline bool tb_switch_is_er ( const struct tb_switch * sw )
{
return sw - > config . device_id = = PCI_DEVICE_ID_INTEL_EAGLE_RIDGE ;
}
2014-06-04 00:04:05 +04:00
int tb_wait_for_port ( struct tb_port * port , bool wait_if_unplugged ) ;
2014-06-04 00:04:07 +04:00
int tb_port_add_nfc_credits ( struct tb_port * port , int credits ) ;
int tb_port_clear_counter ( struct tb_port * port , int counter ) ;
2014-06-04 00:04:05 +04:00
2017-06-06 15:24:58 +03:00
int tb_switch_find_vse_cap ( struct tb_switch * sw , enum tb_switch_vse_cap vsec ) ;
int tb_port_find_cap ( struct tb_port * port , enum tb_port_cap cap ) ;
2014-06-04 00:04:03 +04:00
2017-02-19 14:48:29 +03:00
int tb_pci_port_enable ( struct tb_port * port , bool enable ) ;
2014-06-04 00:04:07 +04:00
struct tb_path * tb_path_alloc ( struct tb * tb , int num_hops ) ;
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 ) ;
2014-06-13 01:11:46 +04:00
int tb_drom_read ( struct tb_switch * sw ) ;
int tb_drom_read_uid_only ( struct tb_switch * sw , u64 * uid ) ;
2014-06-04 00:04:11 +04:00
2019-01-09 17:42:12 +03:00
int tb_lc_read_uuid ( struct tb_switch * sw , u32 * uuid ) ;
2018-10-11 12:33:08 +03:00
int tb_lc_configure_link ( struct tb_switch * sw ) ;
void tb_lc_unconfigure_link ( struct tb_switch * sw ) ;
2019-01-09 18:25:43 +03:00
int tb_lc_set_sleep ( struct tb_switch * sw ) ;
2014-06-04 00:04:02 +04:00
static inline int tb_route_length ( u64 route )
{
return ( fls64 ( route ) + TB_ROUTE_SHIFT - 1 ) / TB_ROUTE_SHIFT ;
}
static inline bool tb_is_upstream_port ( struct tb_port * port )
{
return port = = tb_upstream_port ( port - > sw ) ;
}
2014-06-04 00:04:05 +04: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 13:38:34 +03: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 ) ;
2014-06-04 00:04:00 +04:00
# endif