cachepc-linux

Fork of AMDESE/linux with modifications for CachePC side-channel attack
git clone https://git.sinitax.com/sinitax/cachepc-linux
Log | Files | Refs | README | LICENSE | sfeed.txt

syncpt.h (3217B)

      1/* SPDX-License-Identifier: GPL-2.0-only */
      2/*
      3 * Tegra host1x Syncpoints
      4 *
      5 * Copyright (c) 2010-2013, NVIDIA Corporation.
      6 */
      7
      8#ifndef __HOST1X_SYNCPT_H
      9#define __HOST1X_SYNCPT_H
     10
     11#include <linux/atomic.h>
     12#include <linux/host1x.h>
     13#include <linux/kernel.h>
     14#include <linux/kref.h>
     15#include <linux/sched.h>
     16
     17#include "intr.h"
     18
     19struct host1x;
     20
     21/* Reserved for replacing an expired wait with a NOP */
     22#define HOST1X_SYNCPT_RESERVED			0
     23
     24struct host1x_syncpt_base {
     25	unsigned int id;
     26	bool requested;
     27};
     28
     29struct host1x_syncpt {
     30	struct kref ref;
     31
     32	unsigned int id;
     33	atomic_t min_val;
     34	atomic_t max_val;
     35	u32 base_val;
     36	const char *name;
     37	bool client_managed;
     38	struct host1x *host;
     39	struct host1x_syncpt_base *base;
     40
     41	/* interrupt data */
     42	struct host1x_syncpt_intr intr;
     43
     44	/*
     45	 * If a submission incrementing this syncpoint fails, lock it so that
     46	 * further submission cannot be made until application has handled the
     47	 * failure.
     48	 */
     49	bool locked;
     50};
     51
     52/* Initialize sync point array  */
     53int host1x_syncpt_init(struct host1x *host);
     54
     55/*  Free sync point array */
     56void host1x_syncpt_deinit(struct host1x *host);
     57
     58/* Return number of sync point supported. */
     59unsigned int host1x_syncpt_nb_pts(struct host1x *host);
     60
     61/* Return number of wait bases supported. */
     62unsigned int host1x_syncpt_nb_bases(struct host1x *host);
     63
     64/* Return number of mlocks supported. */
     65unsigned int host1x_syncpt_nb_mlocks(struct host1x *host);
     66
     67/*
     68 * Check sync point sanity. If max is larger than min, there have too many
     69 * sync point increments.
     70 *
     71 * Client managed sync point are not tracked.
     72 * */
     73static inline bool host1x_syncpt_check_max(struct host1x_syncpt *sp, u32 real)
     74{
     75	u32 max;
     76	if (sp->client_managed)
     77		return true;
     78	max = host1x_syncpt_read_max(sp);
     79	return (s32)(max - real) >= 0;
     80}
     81
     82/* Return true if sync point is client managed. */
     83static inline bool host1x_syncpt_client_managed(struct host1x_syncpt *sp)
     84{
     85	return sp->client_managed;
     86}
     87
     88/*
     89 * Returns true if syncpoint min == max, which means that there are no
     90 * outstanding operations.
     91 */
     92static inline bool host1x_syncpt_idle(struct host1x_syncpt *sp)
     93{
     94	int min, max;
     95	smp_rmb();
     96	min = atomic_read(&sp->min_val);
     97	max = atomic_read(&sp->max_val);
     98	return (min == max);
     99}
    100
    101/* Load current value from hardware to the shadow register. */
    102u32 host1x_syncpt_load(struct host1x_syncpt *sp);
    103
    104/* Check if the given syncpoint value has already passed */
    105bool host1x_syncpt_is_expired(struct host1x_syncpt *sp, u32 thresh);
    106
    107/* Save host1x sync point state into shadow registers. */
    108void host1x_syncpt_save(struct host1x *host);
    109
    110/* Reset host1x sync point state from shadow registers. */
    111void host1x_syncpt_restore(struct host1x *host);
    112
    113/* Read current wait base value into shadow register and return it. */
    114u32 host1x_syncpt_load_wait_base(struct host1x_syncpt *sp);
    115
    116/* Indicate future operations by incrementing the sync point max. */
    117u32 host1x_syncpt_incr_max(struct host1x_syncpt *sp, u32 incrs);
    118
    119/* Check if sync point id is valid. */
    120static inline int host1x_syncpt_is_valid(struct host1x_syncpt *sp)
    121{
    122	return sp->id < host1x_syncpt_nb_pts(sp->host);
    123}
    124
    125static inline void host1x_syncpt_set_locked(struct host1x_syncpt *sp)
    126{
    127	sp->locked = true;
    128}
    129
    130#endif