/* Public domain. */

#ifndef _LINUX_SEQLOCK_H
#define _LINUX_SEQLOCK_H

#include <sys/types.h>
#include <sys/mutex.h>
#include <sys/atomic.h>
#include <linux/lockdep.h>
#include <linux/processor.h>
#include <linux/preempt.h>
#include <linux/compiler.h>

typedef struct {
	unsigned int sequence;
} seqcount_t;

static inline void
__seqcount_init(seqcount_t *s, const char *name,
    struct lock_class_key *key)
{
	s->sequence = 0;
}

static inline void
seqcount_init(seqcount_t *s)
{
	__seqcount_init(s, NULL, NULL);
}

static inline unsigned int
__read_seqcount_begin(const seqcount_t *s)
{
	unsigned int r;
	for (;;) {
		r = s->sequence;
		if ((r & 1) == 0)
			break;
		cpu_relax();
	}
	return r;
}

static inline unsigned int
read_seqcount_begin(const seqcount_t *s)
{
	unsigned int r = __read_seqcount_begin(s);
	membar_consumer();
	return r;
}

static inline int
__read_seqcount_retry(const seqcount_t *s, unsigned start)
{
	return (s->sequence != start);
}

static inline int
read_seqcount_retry(const seqcount_t *s, unsigned start)
{
	membar_consumer();
	return __read_seqcount_retry(s, start);
}

static inline void
write_seqcount_begin(seqcount_t *s)
{
	s->sequence++;
	membar_producer();
}

static inline void
write_seqcount_end(seqcount_t *s)
{
	membar_producer();
	s->sequence++;
}

static inline unsigned int
raw_read_seqcount(const seqcount_t *s)
{
	unsigned int r = s->sequence;
	membar_consumer();
	return r;
}

typedef struct {
	unsigned int seq;
	struct mutex lock;
} seqlock_t;

static inline void
seqlock_init(seqlock_t *sl, int wantipl)
{ 
	sl->seq = 0;
	mtx_init(&sl->lock, wantipl);
}

static inline void
write_seqlock(seqlock_t *sl)
{
	mtx_enter(&sl->lock);
	sl->seq++;
	membar_producer();
}

static inline void
__write_seqlock_irqsave(seqlock_t *sl)
{
	mtx_enter(&sl->lock);
	sl->seq++;
	membar_producer();
}
#define write_seqlock_irqsave(_sl, _flags) do {			\
		_flags = 0;					\
		__write_seqlock_irqsave(_sl);			\
	} while (0)

static inline void
write_sequnlock(seqlock_t *sl)
{
	membar_producer();
	sl->seq++;
	mtx_leave(&sl->lock);
}

static inline void
__write_sequnlock_irqrestore(seqlock_t *sl)
{
	membar_producer();
	sl->seq++;
	mtx_leave(&sl->lock);
}
#define write_sequnlock_irqrestore(_sl, _flags) do {		\
		(void)(_flags);					\
		__write_sequnlock_irqrestore(_sl);		\
	} while (0)

static inline unsigned int
read_seqbegin(seqlock_t *sl)
{
	return READ_ONCE(sl->seq);
}

static inline unsigned int
read_seqretry(seqlock_t *sl, unsigned int pos)
{
	return sl->seq != pos;
}

typedef struct {
	seqcount_t seq;
	struct rwlock lock;
} seqcount_mutex_t;

#define seqcount_mutex_init(s, l)	seqcount_init(&(s)->seq)

static inline unsigned int
seqprop_sequence(const seqcount_mutex_t *sm)
{
	return READ_ONCE(sm->seq.sequence);
}

#endif