Loading...
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 | // SPDX-License-Identifier: GPL-2.0-only /* * Tegra host1x Syncpoints * * Copyright (c) 2010-2013, NVIDIA Corporation. */ #include <linux/io.h> #include "../dev.h" #include "../syncpt.h" /* * Write the current syncpoint value back to hw. */ static void syncpt_restore(struct host1x_syncpt *sp) { u32 min = host1x_syncpt_read_min(sp); struct host1x *host = sp->host; host1x_sync_writel(host, min, HOST1X_SYNC_SYNCPT(sp->id)); } /* * Write the current waitbase value back to hw. */ static void syncpt_restore_wait_base(struct host1x_syncpt *sp) { #if HOST1X_HW < 7 struct host1x *host = sp->host; host1x_sync_writel(host, sp->base_val, HOST1X_SYNC_SYNCPT_BASE(sp->id)); #endif } /* * Read waitbase value from hw. */ static void syncpt_read_wait_base(struct host1x_syncpt *sp) { #if HOST1X_HW < 7 struct host1x *host = sp->host; sp->base_val = host1x_sync_readl(host, HOST1X_SYNC_SYNCPT_BASE(sp->id)); #endif } /* * Updates the last value read from hardware. */ static u32 syncpt_load(struct host1x_syncpt *sp) { struct host1x *host = sp->host; u32 old, live; /* Loop in case there's a race writing to min_val */ do { old = host1x_syncpt_read_min(sp); live = host1x_sync_readl(host, HOST1X_SYNC_SYNCPT(sp->id)); } while ((u32)atomic_cmpxchg(&sp->min_val, old, live) != old); if (!host1x_syncpt_check_max(sp, live)) dev_err(host->dev, "%s failed: id=%u, min=%d, max=%d\n", __func__, sp->id, host1x_syncpt_read_min(sp), host1x_syncpt_read_max(sp)); return live; } /* * Write a cpu syncpoint increment to the hardware, without touching * the cache. */ static int syncpt_cpu_incr(struct host1x_syncpt *sp) { struct host1x *host = sp->host; u32 reg_offset = sp->id / 32; if (!host1x_syncpt_client_managed(sp) && host1x_syncpt_idle(sp)) return -EINVAL; host1x_sync_writel(host, BIT(sp->id % 32), HOST1X_SYNC_SYNCPT_CPU_INCR(reg_offset)); wmb(); return 0; } /** * syncpt_assign_to_channel() - Assign syncpoint to channel * @sp: syncpoint * @ch: channel * * On chips with the syncpoint protection feature (Tegra186+), assign @sp to * @ch, preventing other channels from incrementing the syncpoints. If @ch is * NULL, unassigns the syncpoint. * * On older chips, do nothing. */ static void syncpt_assign_to_channel(struct host1x_syncpt *sp, struct host1x_channel *ch) { #if HOST1X_HW >= 6 struct host1x *host = sp->host; if (!host->hv_regs) return; host1x_sync_writel(host, HOST1X_SYNC_SYNCPT_CH_APP_CH(ch ? ch->id : 0xff), HOST1X_SYNC_SYNCPT_CH_APP(sp->id)); #endif } /** * syncpt_enable_protection() - Enable syncpoint protection * @host: host1x instance * * On chips with the syncpoint protection feature (Tegra186+), enable this * feature. On older chips, do nothing. */ static void syncpt_enable_protection(struct host1x *host) { #if HOST1X_HW >= 6 if (!host->hv_regs) return; host1x_hypervisor_writel(host, HOST1X_HV_SYNCPT_PROT_EN_CH_EN, HOST1X_HV_SYNCPT_PROT_EN); #endif } static const struct host1x_syncpt_ops host1x_syncpt_ops = { .restore = syncpt_restore, .restore_wait_base = syncpt_restore_wait_base, .load_wait_base = syncpt_read_wait_base, .load = syncpt_load, .cpu_incr = syncpt_cpu_incr, .assign_to_channel = syncpt_assign_to_channel, .enable_protection = syncpt_enable_protection, }; |