samsung-sm8650/android_kernel_samsung_sm8650-modules
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Initial host-common file folder cleanup and moves

Browse Source 
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
This commit is contained in:
Prakash Dhavali
2016-03-02 00:54:45 -08:00
parent abcec8c47e
commit 142cee4bf2
549 changed files with 0 additions and 467753 deletions
Download Patch File Download Diff File Expand all files Collapse all files

306
qdf/inc/qdf_lock.h Normal file
View File

@@ -0,0 +1,306 @@
/*
* 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 */