hwspinlock.h

Go to the documentation of this file.

/*
 * Hardware spinlock public header
 *
 * Copyright (C) 2010 Texas Instruments Incorporated - http://www.ti.com
 *
 * Contact: Ohad Ben-Cohen <[email protected]>
 *
 * This program is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License version 2 as published
 * by the Free Software Foundation.
 *
 * This program is distributed in the hope that 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.
 */

#ifndef __LINUX_HWSPINLOCK_H
#define __LINUX_HWSPINLOCK_H

#include <linux/err.h>
#include <linux/sched.h>

/* hwspinlock mode argument */
#define HWLOCK_IRQSTATE 0x01    /* Disable interrupts, save state */
#define HWLOCK_IRQ  0x02    /* Disable interrupts, don't save state */

struct device;
struct hwspinlock;
struct hwspinlock_device;
struct hwspinlock_ops;

struct hwspinlock_pdata {
    int base_id;
};

#if defined(CONFIG_HWSPINLOCK) || defined(CONFIG_HWSPINLOCK_MODULE)

int hwspin_lock_register(struct hwspinlock_device *bank, struct device *dev,
        const struct hwspinlock_ops *ops, int base_id, int num_locks);
int hwspin_lock_unregister(struct hwspinlock_device *bank);
struct hwspinlock *hwspin_lock_request(void);
struct hwspinlock *hwspin_lock_request_specific(unsigned int id);
int hwspin_lock_free(struct hwspinlock *hwlock);
int hwspin_lock_get_id(struct hwspinlock *hwlock);
int __hwspin_lock_timeout(struct hwspinlock *, unsigned int, int,
                            unsigned long *);
int __hwspin_trylock(struct hwspinlock *, int, unsigned long *);
void __hwspin_unlock(struct hwspinlock *, int, unsigned long *);

#else /* !CONFIG_HWSPINLOCK */

/*
 * We don't want these functions to fail if CONFIG_HWSPINLOCK is not
 * enabled. We prefer to silently succeed in this case, and let the
 * code path get compiled away. This way, if CONFIG_HWSPINLOCK is not
 * required on a given setup, users will still work.
 *
 * The only exception is hwspin_lock_register/hwspin_lock_unregister, with which
 * we _do_ want users to fail (no point in registering hwspinlock instances if
 * the framework is not available).
 *
 * Note: ERR_PTR(-ENODEV) will still be considered a success for NULL-checking
 * users. Others, which care, can still check this with IS_ERR.
 */
static inline struct hwspinlock *hwspin_lock_request(void)
{
    return ERR_PTR(-ENODEV);
}

static inline struct hwspinlock *hwspin_lock_request_specific(unsigned int id)
{
    return ERR_PTR(-ENODEV);
}

static inline int hwspin_lock_free(struct hwspinlock *hwlock)
{
    return 0;
}

static inline
int __hwspin_lock_timeout(struct hwspinlock *hwlock, unsigned int to,
                    int mode, unsigned long *flags)
{
    return 0;
}

static inline
int __hwspin_trylock(struct hwspinlock *hwlock, int mode, unsigned long *flags)
{
    return 0;
}

static inline
void __hwspin_unlock(struct hwspinlock *hwlock, int mode, unsigned long *flags)
{
}

static inline int hwspin_lock_get_id(struct hwspinlock *hwlock)
{
    return 0;
}

#endif /* !CONFIG_HWSPINLOCK */

static inline
int hwspin_trylock_irqsave(struct hwspinlock *hwlock, unsigned long *flags)
{
    return __hwspin_trylock(hwlock, HWLOCK_IRQSTATE, flags);
}

static inline int hwspin_trylock_irq(struct hwspinlock *hwlock)
{
    return __hwspin_trylock(hwlock, HWLOCK_IRQ, NULL);
}

static inline int hwspin_trylock(struct hwspinlock *hwlock)
{
    return __hwspin_trylock(hwlock, 0, NULL);
}

static inline int hwspin_lock_timeout_irqsave(struct hwspinlock *hwlock,
                unsigned int to, unsigned long *flags)
{
    return __hwspin_lock_timeout(hwlock, to, HWLOCK_IRQSTATE, flags);
}

static inline
int hwspin_lock_timeout_irq(struct hwspinlock *hwlock, unsigned int to)
{
    return __hwspin_lock_timeout(hwlock, to, HWLOCK_IRQ, NULL);
}

static inline
int hwspin_lock_timeout(struct hwspinlock *hwlock, unsigned int to)
{
    return __hwspin_lock_timeout(hwlock, to, 0, NULL);
}

static inline void hwspin_unlock_irqrestore(struct hwspinlock *hwlock,
                            unsigned long *flags)
{
    __hwspin_unlock(hwlock, HWLOCK_IRQSTATE, flags);
}

static inline void hwspin_unlock_irq(struct hwspinlock *hwlock)
{
    __hwspin_unlock(hwlock, HWLOCK_IRQ, NULL);
}

static inline void hwspin_unlock(struct hwspinlock *hwlock)
{
    __hwspin_unlock(hwlock, 0, NULL);
}

#endif /* __LINUX_HWSPINLOCK_H */