mirror of https://github.com/Qortal/Brooklyn
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
243 lines
5.5 KiB
243 lines
5.5 KiB
// SPDX-License-Identifier: GPL-2.0 |
|
/* |
|
* Thunderbolt driver - capabilities lookup |
|
* |
|
* Copyright (c) 2014 Andreas Noever <[email protected]> |
|
* Copyright (C) 2018, Intel Corporation |
|
*/ |
|
|
|
#include <linux/slab.h> |
|
#include <linux/errno.h> |
|
|
|
#include "tb.h" |
|
|
|
#define CAP_OFFSET_MAX 0xff |
|
#define VSE_CAP_OFFSET_MAX 0xffff |
|
#define TMU_ACCESS_EN BIT(20) |
|
|
|
static int tb_port_enable_tmu(struct tb_port *port, bool enable) |
|
{ |
|
struct tb_switch *sw = port->sw; |
|
u32 value, offset; |
|
int ret; |
|
|
|
/* |
|
* Legacy devices need to have TMU access enabled before port |
|
* space can be fully accessed. |
|
*/ |
|
if (tb_switch_is_light_ridge(sw)) |
|
offset = 0x26; |
|
else if (tb_switch_is_eagle_ridge(sw)) |
|
offset = 0x2a; |
|
else |
|
return 0; |
|
|
|
ret = tb_sw_read(sw, &value, TB_CFG_SWITCH, offset, 1); |
|
if (ret) |
|
return ret; |
|
|
|
if (enable) |
|
value |= TMU_ACCESS_EN; |
|
else |
|
value &= ~TMU_ACCESS_EN; |
|
|
|
return tb_sw_write(sw, &value, TB_CFG_SWITCH, offset, 1); |
|
} |
|
|
|
static void tb_port_dummy_read(struct tb_port *port) |
|
{ |
|
/* |
|
* When reading from next capability pointer location in port |
|
* config space the read data is not cleared on LR. To avoid |
|
* reading stale data on next read perform one dummy read after |
|
* port capabilities are walked. |
|
*/ |
|
if (tb_switch_is_light_ridge(port->sw)) { |
|
u32 dummy; |
|
|
|
tb_port_read(port, &dummy, TB_CFG_PORT, 0, 1); |
|
} |
|
} |
|
|
|
/** |
|
* tb_port_next_cap() - Return next capability in the linked list |
|
* @port: Port to find the capability for |
|
* @offset: Previous capability offset (%0 for start) |
|
* |
|
* Returns dword offset of the next capability in port config space |
|
* capability list and returns it. Passing %0 returns the first entry in |
|
* the capability list. If no next capability is found returns %0. In case |
|
* of failure returns negative errno. |
|
*/ |
|
int tb_port_next_cap(struct tb_port *port, unsigned int offset) |
|
{ |
|
struct tb_cap_any header; |
|
int ret; |
|
|
|
if (!offset) |
|
return port->config.first_cap_offset; |
|
|
|
ret = tb_port_read(port, &header, TB_CFG_PORT, offset, 1); |
|
if (ret) |
|
return ret; |
|
|
|
return header.basic.next; |
|
} |
|
|
|
static int __tb_port_find_cap(struct tb_port *port, enum tb_port_cap cap) |
|
{ |
|
int offset = 0; |
|
|
|
do { |
|
struct tb_cap_any header; |
|
int ret; |
|
|
|
offset = tb_port_next_cap(port, offset); |
|
if (offset < 0) |
|
return offset; |
|
|
|
ret = tb_port_read(port, &header, TB_CFG_PORT, offset, 1); |
|
if (ret) |
|
return ret; |
|
|
|
if (header.basic.cap == cap) |
|
return offset; |
|
} while (offset > 0); |
|
|
|
return -ENOENT; |
|
} |
|
|
|
/** |
|
* tb_port_find_cap() - Find port capability |
|
* @port: Port to find the capability for |
|
* @cap: Capability to look |
|
* |
|
* Returns offset to start of capability or %-ENOENT if no such |
|
* capability was found. Negative errno is returned if there was an |
|
* error. |
|
*/ |
|
int tb_port_find_cap(struct tb_port *port, enum tb_port_cap cap) |
|
{ |
|
int ret; |
|
|
|
ret = tb_port_enable_tmu(port, true); |
|
if (ret) |
|
return ret; |
|
|
|
ret = __tb_port_find_cap(port, cap); |
|
|
|
tb_port_dummy_read(port); |
|
tb_port_enable_tmu(port, false); |
|
|
|
return ret; |
|
} |
|
|
|
/** |
|
* tb_switch_next_cap() - Return next capability in the linked list |
|
* @sw: Switch to find the capability for |
|
* @offset: Previous capability offset (%0 for start) |
|
* |
|
* Finds dword offset of the next capability in router config space |
|
* capability list and returns it. Passing %0 returns the first entry in |
|
* the capability list. If no next capability is found returns %0. In case |
|
* of failure returns negative errno. |
|
*/ |
|
int tb_switch_next_cap(struct tb_switch *sw, unsigned int offset) |
|
{ |
|
struct tb_cap_any header; |
|
int ret; |
|
|
|
if (!offset) |
|
return sw->config.first_cap_offset; |
|
|
|
ret = tb_sw_read(sw, &header, TB_CFG_SWITCH, offset, 2); |
|
if (ret) |
|
return ret; |
|
|
|
switch (header.basic.cap) { |
|
case TB_SWITCH_CAP_TMU: |
|
ret = header.basic.next; |
|
break; |
|
|
|
case TB_SWITCH_CAP_VSE: |
|
if (!header.extended_short.length) |
|
ret = header.extended_long.next; |
|
else |
|
ret = header.extended_short.next; |
|
break; |
|
|
|
default: |
|
tb_sw_dbg(sw, "unknown capability %#x at %#x\n", |
|
header.basic.cap, offset); |
|
ret = -EINVAL; |
|
break; |
|
} |
|
|
|
return ret >= VSE_CAP_OFFSET_MAX ? 0 : ret; |
|
} |
|
|
|
/** |
|
* tb_switch_find_cap() - Find switch capability |
|
* @sw: Switch to find the capability for |
|
* @cap: Capability to look |
|
* |
|
* Returns offset to start of capability or %-ENOENT if no such |
|
* capability was found. Negative errno is returned if there was an |
|
* error. |
|
*/ |
|
int tb_switch_find_cap(struct tb_switch *sw, enum tb_switch_cap cap) |
|
{ |
|
int offset = 0; |
|
|
|
do { |
|
struct tb_cap_any header; |
|
int ret; |
|
|
|
offset = tb_switch_next_cap(sw, offset); |
|
if (offset < 0) |
|
return offset; |
|
|
|
ret = tb_sw_read(sw, &header, TB_CFG_SWITCH, offset, 1); |
|
if (ret) |
|
return ret; |
|
|
|
if (header.basic.cap == cap) |
|
return offset; |
|
} while (offset); |
|
|
|
return -ENOENT; |
|
} |
|
|
|
/** |
|
* tb_switch_find_vse_cap() - Find switch vendor specific capability |
|
* @sw: Switch to find the capability for |
|
* @vsec: Vendor specific capability to look |
|
* |
|
* Functions enumerates vendor specific capabilities (VSEC) of a switch |
|
* and returns offset when capability matching @vsec is found. If no |
|
* such capability is found returns %-ENOENT. In case of error returns |
|
* negative errno. |
|
*/ |
|
int tb_switch_find_vse_cap(struct tb_switch *sw, enum tb_switch_vse_cap vsec) |
|
{ |
|
int offset = 0; |
|
|
|
do { |
|
struct tb_cap_any header; |
|
int ret; |
|
|
|
offset = tb_switch_next_cap(sw, offset); |
|
if (offset < 0) |
|
return offset; |
|
|
|
ret = tb_sw_read(sw, &header, TB_CFG_SWITCH, offset, 1); |
|
if (ret) |
|
return ret; |
|
|
|
if (header.extended_short.cap == TB_SWITCH_CAP_VSE && |
|
header.extended_short.vsec_id == vsec) |
|
return offset; |
|
} while (offset); |
|
|
|
return -ENOENT; |
|
}
|
|
|