{
int i;
u32 word = 0;
- for (i = 0; i < num && words[i] && words[i] < 32; i++)
+ for (i = 0; i < num; i++) {
+ if (!words[i] || words[i] > 31)
+ continue;
word |= BIT(words[i]);
+ }
return word;
}
platform_get_drvdata(priv->ch->dev);
struct nvhost_get_param_arg *arg =
(struct nvhost_get_param_arg *)buf;
- if (arg->param >= NVHOST_MODULE_MAX_SYNCPTS
- || !pdata->syncpts[arg->param])
+ if (arg->param >= NVHOST_MODULE_MAX_SYNCPTS)
return -EINVAL;
- arg->value = pdata->syncpts[arg->param];
+ /* if we already have required syncpt then return it ... */
+ if (pdata->syncpts[arg->param]) {
+ arg->value = pdata->syncpts[arg->param];
+ break;
+ }
+ /* ... otherwise get a new syncpt dynamically */
+ arg->value = nvhost_get_syncpt_host_managed(pdata->pdev,
+ arg->param);
+ if (!arg->value)
+ return -EAGAIN;
+ /* ... and store it for further references */
+ pdata->syncpts[arg->param] = arg->value;
break;
}
case NVHOST_IOCTL_CHANNEL_GET_WAITBASES:
#include "nvhost_as.h"
#include "debug.h"
#include "nvhost_sync.h"
+#include "nvhost_syncpt.h"
#include "gk20a.h"
#include "dbg_gpu_gk20a.h"
void gk20a_disable_channel_no_update(struct channel_gk20a *ch)
{
- struct nvhost_device_data *pdata = nvhost_get_devdata(ch->g->dev);
struct nvhost_master *host = host_from_gk20a_channel(ch);
/* ensure no fences are pending */
nvhost_syncpt_set_min_eq_max(&host->syncpt,
- ch->hw_chid + pdata->syncpt_base);
+ ch->syncpt_id);
/* disable channel */
gk20a_writel(ch->g, ccsr_channel_r(ch->hw_chid),
mutex_unlock(&ch->dbg_s_lock);
+ /* free the syncpt used for this channel */
+ nvhost_free_syncpt(ch->syncpt_id);
+ ch->syncpt_id = 0;
+
/* ALWAYS last */
release_used_channel(f, ch);
}
struct gk20a *g = get_gk20a(ch->dev);
struct fifo_gk20a *f = &g->fifo;
struct channel_gk20a *ch_gk20a;
+ struct nvhost_device_data *pdata = nvhost_get_devdata(g->dev);
ch_gk20a = acquire_unused_channel(f);
if (ch_gk20a == NULL) {
return 0;
}
+ /* get a free syncpt id */
+ ch_gk20a->syncpt_id = nvhost_get_syncpt_host_managed(pdata->pdev,
+ ch_gk20a->hw_chid);
+ if (!ch_gk20a->syncpt_id) {
+ nvhost_err(dev_from_gk20a(g), "could not get free syncpt");
+ return 0;
+ }
+
ctx->priv = ch_gk20a;
ch_gk20a->g = g;
/* note the ch here is the same for *EVERY* gk20a channel */
struct nvhost_alloc_gpfifo_args *args)
{
struct gk20a *g = c->g;
- struct nvhost_device_data *pdata = nvhost_get_devdata(g->dev);
struct device *d = dev_from_gk20a(g);
struct vm_gk20a *ch_vm;
u32 gpfifo_size;
c->last_submit_fence.valid = false;
c->last_submit_fence.syncpt_value = 0;
- c->last_submit_fence.syncpt_id = c->hw_chid + pdata->syncpt_base;
+ c->last_submit_fence.syncpt_id = c->syncpt_id;
c->ramfc.offset = 0;
c->ramfc.size = ram_in_ramfc_s() / 8;
u32 flags)
{
struct gk20a *g = c->g;
- struct nvhost_device_data *pdata = nvhost_get_devdata(g->dev);
struct device *d = dev_from_gk20a(g);
struct nvhost_syncpt *sp = syncpt_from_gk20a(g);
u32 i, incr_id = ~0, wait_id = ~0, wait_value = 0;
num_entries,
flags,
fence->syncpt_id, fence->value,
- c->hw_chid + pdata->syncpt_base);
+ c->syncpt_id);
check_gp_put(g, c);
update_gp_get(g, c);
if (incr_cmd) {
int j = 0;
- incr_id = c->hw_chid + pdata->syncpt_base;
+ incr_id = c->syncpt_id;
fence->syncpt_id = incr_id;
fence->value = nvhost_syncpt_incr_max(sp, incr_id, 1);
int gk20a_channel_finish(struct channel_gk20a *ch, unsigned long timeout)
{
struct nvhost_syncpt *sp = syncpt_from_gk20a(ch->g);
- struct nvhost_device_data *pdata = nvhost_get_devdata(ch->g->dev);
struct nvhost_fence fence;
int err = 0;
if (!(ch->last_submit_fence.valid && ch->last_submit_fence.wfi)) {
nvhost_dbg_fn("issuing wfi, incr to finish the channel");
- fence.syncpt_id = ch->hw_chid + pdata->syncpt_base;
+ fence.syncpt_id = ch->syncpt_id;
err = gk20a_channel_submit_wfi_fence(ch->g, ch,
sp, &fence);
}
struct nvhost_fence fence;
struct nvhost_syncpt *sp = syncpt_from_gk20a(g);
struct device *d = dev_from_gk20a(g);
- struct nvhost_device_data *pdata = nvhost_get_devdata(g->dev);
int err;
nvhost_dbg_fn("");
for (chid = 0; chid < f->num_channels; chid++) {
struct channel_gk20a *c = &f->channel[chid];
if (c->in_use && c->obj_class != KEPLER_C) {
- fence.syncpt_id = chid + pdata->syncpt_base;
+ fence.syncpt_id = c->syncpt_id;
err = gk20a_channel_submit_wfi_fence(g,
c, sp, &fence);
if (err) {
bool vpr;
pid_t pid;
+ u32 syncpt_id;
+
struct mem_mgr *memmgr;
struct nvhost_channel *ch;
struct nvhost_hwctx *hwctx;
struct gk20a_platform gk20a_tegra_platform = {
.nvhost = {
- .syncpts = {NVSYNCPT_GK20A_BASE},
- .syncpt_base = NVSYNCPT_GK20A_BASE,
.class = NV_GRAPHICS_GPU_CLASS_ID,
.clocks = {{"PLLG_ref", UINT_MAX},
{"pwr", 204000000},
#include "chip_support.h"
#include "nvhost_channel.h"
+#include "host1x/host1x.h"
+
#define MAX_SYNCPT_LENGTH 5
#define NUM_SYSFS_ENTRY 4
static const char *get_syncpt_name(struct nvhost_syncpt *sp, int id)
{
- struct host1x_device_info *info = &syncpt_to_dev(sp)->info;
const char *name = NULL;
- name = info->syncpt_names[id];
+ name = sp->syncpt_names[id];
return name ? name : "";
}
return 0;
}
+/**
+ * performs a sequential search and returns first free syncpt id
+ */
+static u32 nvhost_find_free_syncpt(struct nvhost_syncpt *sp)
+{
+ u32 i;
+
+ for (i = NVHOST_FREE_SYNCPT_BASE; i < nvhost_syncpt_nb_pts(sp); ++i)
+ if (!sp->assigned[i])
+ return i;
+
+ return 0;
+}
+
+/**
+ * marks a free syncpt id as reserved
+ */
+static int nvhost_reserve_syncpt(struct nvhost_syncpt *sp, u32 id,
+ bool client_managed)
+{
+ /* is it already reserved ? */
+ if (id < NVHOST_FREE_SYNCPT_BASE || sp->assigned[id])
+ return -EINVAL;
+
+ sp->assigned[id] = true;
+ sp->client_managed[id] = client_managed;
+
+ return 0;
+}
+
+/**
+ * assigns a name to syncpt
+ */
+static int nvhost_syncpt_assign_name(struct nvhost_syncpt *sp, u32 id,
+ const char *syncpt_name)
+{
+ if (id < NVHOST_FREE_SYNCPT_BASE || !sp->assigned[id])
+ return -EINVAL;
+
+ sp->syncpt_names[id] = syncpt_name;
+
+ return 0;
+}
+
+static u32 nvhost_get_syncpt(struct nvhost_syncpt *sp, bool client_managed,
+ const char *syncpt_name)
+{
+ u32 id;
+ int err = 0;
+ struct nvhost_master *host = syncpt_to_dev(sp);
+ struct device *d = &host->dev->dev;
+
+ mutex_lock(&sp->syncpt_mutex);
+
+ /* find a syncpt which is free */
+ id = nvhost_find_free_syncpt(sp);
+ if (!id) {
+ nvhost_err(d, "failed to get new free syncpt\n");
+ mutex_unlock(&sp->syncpt_mutex);
+ return 0;
+ }
+
+ /* if we get one, then reserve it */
+ err = nvhost_reserve_syncpt(sp, id, client_managed);
+ if (err) {
+ nvhost_err(d, "syncpt reservation failed\n");
+ mutex_unlock(&sp->syncpt_mutex);
+ return 0;
+ }
+
+ /* assign a name for debugging purpose */
+ err = nvhost_syncpt_assign_name(sp, id, syncpt_name);
+ if (err) {
+ nvhost_err(d, "syncpt name assignment failed\n");
+ mutex_unlock(&sp->syncpt_mutex);
+ return 0;
+ }
+
+ mutex_unlock(&sp->syncpt_mutex);
+
+ return id;
+}
+
+/**
+ * Interface to get a new free (host managed) syncpt dynamically
+ */
+u32 nvhost_get_syncpt_host_managed(struct platform_device *pdev,
+ u32 param)
+{
+ u32 id;
+ char *syncpt_name;
+ struct nvhost_master *nvhost_master = nvhost_get_host(pdev);
+
+ syncpt_name = kasprintf(GFP_KERNEL, "%s_%d",
+ dev_name(&pdev->dev), param);
+
+ id = nvhost_get_syncpt(&nvhost_master->syncpt, false, syncpt_name);
+ if (!id) {
+ nvhost_err(&pdev->dev, "failed to get syncpt\n");
+ return 0;
+ }
+
+ return id;
+}
+
+/**
+ * Interface to get a new free (client managed) syncpt dynamically
+ */
+u32 nvhost_get_syncpt_client_managed(const char *syncpt_name)
+{
+ u32 id;
+ struct nvhost_master *host = nvhost;
+
+ if (!syncpt_name)
+ syncpt_name = kasprintf(GFP_KERNEL, "client_managed");
+
+ id = nvhost_get_syncpt(&host->syncpt, true, syncpt_name);
+ if (!id) {
+ nvhost_err(&host->dev->dev, "failed to get syncpt\n");
+ return 0;
+ }
+
+ return id;
+}
+EXPORT_SYMBOL_GPL(nvhost_get_syncpt_client_managed);
+
+/**
+ * API to mark in-use syncpt as free
+ */
+void nvhost_free_syncpt(u32 id)
+{
+ struct nvhost_master *host = nvhost;
+ struct nvhost_syncpt *sp = &host->syncpt;
+
+ WARN_ON(!sp->assigned[id]);
+
+ mutex_lock(&sp->syncpt_mutex);
+
+ /* set to default state */
+ sp->assigned[id] = false;
+ sp->client_managed[id] = false;
+ kfree(sp->syncpt_names[id]);
+ sp->syncpt_names[id] = NULL;
+
+ mutex_unlock(&sp->syncpt_mutex);
+}
+
+static void nvhost_reserve_vblank_syncpts(struct nvhost_syncpt *sp)
+{
+ mutex_lock(&sp->syncpt_mutex);
+
+ sp->assigned[NVSYNCPT_VBLANK0] = true;
+ sp->client_managed[NVSYNCPT_VBLANK0] = true;
+ sp->syncpt_names[NVSYNCPT_VBLANK0] = "vblank0";
+
+ sp->assigned[NVSYNCPT_VBLANK1] = true;
+ sp->client_managed[NVSYNCPT_VBLANK1] = true;
+ sp->syncpt_names[NVSYNCPT_VBLANK1] = "vblank1";
+
+ mutex_unlock(&sp->syncpt_mutex);
+}
+
int nvhost_syncpt_init(struct platform_device *dev,
struct nvhost_syncpt *sp)
{
int err = 0;
/* Allocate structs for min, max and base values */
+ sp->assigned = kzalloc(sizeof(bool) * nvhost_syncpt_nb_pts(sp),
+ GFP_KERNEL);
+ sp->client_managed = kzalloc(sizeof(bool) * nvhost_syncpt_nb_pts(sp),
+ GFP_KERNEL);
+ sp->syncpt_names = kzalloc(sizeof(char *) * nvhost_syncpt_nb_pts(sp),
+ GFP_KERNEL);
sp->min_val = kzalloc(sizeof(atomic_t) * nvhost_syncpt_nb_pts(sp),
GFP_KERNEL);
sp->max_val = kzalloc(sizeof(atomic_t) * nvhost_syncpt_nb_pts(sp),
}
#endif
- if (!(sp->min_val && sp->max_val && sp->base_val && sp->lock_counts)) {
+ if (!(sp->assigned && sp->client_managed && sp->min_val && sp->max_val
+ && sp->base_val && sp->lock_counts)) {
/* frees happen in the deinit */
err = -ENOMEM;
goto fail;
goto fail;
}
+ mutex_init(&sp->syncpt_mutex);
+
/* Allocate two attributes for each sync point: min and max */
sp->syncpt_attrs = kzalloc(sizeof(*sp->syncpt_attrs)
* nvhost_syncpt_nb_pts(sp) * NUM_SYSFS_ENTRY,
if (err)
goto fail;
+ /* initialize syncpt status */
+ sp->assigned[i] = false;
+ sp->client_managed[i] = false;
+
#ifdef CONFIG_TEGRA_GRHOST_SYNC
sp->timeline[i] = nvhost_sync_timeline_create(sp, i);
if (!sp->timeline[i]) {
}
#endif
+ nvhost_reserve_vblank_syncpts(sp);
+
return err;
fail:
kfree(sp->syncpt_attrs);
sp->syncpt_attrs = NULL;
+ kfree(sp->syncpt_names);
+ sp->syncpt_names = NULL;
+
+ kfree(sp->client_managed);
+ sp->client_managed = NULL;
+
+ kfree(sp->assigned);
+ sp->assigned = NULL;
+
nvhost_syncpt_deinit_timeline(sp);
}
int nvhost_syncpt_client_managed(struct nvhost_syncpt *sp, u32 id)
{
- u64 mask = 1ULL << id;
- return !!(syncpt_to_dev(sp)->info.client_managed & mask);
+ return sp->client_managed[id];
}
int nvhost_syncpt_nb_pts(struct nvhost_syncpt *sp)
void nvhost_syncpt_set_manager(struct nvhost_syncpt *sp, int id, bool client)
{
- u64 mask = 1ULL << id;
- syncpt_to_dev(sp)->info.client_managed &= ~mask;
- syncpt_to_dev(sp)->info.client_managed |= client ? mask : 0;
+ sp->client_managed[id] = client;
}
/* public sync point API */
#include <linux/nvhost.h>
#include <linux/atomic.h>
+/* when searching for free syncpt id, start from this base */
+#define NVHOST_FREE_SYNCPT_BASE 1
+
struct nvhost_syncpt;
/* Attribute struct for sysfs min and max attributes */
};
struct nvhost_syncpt {
+ bool *assigned;
+ bool *client_managed;
struct kobject *kobj;
+ struct mutex syncpt_mutex;
atomic_t *min_val;
atomic_t *max_val;
u32 *base_val;
int nvhost_syncpt_init(struct platform_device *, struct nvhost_syncpt *);
void nvhost_syncpt_deinit(struct nvhost_syncpt *);
+u32 nvhost_get_syncpt_host_managed(struct platform_device *pdata,
+ u32 param);
+void nvhost_free_syncpt(u32 id);
+
#define syncpt_to_dev(sp) container_of(sp, struct nvhost_master, syncpt)
#define SYNCPT_CHECK_PERIOD (2 * HZ)
#define MAX_STUCK_CHECK_COUNT 15
*
* Tegra Graphics Init for Tegra11 Architecture Chips
*
- * Copyright (c) 2011-2013, NVIDIA Corporation. All rights reserved.
+ * Copyright (c) 2011-2014, 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,
struct nvhost_device_data t11_gr3d_info = {
.version = 3,
.index = 1,
- .syncpts = {NVSYNCPT_3D},
.waitbases = {NVWAITBASE_3D},
.modulemutexes = {NVMODMUTEX_3D},
.class = NV_GRAPHICS_3D_CLASS_ID,
struct nvhost_device_data t11_gr2d_info = {
.version = 2,
.index = 2,
- .syncpts = {NVSYNCPT_2D_0, NVSYNCPT_2D_1},
.waitbases = {NVWAITBASE_2D_0, NVWAITBASE_2D_1},
.modulemutexes = {NVMODMUTEX_2D_FULL, NVMODMUTEX_2D_SIMPLE,
NVMODMUTEX_2D_SB_A, NVMODMUTEX_2D_SB_B},
struct nvhost_device_data t11_isp_info = {
.index = 3,
- .syncpts = {NVSYNCPT_VI_ISP_2, NVSYNCPT_VI_ISP_3,
- NVSYNCPT_VI_ISP_4},
.keepalive = true,
NVHOST_MODULE_NO_POWERGATE_IDS,
NVHOST_DEFAULT_CLOCKGATE_DELAY,
struct nvhost_device_data t11_vi_info = {
.index = 4,
- .syncpts = {NVSYNCPT_CSI_VI_0, NVSYNCPT_CSI_VI_1,
- NVSYNCPT_VI_ISP_0, NVSYNCPT_VI_ISP_1,
- NVSYNCPT_VI_ISP_2, NVSYNCPT_VI_ISP_3,
- NVSYNCPT_VI_ISP_4},
.modulemutexes = {NVMODMUTEX_VI},
.clocks = { {"host1x", 136000000, 6} },
.exclusive = true,
struct nvhost_device_data t11_msenc_info = {
.version = NVHOST_ENCODE_MSENC_VER(2, 0),
.index = 5,
- .syncpts = {NVSYNCPT_MSENC},
.waitbases = {NVWAITBASE_MSENC},
.class = NV_VIDEO_ENCODE_MSENC_CLASS_ID,
.clocks = { {"msenc", UINT_MAX, 107, TEGRA_MC_CLIENT_MSENC},
struct nvhost_device_data t11_tsec_info = {
.version = NVHOST_ENCODE_TSEC_VER(1, 0),
.index = 7,
- .syncpts = {NVSYNCPT_TSEC},
.waitbases = {NVWAITBASE_TSEC},
.class = NV_TSEC_CLASS_ID,
.exclusive = false,
static struct platform_device tegra_isp01b_device;
struct nvhost_device_data t124_isp_info = {
/* FIXME: control clocks from user space instead of hard-coding here */
- .syncpts = NV_ISP_0_SYNCPTS,
.moduleid = NVHOST_MODULE_ISP,
.modulemutexes = {NVMODMUTEX_ISP_0},
.exclusive = true,
struct nvhost_device_data t124_ispb_info = {
/* FIXME: control clocks from user space instead of hard-coding here */
- .syncpts = NV_ISP_1_SYNCPTS,
.moduleid = (1 << 16) | NVHOST_MODULE_ISP,
.modulemutexes = {NVMODMUTEX_ISP_1},
.exclusive = true,
struct nvhost_device_data t124_vi_info = {
/* FIXME: resolve powergating dependency with DIS */
/* FIXME: control clocks from user space instead of hard-coding here */
- .syncpts = NV_VI_0_SYNCPTS,
.moduleid = NVHOST_MODULE_VI,
.modulemutexes = {NVMODMUTEX_VI_0},
.exclusive = true,
struct nvhost_device_data t124_vib_info = {
/* FIXME: resolve powergating dependency with DIS */
/* FIXME: control clocks from user space instead of hard-coding here */
- .syncpts = NV_VI_1_SYNCPTS,
.moduleid = (1 << 16 | NVHOST_MODULE_VI),
.modulemutexes = {NVMODMUTEX_VI_1},
.exclusive = true,
struct nvhost_device_data t124_msenc_info = {
.version = NVHOST_ENCODE_MSENC_VER(3, 1),
- .syncpts = {NVSYNCPT_MSENC, NVSYNCPT_MSENC_SLICE},
.waitbases = {NVWAITBASE_MSENC},
.class = NV_VIDEO_ENCODE_MSENC_CLASS_ID,
.clocks = {{"msenc", UINT_MAX, 0, TEGRA_MC_CLIENT_MSENC},
struct nvhost_device_data t124_tsec_info = {
.version = NVHOST_ENCODE_TSEC_VER(1, 0),
- .syncpts = {NVSYNCPT_TSEC},
.waitbases = {NVWAITBASE_TSEC},
.class = NV_TSEC_CLASS_ID,
.exclusive = true,
};
struct nvhost_device_data t124_vic_info = {
- .syncpts = {NVSYNCPT_VIC},
.modulemutexes = {NVMODMUTEX_VIC},
.clocks = {{"vic03", UINT_MAX, 0, TEGRA_MC_CLIENT_VIC},
{"emc", UINT_MAX} },
struct nvhost_device_data t132_isp_info = {
/* FIXME: control clocks from user space instead of hard-coding here */
- .syncpts = NV_ISP_0_SYNCPTS,
.moduleid = NVHOST_MODULE_ISP,
.modulemutexes = {NVMODMUTEX_ISP_0},
.exclusive = true,
struct nvhost_device_data t132_ispb_info = {
/* FIXME: control clocks from user space instead of hard-coding here */
- .syncpts = NV_ISP_1_SYNCPTS,
.moduleid = (1 << 16) | NVHOST_MODULE_ISP,
.modulemutexes = {NVMODMUTEX_ISP_1},
.exclusive = true,
struct nvhost_device_data t132_vi_info = {
/* FIXME: resolve powergating dependency with DIS */
/* FIXME: control clocks from user space instead of hard-coding here */
- .syncpts = NV_VI_0_SYNCPTS,
.moduleid = NVHOST_MODULE_VI,
.modulemutexes = {NVMODMUTEX_VI_0},
.exclusive = true,
struct nvhost_device_data t132_vib_info = {
/* FIXME: resolve powergating dependency with DIS */
/* FIXME: control clocks from user space instead of hard-coding here */
- .syncpts = NV_VI_1_SYNCPTS,
.moduleid = (1 << 16 | NVHOST_MODULE_VI),
.modulemutexes = {NVMODMUTEX_VI_1},
.exclusive = true,
struct nvhost_device_data t132_msenc_info = {
.version = NVHOST_ENCODE_MSENC_VER(3, 1),
- .syncpts = {NVSYNCPT_MSENC, NVSYNCPT_MSENC_SLICE},
.waitbases = {NVWAITBASE_MSENC},
.class = NV_VIDEO_ENCODE_MSENC_CLASS_ID,
.clocks = {{"msenc", UINT_MAX, 0, TEGRA_MC_CLIENT_MSENC},
struct nvhost_device_data t132_tsec_info = {
.version = NVHOST_ENCODE_TSEC_VER(1, 0),
- .syncpts = {NVSYNCPT_TSEC},
.waitbases = {NVWAITBASE_TSEC},
.class = NV_TSEC_CLASS_ID,
.exclusive = true,
#ifdef CONFIG_ARCH_TEGRA_VIC
struct nvhost_device_data t132_vic_info = {
- .syncpts = {NVSYNCPT_VIC},
.modulemutexes = {NVMODMUTEX_VIC},
.clocks = {{"vic03", UINT_MAX, 0, TEGRA_MC_CLIENT_VIC},
{"emc", UINT_MAX} },
#if defined(CONFIG_TEGRA_GK20A)
struct nvhost_device_data t132_gk20a_info = {
- .syncpts = {NVSYNCPT_GK20A_BASE},
- .syncpt_base = NVSYNCPT_GK20A_BASE,
.class = NV_GRAPHICS_GPU_CLASS_ID,
.clocks = {{"PLLG_ref", UINT_MAX},
{"pwr", 204000000},
*
* Tegra Graphics Init for T148 Architecture Chips
*
- * Copyright (c) 2012-2013, NVIDIA Corporation. All rights reserved.
+ * Copyright (c) 2012-2014, 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,
struct nvhost_device_data t14_gr3d_info = {
.version = 3,
.index = 1,
- .syncpts = {NVSYNCPT_3D},
.waitbases = {NVWAITBASE_3D},
.modulemutexes = {NVMODMUTEX_3D},
.class = NV_GRAPHICS_3D_CLASS_ID,
struct nvhost_device_data t14_gr2d_info = {
.index = 2,
- .syncpts = {NVSYNCPT_2D_0, NVSYNCPT_2D_1},
.waitbases = {NVWAITBASE_2D_0, NVWAITBASE_2D_1},
.modulemutexes = {NVMODMUTEX_2D_FULL, NVMODMUTEX_2D_SIMPLE,
NVMODMUTEX_2D_SB_A, NVMODMUTEX_2D_SB_B},
struct nvhost_device_data t14_isp_info = {
.index = 3,
- .syncpts = {NVSYNCPT_VI_ISP_2, NVSYNCPT_VI_ISP_3,
- NVSYNCPT_VI_ISP_4},
NVHOST_MODULE_NO_POWERGATE_IDS,
NVHOST_DEFAULT_CLOCKGATE_DELAY,
.moduleid = NVHOST_MODULE_ISP,
struct nvhost_device_data t14_vi_info = {
.index = 4,
- .syncpts = {NVSYNCPT_CSI_VI_0, NVSYNCPT_CSI_VI_1,
- NVSYNCPT_VI_ISP_0, NVSYNCPT_VI_ISP_1,
- NVSYNCPT_VI_ISP_2, NVSYNCPT_VI_ISP_3,
- NVSYNCPT_VI_ISP_4},
.modulemutexes = {NVMODMUTEX_VI_0},
.clocks = { {"host1x", 136000000, 6} },
.exclusive = true,
struct nvhost_device_data t14_msenc_info = {
.version = NVHOST_ENCODE_MSENC_VER(3, 0),
.index = 5,
- .syncpts = {NVSYNCPT_MSENC},
.waitbases = {NVWAITBASE_MSENC},
.class = NV_VIDEO_ENCODE_MSENC_CLASS_ID,
.clocks = { {"msenc", UINT_MAX, 107, TEGRA_MC_CLIENT_MSENC},
struct nvhost_device_data t14_tsec_info = {
.version = NVHOST_ENCODE_TSEC_VER(1,0),
.index = 7,
- .syncpts = {NVSYNCPT_TSEC},
.waitbases = {NVWAITBASE_TSEC},
.class = NV_TSEC_CLASS_ID,
.exclusive = false,
void nvhost_module_idle_ext(struct platform_device *dev);
/* public host1x sync-point management APIs */
+u32 nvhost_get_syncpt_client_managed(const char *syncpt_name);
u32 nvhost_syncpt_incr_max_ext(struct platform_device *dev, u32 id, u32 incrs);
void nvhost_syncpt_cpu_incr_ext(struct platform_device *dev, u32 id);
u32 nvhost_syncpt_read_ext(struct platform_device *dev, u32 id);
projects / sojka / nv-tegra / linux-3.10.git / commitdiff