1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19#include <linux/module.h>
20#include <linux/device.h>
21#include <linux/slab.h>
22
23#include <trace/events/host1x.h>
24
25#include "syncpt.h"
26#include "dev.h"
27#include "intr.h"
28#include "debug.h"
29
30#define SYNCPT_CHECK_PERIOD (2 * HZ)
31#define MAX_STUCK_CHECK_COUNT 15
32
33static struct host1x_syncpt_base *
34host1x_syncpt_base_request(struct host1x *host)
35{
36 struct host1x_syncpt_base *bases = host->bases;
37 unsigned int i;
38
39 for (i = 0; i < host->info->nb_bases; i++)
40 if (!bases[i].requested)
41 break;
42
43 if (i >= host->info->nb_bases)
44 return NULL;
45
46 bases[i].requested = true;
47 return &bases[i];
48}
49
50static void host1x_syncpt_base_free(struct host1x_syncpt_base *base)
51{
52 if (base)
53 base->requested = false;
54}
55
56static struct host1x_syncpt *host1x_syncpt_alloc(struct host1x *host,
57 struct device *dev,
58 unsigned long flags)
59{
60 int i;
61 struct host1x_syncpt *sp = host->syncpt;
62 char *name;
63
64 for (i = 0; i < host->info->nb_pts && sp->name; i++, sp++)
65 ;
66
67 if (i >= host->info->nb_pts)
68 return NULL;
69
70 if (flags & HOST1X_SYNCPT_HAS_BASE) {
71 sp->base = host1x_syncpt_base_request(host);
72 if (!sp->base)
73 return NULL;
74 }
75
76 name = kasprintf(GFP_KERNEL, "%02d-%s", sp->id,
77 dev ? dev_name(dev) : NULL);
78 if (!name)
79 return NULL;
80
81 sp->dev = dev;
82 sp->name = name;
83
84 if (flags & HOST1X_SYNCPT_CLIENT_MANAGED)
85 sp->client_managed = true;
86 else
87 sp->client_managed = false;
88
89 return sp;
90}
91
92u32 host1x_syncpt_id(struct host1x_syncpt *sp)
93{
94 return sp->id;
95}
96EXPORT_SYMBOL(host1x_syncpt_id);
97
98
99
100
101u32 host1x_syncpt_incr_max(struct host1x_syncpt *sp, u32 incrs)
102{
103 return (u32)atomic_add_return(incrs, &sp->max_val);
104}
105EXPORT_SYMBOL(host1x_syncpt_incr_max);
106
107
108
109
110void host1x_syncpt_restore(struct host1x *host)
111{
112 struct host1x_syncpt *sp_base = host->syncpt;
113 u32 i;
114
115 for (i = 0; i < host1x_syncpt_nb_pts(host); i++)
116 host1x_hw_syncpt_restore(host, sp_base + i);
117 for (i = 0; i < host1x_syncpt_nb_bases(host); i++)
118 host1x_hw_syncpt_restore_wait_base(host, sp_base + i);
119 wmb();
120}
121
122
123
124
125
126void host1x_syncpt_save(struct host1x *host)
127{
128 struct host1x_syncpt *sp_base = host->syncpt;
129 u32 i;
130
131 for (i = 0; i < host1x_syncpt_nb_pts(host); i++) {
132 if (host1x_syncpt_client_managed(sp_base + i))
133 host1x_hw_syncpt_load(host, sp_base + i);
134 else
135 WARN_ON(!host1x_syncpt_idle(sp_base + i));
136 }
137
138 for (i = 0; i < host1x_syncpt_nb_bases(host); i++)
139 host1x_hw_syncpt_load_wait_base(host, sp_base + i);
140}
141
142
143
144
145
146u32 host1x_syncpt_load(struct host1x_syncpt *sp)
147{
148 u32 val;
149 val = host1x_hw_syncpt_load(sp->host, sp);
150 trace_host1x_syncpt_load_min(sp->id, val);
151
152 return val;
153}
154
155
156
157
158u32 host1x_syncpt_load_wait_base(struct host1x_syncpt *sp)
159{
160 u32 val;
161 host1x_hw_syncpt_load_wait_base(sp->host, sp);
162 val = sp->base_val;
163 return val;
164}
165
166
167
168
169int host1x_syncpt_incr(struct host1x_syncpt *sp)
170{
171 return host1x_hw_syncpt_cpu_incr(sp->host, sp);
172}
173EXPORT_SYMBOL(host1x_syncpt_incr);
174
175
176
177
178
179static bool syncpt_load_min_is_expired(struct host1x_syncpt *sp, u32 thresh)
180{
181 host1x_hw_syncpt_load(sp->host, sp);
182 return host1x_syncpt_is_expired(sp, thresh);
183}
184
185
186
187
188int host1x_syncpt_wait(struct host1x_syncpt *sp, u32 thresh, long timeout,
189 u32 *value)
190{
191 DECLARE_WAIT_QUEUE_HEAD_ONSTACK(wq);
192 void *ref;
193 struct host1x_waitlist *waiter;
194 int err = 0, check_count = 0;
195 u32 val;
196
197 if (value)
198 *value = 0;
199
200
201 if (host1x_syncpt_is_expired(sp, thresh)) {
202 if (value)
203 *value = host1x_syncpt_load(sp);
204 return 0;
205 }
206
207
208 val = host1x_hw_syncpt_load(sp->host, sp);
209 if (host1x_syncpt_is_expired(sp, thresh)) {
210 if (value)
211 *value = val;
212 goto done;
213 }
214
215 if (!timeout) {
216 err = -EAGAIN;
217 goto done;
218 }
219
220
221 waiter = kzalloc(sizeof(*waiter), GFP_KERNEL);
222 if (!waiter) {
223 err = -ENOMEM;
224 goto done;
225 }
226
227
228 err = host1x_intr_add_action(sp->host, sp->id, thresh,
229 HOST1X_INTR_ACTION_WAKEUP_INTERRUPTIBLE,
230 &wq, waiter, &ref);
231 if (err)
232 goto done;
233
234 err = -EAGAIN;
235
236 if (timeout < 0)
237 timeout = LONG_MAX;
238
239
240 while (timeout) {
241 long check = min_t(long, SYNCPT_CHECK_PERIOD, timeout);
242 int remain = wait_event_interruptible_timeout(wq,
243 syncpt_load_min_is_expired(sp, thresh),
244 check);
245 if (remain > 0 || host1x_syncpt_is_expired(sp, thresh)) {
246 if (value)
247 *value = host1x_syncpt_load(sp);
248 err = 0;
249 break;
250 }
251 if (remain < 0) {
252 err = remain;
253 break;
254 }
255 timeout -= check;
256 if (timeout && check_count <= MAX_STUCK_CHECK_COUNT) {
257 dev_warn(sp->host->dev,
258 "%s: syncpoint id %d (%s) stuck waiting %d, timeout=%ld\n",
259 current->comm, sp->id, sp->name,
260 thresh, timeout);
261
262 host1x_debug_dump_syncpts(sp->host);
263 if (check_count == MAX_STUCK_CHECK_COUNT)
264 host1x_debug_dump(sp->host);
265 check_count++;
266 }
267 }
268 host1x_intr_put_ref(sp->host, sp->id, ref);
269
270done:
271 return err;
272}
273EXPORT_SYMBOL(host1x_syncpt_wait);
274
275
276
277
278bool host1x_syncpt_is_expired(struct host1x_syncpt *sp, u32 thresh)
279{
280 u32 current_val;
281 u32 future_val;
282 smp_rmb();
283 current_val = (u32)atomic_read(&sp->min_val);
284 future_val = (u32)atomic_read(&sp->max_val);
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328 if (!host1x_syncpt_client_managed(sp))
329 return future_val - thresh >= current_val - thresh;
330 else
331 return (s32)(current_val - thresh) >= 0;
332}
333
334
335int host1x_syncpt_patch_wait(struct host1x_syncpt *sp, void *patch_addr)
336{
337 return host1x_hw_syncpt_patch_wait(sp->host, sp, patch_addr);
338}
339
340int host1x_syncpt_init(struct host1x *host)
341{
342 struct host1x_syncpt_base *bases;
343 struct host1x_syncpt *syncpt;
344 int i;
345
346 syncpt = devm_kzalloc(host->dev, sizeof(*syncpt) * host->info->nb_pts,
347 GFP_KERNEL);
348 if (!syncpt)
349 return -ENOMEM;
350
351 bases = devm_kzalloc(host->dev, sizeof(*bases) * host->info->nb_bases,
352 GFP_KERNEL);
353 if (!bases)
354 return -ENOMEM;
355
356 for (i = 0; i < host->info->nb_pts; i++) {
357 syncpt[i].id = i;
358 syncpt[i].host = host;
359 }
360
361 for (i = 0; i < host->info->nb_bases; i++)
362 bases[i].id = i;
363
364 host->syncpt = syncpt;
365 host->bases = bases;
366
367 host1x_syncpt_restore(host);
368
369
370 host->nop_sp = host1x_syncpt_alloc(host, NULL, 0);
371 if (!host->nop_sp)
372 return -ENOMEM;
373
374 return 0;
375}
376
377struct host1x_syncpt *host1x_syncpt_request(struct device *dev,
378 unsigned long flags)
379{
380 struct host1x *host = dev_get_drvdata(dev->parent);
381 return host1x_syncpt_alloc(host, dev, flags);
382}
383EXPORT_SYMBOL(host1x_syncpt_request);
384
385void host1x_syncpt_free(struct host1x_syncpt *sp)
386{
387 if (!sp)
388 return;
389
390 host1x_syncpt_base_free(sp->base);
391 kfree(sp->name);
392 sp->base = NULL;
393 sp->dev = NULL;
394 sp->name = NULL;
395 sp->client_managed = false;
396}
397EXPORT_SYMBOL(host1x_syncpt_free);
398
399void host1x_syncpt_deinit(struct host1x *host)
400{
401 int i;
402 struct host1x_syncpt *sp = host->syncpt;
403 for (i = 0; i < host->info->nb_pts; i++, sp++)
404 kfree(sp->name);
405}
406
407
408
409
410
411u32 host1x_syncpt_read_max(struct host1x_syncpt *sp)
412{
413 smp_rmb();
414 return (u32)atomic_read(&sp->max_val);
415}
416EXPORT_SYMBOL(host1x_syncpt_read_max);
417
418
419
420
421u32 host1x_syncpt_read_min(struct host1x_syncpt *sp)
422{
423 smp_rmb();
424 return (u32)atomic_read(&sp->min_val);
425}
426EXPORT_SYMBOL(host1x_syncpt_read_min);
427
428int host1x_syncpt_nb_pts(struct host1x *host)
429{
430 return host->info->nb_pts;
431}
432
433int host1x_syncpt_nb_bases(struct host1x *host)
434{
435 return host->info->nb_bases;
436}
437
438int host1x_syncpt_nb_mlocks(struct host1x *host)
439{
440 return host->info->nb_mlocks;
441}
442
443struct host1x_syncpt *host1x_syncpt_get(struct host1x *host, u32 id)
444{
445 if (host->info->nb_pts < id)
446 return NULL;
447 return host->syncpt + id;
448}
449EXPORT_SYMBOL(host1x_syncpt_get);
450
451struct host1x_syncpt_base *host1x_syncpt_get_base(struct host1x_syncpt *sp)
452{
453 return sp ? sp->base : NULL;
454}
455EXPORT_SYMBOL(host1x_syncpt_get_base);
456
457u32 host1x_syncpt_base_id(struct host1x_syncpt_base *base)
458{
459 return base->id;
460}
461EXPORT_SYMBOL(host1x_syncpt_base_id);
462