d/freebsd-skq
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
c47514db10
freebsd-skq/sys/dev/ixl/ixl_iw.c
Marius Strobl b97de13ae0 - Stop iflib(4) from leaking MSI messages on detachment by calling 
bus_teardown_intr(9) before pci_release_msi(9).
- Ensure that iflib(4) and associated drivers pass correct RIDs to
  bus_release_resource(9) by obtaining the RIDs via rman_get_rid(9)
  on the corresponding resources instead of using the RIDs initially
  passed to bus_alloc_resource_any(9) as the latter function may
  change those RIDs. Solely em(4) for the ioport resource (but not
  others) and bnxt(4) were using the correct RIDs by caching the ones
  returned by bus_alloc_resource_any(9).
- Change the logic of iflib_msix_init() around to only map the MSI-X
  BAR if MSI-X is actually supported, i. e. pci_msix_count(9) returns
  > 0. Otherwise the "Unable to map MSIX table " message triggers for
  devices that simply don't support MSI-X and the user may think that
  something is wrong while in fact everything works as expected.
- Put some (mostly redundant) debug messages emitted by iflib(4)
  and em(4) during attachment under bootverbose. The non-verbose
  output of em(4) seen during attachment now is close to the one
  prior to the conversion to iflib(4).
- Replace various variants of spelling "MSI-X" (several in messages)
  with "MSI-X" as used in the PCI specifications.
- Remove some trailing whitespace from messages emitted by iflib(4)
  and change them to consistently start with uppercase.
- Remove some obsolete comments about releasing interrupts from
  drivers and correct a few others.

Reviewed by:	erj, Jacob Keller, shurd
Differential Revision:	https://reviews.freebsd.org/D18980
2019-01-30 13:21:26 +00:00

491 lines
12 KiB
C
Raw Blame History

/******************************************************************************
Copyright (c) 2013-2018, Intel Corporation
All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:
1. Redistributions of source code must retain the above copyright notice,
this list of conditions and the following disclaimer.
2. Redistributions in binary form must reproduce the above copyright
notice, this list of conditions and the following disclaimer in the
documentation and/or other materials provided with the distribution.
3. Neither the name of the Intel Corporation nor the names of its
contributors may be used to endorse or promote products derived from
this software without specific prior written permission.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
POSSIBILITY OF SUCH DAMAGE.
******************************************************************************/
/*$FreeBSD$*/
#include "ixl.h"
#include "ixl_pf.h"
#include "ixl_iw.h"
#include "ixl_iw_int.h"
#ifdef IXL_IW
#define IXL_IW_VEC_BASE(pf) ((pf)->msix - (pf)->iw_msix)
#define IXL_IW_VEC_COUNT(pf) ((pf)->iw_msix)
#define IXL_IW_VEC_LIMIT(pf) ((pf)->msix)
extern int ixl_enable_iwarp;
static struct ixl_iw_state ixl_iw;
static int ixl_iw_ref_cnt;
static void
ixl_iw_pf_msix_reset(struct ixl_pf *pf)
{
struct i40e_hw *hw = &pf->hw;
u32 reg;
int vec;
for (vec = IXL_IW_VEC_BASE(pf); vec < IXL_IW_VEC_LIMIT(pf); vec++) {
reg = I40E_PFINT_LNKLSTN_FIRSTQ_INDX_MASK;
wr32(hw, I40E_PFINT_LNKLSTN(vec - 1), reg);
}
return;
}
static void
ixl_iw_invoke_op(void *context, int pending)
{
struct ixl_iw_pf_entry *pf_entry = (struct ixl_iw_pf_entry *)context;
struct ixl_iw_pf info;
bool initialize;
int err;
INIT_DEBUGOUT("begin");
mtx_lock(&ixl_iw.mtx);
if ((pf_entry->state.iw_scheduled == IXL_IW_PF_STATE_ON) &&
(pf_entry->state.iw_current == IXL_IW_PF_STATE_OFF))
initialize = true;
else if ((pf_entry->state.iw_scheduled == IXL_IW_PF_STATE_OFF) &&
(pf_entry->state.iw_current == IXL_IW_PF_STATE_ON))
initialize = false;
else {
/* nothing to be done, so finish here */
mtx_unlock(&ixl_iw.mtx);
return;
}
info = pf_entry->pf_info;
mtx_unlock(&ixl_iw.mtx);
if (initialize) {
err = ixl_iw.ops->init(&info);
if (err)
device_printf(pf_entry->pf->dev,
"%s: failed to initialize iwarp (err %d)\n",
__func__, err);
else
pf_entry->state.iw_current = IXL_IW_PF_STATE_ON;
} else {
err = ixl_iw.ops->stop(&info);
if (err)
device_printf(pf_entry->pf->dev,
"%s: failed to stop iwarp (err %d)\n",
__func__, err);
else {
ixl_iw_pf_msix_reset(pf_entry->pf);
pf_entry->state.iw_current = IXL_IW_PF_STATE_OFF;
}
}
return;
}
static void
ixl_iw_uninit(void)
{
INIT_DEBUGOUT("begin");
mtx_destroy(&ixl_iw.mtx);
return;
}
static void
ixl_iw_init(void)
{
INIT_DEBUGOUT("begin");
LIST_INIT(&ixl_iw.pfs);
mtx_init(&ixl_iw.mtx, "ixl_iw_pfs", NULL, MTX_DEF);
ixl_iw.registered = false;
return;
}
/******************************************************************************
* if_ixl internal API
*****************************************************************************/
int
ixl_iw_pf_init(struct ixl_pf *pf)
{
struct ixl_iw_pf_entry *pf_entry;
struct ixl_iw_pf *pf_info;
int err = 0;
INIT_DEBUGOUT("begin");
mtx_lock(&ixl_iw.mtx);
LIST_FOREACH(pf_entry, &ixl_iw.pfs, node)
if (pf_entry->pf == pf)
break;
if (pf_entry == NULL) {
/* attempt to initialize PF not yet attached - sth is wrong */
device_printf(pf->dev, "%s: PF not found\n", __func__);
err = ENOENT;
goto out;
}
pf_info = &pf_entry->pf_info;
pf_info->handle = (void *)pf;
pf_info->ifp = pf->vsi.ifp;
pf_info->dev = pf->dev;
pf_info->pci_mem = pf->pci_mem;
pf_info->pf_id = pf->hw.pf_id;
pf_info->mtu = pf->vsi.ifp->if_mtu;
pf_info->iw_msix.count = IXL_IW_VEC_COUNT(pf);
pf_info->iw_msix.base = IXL_IW_VEC_BASE(pf);
for (int i = 0; i < IXL_IW_MAX_USER_PRIORITY; i++)
pf_info->qs_handle[i] = le16_to_cpu(pf->vsi.info.qs_handle[0]);
pf_entry->state.pf = IXL_IW_PF_STATE_ON;
if (ixl_iw.registered) {
pf_entry->state.iw_scheduled = IXL_IW_PF_STATE_ON;
taskqueue_enqueue(ixl_iw.tq, &pf_entry->iw_task);
}
out:
mtx_unlock(&ixl_iw.mtx);
return (err);
}
void
ixl_iw_pf_stop(struct ixl_pf *pf)
{
struct ixl_iw_pf_entry *pf_entry;
INIT_DEBUGOUT("begin");
mtx_lock(&ixl_iw.mtx);
LIST_FOREACH(pf_entry, &ixl_iw.pfs, node)
if (pf_entry->pf == pf)
break;
if (pf_entry == NULL) {
/* attempt to stop PF which has not been attached - sth is wrong */
device_printf(pf->dev, "%s: PF not found\n", __func__);
goto out;
}
pf_entry->state.pf = IXL_IW_PF_STATE_OFF;
if (pf_entry->state.iw_scheduled == IXL_IW_PF_STATE_ON) {
pf_entry->state.iw_scheduled = IXL_IW_PF_STATE_OFF;
if (ixl_iw.registered)
taskqueue_enqueue(ixl_iw.tq, &pf_entry->iw_task);
}
out:
mtx_unlock(&ixl_iw.mtx);
return;
}
int
ixl_iw_pf_attach(struct ixl_pf *pf)
{
struct ixl_iw_pf_entry *pf_entry;
int err = 0;
INIT_DEBUGOUT("begin");
if (ixl_iw_ref_cnt == 0)
ixl_iw_init();
mtx_lock(&ixl_iw.mtx);
LIST_FOREACH(pf_entry, &ixl_iw.pfs, node)
if (pf_entry->pf == pf) {
device_printf(pf->dev, "%s: PF already exists\n",
__func__);
err = EEXIST;
goto out;
}
pf_entry = malloc(sizeof(struct ixl_iw_pf_entry),
M_DEVBUF, M_NOWAIT | M_ZERO);
if (pf_entry == NULL) {
device_printf(pf->dev,
"%s: failed to allocate memory to attach new PF\n",
__func__);
err = ENOMEM;
goto out;
}
pf_entry->pf = pf;
pf_entry->state.pf = IXL_IW_PF_STATE_OFF;
pf_entry->state.iw_scheduled = IXL_IW_PF_STATE_OFF;
pf_entry->state.iw_current = IXL_IW_PF_STATE_OFF;
LIST_INSERT_HEAD(&ixl_iw.pfs, pf_entry, node);
ixl_iw_ref_cnt++;
TASK_INIT(&pf_entry->iw_task, 0, ixl_iw_invoke_op, pf_entry);
out:
mtx_unlock(&ixl_iw.mtx);
return (err);
}
int
ixl_iw_pf_detach(struct ixl_pf *pf)
{
struct ixl_iw_pf_entry *pf_entry;
int err = 0;
INIT_DEBUGOUT("begin");
mtx_lock(&ixl_iw.mtx);
LIST_FOREACH(pf_entry, &ixl_iw.pfs, node)
if (pf_entry->pf == pf)
break;
if (pf_entry == NULL) {
/* attempt to stop PF which has not been attached - sth is wrong */
device_printf(pf->dev, "%s: PF not found\n", __func__);
err = ENOENT;
goto out;
}
if (pf_entry->state.pf != IXL_IW_PF_STATE_OFF) {
/* attempt to detach PF which has not yet been stopped - sth is wrong */
device_printf(pf->dev, "%s: failed - PF is still active\n",
__func__);
err = EBUSY;
goto out;
}
LIST_REMOVE(pf_entry, node);
free(pf_entry, M_DEVBUF);
ixl_iw_ref_cnt--;
out:
mtx_unlock(&ixl_iw.mtx);
if (ixl_iw_ref_cnt == 0)
ixl_iw_uninit();
return (err);
}
/******************************************************************************
* API exposed to iw_ixl module
*****************************************************************************/
int
ixl_iw_pf_reset(void *pf_handle)
{
struct ixl_pf *pf = (struct ixl_pf *)pf_handle;
INIT_DEBUGOUT("begin");
IXL_PF_LOCK(pf);
ixl_init_locked(pf);
IXL_PF_UNLOCK(pf);
return (0);
}
int
ixl_iw_pf_msix_init(void *pf_handle,
struct ixl_iw_msix_mapping *msix_info)
{
struct ixl_pf *pf = (struct ixl_pf *)pf_handle;
struct i40e_hw *hw = &pf->hw;
u32 reg;
int vec, i;
INIT_DEBUGOUT("begin");
if ((msix_info->aeq_vector < IXL_IW_VEC_BASE(pf)) ||
(msix_info->aeq_vector >= IXL_IW_VEC_LIMIT(pf))) {
printf("%s: invalid MSI-X vector (%i) for AEQ\n",
__func__, msix_info->aeq_vector);
return (EINVAL);
}
reg = I40E_PFINT_AEQCTL_CAUSE_ENA_MASK |
(msix_info->aeq_vector << I40E_PFINT_AEQCTL_MSIX_INDX_SHIFT) |
(msix_info->itr_indx << I40E_PFINT_AEQCTL_ITR_INDX_SHIFT);
wr32(hw, I40E_PFINT_AEQCTL, reg);
for (vec = IXL_IW_VEC_BASE(pf); vec < IXL_IW_VEC_LIMIT(pf); vec++) {
for (i = 0; i < msix_info->ceq_cnt; i++)
if (msix_info->ceq_vector[i] == vec)
break;
if (i == msix_info->ceq_cnt) {
/* this vector has no CEQ mapped */
reg = I40E_PFINT_LNKLSTN_FIRSTQ_INDX_MASK;
wr32(hw, I40E_PFINT_LNKLSTN(vec - 1), reg);
} else {
reg = (i & I40E_PFINT_LNKLSTN_FIRSTQ_INDX_MASK) |
(I40E_QUEUE_TYPE_PE_CEQ <<
I40E_PFINT_LNKLSTN_FIRSTQ_TYPE_SHIFT);
wr32(hw, I40E_PFINT_LNKLSTN(vec - 1), reg);
reg = I40E_PFINT_CEQCTL_CAUSE_ENA_MASK |
(vec << I40E_PFINT_CEQCTL_MSIX_INDX_SHIFT) |
(msix_info->itr_indx <<
I40E_PFINT_CEQCTL_ITR_INDX_SHIFT) |
(IXL_QUEUE_EOL <<
I40E_PFINT_CEQCTL_NEXTQ_INDX_SHIFT);
wr32(hw, I40E_PFINT_CEQCTL(i), reg);
}
}
return (0);
}
int
ixl_iw_register(struct ixl_iw_ops *ops)
{
struct ixl_iw_pf_entry *pf_entry;
int err = 0;
int iwarp_cap_on_pfs = 0;
INIT_DEBUGOUT("begin");
LIST_FOREACH(pf_entry, &ixl_iw.pfs, node)
iwarp_cap_on_pfs += pf_entry->pf->hw.func_caps.iwarp;
if (!iwarp_cap_on_pfs && ixl_enable_iwarp) {
printf("%s: the device is not iwarp-capable, registering dropped\n",
__func__);
return (ENODEV);
}
if (ixl_enable_iwarp == 0) {
printf("%s: enable_iwarp is off, registering dropped\n",
__func__);
return (EACCES);
}
if ((ops->init == NULL) || (ops->stop == NULL)) {
printf("%s: invalid iwarp driver ops\n", __func__);
return (EINVAL);
}
mtx_lock(&ixl_iw.mtx);
if (ixl_iw.registered) {
printf("%s: iwarp driver already registered\n", __func__);
err = (EBUSY);
goto out;
}
ixl_iw.registered = true;
mtx_unlock(&ixl_iw.mtx);
ixl_iw.tq = taskqueue_create("ixl_iw", M_NOWAIT,
taskqueue_thread_enqueue, &ixl_iw.tq);
if (ixl_iw.tq == NULL) {
printf("%s: failed to create queue\n", __func__);
ixl_iw.registered = false;
return (ENOMEM);
}
taskqueue_start_threads(&ixl_iw.tq, 1, PI_NET, "ixl iw");
ixl_iw.ops = malloc(sizeof(struct ixl_iw_ops),
M_DEVBUF, M_NOWAIT | M_ZERO);
if (ixl_iw.ops == NULL) {
printf("%s: failed to allocate memory\n", __func__);
taskqueue_free(ixl_iw.tq);
ixl_iw.registered = false;
return (ENOMEM);
}
ixl_iw.ops->init = ops->init;
ixl_iw.ops->stop = ops->stop;
mtx_lock(&ixl_iw.mtx);
LIST_FOREACH(pf_entry, &ixl_iw.pfs, node)
if (pf_entry->state.pf == IXL_IW_PF_STATE_ON) {
pf_entry->state.iw_scheduled = IXL_IW_PF_STATE_ON;
taskqueue_enqueue(ixl_iw.tq, &pf_entry->iw_task);
}
out:
mtx_unlock(&ixl_iw.mtx);
return (err);
}
int
ixl_iw_unregister(void)
{
struct ixl_iw_pf_entry *pf_entry;
int iwarp_cap_on_pfs = 0;
INIT_DEBUGOUT("begin");
LIST_FOREACH(pf_entry, &ixl_iw.pfs, node)
iwarp_cap_on_pfs += pf_entry->pf->hw.func_caps.iwarp;
if (!iwarp_cap_on_pfs && ixl_enable_iwarp) {
printf("%s: attempt to unregister driver when no iwarp-capable device present\n",
__func__);
return (ENODEV);
}
if (ixl_enable_iwarp == 0) {
printf("%s: attempt to unregister driver when enable_iwarp is off\n",
__func__);
return (ENODEV);
}
mtx_lock(&ixl_iw.mtx);
if (!ixl_iw.registered) {
printf("%s: failed - iwarp driver has not been registered\n",
__func__);
mtx_unlock(&ixl_iw.mtx);
return (ENOENT);
}
LIST_FOREACH(pf_entry, &ixl_iw.pfs, node)
if (pf_entry->state.iw_scheduled == IXL_IW_PF_STATE_ON) {
pf_entry->state.iw_scheduled = IXL_IW_PF_STATE_OFF;
taskqueue_enqueue(ixl_iw.tq, &pf_entry->iw_task);
}
ixl_iw.registered = false;
mtx_unlock(&ixl_iw.mtx);
LIST_FOREACH(pf_entry, &ixl_iw.pfs, node)
taskqueue_drain(ixl_iw.tq, &pf_entry->iw_task);
taskqueue_free(ixl_iw.tq);
ixl_iw.tq = NULL;
free(ixl_iw.ops, M_DEVBUF);
ixl_iw.ops = NULL;
return (0);
}
#endif /* IXL_IW */
Reference in New Issue View Git Blame Copy Permalink