mirror of
https://git.kernel.org/pub/scm/linux/kernel/git/stable/linux.git
synced 2024-08-21 08:19:28 +00:00
![Lee Jones](/assets/img/avatar_default.png)
Fixes the following W=1 kernel build warning(s): drivers/thunderbolt/cap.c:189: warning: Function parameter or member 'sw' not described in 'tb_switch_find_cap' Cc: Andreas Noever <andreas.noever@gmail.com> Cc: Michael Jamet <michael.jamet@intel.com> Cc: Yehezkel Bernat <YehezkelShB@gmail.com> Cc: linux-usb@vger.kernel.org Signed-off-by: Lee Jones <lee.jones@linaro.org> Signed-off-by: Mika Westerberg <mika.westerberg@linux.intel.com>
243 lines
5.5 KiB
C
243 lines
5.5 KiB
C
// SPDX-License-Identifier: GPL-2.0
|
|
/*
|
|
* Thunderbolt driver - capabilities lookup
|
|
*
|
|
* Copyright (c) 2014 Andreas Noever <andreas.noever@gmail.com>
|
|
* 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;
|
|
}
|