Release 4.11 drivers/gpu/host1x/syncpt.c

Directory: drivers/gpu/host1x
/*
 * Tegra host1x Syncpoints
 *
 * Copyright (c) 2010-2015, NVIDIA Corporation.
 *
 * 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/>.
 */

#include <linux/module.h>
#include <linux/device.h>
#include <linux/slab.h>

#include <trace/events/host1x.h>

#include "syncpt.h"
#include "dev.h"
#include "intr.h"
#include "debug.h"


#define SYNCPT_CHECK_PERIOD (2 * HZ)

#define MAX_STUCK_CHECK_COUNT 15


static struct host1x_syncpt_base *

host1x_syncpt_base_request(struct host1x *host)
{
	struct host1x_syncpt_base *bases = host->bases;
	unsigned int i;

	for (i = 0; i < host->info->nb_bases; i++)
		if (!bases[i].requested)
			break;

	if (i >= host->info->nb_bases)
		return NULL;

	bases[i].requested = true;
	return &bases[i];
}

Contributors
Person Tokens Prop Commits CommitProp
Arto Merilainen 83 100.00% 1 100.00%
Total 83 100.00% 1 100.00%



static void host1x_syncpt_base_free(struct host1x_syncpt_base *base)
{
	if (base)
		base->requested = false;
}

Contributors
Person Tokens Prop Commits CommitProp
Arto Merilainen 21 100.00% 1 100.00%
Total 21 100.00% 1 100.00%



static struct host1x_syncpt *host1x_syncpt_alloc(struct host1x *host,
						 struct device *dev,
						 unsigned long flags)
{
	int i;
	struct host1x_syncpt *sp = host->syncpt;
	char *name;

	mutex_lock(&host->syncpt_mutex);

	for (i = 0; i < host->info->nb_pts && sp->name; i++, sp++)
		;

	if (i >= host->info->nb_pts)
		goto unlock;

	if (flags & HOST1X_SYNCPT_HAS_BASE) {
		sp->base = host1x_syncpt_base_request(host);
		if (!sp->base)
			goto unlock;
	}

	name = kasprintf(GFP_KERNEL, "%02u-%s", sp->id,
			dev ? dev_name(dev) : NULL);
	if (!name)
		goto free_base;

	sp->dev = dev;
	sp->name = name;

	if (flags & HOST1X_SYNCPT_CLIENT_MANAGED)
		sp->client_managed = true;
	else
		sp->client_managed = false;

	mutex_unlock(&host->syncpt_mutex);
	return sp;

free_base:
	host1x_syncpt_base_free(sp->base);
	sp->base = NULL;
unlock:
	mutex_unlock(&host->syncpt_mutex);
	return NULL;
}

Contributors
Person Tokens Prop Commits CommitProp
Terje Bergstrom 110 52.13% 1 16.67%
Arto Merilainen 100 47.39% 4 66.67%
Thierry Reding 1 0.47% 1 16.67%
Total 211 100.00% 6 100.00%



u32 host1x_syncpt_id(struct host1x_syncpt *sp)
{
	return sp->id;
}
Contributors
Person Tokens Prop Commits CommitProp
Terje Bergstrom 15 100.00% 1 100.00%
Total 15 100.00% 1 100.00%


EXPORT_SYMBOL(host1x_syncpt_id);

/*
 * Updates the value sent to hardware.
 */


u32 host1x_syncpt_incr_max(struct host1x_syncpt *sp, u32 incrs)
{
	return (u32)atomic_add_return(incrs, &sp->max_val);
}
Contributors
Person Tokens Prop Commits CommitProp
Terje Bergstrom 27 100.00% 1 100.00%
Total 27 100.00% 1 100.00%


EXPORT_SYMBOL(host1x_syncpt_incr_max);

 /*
 * Write cached syncpoint and waitbase values to hardware.
 */


void host1x_syncpt_restore(struct host1x *host)
{
	struct host1x_syncpt *sp_base = host->syncpt;
	unsigned int i;

	for (i = 0; i < host1x_syncpt_nb_pts(host); i++)
		host1x_hw_syncpt_restore(host, sp_base + i);

	for (i = 0; i < host1x_syncpt_nb_bases(host); i++)
		host1x_hw_syncpt_restore_wait_base(host, sp_base + i);

	wmb();
}

Contributors
Person Tokens Prop Commits CommitProp
Terje Bergstrom 74 97.37% 1 50.00%
Thierry Reding 2 2.63% 1 50.00%
Total 76 100.00% 2 100.00%

/*
 * Update the cached syncpoint and waitbase values by reading them
 * from the registers.
  */


void host1x_syncpt_save(struct host1x *host)
{
	struct host1x_syncpt *sp_base = host->syncpt;
	unsigned int i;

	for (i = 0; i < host1x_syncpt_nb_pts(host); i++) {
		if (host1x_syncpt_client_managed(sp_base + i))
			host1x_hw_syncpt_load(host, sp_base + i);
		else
			WARN_ON(!host1x_syncpt_idle(sp_base + i));
	}

	for (i = 0; i < host1x_syncpt_nb_bases(host); i++)
		host1x_hw_syncpt_load_wait_base(host, sp_base + i);
}

Contributors
Person Tokens Prop Commits CommitProp
Terje Bergstrom 94 97.92% 1 50.00%
Thierry Reding 2 2.08% 1 50.00%
Total 96 100.00% 2 100.00%

/*
 * Updates the cached syncpoint value by reading a new value from the hardware
 * register
 */


u32 host1x_syncpt_load(struct host1x_syncpt *sp)
{
	u32 val;

	val = host1x_hw_syncpt_load(sp->host, sp);
	trace_host1x_syncpt_load_min(sp->id, val);

	return val;
}

Contributors
Person Tokens Prop Commits CommitProp
Terje Bergstrom 36 100.00% 1 100.00%
Total 36 100.00% 1 100.00%

/*
 * Get the current syncpoint base
 */


u32 host1x_syncpt_load_wait_base(struct host1x_syncpt *sp)
{
	host1x_hw_syncpt_load_wait_base(sp->host, sp);

	return sp->base_val;
}

Contributors
Person Tokens Prop Commits CommitProp
Terje Bergstrom 23 95.83% 1 50.00%
Thierry Reding 1 4.17% 1 50.00%
Total 24 100.00% 2 100.00%

/*
 * Increment syncpoint value from cpu, updating cache
 */


int host1x_syncpt_incr(struct host1x_syncpt *sp)
{
	return host1x_hw_syncpt_cpu_incr(sp->host, sp);
}
Contributors
Person Tokens Prop Commits CommitProp
Terje Bergstrom 14 70.00% 1 50.00%
Arto Merilainen 6 30.00% 1 50.00%
Total 20 100.00% 2 100.00%


EXPORT_SYMBOL(host1x_syncpt_incr);

/*
 * Updated sync point form hardware, and returns true if syncpoint is expired,
 * false if we may need to wait
 */


static bool syncpt_load_min_is_expired(struct host1x_syncpt *sp, u32 thresh)
{
	host1x_hw_syncpt_load(sp->host, sp);

	return host1x_syncpt_is_expired(sp, thresh);
}

Contributors
Person Tokens Prop Commits CommitProp
Terje Bergstrom 31 100.00% 1 100.00%
Total 31 100.00% 1 100.00%

/*
 * Main entrypoint for syncpoint value waits.
 */


int host1x_syncpt_wait(struct host1x_syncpt *sp, u32 thresh, long timeout,
		       u32 *value)
{
	DECLARE_WAIT_QUEUE_HEAD_ONSTACK(wq);
	void *ref;
	struct host1x_waitlist *waiter;
	int err = 0, check_count = 0;
	u32 val;

	if (value)
		*value = 0;

	/* first check cache */
	if (host1x_syncpt_is_expired(sp, thresh)) {
		if (value)
			*value = host1x_syncpt_load(sp);

		return 0;
	}

	/* try to read from register */
	val = host1x_hw_syncpt_load(sp->host, sp);
	if (host1x_syncpt_is_expired(sp, thresh)) {
		if (value)
			*value = val;

		goto done;
	}

	if (!timeout) {
		err = -EAGAIN;
		goto done;
	}

	/* allocate a waiter */
	waiter = kzalloc(sizeof(*waiter), GFP_KERNEL);
	if (!waiter) {
		err = -ENOMEM;
		goto done;
	}

	/* schedule a wakeup when the syncpoint value is reached */
	err = host1x_intr_add_action(sp->host, sp->id, thresh,
				     HOST1X_INTR_ACTION_WAKEUP_INTERRUPTIBLE,
				     &wq, waiter, &ref);
	if (err)
		goto done;

	err = -EAGAIN;
	/* Caller-specified timeout may be impractically low */
	if (timeout < 0)
		timeout = LONG_MAX;

	/* wait for the syncpoint, or timeout, or signal */
	while (timeout) {
		long check = min_t(long, SYNCPT_CHECK_PERIOD, timeout);
		int remain;

		remain = wait_event_interruptible_timeout(wq,
				syncpt_load_min_is_expired(sp, thresh),
				check);
		if (remain > 0 || host1x_syncpt_is_expired(sp, thresh)) {
			if (value)
				*value = host1x_syncpt_load(sp);

			err = 0;

			break;
		}

		if (remain < 0) {
			err = remain;
			break;
		}

		timeout -= check;

		if (timeout && check_count <= MAX_STUCK_CHECK_COUNT) {
			dev_warn(sp->host->dev,
				"%s: syncpoint id %u (%s) stuck waiting %d, timeout=%ld\n",
				 current->comm, sp->id, sp->name,
				 thresh, timeout);

			host1x_debug_dump_syncpts(sp->host);

			if (check_count == MAX_STUCK_CHECK_COUNT)
				host1x_debug_dump(sp->host);

			check_count++;
		}
	}

	host1x_intr_put_ref(sp->host, sp->id, ref);

done:
	return err;
}
Contributors
Person Tokens Prop Commits CommitProp
Terje Bergstrom 370 98.67% 2 50.00%
Thierry Reding 5 1.33% 2 50.00%
Total 375 100.00% 4 100.00%


EXPORT_SYMBOL(host1x_syncpt_wait);

/*
 * Returns true if syncpoint is expired, false if we may need to wait
 */


bool host1x_syncpt_is_expired(struct host1x_syncpt *sp, u32 thresh)
{
	u32 current_val;
	u32 future_val;

	smp_rmb();

	current_val = (u32)atomic_read(&sp->min_val);
	future_val = (u32)atomic_read(&sp->max_val);

	/* Note the use of unsigned arithmetic here (mod 1<<32).
         *
         * c = current_val = min_val    = the current value of the syncpoint.
         * t = thresh                   = the value we are checking
         * f = future_val  = max_val    = the value c will reach when all
         *                                outstanding increments have completed.
         *
         * Note that c always chases f until it reaches f.
         *
         * Dtf = (f - t)
         * Dtc = (c - t)
         *
         *  Consider all cases:
         *
         *      A) .....c..t..f.....    Dtf < Dtc       need to wait
         *      B) .....c.....f..t..    Dtf > Dtc       expired
         *      C) ..t..c.....f.....    Dtf > Dtc       expired    (Dct very large)
         *
         *  Any case where f==c: always expired (for any t).    Dtf == Dcf
         *  Any case where t==c: always expired (for any f).    Dtf >= Dtc (because Dtc==0)
         *  Any case where t==f!=c: always wait.                Dtf <  Dtc (because Dtf==0,
         *                                                      Dtc!=0)
         *
         *  Other cases:
         *
         *      A) .....t..f..c.....    Dtf < Dtc       need to wait
         *      A) .....f..c..t.....    Dtf < Dtc       need to wait
         *      A) .....f..t..c.....    Dtf > Dtc       expired
         *
         *   So:
         *         Dtf >= Dtc implies EXPIRED   (return true)
         *         Dtf <  Dtc implies WAIT      (return false)
         *
         * Note: If t is expired then we *cannot* wait on it. We would wait
         * forever (hang the system).
         *
         * Note: do NOT get clever and remove the -thresh from both sides. It
         * is NOT the same.
         *
         * If future valueis zero, we have a client managed sync point. In that
         * case we do a direct comparison.
         */
	if (!host1x_syncpt_client_managed(sp))
		return future_val - thresh >= current_val - thresh;
	else
		return (s32)(current_val - thresh) >= 0;
}

Contributors
Person Tokens Prop Commits CommitProp
Terje Bergstrom 79 100.00% 1 100.00%
Total 79 100.00% 1 100.00%

/* remove a wait pointed to by patch_addr */


int host1x_syncpt_patch_wait(struct host1x_syncpt *sp, void *patch_addr)
{
	return host1x_hw_syncpt_patch_wait(sp->host, sp, patch_addr);
}

Contributors
Person Tokens Prop Commits CommitProp
Terje Bergstrom 26 100.00% 1 100.00%
Total 26 100.00% 1 100.00%



int host1x_syncpt_init(struct host1x *host)
{
	struct host1x_syncpt_base *bases;
	struct host1x_syncpt *syncpt;
	unsigned int i;

	syncpt = devm_kcalloc(host->dev, host->info->nb_pts, sizeof(*syncpt),
			      GFP_KERNEL);
	if (!syncpt)
		return -ENOMEM;

	bases = devm_kcalloc(host->dev, host->info->nb_bases, sizeof(*bases),
			     GFP_KERNEL);
	if (!bases)
		return -ENOMEM;

	for (i = 0; i < host->info->nb_pts; i++) {
		syncpt[i].id = i;
		syncpt[i].host = host;
	}

	for (i = 0; i < host->info->nb_bases; i++)
		bases[i].id = i;

	mutex_init(&host->syncpt_mutex);
	host->syncpt = syncpt;
	host->bases = bases;

	host1x_syncpt_restore(host);

	/* Allocate sync point to use for clearing waits for expired fences */
	host->nop_sp = host1x_syncpt_alloc(host, NULL, 0);
	if (!host->nop_sp)
		return -ENOMEM;

	return 0;
}

Contributors
Person Tokens Prop Commits CommitProp
Terje Bergstrom 116 56.86% 2 28.57%
Arto Merilainen 73 35.78% 3 42.86%
Thierry Reding 15 7.35% 2 28.57%
Total 204 100.00% 7 100.00%



struct host1x_syncpt *host1x_syncpt_request(struct device *dev,
					    unsigned long flags)
{
	struct host1x *host = dev_get_drvdata(dev->parent);

	return host1x_syncpt_alloc(host, dev, flags);
}
Contributors
Person Tokens Prop Commits CommitProp
Terje Bergstrom 33 86.84% 1 50.00%
Arto Merilainen 5 13.16% 1 50.00%
Total 38 100.00% 2 100.00%


EXPORT_SYMBOL(host1x_syncpt_request);



void host1x_syncpt_free(struct host1x_syncpt *sp)
{
	if (!sp)
		return;

	mutex_lock(&sp->host->syncpt_mutex);

	host1x_syncpt_base_free(sp->base);
	kfree(sp->name);
	sp->base = NULL;
	sp->dev = NULL;
	sp->name = NULL;
	sp->client_managed = false;

	mutex_unlock(&sp->host->syncpt_mutex);
}
Contributors
Person Tokens Prop Commits CommitProp
Terje Bergstrom 40 54.05% 1 25.00%
Arto Merilainen 34 45.95% 3 75.00%
Total 74 100.00% 4 100.00%


EXPORT_SYMBOL(host1x_syncpt_free);



void host1x_syncpt_deinit(struct host1x *host)
{
	struct host1x_syncpt *sp = host->syncpt;
	unsigned int i;

	for (i = 0; i < host->info->nb_pts; i++, sp++)
		kfree(sp->name);
}

Contributors
Person Tokens Prop Commits CommitProp
Terje Bergstrom 46 92.00% 1 50.00%
Thierry Reding 4 8.00% 1 50.00%
Total 50 100.00% 2 100.00%

/*
 * Read max. It indicates how many operations there are in queue, either in
 * channel or in a software thread.
 */


u32 host1x_syncpt_read_max(struct host1x_syncpt *sp)
{
	smp_rmb();

	return (u32)atomic_read(&sp->max_val);
}
Contributors
Person Tokens Prop Commits CommitProp
Thierry Reding 25 100.00% 1 100.00%
Total 25 100.00% 1 100.00%


EXPORT_SYMBOL(host1x_syncpt_read_max);

/*
 * Read min, which is a shadow of the current sync point value in hardware.
 */


u32 host1x_syncpt_read_min(struct host1x_syncpt *sp)
{
	smp_rmb();

	return (u32)atomic_read(&sp->min_val);
}
Contributors
Person Tokens Prop Commits CommitProp
Thierry Reding 25 100.00% 1 100.00%
Total 25 100.00% 1 100.00%


EXPORT_SYMBOL(host1x_syncpt_read_min);



u32 host1x_syncpt_read(struct host1x_syncpt *sp)
{
	return host1x_syncpt_load(sp);
}
Contributors
Person Tokens Prop Commits CommitProp
Thierry Reding 16 100.00% 1 100.00%
Total 16 100.00% 1 100.00%


EXPORT_SYMBOL(host1x_syncpt_read);



unsigned int host1x_syncpt_nb_pts(struct host1x *host)
{
	return host->info->nb_pts;
}

Contributors
Person Tokens Prop Commits CommitProp
Terje Bergstrom 17 94.44% 1 50.00%
Thierry Reding 1 5.56% 1 50.00%
Total 18 100.00% 2 100.00%



unsigned int host1x_syncpt_nb_bases(struct host1x *host)
{
	return host->info->nb_bases;
}

Contributors
Person Tokens Prop Commits CommitProp
Terje Bergstrom 17 94.44% 1 50.00%
Thierry Reding 1 5.56% 1 50.00%
Total 18 100.00% 2 100.00%



unsigned int host1x_syncpt_nb_mlocks(struct host1x *host)
{
	return host->info->nb_mlocks;
}

Contributors
Person Tokens Prop Commits CommitProp
Terje Bergstrom 17 94.44% 1 50.00%
Thierry Reding 1 5.56% 1 50.00%
Total 18 100.00% 2 100.00%



struct host1x_syncpt *host1x_syncpt_get(struct host1x *host, unsigned int id)
{
	if (host->info->nb_pts < id)
		return NULL;

	return host->syncpt + id;
}
Contributors
Person Tokens Prop Commits CommitProp
Terje Bergstrom 34 94.44% 1 50.00%
Thierry Reding 2 5.56% 1 50.00%
Total 36 100.00% 2 100.00%


EXPORT_SYMBOL(host1x_syncpt_get);



struct host1x_syncpt_base *host1x_syncpt_get_base(struct host1x_syncpt *sp)
{
	return sp ? sp->base : NULL;
}
Contributors
Person Tokens Prop Commits CommitProp
Arto Merilainen 21 100.00% 1 100.00%
Total 21 100.00% 1 100.00%


EXPORT_SYMBOL(host1x_syncpt_get_base);



u32 host1x_syncpt_base_id(struct host1x_syncpt_base *base)
{
	return base->id;
}
Contributors
Person Tokens Prop Commits CommitProp
Arto Merilainen 15 100.00% 1 100.00%
Total 15 100.00% 1 100.00%


EXPORT_SYMBOL(host1x_syncpt_base_id);
Overall Contributors
Person Tokens Prop Commits CommitProp
Terje Bergstrom 1266 71.00% 4 20.00%
Arto Merilainen 359 20.13% 6 30.00%
Thierry Reding 153 8.58% 9 45.00%
Bryan Wu 5 0.28% 1 5.00%
Total 1783 100.00% 20 100.00%
Directory: drivers/gpu/host1x

Information contained on this website is for historical information purposes only and does not indicate or represent copyright ownership.
Created with cregit.
Person	Tokens	Prop	Commits	CommitProp
Arto Merilainen	83	100.00%	1	100.00%
Total	83	100.00%	1	100.00%
cregit-Linux how code gets into the kernel

Release 4.11 drivers/gpu/host1x/syncpt.c

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Overall Contributors
