142cee4bf2
Initial host-common file folder cleanup and moves on top of baseline reference of MCL WLAN driver SU#5.0.0.160. Move dp, ht comm, hif, wmi and qdf folders one level up Change-Id: I2120898024b1eafd5d651c48768dbf48bf05995d
307 lines
8.6 KiB
C
307 lines
8.6 KiB
C
/*
|
|
* Copyright (c) 2014-2016 The Linux Foundation. All rights reserved.
|
|
*
|
|
* Previously licensed under the ISC license by Qualcomm Atheros, Inc.
|
|
*
|
|
*
|
|
* Permission to use, copy, modify, and/or distribute this software for
|
|
* any purpose with or without fee is hereby granted, provided that the
|
|
* above copyright notice and this permission notice appear in all
|
|
* copies.
|
|
*
|
|
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL
|
|
* WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED
|
|
* WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE
|
|
* AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL
|
|
* DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
|
|
* PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
|
|
* TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
|
|
* PERFORMANCE OF THIS SOFTWARE.
|
|
*/
|
|
|
|
/*
|
|
* This file was originally distributed by Qualcomm Atheros, Inc.
|
|
* under proprietary terms before Copyright ownership was assigned
|
|
* to the Linux Foundation.
|
|
*/
|
|
|
|
#if !defined(__CDF_LOCK_H)
|
|
#define __CDF_LOCK_H
|
|
|
|
/**
|
|
*
|
|
* @file cdf_lock.h
|
|
*
|
|
* @brief Connectivity driver framework (CDF) lock APIs
|
|
*
|
|
* Definitions for CDF locks
|
|
*
|
|
*/
|
|
|
|
/* Include Files */
|
|
#include "cdf_status.h"
|
|
#include "i_cdf_lock.h"
|
|
|
|
/* Preprocessor definitions and constants */
|
|
|
|
/* Type declarations */
|
|
/**
|
|
* @brief Platform spinlock object
|
|
*/
|
|
typedef __cdf_spinlock_t cdf_spinlock_t;
|
|
/**
|
|
* @brief Platform mutex object
|
|
*/
|
|
typedef __cdf_semaphore_t cdf_semaphore_t;
|
|
|
|
/* Function declarations and documenation */
|
|
|
|
/**
|
|
* cdf_semaphore_init() - initialize a semaphore
|
|
* @m: Semaphore to initialize
|
|
*
|
|
* Return: None
|
|
*/
|
|
|
|
static inline void cdf_semaphore_init(cdf_semaphore_t *m)
|
|
{
|
|
__cdf_semaphore_init(m);
|
|
}
|
|
|
|
/**
|
|
* cdf_semaphore_acquire() - take the semaphore
|
|
* @m: Semaphore to take
|
|
*
|
|
* Return: None
|
|
*/
|
|
static inline int cdf_semaphore_acquire(cdf_device_t osdev, cdf_semaphore_t *m)
|
|
{
|
|
return __cdf_semaphore_acquire(osdev, m);
|
|
}
|
|
|
|
/**
|
|
* cdf_semaphore_release () - give the semaphore
|
|
* @m: Semaphore to give
|
|
*
|
|
* Return: None
|
|
*/
|
|
static inline void
|
|
cdf_semaphore_release(cdf_device_t osdev, cdf_semaphore_t *m)
|
|
{
|
|
__cdf_semaphore_release(osdev, m);
|
|
}
|
|
|
|
/**
|
|
* cdf_mutex_init() - initialize a CDF lock
|
|
* @lock: Pointer to the opaque lock object to initialize
|
|
*
|
|
* cdf_mutex_init() function initializes the specified lock. Upon
|
|
* successful initialization, the state of the lock becomes initialized
|
|
* and unlocked.
|
|
*
|
|
* A lock must be initialized by calling cdf_mutex_init() before it
|
|
* may be used in any other lock functions.
|
|
*
|
|
* Attempting to initialize an already initialized lock results in
|
|
* a failure.
|
|
*
|
|
* Return:
|
|
* CDF_STATUS_SUCCESS: lock was successfully initialized
|
|
* CDF failure reason codes: lock is not initialized and can't be used
|
|
*/
|
|
CDF_STATUS cdf_mutex_init(cdf_mutex_t *lock);
|
|
|
|
/**
|
|
* cdf_mutex_acquire () - acquire a CDF lock
|
|
* @lock: Pointer to the opaque lock object to acquire
|
|
*
|
|
* A lock object is acquired by calling cdf_mutex_acquire(). If the lock
|
|
* is already locked, the calling thread shall block until the lock becomes
|
|
* available. This operation shall return with the lock object referenced by
|
|
* lock in the locked state with the calling thread as its owner.
|
|
*
|
|
* Return:
|
|
* CDF_STATUS_SUCCESS: lock was successfully initialized
|
|
* CDF failure reason codes: lock is not initialized and can't be used
|
|
*/
|
|
CDF_STATUS cdf_mutex_acquire(cdf_mutex_t *lock);
|
|
|
|
/**
|
|
* cdf_mutex_release() - release a CDF lock
|
|
* @lock: Pointer to the opaque lock object to be released
|
|
*
|
|
* cdf_mutex_release() function shall release the lock object
|
|
* referenced by 'lock'.
|
|
*
|
|
* If a thread attempts to release a lock that it unlocked or is not
|
|
* initialized, an error is returned.
|
|
*
|
|
* Return:
|
|
* CDF_STATUS_SUCCESS: lock was successfully initialized
|
|
* CDF failure reason codes: lock is not initialized and can't be used
|
|
*/
|
|
CDF_STATUS cdf_mutex_release(cdf_mutex_t *lock);
|
|
|
|
/**
|
|
* cdf_mutex_destroy() - destroy a CDF lock
|
|
* @lock: Pointer to the opaque lock object to be destroyed
|
|
*
|
|
* cdf_mutex_destroy() function shall destroy the lock object
|
|
* referenced by lock. After a successful return from \a cdf_mutex_destroy()
|
|
* the lock object becomes, in effect, uninitialized.
|
|
*
|
|
* A destroyed lock object can be reinitialized using cdf_mutex_init();
|
|
* the results of otherwise referencing the object after it has been destroyed
|
|
* are undefined. Calls to CDF lock functions to manipulate the lock such
|
|
* as cdf_mutex_acquire() will fail if the lock is destroyed. Therefore,
|
|
* don't use the lock after it has been destroyed until it has
|
|
* been re-initialized.
|
|
*
|
|
* Return:
|
|
* CDF_STATUS_SUCCESS: lock was successfully initialized
|
|
* CDF failure reason codes: lock is not initialized and can't be used
|
|
*/
|
|
CDF_STATUS cdf_mutex_destroy(cdf_mutex_t *lock);
|
|
|
|
/**
|
|
* cdf_spinlock_init() - initialize a spinlock
|
|
* @lock: Spinlock object pointer
|
|
*
|
|
* Return: None
|
|
*/
|
|
static inline void cdf_spinlock_init(cdf_spinlock_t *lock)
|
|
{
|
|
__cdf_spinlock_init(lock);
|
|
}
|
|
|
|
/**
|
|
* cdf_spinlock_destroy() - delete a spinlock
|
|
* @lock: Spinlock object pointer
|
|
*
|
|
* Return: None
|
|
*/
|
|
static inline void cdf_spinlock_destroy(cdf_spinlock_t *lock)
|
|
{
|
|
__cdf_spinlock_destroy(lock);
|
|
}
|
|
|
|
/**
|
|
* cdf_spin_lock_bh() - locks the spinlock semaphore in soft irq context
|
|
* @lock: Spinlock object pointer
|
|
*
|
|
* Return: None
|
|
*/
|
|
static inline void cdf_spin_lock_bh(cdf_spinlock_t *lock)
|
|
{
|
|
__cdf_spin_lock_bh(lock);
|
|
}
|
|
|
|
/**
|
|
* cdf_spin_lock_bh() - unlocks the spinlock semaphore in soft irq context
|
|
* @lock: Spinlock object pointer
|
|
*
|
|
* Return: None
|
|
*/
|
|
static inline void cdf_spin_unlock_bh(cdf_spinlock_t *lock)
|
|
{
|
|
__cdf_spin_unlock_bh(lock);
|
|
}
|
|
|
|
/**
|
|
* cdf_wake_lock_init() - initializes a CDF wake lock
|
|
* @lock: The wake lock to initialize
|
|
* @name: Name of wake lock
|
|
*
|
|
* Return:
|
|
* CDF status success : if wake lock is initialized
|
|
* CDF status fialure : if wake lock was not initialized
|
|
*/
|
|
CDF_STATUS cdf_wake_lock_init(cdf_wake_lock_t *lock, const char *name);
|
|
|
|
/**
|
|
* cdf_wake_lock_acquire() - acquires a wake lock
|
|
* @lock: The wake lock to acquire
|
|
* @reason: Reason for taking wakelock
|
|
*
|
|
* Return:
|
|
* CDF status success : if wake lock is acquired
|
|
* CDF status fialure : if wake lock was not acquired
|
|
*/
|
|
CDF_STATUS cdf_wake_lock_acquire(cdf_wake_lock_t *pLock, uint32_t reason);
|
|
|
|
/**
|
|
* cdf_wake_lock_timeout_acquire() - acquires a wake lock with a timeout
|
|
* @lock: The wake lock to acquire
|
|
* @reason: Reason for taking wakelock
|
|
*
|
|
* Return:
|
|
* CDF status success : if wake lock is acquired
|
|
* CDF status fialure : if wake lock was not acquired
|
|
*/
|
|
CDF_STATUS cdf_wake_lock_timeout_acquire(cdf_wake_lock_t *pLock,
|
|
uint32_t msec, uint32_t reason);
|
|
|
|
/**
|
|
* cdf_wake_lock_release() - releases a wake lock
|
|
* @lock: the wake lock to release
|
|
* @@reason: Reason for taking wakelock
|
|
*
|
|
* Return:
|
|
* CDF status success : if wake lock is acquired
|
|
* CDF status fialure : if wake lock was not acquired
|
|
*/
|
|
CDF_STATUS cdf_wake_lock_release(cdf_wake_lock_t *pLock, uint32_t reason);
|
|
|
|
/**
|
|
* cdf_wake_lock_destroy() - destroys a wake lock
|
|
* @lock: The wake lock to destroy
|
|
*
|
|
* Return:
|
|
* CDF status success : if wake lock is acquired
|
|
* CDF status fialure : if wake lock was not acquired
|
|
*/
|
|
CDF_STATUS cdf_wake_lock_destroy(cdf_wake_lock_t *pLock);
|
|
|
|
struct hif_pm_runtime_lock;
|
|
typedef struct hif_pm_runtime_lock *cdf_runtime_lock_t;
|
|
|
|
CDF_STATUS cdf_runtime_pm_get(void);
|
|
CDF_STATUS cdf_runtime_pm_put(void);
|
|
CDF_STATUS cdf_runtime_pm_prevent_suspend(cdf_runtime_lock_t lock);
|
|
CDF_STATUS cdf_runtime_pm_allow_suspend(cdf_runtime_lock_t lock);
|
|
cdf_runtime_lock_t cdf_runtime_lock_init(const char *name);
|
|
void cdf_runtime_lock_deinit(cdf_runtime_lock_t lock);
|
|
|
|
/**
|
|
* cdf_spinlock_acquire() - acquires a spin lock
|
|
* @lock: Spin lock to acquire
|
|
*
|
|
* Return:
|
|
* CDF status success : if wake lock is acquired
|
|
* CDF status fialure : if wake lock was not acquired
|
|
*/
|
|
CDF_STATUS cdf_spinlock_acquire(cdf_spinlock_t *pLock);
|
|
|
|
/**
|
|
* cdf_spinlock_release() - release a spin lock
|
|
* @lock: Spin lock to release
|
|
*
|
|
* Return:
|
|
* CDF status success : if wake lock is acquired
|
|
* CDF status fialure : if wake lock was not acquired
|
|
*/
|
|
CDF_STATUS cdf_spinlock_release(cdf_spinlock_t *pLock);
|
|
|
|
#define cdf_spin_lock(_lock) __cdf_spin_lock(_lock)
|
|
#define cdf_spin_unlock(_lock) __cdf_spin_unlock(_lock)
|
|
#define cdf_spin_lock_irqsave(_lock) __cdf_spin_lock_irqsave(_lock)
|
|
#define cdf_spin_unlock_irqrestore(_lock) \
|
|
__cdf_spin_unlock_irqrestore(_lock)
|
|
#define cdf_spin_lock_irq(_pLock, _flags) __cdf_spin_lock_irq(_pLock, _flags)
|
|
#define cdf_spin_unlock_irq(_pLock, _flags) \
|
|
__cdf_spin_unlock_irq(_pLock, _flags)
|
|
|
|
#define cdf_in_softirq() __cdf_in_softirq()
|
|
|
|
#endif /* __CDF_LOCK_H */
|