1405 lines
35 KiB
C
1405 lines
35 KiB
C
/*-
|
|
* Copyright (c) 2017 Broadcom. All rights reserved.
|
|
* The term "Broadcom" refers to Broadcom Limited and/or its subsidiaries.
|
|
*
|
|
* 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 copyright holder 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 HOLDER 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.
|
|
*/
|
|
|
|
/**
|
|
* @file
|
|
* bsd specific headers common to the driver
|
|
*/
|
|
|
|
#ifndef _OCS_OS_H
|
|
#define _OCS_OS_H
|
|
|
|
/***************************************************************************
|
|
* OS specific includes
|
|
*/
|
|
#include "opt_stack.h"
|
|
|
|
#include <sys/param.h>
|
|
#include <sys/systm.h>
|
|
#include <sys/malloc.h>
|
|
#include <sys/kernel.h>
|
|
#include <sys/module.h>
|
|
#include <sys/bus.h>
|
|
#include <sys/rman.h>
|
|
#include <sys/endian.h>
|
|
#include <sys/stddef.h>
|
|
#include <sys/lock.h>
|
|
#include <sys/mutex.h>
|
|
#include <sys/taskqueue.h>
|
|
#include <sys/bitstring.h>
|
|
#include <sys/stack.h>
|
|
|
|
#include <machine/atomic.h>
|
|
#include <machine/bus.h>
|
|
#include <machine/stdarg.h>
|
|
|
|
#include <dev/pci/pcivar.h>
|
|
|
|
#include <sys/sema.h>
|
|
#include <sys/time.h>
|
|
|
|
#include <sys/proc.h>
|
|
#include <sys/kthread.h>
|
|
#include <sys/unistd.h>
|
|
#include <sys/sched.h>
|
|
|
|
#include <sys/conf.h>
|
|
#include <sys/sysctl.h>
|
|
#include <sys/ioccom.h>
|
|
#include <sys/ctype.h>
|
|
|
|
#include <sys/linker.h> /* for debug of memory allocations */
|
|
|
|
/* OCS_OS_MAX_ISR_TIME_MSEC - maximum time driver code should spend in an interrupt
|
|
* or kernel thread context without yielding
|
|
*/
|
|
#define OCS_OS_MAX_ISR_TIME_MSEC 1000
|
|
|
|
/* BSD driver specific definitions */
|
|
|
|
#define ARRAY_SIZE(x) (sizeof(x) / sizeof((x)[0]))
|
|
|
|
#define OCS_MAX_LUN 512
|
|
#define OCS_NUM_UNSOLICITED_FRAMES 1024
|
|
|
|
#define OCS_MAX_DOMAINS 1
|
|
#define OCS_MAX_REMOTE_NODES 2048
|
|
#define OCS_MAX_TARGETS 1024
|
|
#define OCS_MAX_INITIATORS 1024
|
|
/** Reserve this number of IO for each intiator to return FULL/BUSY status */
|
|
#define OCS_RSVD_INI_IO 8
|
|
|
|
#define OCS_MIN_DMA_ALIGNMENT 16
|
|
#define OCS_MAX_DMA_ALLOC (64*1024) /* maximum DMA allocation that is expected to reliably succeed */
|
|
|
|
/*
|
|
* Macros used to size the CQ hash table. We want to round up to the next
|
|
* power of 2 for the hash.
|
|
*/
|
|
#define B2(x) ( (x) | ( (x) >> 1) )
|
|
#define B4(x) ( B2(x) | ( B2(x) >> 2) )
|
|
#define B8(x) ( B4(x) | ( B4(x) >> 4) )
|
|
#define B16(x) ( B8(x) | ( B8(x) >> 8) )
|
|
#define B32(x) (B16(x) | (B16(x) >>16) )
|
|
#define B32_NEXT_POWER_OF_2(x) (B32((x)-1) + 1)
|
|
|
|
/*
|
|
* likely/unlikely - branch prediction hint
|
|
*/
|
|
#define likely(x) __builtin_expect(!!(x), 1)
|
|
#define unlikely(x) __builtin_expect(!!(x), 0)
|
|
|
|
/***************************************************************************
|
|
* OS abstraction
|
|
*/
|
|
|
|
/**
|
|
* @brief Min/Max macros
|
|
*
|
|
*/
|
|
#define OCS_MAX(x, y) ((x) > (y) ? (x) : (y))
|
|
#define OCS_MIN(x, y) ((x) < (y) ? (x) : (y))
|
|
|
|
#define PRIX64 "lX"
|
|
#define PRIx64 "lx"
|
|
#define PRId64 "ld"
|
|
#define PRIu64 "lu"
|
|
|
|
/**
|
|
* Enable optional features
|
|
* - OCS_INCLUDE_DEBUG include low-level SLI debug support
|
|
*/
|
|
#define OCS_INCLUDE_DEBUG
|
|
|
|
/**
|
|
* @brief Set the Nth bit
|
|
*
|
|
* @todo move to a private file used internally?
|
|
*/
|
|
#ifndef BIT
|
|
#define BIT(n) (1U << (n))
|
|
#endif
|
|
|
|
/***************************************************************************
|
|
* Platform specific operations
|
|
*/
|
|
|
|
typedef struct ocs_softc ocs_t;
|
|
|
|
/**
|
|
* @ingroup os
|
|
* @typedef ocs_os_handle_t
|
|
* @brief OS specific handle or driver context
|
|
*
|
|
* This can be anything from a void * to some other OS specific type. The lower
|
|
* layers make no assumption about its value and pass it back as the first
|
|
* parameter to most OS functions.
|
|
*/
|
|
typedef ocs_t * ocs_os_handle_t;
|
|
|
|
/**
|
|
* @ingroup os
|
|
* @brief return the lower 32-bits of a bus address
|
|
*
|
|
* @param addr Physical or bus address to convert
|
|
* @return lower 32-bits of a bus address
|
|
*
|
|
* @note this may be a good cadidate for an inline or macro
|
|
*/
|
|
static inline uint32_t ocs_addr32_lo(uintptr_t addr)
|
|
{
|
|
#if defined(__LP64__)
|
|
return (uint32_t)(addr & 0xffffffffUL);
|
|
#else
|
|
return addr;
|
|
#endif
|
|
}
|
|
|
|
/**
|
|
* @ingroup os
|
|
* @brief return the upper 32-bits of a bus address
|
|
*
|
|
* @param addr Physical or bus address to convert
|
|
* @return upper 32-bits of a bus address
|
|
*
|
|
* @note this may be a good cadidate for an inline or macro
|
|
*/
|
|
static inline uint32_t ocs_addr32_hi(uintptr_t addr)
|
|
{
|
|
#if defined(__LP64__)
|
|
return (uint32_t)(addr >> 32);
|
|
#else
|
|
return 0;
|
|
#endif
|
|
}
|
|
|
|
/**
|
|
* @ingroup os
|
|
* @brief return the log2(val)
|
|
*
|
|
* @param val number to use (assumed to be exact power of 2)
|
|
*
|
|
* @return log base 2 of val
|
|
*/
|
|
static inline uint32_t ocs_lg2(uint32_t val)
|
|
{
|
|
#if defined(__GNUC__)
|
|
/*
|
|
* clz = "count leading zero's"
|
|
*
|
|
* Assuming val is an exact power of 2, the most significant bit
|
|
* will be the log base 2 of val
|
|
*/
|
|
return 31 - __builtin_clz(val);
|
|
#else
|
|
#error You need to provide a non-GCC version of this function
|
|
#endif
|
|
}
|
|
|
|
/**
|
|
* @ingroup os
|
|
* @brief optimization barrier
|
|
*
|
|
* Optimization barrier. Prevents compiler re-ordering
|
|
* instructions across barrier.
|
|
*
|
|
* @return none
|
|
*/
|
|
#define ocs_barrier() __asm __volatile("" : : : "memory");
|
|
|
|
/**
|
|
* @ingroup os
|
|
* @brief convert a big endian 32 bit value to the host's native format
|
|
*
|
|
* @param val 32 bit big endian value
|
|
*
|
|
* @return value converted to the host's native endianness
|
|
*/
|
|
#define ocs_be32toh(val) be32toh(val)
|
|
|
|
/**
|
|
* @ingroup os
|
|
* @brief convert a 32 bit value from the host's native format to big endian
|
|
*
|
|
* @param val 32 bit native endian value
|
|
*
|
|
* @return value converted to big endian
|
|
*/
|
|
#define ocs_htobe32(val) htobe32(val)
|
|
|
|
/**
|
|
* @ingroup os
|
|
* @brief convert a 16 bit value from the host's native format to big endian
|
|
*
|
|
* @param v 16 bit native endian value
|
|
*
|
|
* @return value converted to big endian
|
|
*/
|
|
#define ocs_htobe16(v) htobe16(v)
|
|
#define ocs_be16toh(v) be16toh(v)
|
|
|
|
#define ocs_htobe64(v) htobe64(v)
|
|
#define ocs_be64toh(v) be64toh(v)
|
|
|
|
/**
|
|
* @ingroup os
|
|
* @brief Delay execution by the given number of micro-seconds
|
|
*
|
|
* @param usec number of micro-seconds to "busy-wait"
|
|
*
|
|
* @note The value of usec may be greater than 1,000,000
|
|
*/
|
|
#define ocs_udelay(usec) DELAY(usec)
|
|
|
|
/**
|
|
* @ingroup os
|
|
* @brief Delay execution by the given number of milli-seconds
|
|
*
|
|
* @param msec number of milli-seconds to "busy-wait"
|
|
*
|
|
* @note The value of usec may be greater than 1,000,000
|
|
*/
|
|
#define ocs_msleep(msec) ocs_udelay((msec)*1000)
|
|
|
|
/**
|
|
* @ingroup os
|
|
* @brief Get time of day in msec
|
|
*
|
|
* @return time of day in msec
|
|
*/
|
|
static inline time_t
|
|
ocs_msectime(void)
|
|
{
|
|
struct timeval tv;
|
|
|
|
getmicrotime(&tv);
|
|
return (tv.tv_sec*1000) + (tv.tv_usec / 1000);
|
|
}
|
|
|
|
/**
|
|
* @ingroup os
|
|
* @brief Copy length number of bytes from the source to destination address
|
|
*
|
|
* @param d pointer to the destination memory
|
|
* @param s pointer to the source memory
|
|
* @param l number of bytes to copy
|
|
*
|
|
* @return original value of dst pointer
|
|
*/
|
|
#define ocs_memcpy(d, s, l) memcpy(d, s, l)
|
|
|
|
#define ocs_strlen(s) strlen(s)
|
|
#define ocs_strcpy(d,s) strcpy(d, s)
|
|
#define ocs_strncpy(d,s, n) strncpy(d, s, n)
|
|
#define ocs_strcat(d, s) strcat(d, s)
|
|
#define ocs_strtoul(s,ep,b) strtoul(s,ep,b)
|
|
#define ocs_strtoull(s,ep,b) ((uint64_t)strtouq(s,ep,b))
|
|
#define ocs_atoi(s) strtol(s, 0, 0)
|
|
#define ocs_strcmp(d,s) strcmp(d,s)
|
|
#define ocs_strcasecmp(d,s) strcasecmp(d,s)
|
|
#define ocs_strncmp(d,s,n) strncmp(d,s,n)
|
|
#define ocs_strstr(h,n) strstr(h,n)
|
|
#define ocs_strsep(h, n) strsep(h, n)
|
|
#define ocs_strchr(s,c) strchr(s,c)
|
|
#define ocs_copy_from_user(dst, src, n) copyin(src, dst, n)
|
|
#define ocs_copy_to_user(dst, src, n) copyout(src, dst, n)
|
|
#define ocs_snprintf(buf, n, fmt, ...) snprintf(buf, n, fmt, ##__VA_ARGS__)
|
|
#define ocs_vsnprintf(buf, n, fmt, ap) vsnprintf((char*)buf, n, fmt, ap)
|
|
#define ocs_sscanf(buf,fmt, ...) sscanf(buf, fmt, ##__VA_ARGS__)
|
|
#define ocs_printf printf
|
|
#define ocs_isspace(c) isspace(c)
|
|
#define ocs_isdigit(c) isdigit(c)
|
|
#define ocs_isxdigit(c) isxdigit(c)
|
|
|
|
extern uint64_t ocs_get_tsc(void);
|
|
extern void *ocs_ioctl_preprocess(ocs_os_handle_t os, void *arg, size_t size);
|
|
extern int32_t ocs_ioctl_postprocess(ocs_os_handle_t os, void *arg, void *kern_ptr, size_t size);
|
|
extern void ocs_ioctl_free(ocs_os_handle_t os, void *kern_ptr, size_t size);
|
|
extern char *ocs_strdup(const char *s);
|
|
|
|
/**
|
|
* @ingroup os
|
|
* @brief Set the value of each byte in memory
|
|
*
|
|
* @param b pointer to the memory
|
|
* @param c value used to set memory
|
|
* @param l number of bytes to set
|
|
*
|
|
* @return original value of mem pointer
|
|
*/
|
|
#define ocs_memset(b, c, l) memset(b, c, l)
|
|
|
|
#define LOG_CRIT 0
|
|
#define LOG_ERR 1
|
|
#define LOG_WARN 2
|
|
#define LOG_INFO 3
|
|
#define LOG_TEST 4
|
|
#define LOG_DEBUG 5
|
|
|
|
extern int loglevel;
|
|
|
|
extern void _ocs_log(ocs_t *ocs, const char *func, int line, const char *fmt, ...);
|
|
|
|
#define ocs_log_crit(os, fmt, ...) ocs_log(os, LOG_CRIT, fmt, ##__VA_ARGS__);
|
|
#define ocs_log_err(os, fmt, ...) ocs_log(os, LOG_ERR, fmt, ##__VA_ARGS__);
|
|
#define ocs_log_warn(os, fmt, ...) ocs_log(os, LOG_WARN, fmt, ##__VA_ARGS__);
|
|
#define ocs_log_info(os, fmt, ...) ocs_log(os, LOG_INFO, fmt, ##__VA_ARGS__);
|
|
#define ocs_log_test(os, fmt, ...) ocs_log(os, LOG_TEST, fmt, ##__VA_ARGS__);
|
|
#define ocs_log_debug(os, fmt, ...) ocs_log(os, LOG_DEBUG, fmt, ##__VA_ARGS__);
|
|
|
|
#define ocs_log(os, level, fmt, ...) \
|
|
do { \
|
|
if (level <= loglevel) { \
|
|
_ocs_log(os, __func__, __LINE__, fmt, ##__VA_ARGS__); \
|
|
} \
|
|
} while (0)
|
|
|
|
static inline uint32_t ocs_roundup(uint32_t x, uint32_t y)
|
|
{
|
|
return (((x + y - 1) / y) * y);
|
|
}
|
|
|
|
static inline uint32_t ocs_rounddown(uint32_t x, uint32_t y)
|
|
{
|
|
return ((x / y) * y);
|
|
}
|
|
|
|
/***************************************************************************
|
|
* Memory allocation interfaces
|
|
*/
|
|
|
|
#define OCS_M_ZERO M_ZERO
|
|
#define OCS_M_NOWAIT M_NOWAIT
|
|
|
|
/**
|
|
* @ingroup os
|
|
* @brief Allocate host memory
|
|
*
|
|
* @param os OS handle
|
|
* @param size number of bytes to allocate
|
|
* @param flags additional options
|
|
*
|
|
* Flags include
|
|
* - OCS_M_ZERO zero memory after allocating
|
|
* - OCS_M_NOWAIT do not block/sleep waiting for an allocation request
|
|
*
|
|
* @return pointer to allocated memory, NULL otherwise
|
|
*/
|
|
extern void *ocs_malloc(ocs_os_handle_t os, size_t size, int32_t flags);
|
|
|
|
/**
|
|
* @ingroup os
|
|
* @brief Free host memory
|
|
*
|
|
* @param os OS handle
|
|
* @param addr pointer to memory
|
|
* @param size bytes to free
|
|
*/
|
|
extern void ocs_free(ocs_os_handle_t os, void *addr, size_t size);
|
|
|
|
/**
|
|
* @ingroup os
|
|
* @brief generic DMA memory descriptor for driver allocations
|
|
*
|
|
* Memory regions ultimately used by the hardware are described using
|
|
* this structure. All implementations must include the structure members
|
|
* defined in the first section, and they may also add their own structure
|
|
* members in the second section.
|
|
*
|
|
* Note that each region described by ocs_dma_s is assumed to be physically
|
|
* contiguous.
|
|
*/
|
|
typedef struct ocs_dma_s {
|
|
/*
|
|
* OCS layer requires the following members
|
|
*/
|
|
void *virt; /**< virtual address of the memory used by the CPU */
|
|
void *alloc; /**< originally allocated virtual address used to restore virt if modified */
|
|
uintptr_t phys; /**< physical or bus address of the memory used by the hardware */
|
|
size_t size; /**< size in bytes of the memory */
|
|
/*
|
|
* Implementation specific fields allowed here
|
|
*/
|
|
size_t len; /**< application specific length */
|
|
bus_dma_tag_t tag;
|
|
bus_dmamap_t map;
|
|
} ocs_dma_t;
|
|
|
|
/**
|
|
* @ingroup os
|
|
* @brief Returns maximum supported DMA allocation size
|
|
*
|
|
* @param os OS specific handle or driver context
|
|
* @param align alignment requirement for DMA allocation
|
|
*
|
|
* Return maximum supported DMA allocation size, given alignment
|
|
* requirement.
|
|
*
|
|
* @return maximum supported DMA allocation size
|
|
*/
|
|
static inline uint32_t ocs_max_dma_alloc(ocs_os_handle_t os, size_t align)
|
|
{
|
|
return ~((uint32_t)0); /* no max */
|
|
}
|
|
|
|
/**
|
|
* @ingroup os
|
|
* @brief Allocate a DMA capable block of memory
|
|
*
|
|
* @param os OS specific handle or driver context
|
|
* @param dma DMA descriptor containing results of memory allocation
|
|
* @param size Size in bytes of desired allocation
|
|
* @param align Alignment in bytes of the requested allocation
|
|
*
|
|
* @return 0 on success, non-zero otherwise
|
|
*/
|
|
extern int32_t ocs_dma_alloc(ocs_os_handle_t, ocs_dma_t *, size_t, size_t);
|
|
|
|
/**
|
|
* @ingroup os
|
|
* @brief Free a DMA capable block of memory
|
|
*
|
|
* @param os OS specific handle or driver context
|
|
* @param dma DMA descriptor for memory to be freed
|
|
*
|
|
* @return 0 if memory is de-allocated, non-zero otherwise
|
|
*/
|
|
extern int32_t ocs_dma_free(ocs_os_handle_t, ocs_dma_t *);
|
|
extern int32_t ocs_dma_copy_in(ocs_dma_t *dma, void *buffer, uint32_t buffer_length);
|
|
extern int32_t ocs_dma_copy_out(ocs_dma_t *dma, void *buffer, uint32_t buffer_length);
|
|
|
|
static inline int32_t ocs_dma_valid(ocs_dma_t *dma)
|
|
{
|
|
return (dma->size != 0);
|
|
}
|
|
|
|
/**
|
|
* @ingroup os
|
|
* @brief Synchronize the DMA buffer memory
|
|
*
|
|
* Ensures memory coherency between the CPU and device
|
|
*
|
|
* @param dma DMA descriptor of memory to synchronize
|
|
* @param flags Describes direction of synchronization
|
|
* - OCS_DMASYNC_PREREAD sync needed before hardware updates host memory
|
|
* - OCS_DMASYNC_PREWRITE sync needed after CPU updates host memory but before hardware can access
|
|
* - OCS_DMASYNC_POSTREAD sync needed after hardware updates host memory but before CPU can access
|
|
* - OCS_DMASYNC_POSTWRITE sync needed after hardware updates host memory
|
|
*/
|
|
extern void ocs_dma_sync(ocs_dma_t *, uint32_t);
|
|
|
|
#define OCS_DMASYNC_PREWRITE BUS_DMASYNC_PREWRITE
|
|
#define OCS_DMASYNC_POSTREAD BUS_DMASYNC_POSTREAD
|
|
|
|
/***************************************************************************
|
|
* Locking
|
|
*/
|
|
|
|
/**
|
|
* @ingroup os
|
|
* @typedef ocs_lock_t
|
|
* @brief Define the type used implement locking
|
|
*/
|
|
#define MAX_LOCK_DESC_LEN 64
|
|
typedef struct ocs_lock_s {
|
|
struct mtx lock;
|
|
char name[MAX_LOCK_DESC_LEN];
|
|
} ocs_lock_t;
|
|
|
|
/**
|
|
* @ingroup os
|
|
* @brief Initialize a lock
|
|
*
|
|
* @param lock lock to initialize
|
|
* @param name string identifier for the lock
|
|
*/
|
|
extern void ocs_lock_init(void *os, ocs_lock_t *lock, const char *name, ...);
|
|
|
|
/**
|
|
* @ingroup os
|
|
* @brief Free a previously allocated lock
|
|
*
|
|
* @param lock lock to free
|
|
*/
|
|
static inline void
|
|
ocs_lock_free(ocs_lock_t *lock)
|
|
{
|
|
|
|
if (mtx_initialized(&(lock)->lock)) {
|
|
mtx_assert(&(lock)->lock, MA_NOTOWNED);
|
|
mtx_destroy(&(lock)->lock);
|
|
} else {
|
|
panic("XXX trying to free with un-initialized mtx!?!?\n");
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @ingroup os
|
|
* @brief Acquire a lock
|
|
*
|
|
* @param lock lock to obtain
|
|
*/
|
|
static inline void
|
|
ocs_lock(ocs_lock_t *lock)
|
|
{
|
|
|
|
if (mtx_initialized(&(lock)->lock)) {
|
|
mtx_assert(&(lock)->lock, MA_NOTOWNED);
|
|
mtx_lock(&(lock)->lock);
|
|
} else {
|
|
panic("XXX trying to lock with un-initialized mtx!?!?\n");
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @ingroup os
|
|
* @brief Release a lock
|
|
*
|
|
* @param lock lock to release
|
|
*/
|
|
static inline void
|
|
ocs_unlock(ocs_lock_t *lock)
|
|
{
|
|
|
|
if (mtx_initialized(&(lock)->lock)) {
|
|
mtx_assert(&(lock)->lock, MA_OWNED | MA_NOTRECURSED);
|
|
mtx_unlock(&(lock)->lock);
|
|
} else {
|
|
panic("XXX trying to unlock with un-initialized mtx!?!?\n");
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @ingroup os
|
|
* @typedef ocs_lock_t
|
|
* @brief Define the type used implement recursive locking
|
|
*/
|
|
typedef struct ocs_lock_s ocs_rlock_t;
|
|
|
|
/**
|
|
* @ingroup os
|
|
* @brief Initialize a recursive lock
|
|
*
|
|
* @param ocs pointer to ocs structure
|
|
* @param lock lock to initialize
|
|
* @param name string identifier for the lock
|
|
*/
|
|
static inline void
|
|
ocs_rlock_init(ocs_t *ocs, ocs_rlock_t *lock, const char *name)
|
|
{
|
|
ocs_strncpy(lock->name, name, MAX_LOCK_DESC_LEN);
|
|
mtx_init(&(lock)->lock, lock->name, NULL, MTX_DEF | MTX_RECURSE | MTX_DUPOK);
|
|
}
|
|
|
|
/**
|
|
* @ingroup os
|
|
* @brief Free a previously allocated recursive lock
|
|
*
|
|
* @param lock lock to free
|
|
*/
|
|
static inline void
|
|
ocs_rlock_free(ocs_rlock_t *lock)
|
|
{
|
|
if (mtx_initialized(&(lock)->lock)) {
|
|
mtx_destroy(&(lock)->lock);
|
|
} else {
|
|
panic("XXX trying to free with un-initialized mtx!?!?\n");
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @brief try to acquire a recursive lock
|
|
*
|
|
* Attempt to acquire a recursive lock, return TRUE if successful
|
|
*
|
|
* @param lock pointer to recursive lock
|
|
*
|
|
* @return TRUE if lock was acquired, FALSE if not
|
|
*/
|
|
static inline int32_t
|
|
ocs_rlock_try(ocs_rlock_t *lock)
|
|
{
|
|
int rc = mtx_trylock(&(lock)->lock);
|
|
|
|
return rc != 0;
|
|
}
|
|
|
|
/**
|
|
* @ingroup os
|
|
* @brief Acquire a recursive lock
|
|
*
|
|
* @param lock lock to obtain
|
|
*/
|
|
static inline void
|
|
ocs_rlock_acquire(ocs_rlock_t *lock)
|
|
{
|
|
if (mtx_initialized(&(lock)->lock)) {
|
|
mtx_lock(&(lock)->lock);
|
|
} else {
|
|
panic("XXX trying to lock with un-initialized mtx!?!?\n");
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @ingroup os
|
|
* @brief Release a recursive lock
|
|
*
|
|
* @param lock lock to release
|
|
*/
|
|
static inline void
|
|
ocs_rlock_release(ocs_rlock_t *lock)
|
|
{
|
|
if (mtx_initialized(&(lock)->lock)) {
|
|
mtx_assert(&(lock)->lock, MA_OWNED);
|
|
mtx_unlock(&(lock)->lock);
|
|
} else {
|
|
panic("XXX trying to unlock with un-initialized mtx!?!?\n");
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @brief counting semaphore
|
|
*
|
|
* Declaration of the counting semaphore object
|
|
*
|
|
*/
|
|
typedef struct {
|
|
char name[32];
|
|
struct sema sem; /**< OS counting semaphore structure */
|
|
} ocs_sem_t;
|
|
|
|
#define OCS_SEM_FOREVER (-1)
|
|
#define OCS_SEM_TRY (0)
|
|
|
|
/**
|
|
* @brief Initialize a counting semaphore
|
|
*
|
|
* The semaphore is initiatlized to the value
|
|
*
|
|
* @param sem pointer to semaphore
|
|
* @param val initial value
|
|
* @param name label for the semaphore
|
|
*
|
|
* @return returns 0 for success, a negative error code value for failure.
|
|
*/
|
|
|
|
extern int ocs_sem_init(ocs_sem_t *sem, int val, const char *name, ...) __attribute__((format(printf, 3, 4)));
|
|
|
|
/**
|
|
* @brief execute a P (decrement) operation
|
|
*
|
|
* A P (decrement and block if negative) operation is performed on the semaphore.
|
|
*
|
|
* If timeout_usec is zero, the semaphore attempts one time and returns 0 if acquired.
|
|
* If timeout_usec is greater than zero, then the call will block until the semaphore
|
|
* is acquired, or a timeout occurred. If timeout_usec is less than zero, then
|
|
* the call will block until the semaphore is acquired.
|
|
*
|
|
* @param sem pointer to semaphore
|
|
* @param timeout_usec timeout in microseconds
|
|
*
|
|
* @return returns 0 for success, negative value if the semaphore was not acquired.
|
|
*/
|
|
|
|
static inline int
|
|
ocs_sem_p(ocs_sem_t *sem, int timeout_usec)
|
|
{
|
|
int32_t rc = 0;
|
|
|
|
if (timeout_usec == 0) {
|
|
rc = sema_trywait(&sem->sem);
|
|
if (rc == 0) {
|
|
rc = -1;
|
|
}
|
|
} else if (timeout_usec > 0) {
|
|
struct timeval tv;
|
|
uint32_t ticks;
|
|
|
|
tv.tv_sec = timeout_usec / 1000000;
|
|
tv.tv_usec = timeout_usec % 1000000;
|
|
ticks = tvtohz(&tv);
|
|
if (ticks == 0) {
|
|
ticks ++;
|
|
}
|
|
rc = sema_timedwait(&sem->sem, ticks);
|
|
if (rc != 0) {
|
|
rc = -1;
|
|
}
|
|
} else {
|
|
sema_wait(&sem->sem);
|
|
}
|
|
if (rc)
|
|
rc = -1;
|
|
|
|
return rc;
|
|
}
|
|
|
|
/**
|
|
* @brief perform a V (increment) operation on a counting semaphore
|
|
*
|
|
* The semaphore is incremented, unblocking one thread that is waiting on the
|
|
* sempahore
|
|
*
|
|
* @param sem pointer to the semaphore
|
|
*
|
|
* @return none
|
|
*/
|
|
|
|
static inline void
|
|
ocs_sem_v(ocs_sem_t *sem)
|
|
{
|
|
sema_post(&sem->sem);
|
|
}
|
|
|
|
/***************************************************************************
|
|
* Bitmap
|
|
*/
|
|
|
|
/**
|
|
* @ingroup os
|
|
* @typedef ocs_bitmap_t
|
|
* @brief Define the type used implement bit-maps
|
|
*/
|
|
typedef bitstr_t ocs_bitmap_t;
|
|
|
|
/**
|
|
* @ingroup os
|
|
* @brief Allocate a bitmap
|
|
*
|
|
* @param n_bits Minimum number of entries in the bit-map
|
|
*
|
|
* @return pointer to the bit-map or NULL on error
|
|
*/
|
|
extern ocs_bitmap_t *ocs_bitmap_alloc(uint32_t n_bits);
|
|
|
|
/**
|
|
* @ingroup os
|
|
* @brief Free a bit-map
|
|
*
|
|
* @param bitmap Bit-map to free
|
|
*/
|
|
extern void ocs_bitmap_free(ocs_bitmap_t *bitmap);
|
|
|
|
/**
|
|
* @ingroup os
|
|
* @brief Find next unset bit and set it
|
|
*
|
|
* @param bitmap bit map to search
|
|
* @param n_bits number of bits in map
|
|
*
|
|
* @return bit position or -1 if map is full
|
|
*/
|
|
extern int32_t ocs_bitmap_find(ocs_bitmap_t *bitmap, uint32_t n_bits);
|
|
|
|
/**
|
|
* @ingroup os
|
|
* @brief search for next (un)set bit
|
|
*
|
|
* @param bitmap bit map to search
|
|
* @param set search for a set or unset bit
|
|
* @param n_bits number of bits in map
|
|
*
|
|
* @return bit position or -1
|
|
*/
|
|
extern int32_t ocs_bitmap_search(ocs_bitmap_t *bitmap, uint8_t set, uint32_t n_bits);
|
|
|
|
/**
|
|
* @ingroup os
|
|
* @brief clear the specified bit
|
|
*
|
|
* @param bitmap pointer to bit map
|
|
* @param bit bit number to clear
|
|
*/
|
|
extern void ocs_bitmap_clear(ocs_bitmap_t *bitmap, uint32_t bit);
|
|
|
|
extern int32_t ocs_get_property(const char *prop_name, char *buffer, uint32_t buffer_len);
|
|
|
|
/***************************************************************************
|
|
* Timer Routines
|
|
*
|
|
* Functions for setting, querying and canceling timers.
|
|
*/
|
|
typedef struct {
|
|
struct callout callout;
|
|
struct mtx lock;
|
|
|
|
void (*func)(void *);
|
|
void *data;
|
|
} ocs_timer_t;
|
|
|
|
/**
|
|
* @ingroup os
|
|
* @brief Initialize and set a timer
|
|
*
|
|
* @param os OS handle
|
|
* @param timer pointer to the structure allocated for this timer
|
|
* @param func the function to call when the timer expires
|
|
* @param data Data to pass to the provided timer function when the timer
|
|
* expires.
|
|
* @param timeout_ms the timeout in milliseconds
|
|
*/
|
|
extern int32_t ocs_setup_timer(ocs_os_handle_t os, ocs_timer_t *timer, void(*func)(void *arg),
|
|
void *data, uint32_t timeout_ms);
|
|
|
|
/**
|
|
* @ingroup os
|
|
* @brief Modify a timer's expiration
|
|
*
|
|
* @param timer pointer to the structure allocated for this timer
|
|
* @param timeout_ms the timeout in milliseconds
|
|
*/
|
|
extern int32_t ocs_mod_timer(ocs_timer_t *timer, uint32_t timeout_ms);
|
|
|
|
/**
|
|
* @ingroup os
|
|
* @brief Queries to see if a timer is pending.
|
|
*
|
|
* @param timer pointer to the structure allocated for this timer
|
|
*
|
|
* @return non-zero if the timer is pending
|
|
*/
|
|
extern int32_t ocs_timer_pending(ocs_timer_t *timer);
|
|
|
|
/**
|
|
* @ingroup os
|
|
* @brief Remove a pending timer
|
|
*
|
|
* @param timer pointer to the structure allocated for this timer
|
|
* expires.
|
|
*/
|
|
extern int32_t ocs_del_timer(ocs_timer_t *timer);
|
|
|
|
/***************************************************************************
|
|
* Atomics
|
|
*
|
|
*/
|
|
|
|
typedef uint32_t ocs_atomic_t;
|
|
|
|
/**
|
|
* @ingroup os
|
|
* @brief initialize an atomic
|
|
*
|
|
* @param a pointer to the atomic object
|
|
* @param v initial value
|
|
*
|
|
* @return none
|
|
*/
|
|
#define ocs_atomic_init(a, v) ocs_atomic_set(a, v)
|
|
|
|
/**
|
|
* @ingroup os
|
|
* @brief adds an integer to an atomic value
|
|
*
|
|
* @param a pointer to the atomic object
|
|
* @param v value to increment
|
|
*
|
|
* @return the value of the atomic before incrementing.
|
|
*/
|
|
#define ocs_atomic_add_return(a, v) atomic_fetchadd_32(a, v)
|
|
|
|
/**
|
|
* @ingroup os
|
|
* @brief subtracts an integer to an atomic value
|
|
*
|
|
* @param a pointer to the atomic object
|
|
* @param v value to increment
|
|
*
|
|
* @return the value of the atomic before subtracting.
|
|
*/
|
|
#define ocs_atomic_sub_return(a, v) atomic_fetchadd_32(a, (-(v)))
|
|
|
|
/**
|
|
* @ingroup os
|
|
* @brief returns the current value of an atomic object
|
|
*
|
|
* @param a pointer to the atomic object
|
|
*
|
|
* @return the value of the atomic.
|
|
*/
|
|
#define ocs_atomic_read(a) atomic_load_acq_32(a)
|
|
|
|
/**
|
|
* @ingroup os
|
|
* @brief sets the current value of an atomic object
|
|
*
|
|
* @param a pointer to the atomic object
|
|
*/
|
|
#define ocs_atomic_set(a, v) atomic_store_rel_32(a, v)
|
|
|
|
/**
|
|
* @ingroup os
|
|
* @brief Sets atomic to 0, returns previous value
|
|
*
|
|
* @param a pointer to the atomic object
|
|
*
|
|
* @return the value of the atomic before the operation.
|
|
*/
|
|
#define ocs_atomic_read_and_clear atomic_readandclear_32(a)
|
|
|
|
/**
|
|
* @brief OCS thread structure
|
|
*
|
|
*/
|
|
|
|
typedef struct ocs_thread_s ocs_thread_t;
|
|
|
|
typedef int32_t (*ocs_thread_fctn)(ocs_thread_t *mythread);
|
|
|
|
struct ocs_thread_s {
|
|
struct thread *tcb; /*<< thread control block */
|
|
ocs_thread_fctn fctn; /*<< thread function */
|
|
char *name; /*<< name of thread */
|
|
void *arg; /*<< pointer to thread argument */
|
|
ocs_atomic_t terminate; /*<< terminate request */
|
|
int32_t retval; /*<< return value */
|
|
uint32_t cpu_affinity; /*<< cpu affinity */
|
|
};
|
|
#define OCS_THREAD_DEFAULT_STACK_SIZE_PAGES 8
|
|
|
|
/**
|
|
* @brief OCS thread start options
|
|
*
|
|
*/
|
|
|
|
typedef enum {
|
|
OCS_THREAD_RUN, /*<< run immediately */
|
|
OCS_THREAD_CREATE, /*<< create and wait for start request */
|
|
} ocs_thread_start_e;
|
|
|
|
extern int32_t ocs_thread_create(ocs_os_handle_t os, ocs_thread_t *thread, ocs_thread_fctn fctn,
|
|
const char *name, void *arg, ocs_thread_start_e start_option);
|
|
extern int32_t ocs_thread_start(ocs_thread_t *thread);
|
|
extern void *ocs_thread_get_arg(ocs_thread_t *mythread);
|
|
extern int32_t ocs_thread_terminate(ocs_thread_t *thread);
|
|
extern int32_t ocs_thread_terminate_requested(ocs_thread_t *thread);
|
|
extern int32_t ocs_thread_get_retval(ocs_thread_t *thread);
|
|
extern void ocs_thread_yield(ocs_thread_t *thread);
|
|
extern ocs_thread_t *ocs_thread_self(void);
|
|
extern int32_t ocs_thread_setcpu(ocs_thread_t *thread, uint32_t cpu);
|
|
extern int32_t ocs_thread_getcpu(void);
|
|
|
|
/***************************************************************************
|
|
* PCI
|
|
*
|
|
* Several functions below refer to a "register set". This is one or
|
|
* more PCI BARs that constitute a PCI address. For example, if a MMIO
|
|
* region is described using both BAR[0] and BAR[1], the combination of
|
|
* BARs defines register set 0.
|
|
*/
|
|
|
|
/**
|
|
* @brief tracks mapped PCI memory regions
|
|
*/
|
|
typedef struct ocs_pci_reg_s {
|
|
uint32_t rid;
|
|
struct resource *res;
|
|
bus_space_tag_t btag;
|
|
bus_space_handle_t bhandle;
|
|
} ocs_pci_reg_t;
|
|
|
|
#define PCI_MAX_BAR 6
|
|
#define PCI_64BIT_BAR0 0
|
|
|
|
#define PCI_VENDOR_EMULEX 0x10df /* Emulex */
|
|
|
|
#define PCI_PRODUCT_EMULEX_OCE16001 0xe200 /* OneCore 16Gb FC (lancer) */
|
|
#define PCI_PRODUCT_EMULEX_OCE16002 0xe200 /* OneCore 16Gb FC (lancer) */
|
|
#define PCI_PRODUCT_EMULEX_LPE31004 0xe300 /* LightPulse 16Gb x 4 FC (lancer-g6) */
|
|
#define PCI_PRODUCT_EMULEX_LPE32002 0xe300 /* LightPulse 32Gb x 2 FC (lancer-g6) */
|
|
#define PCI_PRODUCT_EMULEX_LANCER_G7 0xf400 /* LightPulse 32Gb x 4 FC (lancer-g7) */
|
|
|
|
#define PCI_PRODUCT_EMULEX_OCE1600_VF 0xe208
|
|
#define PCI_PRODUCT_EMULEX_OCE50102 0xe260 /* OneCore FCoE (lancer) */
|
|
#define PCI_PRODUCT_EMULEX_OCE50102_VF 0xe268
|
|
|
|
/**
|
|
* @ingroup os
|
|
* @brief Get the PCI bus, device, and function values
|
|
*
|
|
* @param ocs OS specific handle or driver context
|
|
* @param bus Pointer to location to store the bus number.
|
|
* @param dev Pointer to location to store the device number.
|
|
* @param func Pointer to location to store the function number.
|
|
*
|
|
*/
|
|
extern void
|
|
ocs_get_bus_dev_func(ocs_t *ocs, uint8_t* bus, uint8_t* dev, uint8_t* func);
|
|
|
|
extern ocs_t *ocs_get_instance(uint32_t index);
|
|
extern uint32_t ocs_instance(void *os);
|
|
|
|
/**
|
|
* @ingroup os
|
|
* @brief Read a 32 bit value from the specified configuration register
|
|
*
|
|
* @param os OS specific handle or driver context
|
|
* @param reg register offset
|
|
*
|
|
* @return The 32 bit value
|
|
*/
|
|
extern uint32_t ocs_config_read32(ocs_os_handle_t os, uint32_t reg);
|
|
|
|
/**
|
|
* @ingroup os
|
|
* @brief Read a 16 bit value from the specified configuration
|
|
* register
|
|
*
|
|
* @param os OS specific handle or driver context
|
|
* @param reg register offset
|
|
*
|
|
* @return The 16 bit value
|
|
*/
|
|
extern uint16_t ocs_config_read16(ocs_os_handle_t os, uint32_t reg);
|
|
|
|
/**
|
|
* @ingroup os
|
|
* @brief Read a 8 bit value from the specified configuration
|
|
* register
|
|
*
|
|
* @param os OS specific handle or driver context
|
|
* @param reg register offset
|
|
*
|
|
* @return The 8 bit value
|
|
*/
|
|
extern uint8_t ocs_config_read8(ocs_os_handle_t os, uint32_t reg);
|
|
|
|
/**
|
|
* @ingroup os
|
|
* @brief Write a 8 bit value to the specified configuration
|
|
* register
|
|
*
|
|
* @param os OS specific handle or driver context
|
|
* @param reg register offset
|
|
* @param val value to write
|
|
*
|
|
* @return None
|
|
*/
|
|
extern void ocs_config_write8(ocs_os_handle_t os, uint32_t reg, uint8_t val);
|
|
|
|
/**
|
|
* @ingroup os
|
|
* @brief Write a 16 bit value to the specified configuration
|
|
* register
|
|
*
|
|
* @param os OS specific handle or driver context
|
|
* @param reg register offset
|
|
* @param val value to write
|
|
*
|
|
* @return None
|
|
*/
|
|
extern void ocs_config_write16(ocs_os_handle_t os, uint32_t reg, uint16_t val);
|
|
|
|
/**
|
|
* @ingroup os
|
|
* @brief Write a 32 bit value to the specified configuration
|
|
* register
|
|
*
|
|
* @param os OS specific handle or driver context
|
|
* @param reg register offset
|
|
* @param val value to write
|
|
*
|
|
* @return None
|
|
*/
|
|
extern void ocs_config_write32(ocs_os_handle_t os, uint32_t reg, uint32_t val);
|
|
|
|
/**
|
|
* @ingroup os
|
|
* @brief Read a PCI register
|
|
*
|
|
* @param os OS specific handle or driver context
|
|
* @param rset Which "register set" to use
|
|
* @param off Register offset
|
|
*
|
|
* @return 32 bit conents of the register
|
|
*/
|
|
extern uint32_t ocs_reg_read32(ocs_os_handle_t os, uint32_t rset, uint32_t off);
|
|
|
|
/**
|
|
* @ingroup os
|
|
* @brief Read a PCI register
|
|
*
|
|
* @param os OS specific handle or driver context
|
|
* @param rset Which "register set" to use
|
|
* @param off Register offset
|
|
*
|
|
* @return 16 bit conents of the register
|
|
*/
|
|
extern uint16_t ocs_reg_read16(ocs_os_handle_t os, uint32_t rset, uint32_t off);
|
|
|
|
/**
|
|
* @ingroup os
|
|
* @brief Read a PCI register
|
|
*
|
|
* @param os OS specific handle or driver context
|
|
* @param rset Which "register set" to use
|
|
* @param off Register offset
|
|
*
|
|
* @return 8 bit conents of the register
|
|
*/
|
|
extern uint8_t ocs_reg_read8(ocs_os_handle_t os, uint32_t rset, uint32_t off);
|
|
|
|
/**
|
|
* @ingroup os
|
|
* @brief Write a PCI register
|
|
*
|
|
* @param os OS specific handle or driver context
|
|
* @param rset Which "register set" to use
|
|
* @param off Register offset
|
|
* @param val 32-bit value to write
|
|
*/
|
|
extern void ocs_reg_write32(ocs_os_handle_t os, uint32_t rset, uint32_t off, uint32_t val);
|
|
|
|
/**
|
|
* @ingroup os
|
|
* @brief Write a PCI register
|
|
*
|
|
* @param os OS specific handle or driver context
|
|
* @param rset Which "register set" to use
|
|
* @param off Register offset
|
|
* @param val 16-bit value to write
|
|
*/
|
|
extern void ocs_reg_write16(ocs_os_handle_t os, uint32_t rset, uint32_t off, uint16_t val);
|
|
|
|
/**
|
|
* @ingroup os
|
|
* @brief Write a PCI register
|
|
*
|
|
* @param os OS specific handle or driver context
|
|
* @param rset Which "register set" to use
|
|
* @param off Register offset
|
|
* @param val 8-bit value to write
|
|
*/
|
|
extern void ocs_reg_write8(ocs_os_handle_t os, uint32_t rset, uint32_t off, uint8_t val);
|
|
|
|
/**
|
|
* @ingroup os
|
|
* @brief Disable interrupts
|
|
*
|
|
* @param os OS specific handle or driver context
|
|
*/
|
|
extern void ocs_intr_disable(ocs_os_handle_t os);
|
|
|
|
/**
|
|
* @ingroup os
|
|
* @brief Enable interrupts
|
|
*
|
|
* @param os OS specific handle or driver context
|
|
*/
|
|
extern void ocs_intr_enable(ocs_os_handle_t os);
|
|
|
|
/**
|
|
* @ingroup os
|
|
* @brief Return model string
|
|
*
|
|
* @param os OS specific handle or driver context
|
|
*/
|
|
extern const char *ocs_pci_model(uint16_t vendor, uint16_t device);
|
|
|
|
extern void ocs_print_stack(void);
|
|
|
|
extern void ocs_abort(void) __attribute__((noreturn));
|
|
|
|
/***************************************************************************
|
|
* Reference counting
|
|
*
|
|
*/
|
|
|
|
/**
|
|
* @ingroup os
|
|
* @brief reference counter object
|
|
*/
|
|
typedef void (*ocs_ref_release_t)(void *arg);
|
|
typedef struct ocs_ref_s {
|
|
ocs_ref_release_t release; /* release function to call */
|
|
void *arg;
|
|
uint32_t count; /* ref count; no need to be atomic if we have a lock */
|
|
} ocs_ref_t;
|
|
|
|
/**
|
|
* @ingroup os
|
|
* @brief initialize given reference object
|
|
*
|
|
* @param ref Pointer to reference object
|
|
* @param release Function to be called when count is 0.
|
|
* @param arg Argument to be passed to release function.
|
|
*/
|
|
static inline void
|
|
ocs_ref_init(ocs_ref_t *ref, ocs_ref_release_t release, void *arg)
|
|
{
|
|
ref->release = release;
|
|
ref->arg = arg;
|
|
ocs_atomic_init(&ref->count, 1);
|
|
}
|
|
|
|
/**
|
|
* @ingroup os
|
|
* @brief Return reference count value
|
|
*
|
|
* @param ref Pointer to reference object
|
|
*
|
|
* @return Count value of given reference object
|
|
*/
|
|
static inline uint32_t
|
|
ocs_ref_read_count(ocs_ref_t *ref)
|
|
{
|
|
return ocs_atomic_read(&ref->count);
|
|
}
|
|
|
|
/**
|
|
* @ingroup os
|
|
* @brief Set count on given reference object to a value.
|
|
*
|
|
* @param ref Pointer to reference object
|
|
* @param i Set count to this value
|
|
*/
|
|
static inline void
|
|
ocs_ref_set(ocs_ref_t *ref, int i)
|
|
{
|
|
ocs_atomic_set(&ref->count, i);
|
|
}
|
|
|
|
/**
|
|
* @ingroup os
|
|
* @brief Take a reference on given object.
|
|
*
|
|
* @par Description
|
|
* This function takes a reference on an object.
|
|
*
|
|
* Note: this function should only be used if the caller can
|
|
* guarantee that the reference count is >= 1 and will stay >= 1
|
|
* for the duration of this call (i.e. won't go to zero). If it
|
|
* can't (the refcount may go to zero during this call),
|
|
* ocs_ref_get_unless_zero() should be used instead.
|
|
*
|
|
* @param ref Pointer to reference object
|
|
*
|
|
*/
|
|
static inline void
|
|
ocs_ref_get(ocs_ref_t *ref)
|
|
{
|
|
ocs_atomic_add_return(&ref->count, 1);
|
|
}
|
|
|
|
/**
|
|
* @ingroup os
|
|
* @brief Take a reference on given object if count is not zero.
|
|
*
|
|
* @par Description
|
|
* This function takes a reference on an object if and only if
|
|
* the given reference object is "active" or valid.
|
|
*
|
|
* @param ref Pointer to reference object
|
|
*
|
|
* @return non-zero if "get" succeeded; Return zero if ref count
|
|
* is zero.
|
|
*/
|
|
static inline uint32_t
|
|
ocs_ref_get_unless_zero(ocs_ref_t *ref)
|
|
{
|
|
uint32_t rc = 0;
|
|
rc = ocs_atomic_read(&ref->count);
|
|
if (rc != 0) {
|
|
ocs_atomic_add_return(&ref->count, 1);
|
|
}
|
|
return rc;
|
|
}
|
|
|
|
/**
|
|
* @ingroup os
|
|
* @brief Decrement reference on given object
|
|
*
|
|
* @par Description
|
|
* This function decrements the reference count on the given
|
|
* reference object. If the reference count becomes zero, the
|
|
* "release" function (set during "init" time) is called.
|
|
*
|
|
* @param ref Pointer to reference object
|
|
*
|
|
* @return non-zero if release function was called; zero
|
|
* otherwise.
|
|
*/
|
|
static inline uint32_t
|
|
ocs_ref_put(ocs_ref_t *ref)
|
|
{
|
|
uint32_t rc = 0;
|
|
if (ocs_atomic_sub_return(&ref->count, 1) == 1) {
|
|
ref->release(ref->arg);
|
|
rc = 1;
|
|
}
|
|
return rc;
|
|
}
|
|
|
|
/**
|
|
* @ingroup os
|
|
* @brief Get the OS system ticks
|
|
*
|
|
* @return number of ticks that have occurred since the system
|
|
* booted.
|
|
*/
|
|
static inline uint64_t
|
|
ocs_get_os_ticks(void)
|
|
{
|
|
return ticks;
|
|
}
|
|
|
|
/**
|
|
* @ingroup os
|
|
* @brief Get the OS system tick frequency
|
|
*
|
|
* @return frequency of system ticks.
|
|
*/
|
|
static inline uint32_t
|
|
ocs_get_os_tick_freq(void)
|
|
{
|
|
return hz;
|
|
}
|
|
|
|
/*****************************************************************************
|
|
*
|
|
* CPU topology API
|
|
*/
|
|
|
|
typedef struct {
|
|
uint32_t num_cpus; /* Number of CPU cores */
|
|
uint8_t hyper; /* TRUE if threaded CPUs */
|
|
} ocs_cpuinfo_t;
|
|
|
|
extern int32_t ocs_get_cpuinfo(ocs_cpuinfo_t *cpuinfo);
|
|
extern uint32_t ocs_get_num_cpus(void);
|
|
|
|
#include "ocs_list.h"
|
|
#include "ocs_utils.h"
|
|
#include "ocs_mgmt.h"
|
|
#include "ocs_common.h"
|
|
|
|
#endif /* !_OCS_OS_H */
|