nv-tegra-mirror/linux-nvgpu
1
0
Fork 0
mirror of git://nv-tegra.nvidia.com/linux-nvgpu.git synced 2025-12-24 10:34:43 +03:00
Code Issues Packages Projects Releases Wiki Activity

gpu: nvgpu: add mutex and spinlock abstraction files

Browse Source 
Add new abstraction file <nvgpu/lock.h> for all mutex,
spinlock and raw_spinlock operations.

Add linux specific file <nvgpu/lock_linux.h>
which implements linux specific operations for above

Jira NVGPU-13

Change-Id: Idab96aa8bf949d6a92ea0edc9f40e90fca401ea4
Signed-off-by: Deepak Nibade <dnibade@nvidia.com>
Reviewed-on: http://git-master/r/1293186
GVS: Gerrit_Virtual_Submit
Reviewed-by: Konsta Holtta <kholtta@nvidia.com>
Reviewed-by: Bharat Nihalani <bnihalani@nvidia.com>
This commit is contained in:
Deepak Nibade
2017-01-24 16:41:51 +05:30
committed by mobile promotions
parent 76611c4268
commit 1f855af63f
2 changed files with 144 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

63
drivers/gpu/nvgpu/include/nvgpu/lock.h Normal file
View File

@@ -0,0 +1,63 @@
/*
* Copyright (c) 2017, NVIDIA CORPORATION. All rights reserved.
*
* This program is free software; you can redistribute it and/or modify it
* under the terms and conditions of the GNU General Public License,
* version 2, as published by the Free Software Foundation.
*
* This program is distributed in the hope it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
* more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#ifndef NVGPU_LOCK_H
#define NVGPU_LOCK_H
#include <nvgpu/lock_linux.h>
/*
* struct nvgpu_mutex
*
* Should be implemented per-OS in a separate library
* But implementation should adhere to mutex implementation
* as specified in Linux Documentation
*/
struct nvgpu_mutex;
/*
* struct nvgpu_spinlock
*
* Should be implemented per-OS in a separate library
* But implementation should adhere to spinlock implementation
* as specified in Linux Documentation
*/
struct nvgpu_spinlock;
/*
* struct nvgpu_raw_spinlock
*
* Should be implemented per-OS in a separate library
* But implementation should adhere to raw_spinlock implementation
* as specified in Linux Documentation
*/
struct nvgpu_raw_spinlock;
int nvgpu_mutex_init(struct nvgpu_mutex *mutex);
void nvgpu_mutex_acquire(struct nvgpu_mutex *mutex);
void nvgpu_mutex_release(struct nvgpu_mutex *mutex);
int nvgpu_mutex_tryacquire(struct nvgpu_mutex *mutex);
void nvgpu_mutex_destroy(struct nvgpu_mutex *mutex);
void nvgpu_spinlock_init(struct nvgpu_spinlock *spinlock);
void nvgpu_spinlock_acquire(struct nvgpu_spinlock *spinlock);
void nvgpu_spinlock_release(struct nvgpu_spinlock *spinlock);
void nvgpu_raw_spinlock_init(struct nvgpu_raw_spinlock *spinlock);
void nvgpu_raw_spinlock_acquire(struct nvgpu_raw_spinlock *spinlock);
void nvgpu_raw_spinlock_release(struct nvgpu_raw_spinlock *spinlock);
#endif /* NVGPU_LOCK_H */

81
drivers/gpu/nvgpu/include/nvgpu/lock_linux.h Normal file
View File

@@ -0,0 +1,81 @@
/*
* Copyright (c) 2017, NVIDIA CORPORATION. All rights reserved.
*
* This program is free software; you can redistribute it and/or modify it
* under the terms and conditions of the GNU General Public License,
* version 2, as published by the Free Software Foundation.
*
* This program is distributed in the hope it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
* more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#ifndef NVGPU_LOCK_LINUX_H
#define NVGPU_LOCK_LINUX_H
#include <linux/mutex.h>
#include <linux/spinlock.h>
struct nvgpu_mutex {
struct mutex mutex;
};
struct nvgpu_spinlock {
spinlock_t spinlock;
};
struct nvgpu_raw_spinlock {
raw_spinlock_t spinlock;
};
static inline int nvgpu_mutex_init(struct nvgpu_mutex *mutex)
{
mutex_init(&mutex->mutex);
return 0;
};
static inline void nvgpu_mutex_acquire(struct nvgpu_mutex *mutex)
{
mutex_lock(&mutex->mutex);
};
static inline void nvgpu_mutex_release(struct nvgpu_mutex *mutex)
{
mutex_unlock(&mutex->mutex);
};
static inline int nvgpu_mutex_tryacquire(struct nvgpu_mutex *mutex)
{
return mutex_trylock(&mutex->mutex);
};
static inline void nvgpu_mutex_destroy(struct nvgpu_mutex *mutex)
{
mutex_destroy(&mutex->mutex);
};
static inline void nvgpu_spinlock_init(struct nvgpu_spinlock *spinlock)
{
spin_lock_init(&spinlock->spinlock);
};
static inline void nvgpu_spinlock_acquire(struct nvgpu_spinlock *spinlock)
{
spin_lock(&spinlock->spinlock);
};
static inline void nvgpu_spinlock_release(struct nvgpu_spinlock *spinlock)
{
spin_unlock(&spinlock->spinlock);
};
static inline void nvgpu_raw_spinlock_init(struct nvgpu_raw_spinlock *spinlock)
{
raw_spin_lock_init(&spinlock->spinlock);
};
static inline void nvgpu_raw_spinlock_acquire(struct nvgpu_raw_spinlock *spinlock)
{
raw_spin_lock(&spinlock->spinlock);
};
static inline void nvgpu_raw_spinlock_release(struct nvgpu_raw_spinlock *spinlock)
{
raw_spin_unlock(&spinlock->spinlock);
};
#endif /* NVGPU_LOCK_LINUX_H */