2014-05-19 01:21:02 +00:00
|
|
|
/******************************************************************************
|
|
|
|
|
2016-05-12 18:18:55 +00:00
|
|
|
Copyright (c) 2013-2015, Intel Corporation
|
2014-05-19 01:21:02 +00:00
|
|
|
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 <machine/stdarg.h>
|
|
|
|
|
2014-08-22 18:59:19 +00:00
|
|
|
#include "ixl.h"
|
2014-05-19 01:21:02 +00:00
|
|
|
|
|
|
|
/********************************************************************
|
|
|
|
* Manage DMA'able memory.
|
|
|
|
*******************************************************************/
|
|
|
|
static void
|
|
|
|
i40e_dmamap_cb(void *arg, bus_dma_segment_t * segs, int nseg, int error)
|
|
|
|
{
|
|
|
|
if (error)
|
|
|
|
return;
|
|
|
|
*(bus_addr_t *) arg = segs->ds_addr;
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
i40e_status
|
2014-09-18 21:13:03 +00:00
|
|
|
i40e_allocate_virt_mem(struct i40e_hw *hw, struct i40e_virt_mem *mem, u32 size)
|
2014-05-19 01:21:02 +00:00
|
|
|
{
|
2014-09-18 08:56:25 +00:00
|
|
|
mem->va = malloc(size, M_DEVBUF, M_NOWAIT | M_ZERO);
|
|
|
|
return(mem->va == NULL);
|
2014-05-19 01:21:02 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
i40e_status
|
2014-09-18 21:13:03 +00:00
|
|
|
i40e_free_virt_mem(struct i40e_hw *hw, struct i40e_virt_mem *mem)
|
2014-05-19 01:21:02 +00:00
|
|
|
{
|
2014-09-18 08:56:25 +00:00
|
|
|
free(mem->va, M_DEVBUF);
|
2014-05-19 01:21:02 +00:00
|
|
|
return(0);
|
|
|
|
}
|
|
|
|
|
|
|
|
i40e_status
|
2014-09-18 21:13:03 +00:00
|
|
|
i40e_allocate_dma_mem(struct i40e_hw *hw, struct i40e_dma_mem *mem,
|
|
|
|
enum i40e_memory_type type __unused, u64 size, u32 alignment)
|
2014-05-19 01:21:02 +00:00
|
|
|
{
|
|
|
|
device_t dev = ((struct i40e_osdep *)hw->back)->dev;
|
|
|
|
int err;
|
|
|
|
|
|
|
|
|
|
|
|
err = bus_dma_tag_create(bus_get_dma_tag(dev), /* parent */
|
|
|
|
alignment, 0, /* alignment, bounds */
|
|
|
|
BUS_SPACE_MAXADDR, /* lowaddr */
|
|
|
|
BUS_SPACE_MAXADDR, /* highaddr */
|
|
|
|
NULL, NULL, /* filter, filterarg */
|
|
|
|
size, /* maxsize */
|
|
|
|
1, /* nsegments */
|
|
|
|
size, /* maxsegsize */
|
|
|
|
BUS_DMA_ALLOCNOW, /* flags */
|
|
|
|
NULL, /* lockfunc */
|
|
|
|
NULL, /* lockfuncarg */
|
2014-09-18 08:56:25 +00:00
|
|
|
&mem->tag);
|
2014-05-19 01:21:02 +00:00
|
|
|
if (err != 0) {
|
|
|
|
device_printf(dev,
|
|
|
|
"i40e_allocate_dma: bus_dma_tag_create failed, "
|
|
|
|
"error %u\n", err);
|
|
|
|
goto fail_0;
|
|
|
|
}
|
2014-09-18 08:56:25 +00:00
|
|
|
err = bus_dmamem_alloc(mem->tag, (void **)&mem->va,
|
|
|
|
BUS_DMA_NOWAIT | BUS_DMA_ZERO, &mem->map);
|
2014-05-19 01:21:02 +00:00
|
|
|
if (err != 0) {
|
|
|
|
device_printf(dev,
|
|
|
|
"i40e_allocate_dma: bus_dmamem_alloc failed, "
|
|
|
|
"error %u\n", err);
|
|
|
|
goto fail_1;
|
|
|
|
}
|
2014-09-18 08:56:25 +00:00
|
|
|
err = bus_dmamap_load(mem->tag, mem->map, mem->va,
|
2014-05-19 01:21:02 +00:00
|
|
|
size,
|
|
|
|
i40e_dmamap_cb,
|
2014-09-18 08:56:25 +00:00
|
|
|
&mem->pa,
|
2014-05-19 01:21:02 +00:00
|
|
|
BUS_DMA_NOWAIT);
|
|
|
|
if (err != 0) {
|
|
|
|
device_printf(dev,
|
|
|
|
"i40e_allocate_dma: bus_dmamap_load failed, "
|
|
|
|
"error %u\n", err);
|
|
|
|
goto fail_2;
|
|
|
|
}
|
2014-11-06 23:45:05 +00:00
|
|
|
mem->nseg = 1;
|
2014-09-18 08:56:25 +00:00
|
|
|
mem->size = size;
|
|
|
|
bus_dmamap_sync(mem->tag, mem->map,
|
2014-05-19 01:21:02 +00:00
|
|
|
BUS_DMASYNC_PREREAD|BUS_DMASYNC_PREWRITE);
|
|
|
|
return (0);
|
|
|
|
fail_2:
|
2014-09-18 08:56:25 +00:00
|
|
|
bus_dmamem_free(mem->tag, mem->va, mem->map);
|
2014-05-19 01:21:02 +00:00
|
|
|
fail_1:
|
2014-09-18 08:56:25 +00:00
|
|
|
bus_dma_tag_destroy(mem->tag);
|
2014-05-19 01:21:02 +00:00
|
|
|
fail_0:
|
2014-09-18 08:56:25 +00:00
|
|
|
mem->map = NULL;
|
|
|
|
mem->tag = NULL;
|
2014-05-19 01:21:02 +00:00
|
|
|
return (err);
|
|
|
|
}
|
|
|
|
|
|
|
|
i40e_status
|
2014-09-18 21:13:03 +00:00
|
|
|
i40e_free_dma_mem(struct i40e_hw *hw, struct i40e_dma_mem *mem)
|
2014-05-19 01:21:02 +00:00
|
|
|
{
|
2014-09-18 08:56:25 +00:00
|
|
|
bus_dmamap_sync(mem->tag, mem->map,
|
2014-05-19 01:21:02 +00:00
|
|
|
BUS_DMASYNC_POSTREAD | BUS_DMASYNC_POSTWRITE);
|
2014-09-18 08:56:25 +00:00
|
|
|
bus_dmamap_unload(mem->tag, mem->map);
|
|
|
|
bus_dmamem_free(mem->tag, mem->va, mem->map);
|
|
|
|
bus_dma_tag_destroy(mem->tag);
|
2014-05-19 01:21:02 +00:00
|
|
|
return (0);
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
i40e_init_spinlock(struct i40e_spinlock *lock)
|
|
|
|
{
|
|
|
|
mtx_init(&lock->mutex, "mutex",
|
|
|
|
MTX_NETWORK_LOCK, MTX_DEF | MTX_DUPOK);
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
i40e_acquire_spinlock(struct i40e_spinlock *lock)
|
|
|
|
{
|
|
|
|
mtx_lock(&lock->mutex);
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
i40e_release_spinlock(struct i40e_spinlock *lock)
|
|
|
|
{
|
|
|
|
mtx_unlock(&lock->mutex);
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
i40e_destroy_spinlock(struct i40e_spinlock *lock)
|
|
|
|
{
|
2016-05-12 18:21:52 +00:00
|
|
|
if (mtx_initialized(&lock->mutex))
|
|
|
|
mtx_destroy(&lock->mutex);
|
2014-05-19 01:21:02 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
2016-05-12 18:21:34 +00:00
|
|
|
* Helper function for debug statement printing
|
|
|
|
*/
|
|
|
|
void
|
|
|
|
i40e_debug_d(struct i40e_hw *hw, enum i40e_debug_mask mask, char *fmt, ...)
|
2014-05-19 01:21:02 +00:00
|
|
|
{
|
2016-05-12 18:21:34 +00:00
|
|
|
va_list args;
|
2014-05-19 01:21:02 +00:00
|
|
|
|
2016-05-12 18:21:34 +00:00
|
|
|
if (!(mask & ((struct i40e_hw *)hw)->debug_mask))
|
|
|
|
return;
|
2014-05-19 01:21:02 +00:00
|
|
|
|
|
|
|
va_start(args, fmt);
|
2016-05-12 18:21:34 +00:00
|
|
|
device_printf(((struct i40e_osdep *)hw->back)->dev, fmt, args);
|
2014-05-19 01:21:02 +00:00
|
|
|
va_end(args);
|
|
|
|
}
|
|
|
|
|
|
|
|
u16
|
|
|
|
i40e_read_pci_cfg(struct i40e_hw *hw, u32 reg)
|
|
|
|
{
|
|
|
|
u16 value;
|
|
|
|
|
|
|
|
value = pci_read_config(((struct i40e_osdep *)hw->back)->dev,
|
|
|
|
reg, 2);
|
|
|
|
|
|
|
|
return (value);
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
i40e_write_pci_cfg(struct i40e_hw *hw, u32 reg, u16 value)
|
|
|
|
{
|
|
|
|
pci_write_config(((struct i40e_osdep *)hw->back)->dev,
|
|
|
|
reg, value, 2);
|
|
|
|
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|