自学教程：C++ syncpt_to_dev函数代码示例

/** * Get the current syncpoint value */u32 nvhost_syncpt_read(struct nvhost_syncpt *sp, u32 id){	u32 val;	nvhost_module_busy(syncpt_to_dev(sp)->dev);	val = syncpt_op().update_min(sp, id);	nvhost_module_idle(syncpt_to_dev(sp)->dev);	return val;}

/** * Get the current syncpoint base */u32 nvhost_syncpt_read_wait_base(struct nvhost_syncpt *sp, u32 id){	u32 val;	nvhost_module_busy(syncpt_to_dev(sp)->dev);	syncpt_op().read_wait_base(sp, id);	val = sp->base_val[id];	nvhost_module_idle(syncpt_to_dev(sp)->dev);	return val;}

/** * Return current syncpoint value on success */int nvhost_syncpt_read_check(struct nvhost_syncpt *sp, u32 id, u32 *val){	if (nvhost_module_busy(syncpt_to_dev(sp)->dev))		return -EINVAL;	*val = syncpt_op().update_min(sp, id);	nvhost_module_idle(syncpt_to_dev(sp)->dev);	return 0;}

/** * Get the current syncpoint base */u32 nvhost_syncpt_read_wait_base(struct nvhost_syncpt *sp, u32 id){	u32 val;	BUG_ON(!syncpt_op(sp).read_wait_base);	nvhost_module_busy(&syncpt_to_dev(sp)->mod);	syncpt_op(sp).read_wait_base(sp, id);	val = sp->base_val[id];	nvhost_module_idle(&syncpt_to_dev(sp)->mod);	return val;}

/** * Get the current syncpoint value */u32 nvhost_syncpt_read(struct nvhost_syncpt *sp, u32 id){	u32 val = 0xffffffff;	int err;	err = nvhost_module_busy(syncpt_to_dev(sp)->dev);	if (err)		return val;	val = syncpt_op().update_min(sp, id);	nvhost_module_idle(syncpt_to_dev(sp)->dev);	return val;}

/** * Write a cpu syncpoint increment to the hardware, without touching * the cache. Caller is responsible for host being powered. */void nvhost_syncpt_cpu_incr(struct nvhost_syncpt *sp, u32 id){	struct nvhost_dev *dev = syncpt_to_dev(sp);        if (!client_managed(id) && nvhost_syncpt_min_eq_max(sp, id)) {                dev_err(&syncpt_to_dev(sp)->pdev->dev,                        "Syncpoint id %d /n", id);                BUG();        }	writel(BIT(id), dev->sync_aperture + HOST1X_SYNC_SYNCPT_CPU_INCR);	wmb();}

/** * Increment syncpoint value from cpu, updating cache */int nvhost_syncpt_incr(struct nvhost_syncpt *sp, u32 id){	int err;	err = nvhost_module_busy(syncpt_to_dev(sp)->dev);	if (err)		return err;	if (nvhost_syncpt_client_managed(sp, id))		nvhost_syncpt_incr_max(sp, id, 1);	nvhost_syncpt_cpu_incr(sp, id);	nvhost_module_idle(syncpt_to_dev(sp)->dev);	return 0;}

int nvhost_syncpt_nb_pts_ext(struct platform_device *dev){	struct nvhost_master *master = nvhost_get_host(dev);	struct nvhost_syncpt *sp = &master->syncpt;	return syncpt_to_dev(sp)->info.nb_pts;}

/** * Updates the last value read from hardware. */u32 nvhost_syncpt_update_min(struct nvhost_syncpt *sp, u32 id){	struct nvhost_dev *dev = syncpt_to_dev(sp);	void __iomem *sync_regs = dev->sync_aperture;	u32 old, live, maxsp;	do {		smp_rmb();		old = (u32)atomic_read(&sp->min_val[id]);		live = readl(sync_regs + (HOST1X_SYNC_SYNCPT_0 + id * 4));	} while ((u32)atomic_cmpxchg(&sp->min_val[id], old, live) != old);	if(!check_max(sp, id, live))        {              smp_rmb();              maxsp = (u32)atomic_read(&sp->max_val[id]);              nvhost_sync_reg_dump(dev);              printk("%s check_max failed: id=%lu  max=%lu  real=%lu /n",__func__,                                                               (unsigned long)id,                                                               (unsigned long)maxsp,                                                               (unsigned long)live);              BUG();        }	return live;}

/** * Write a cpu syncpoint increment to the hardware, without touching * the cache. Caller is responsible for host being powered. */static void t20_syncpt_cpu_incr(struct nvhost_syncpt *sp, u32 id){	struct nvhost_master *dev = syncpt_to_dev(sp);	u32 reg_offset = id / 32;	if (!nvhost_syncpt_client_managed(sp, id)			&& nvhost_syncpt_min_eq_max(sp, id)) {		dev_err(&syncpt_to_dev(sp)->dev->dev,			"Trying to increment syncpoint id %d beyond max/n",			id);		nvhost_debug_dump(syncpt_to_dev(sp));		return;	}	writel(bit_mask(id), dev->sync_aperture +			host1x_sync_syncpt_cpu_incr_r() + reg_offset * 4);}

/** * Increment syncpoint value from cpu, updating cache */void nvhost_syncpt_incr(struct nvhost_syncpt *sp, u32 id){#ifdef CONFIG_MACH_N1	u32 min, max;	max = nvhost_syncpt_incr_max(sp, id, 1);	min = nvhost_syncpt_incr_min(sp, id, 1);	if (sp->restore_needed) {		/* XXX restore_needed used only for logging (to be removed in final checkin) */		dev_warn(&syncpt_to_dev(sp)->pdev->dev,				 "syncpoint id %d (%s) incremented min = %d, max = %d while nvhost suspended/n",				 id, nvhost_syncpt_name(id), min, max);	}#else	nvhost_syncpt_incr_max(sp, id, 1);#endif	nvhost_module_busy(&syncpt_to_dev(sp)->mod);	nvhost_syncpt_cpu_incr(sp, id);	nvhost_module_idle(&syncpt_to_dev(sp)->mod);}

/** * Updates the last value read from hardware. * (was nvhost_syncpt_update_min) */static u32 t20_syncpt_update_min(struct nvhost_syncpt *sp, u32 id){	struct nvhost_master *dev = syncpt_to_dev(sp);	void __iomem *sync_regs = dev->sync_aperture;	u32 old, live;	do {		old = nvhost_syncpt_read_min(sp, id);		live = readl(sync_regs + (host1x_sync_syncpt_0_r() + id * 4));	} while ((u32)atomic_cmpxchg(&sp->min_val[id], old, live) != old);	return live;}

/* * Check driver supplied waitchk structs for syncpt thresholds * that have already been satisfied and NULL the comparison (to * avoid a wrap condition in the HW). */static int do_waitchks(struct nvhost_job *job, struct nvhost_syncpt *sp,		u32 patch_mem, void *patch_addr){	int i;	/* compare syncpt vs wait threshold */	for (i = 0; i < job->num_waitchk; i++) {		struct nvhost_waitchk *wait = &job->waitchk[i];		/* skip all other gathers */		if (patch_mem != wait->mem)			continue;		trace_nvhost_syncpt_wait_check(wait->mem, wait->offset,				wait->syncpt_id, wait->thresh,				nvhost_syncpt_read(sp, wait->syncpt_id));		if (nvhost_syncpt_is_expired(sp,					wait->syncpt_id, wait->thresh)) {			/*			 * NULL an already satisfied WAIT_SYNCPT host method,			 * by patching its args in the command stream. The			 * method data is changed to reference a reserved			 * (never given out or incr) NVSYNCPT_GRAPHICS_HOST			 * syncpt with a matching threshold value of 0, so			 * is guaranteed to be popped by the host HW.			 */			dev_dbg(&syncpt_to_dev(sp)->dev->dev,			    "drop WAIT id %d (%s) thresh 0x%x, min 0x%x/n",			    wait->syncpt_id,			    syncpt_op().name(sp, wait->syncpt_id),			    wait->thresh,			    nvhost_syncpt_read_min(sp, wait->syncpt_id));			/* patch the wait */			nvhost_syncpt_patch_wait(sp,					(patch_addr + wait->offset));		}		wait->mem = 0;	}	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;}