/* SPDX-License-Identifier: BSD-3-Clause */
/* Copyright (c) 2021, 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$*/
/**
* @file iavf_osdep.c
* @brief OS compatibility layer
*
* Contains definitions for various functions used to provide an OS
* independent layer for sharing code between drivers on different operating
* systems.
*/
#include <machine/stdarg.h>
#include "iavf_iflib.h"
/********************************************************************
* Manage DMA'able memory.
*******************************************************************/
/**
* iavf_dmamap_cb - DMA mapping callback function
* @arg: pointer to return the segment address
* @segs: the segments array
* @nseg: number of segments in the array
* @error: error code
*
* Callback used by the bus DMA code to obtain the segment address.
*/
static void
iavf_dmamap_cb(void *arg, bus_dma_segment_t * segs, int nseg __unused,
int error)
{
if (error)
return;
*(bus_addr_t *) arg = segs->ds_addr;
return;
}
/**
* iavf_allocate_virt_mem - Allocate virtual memory
* @hw: hardware structure
* @mem: structure describing the memory allocation
* @size: size of the allocation
*
* OS compatibility function to allocate virtual memory.
*
* @returns zero on success, or a status code on failure.
*/
enum iavf_status
iavf_allocate_virt_mem(struct iavf_hw *hw __unused, struct iavf_virt_mem *mem,
u32 size)
{
mem->va = malloc(size, M_IAVF, M_NOWAIT | M_ZERO);
return(mem->va == NULL);
}
/**
* iavf_free_virt_mem - Free virtual memory
* @hw: hardware structure
* @mem: structure describing the memory to free
*
* OS compatibility function to free virtual memory
*
* @returns zero.
*/
enum iavf_status
iavf_free_virt_mem(struct iavf_hw *hw __unused, struct iavf_virt_mem *mem)
{
free(mem->va, M_IAVF);
mem->va = NULL;
return(0);
}
/**
* iavf_allocate_dma_mem - Allocate DMA memory
* @hw: hardware structure
* @mem: structure describing the memory allocation
* @type: unused type parameter specifying the type of allocation
* @size: size of the allocation
* @alignment: alignment requirements for the allocation
*
* Allocates DMA memory by using bus_dma_tag_create to create a DMA tag, and
* them bus_dmamem_alloc to allocate the associated memory.
*
* @returns zero on success, or a status code on failure.
*/
enum iavf_status
iavf_allocate_dma_mem(struct iavf_hw *hw, struct iavf_dma_mem *mem,
enum iavf_memory_type type __unused, u64 size, u32 alignment)
{
device_t dev = ((struct iavf_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 */
&mem->tag);
if (err != 0) {
device_printf(dev,
"iavf_allocate_dma: bus_dma_tag_create failed, "
"error %u\n", err);
goto fail_0;
}
err = bus_dmamem_alloc(mem->tag, (void **)&mem->va,
BUS_DMA_NOWAIT | BUS_DMA_ZERO, &mem->map);
if (err != 0) {
device_printf(dev,
"iavf_allocate_dma: bus_dmamem_alloc failed, "
"error %u\n", err);
goto fail_1;
}
err = bus_dmamap_load(mem->tag, mem->map, mem->va,
size,
iavf_dmamap_cb,
&mem->pa,
BUS_DMA_NOWAIT);
if (err != 0) {
device_printf(dev,
"iavf_allocate_dma: bus_dmamap_load failed, "
"error %u\n", err);
goto fail_2;
}
mem->nseg = 1;
mem->size = size;
bus_dmamap_sync(mem->tag, mem->map,
BUS_DMASYNC_PREREAD|BUS_DMASYNC_PREWRITE);
return (0);
fail_2:
bus_dmamem_free(mem->tag, mem->va, mem->map);
fail_1:
bus_dma_tag_destroy(mem->tag);
fail_0:
mem->map = NULL;
mem->tag = NULL;
return (err);
}
/**
* iavf_free_dma_mem - Free DMA memory allocation
* @hw: hardware structure
* @mem: pointer to memory structure previously allocated
*
* Releases DMA memory that was previously allocated by iavf_allocate_dma_mem.
*
* @returns zero.
*/
enum iavf_status
iavf_free_dma_mem(struct iavf_hw *hw __unused, struct iavf_dma_mem *mem)
{
bus_dmamap_sync(mem->tag, mem->map,
BUS_DMASYNC_POSTREAD | BUS_DMASYNC_POSTWRITE);
bus_dmamap_unload(mem->tag, mem->map);
bus_dmamem_free(mem->tag, mem->va, mem->map);
bus_dma_tag_destroy(mem->tag);
return (0);
}
/**
* iavf_init_spinlock - Initialize a spinlock
* @lock: OS compatibility lock structure
*
* Use the mutex layer to initialize a spin lock that can be used via the OS
* compatibility layer accessors.
*
* @remark we pass MTX_DUPOK because the mutex name will not be unique. An
* alternative would be to somehow generate a name, such as by passing in the
* __file__ and __line__ values from a macro.
*/
void
iavf_init_spinlock(struct iavf_spinlock *lock)
{
mtx_init(&lock->mutex, "mutex",
"iavf spinlock", MTX_DEF | MTX_DUPOK);
}
/**
* iavf_acquire_spinlock - Acquire a spin lock
* @lock: OS compatibility lock structure
*
* Acquire a spin lock using mtx_lock.
*/
void
iavf_acquire_spinlock(struct iavf_spinlock *lock)
{
mtx_lock(&lock->mutex);
}
/**
* iavf_release_spinlock - Release a spin lock
* @lock: OS compatibility lock structure
*
* Release a spin lock using mtx_unlock.
*/
void
iavf_release_spinlock(struct iavf_spinlock *lock)
{
mtx_unlock(&lock->mutex);
}
/**
* iavf_destroy_spinlock - Destroy a spin lock
* @lock: OS compatibility lock structure
*
* Destroy (deinitialize) a spin lock by calling mtx_destroy.
*
* @remark we only destroy the lock if it was initialized. This means that
* calling iavf_destroy_spinlock on a lock that was already destroyed or was
* never initialized is not considered a bug.
*/
void
iavf_destroy_spinlock(struct iavf_spinlock *lock)
{
if (mtx_initialized(&lock->mutex))
mtx_destroy(&lock->mutex);
}
/**
* iavf_debug_shared - Log a debug message if enabled
* @hw: device hardware structure
* @mask: bit indicating the type of the message
* @fmt: printf format string
*
* Checks if the mask is enabled in the hw->debug_mask. If so, prints
* a message to the console using vprintf().
*/
void
iavf_debug_shared(struct iavf_hw *hw, uint64_t mask, char *fmt, ...)
{
va_list args;
device_t dev;
if (!(mask & ((struct iavf_hw *)hw)->debug_mask))
return;
dev = ((struct iavf_osdep *)hw->back)->dev;
/* Re-implement device_printf() */
device_print_prettyname(dev);
va_start(args, fmt);
vprintf(fmt, args);
va_end(args);
}
/**
* iavf_read_pci_cfg - Read a PCI config register
* @hw: device hardware structure
* @reg: the PCI register to read
*
* Calls pci_read_config to read the given PCI register from the PCI config
* space.
*
* @returns the value of the register.
*/
u16
iavf_read_pci_cfg(struct iavf_hw *hw, u32 reg)
{
u16 value;
value = pci_read_config(((struct iavf_osdep *)hw->back)->dev,
reg, 2);
return (value);
}
/**
* iavf_write_pci_cfg - Write a PCI config register
* @hw: device hardware structure
* @reg: the PCI register to write
* @value: the value to write
*
* Calls pci_write_config to write to a given PCI register in the PCI config
* space.
*/
void
iavf_write_pci_cfg(struct iavf_hw *hw, u32 reg, u16 value)
{
pci_write_config(((struct iavf_osdep *)hw->back)->dev,
reg, value, 2);
return;
}
/**
* iavf_rd32 - Read a 32bit hardware register value
* @hw: the private hardware structure
* @reg: register address to read
*
* Read the specified 32bit register value from BAR0 and return its contents.
*
* @returns the value of the 32bit register.
*/
inline uint32_t
iavf_rd32(struct iavf_hw *hw, uint32_t reg)
{
struct iavf_osdep *osdep = (struct iavf_osdep *)hw->back;
KASSERT(reg < osdep->mem_bus_space_size,
("iavf: register offset %#jx too large (max is %#jx)",
(uintmax_t)reg, (uintmax_t)osdep->mem_bus_space_size));
return (bus_space_read_4(osdep->mem_bus_space_tag,
osdep->mem_bus_space_handle, reg));
}
/**
* iavf_wr32 - Write a 32bit hardware register
* @hw: the private hardware structure
* @reg: the register address to write to
* @val: the 32bit value to write
*
* Write the specified 32bit value to a register address in BAR0.
*/
inline void
iavf_wr32(struct iavf_hw *hw, uint32_t reg, uint32_t val)
{
struct iavf_osdep *osdep = (struct iavf_osdep *)hw->back;
KASSERT(reg < osdep->mem_bus_space_size,
("iavf: register offset %#jx too large (max is %#jx)",
(uintmax_t)reg, (uintmax_t)osdep->mem_bus_space_size));
bus_space_write_4(osdep->mem_bus_space_tag,
osdep->mem_bus_space_handle, reg, val);
}
/**
* iavf_flush - Flush register writes
* @hw: private hardware structure
*
* Forces the completion of outstanding PCI register writes by reading from
* a specific hardware register.
*/
inline void
iavf_flush(struct iavf_hw *hw)
{
struct iavf_osdep *osdep = (struct iavf_osdep *)hw->back;
rd32(hw, osdep->flush_reg);
}
/**
* iavf_debug_core - Debug printf for core driver code
* @dev: the device_t to log under
* @enabled_mask: the mask of enabled messages
* @mask: the mask of the requested message to print
* @fmt: printf format string
*
* If enabled_mask has the bit from the mask set, print a message to the
* console using the specified format. This is used to conditionally enable
* log messages at run time by toggling the enabled_mask in the device
* structure.
*/
void
iavf_debug_core(device_t dev, u32 enabled_mask, u32 mask, char *fmt, ...)
{
va_list args;
if (!(mask & enabled_mask))
return;
/* Re-implement device_printf() */
device_print_prettyname(dev);
va_start(args, fmt);
vprintf(fmt, args);
va_end(args);
}