2 * Copyright (C) 2011-2014 ARM Limited. All rights reserved.
4 * This program is free software and is provided to you under the terms of the GNU General Public License version 2
5 * as published by the Free Software Foundation, and any use by you of this program is subject to the terms of such GNU licence.
7 * A copy of the licence is included with the program, and can also be obtained from Free Software
8 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
11 #ifndef __MALI_PP_JOB_H__
12 #define __MALI_PP_JOB_H__
15 #include "mali_osk_list.h"
16 #include "mali_uk_types.h"
17 #include "mali_session.h"
18 #include "mali_kernel_common.h"
19 #include "regs/mali_200_regs.h"
20 #include "mali_kernel_core.h"
21 #include "mali_dlbu.h"
22 #include "mali_timeline.h"
23 #include "mali_scheduler.h"
24 #include "mali_executor.h"
25 #if defined(CONFIG_DMA_SHARED_BUFFER) && !defined(CONFIG_MALI_DMA_BUF_MAP_ON_ATTACH)
26 #include "linux/mali_memory_dma_buf.h"
30 * This structure represents a PP job, including all sub jobs.
32 * The PP job object itself is not protected by any single lock,
33 * but relies on other locks instead (scheduler, executor and timeline lock).
34 * Think of the job object as moving between these sub systems through-out
35 * its lifetime. Different part of the PP job struct is used by different
36 * subsystems. Accessor functions ensure that correct lock is taken.
37 * Do NOT access any data members directly from outside this module!
41 * These members are typically only set at creation,
42 * and only read later on.
43 * They do not require any lock protection.
45 _mali_uk_pp_start_job_s uargs; /**< Arguments from user space */
46 struct mali_session_data *session; /**< Session which submitted this job */
47 u32 pid; /**< Process ID of submitting process */
48 u32 tid; /**< Thread ID of submitting thread */
49 u32 id; /**< Identifier for this job in kernel space (sequential numbering) */
50 u32 cache_order; /**< Cache order used for L2 cache flushing (sequential numbering) */
51 struct mali_timeline_tracker tracker; /**< Timeline tracker for this job */
52 _mali_osk_notification_t *finished_notification; /**< Notification sent back to userspace on job complete */
53 u32 perf_counter_per_sub_job_count; /**< Number of values in the two arrays which is != MALI_HW_CORE_NO_COUNTER */
54 u32 perf_counter_per_sub_job_src0[_MALI_PP_MAX_SUB_JOBS]; /**< Per sub job counters src0 */
55 u32 perf_counter_per_sub_job_src1[_MALI_PP_MAX_SUB_JOBS]; /**< Per sub job counters src1 */
56 u32 sub_jobs_num; /**< Number of subjobs; set to 1 for Mali-450 if DLBU is used, otherwise equals number of PP cores */
59 * These members are used by both scheduler and executor.
60 * They are "protected" by atomic operations.
62 _mali_osk_atomic_t sub_jobs_completed; /**< Number of completed sub-jobs in this superjob */
63 _mali_osk_atomic_t sub_job_errors; /**< Bitfield with errors (errors for each single sub-job is or'ed together) */
66 * These members are used by scheduler, but only when no one else
67 * knows about this job object but the working function.
68 * No lock is thus needed for these.
70 u32 *memory_cookies; /**< Memory cookies attached to job */
71 #if defined(CONFIG_DMA_SHARED_BUFFER) && !defined(CONFIG_MALI_DMA_BUF_MAP_ON_ATTACH)
72 struct mali_dma_buf_attachment **dma_bufs; /**< Array of DMA-bufs used by job */
76 * These members are used by the scheduler,
77 * protected by scheduler lock
79 _mali_osk_list_t list; /**< Used to link jobs together in the scheduler queue */
80 _mali_osk_list_t session_fb_lookup_list; /**< Used to link jobs together from the same frame builder in the session */
81 u32 sub_jobs_started; /**< Total number of sub-jobs started (always started in ascending order) */
84 * Set by executor/group on job completion, read by scheduler when
85 * returning job to user. Hold executor lock when setting,
86 * no lock needed when reading
88 u32 perf_counter_value0[_MALI_PP_MAX_SUB_JOBS]; /**< Value of performance counter 0 (to be returned to user space), one for each sub job */
89 u32 perf_counter_value1[_MALI_PP_MAX_SUB_JOBS]; /**< Value of performance counter 1 (to be returned to user space), one for each sub job */
92 void mali_pp_job_initialize(void);
93 void mali_pp_job_terminate(void);
95 struct mali_pp_job *mali_pp_job_create(struct mali_session_data *session, _mali_uk_pp_start_job_s *uargs, u32 id);
96 void mali_pp_job_delete(struct mali_pp_job *job);
98 u32 mali_pp_job_get_perf_counter_src0(struct mali_pp_job *job, u32 sub_job);
99 u32 mali_pp_job_get_perf_counter_src1(struct mali_pp_job *job, u32 sub_job);
101 void mali_pp_job_set_pp_counter_global_src0(u32 counter);
102 void mali_pp_job_set_pp_counter_global_src1(u32 counter);
103 void mali_pp_job_set_pp_counter_sub_job_src0(u32 sub_job, u32 counter);
104 void mali_pp_job_set_pp_counter_sub_job_src1(u32 sub_job, u32 counter);
106 u32 mali_pp_job_get_pp_counter_global_src0(void);
107 u32 mali_pp_job_get_pp_counter_global_src1(void);
108 u32 mali_pp_job_get_pp_counter_sub_job_src0(u32 sub_job);
109 u32 mali_pp_job_get_pp_counter_sub_job_src1(u32 sub_job);
111 MALI_STATIC_INLINE u32 mali_pp_job_get_id(struct mali_pp_job *job)
113 MALI_DEBUG_ASSERT_POINTER(job);
114 return (NULL == job) ? 0 : job->id;
117 MALI_STATIC_INLINE void mali_pp_job_set_cache_order(struct mali_pp_job *job,
120 MALI_DEBUG_ASSERT_POINTER(job);
121 MALI_DEBUG_ASSERT_SCHEDULER_LOCK_HELD();
122 job->cache_order = cache_order;
125 MALI_STATIC_INLINE u32 mali_pp_job_get_cache_order(struct mali_pp_job *job)
127 MALI_DEBUG_ASSERT_POINTER(job);
128 return (NULL == job) ? 0 : job->cache_order;
131 MALI_STATIC_INLINE u64 mali_pp_job_get_user_id(struct mali_pp_job *job)
133 MALI_DEBUG_ASSERT_POINTER(job);
134 return job->uargs.user_job_ptr;
137 MALI_STATIC_INLINE u32 mali_pp_job_get_frame_builder_id(struct mali_pp_job *job)
139 MALI_DEBUG_ASSERT_POINTER(job);
140 return job->uargs.frame_builder_id;
143 MALI_STATIC_INLINE u32 mali_pp_job_get_flush_id(struct mali_pp_job *job)
145 MALI_DEBUG_ASSERT_POINTER(job);
146 return job->uargs.flush_id;
149 MALI_STATIC_INLINE u32 mali_pp_job_get_pid(struct mali_pp_job *job)
151 MALI_DEBUG_ASSERT_POINTER(job);
155 MALI_STATIC_INLINE u32 mali_pp_job_get_tid(struct mali_pp_job *job)
157 MALI_DEBUG_ASSERT_POINTER(job);
161 MALI_STATIC_INLINE u32 *mali_pp_job_get_frame_registers(struct mali_pp_job *job)
163 MALI_DEBUG_ASSERT_POINTER(job);
164 return job->uargs.frame_registers;
167 MALI_STATIC_INLINE u32 *mali_pp_job_get_dlbu_registers(struct mali_pp_job *job)
169 MALI_DEBUG_ASSERT_POINTER(job);
170 return job->uargs.dlbu_registers;
173 MALI_STATIC_INLINE mali_bool mali_pp_job_is_virtual(struct mali_pp_job *job)
175 #if defined(CONFIG_MALI450)
176 MALI_DEBUG_ASSERT_POINTER(job);
177 return (0 == job->uargs.num_cores) ? MALI_TRUE : MALI_FALSE;
183 MALI_STATIC_INLINE u32 mali_pp_job_get_addr_frame(struct mali_pp_job *job, u32 sub_job)
185 MALI_DEBUG_ASSERT_POINTER(job);
187 if (mali_pp_job_is_virtual(job)) {
188 return MALI_DLBU_VIRT_ADDR;
189 } else if (0 == sub_job) {
190 return job->uargs.frame_registers[MALI200_REG_ADDR_FRAME / sizeof(u32)];
191 } else if (sub_job < _MALI_PP_MAX_SUB_JOBS) {
192 return job->uargs.frame_registers_addr_frame[sub_job - 1];
198 MALI_STATIC_INLINE u32 mali_pp_job_get_addr_stack(struct mali_pp_job *job, u32 sub_job)
200 MALI_DEBUG_ASSERT_POINTER(job);
203 return job->uargs.frame_registers[MALI200_REG_ADDR_STACK / sizeof(u32)];
204 } else if (sub_job < _MALI_PP_MAX_SUB_JOBS) {
205 return job->uargs.frame_registers_addr_stack[sub_job - 1];
211 void mali_pp_job_list_add(struct mali_pp_job *job, _mali_osk_list_t *list);
213 MALI_STATIC_INLINE void mali_pp_job_list_addtail(struct mali_pp_job *job,
214 _mali_osk_list_t *list)
216 _mali_osk_list_addtail(&job->list, list);
219 MALI_STATIC_INLINE void mali_pp_job_list_move(struct mali_pp_job *job,
220 _mali_osk_list_t *list)
222 MALI_DEBUG_ASSERT_POINTER(job);
223 MALI_DEBUG_ASSERT_SCHEDULER_LOCK_HELD();
224 MALI_DEBUG_ASSERT(!_mali_osk_list_empty(&job->list));
225 _mali_osk_list_move(&job->list, list);
228 MALI_STATIC_INLINE void mali_pp_job_list_remove(struct mali_pp_job *job)
230 MALI_DEBUG_ASSERT_POINTER(job);
231 MALI_DEBUG_ASSERT_SCHEDULER_LOCK_HELD();
232 _mali_osk_list_delinit(&job->list);
235 MALI_STATIC_INLINE u32 *mali_pp_job_get_wb0_registers(struct mali_pp_job *job)
237 MALI_DEBUG_ASSERT_POINTER(job);
238 return job->uargs.wb0_registers;
241 MALI_STATIC_INLINE u32 *mali_pp_job_get_wb1_registers(struct mali_pp_job *job)
243 MALI_DEBUG_ASSERT_POINTER(job);
244 return job->uargs.wb1_registers;
247 MALI_STATIC_INLINE u32 *mali_pp_job_get_wb2_registers(struct mali_pp_job *job)
249 MALI_DEBUG_ASSERT_POINTER(job);
250 return job->uargs.wb2_registers;
253 MALI_STATIC_INLINE u32 mali_pp_job_get_wb0_source_addr(struct mali_pp_job *job)
255 MALI_DEBUG_ASSERT_POINTER(job);
256 return job->uargs.wb0_registers[MALI200_REG_ADDR_WB_SOURCE_ADDR / sizeof(u32)];
259 MALI_STATIC_INLINE u32 mali_pp_job_get_wb1_source_addr(struct mali_pp_job *job)
261 MALI_DEBUG_ASSERT_POINTER(job);
262 return job->uargs.wb1_registers[MALI200_REG_ADDR_WB_SOURCE_ADDR / sizeof(u32)];
265 MALI_STATIC_INLINE u32 mali_pp_job_get_wb2_source_addr(struct mali_pp_job *job)
267 MALI_DEBUG_ASSERT_POINTER(job);
268 return job->uargs.wb2_registers[MALI200_REG_ADDR_WB_SOURCE_ADDR / sizeof(u32)];
271 MALI_STATIC_INLINE void mali_pp_job_disable_wb0(struct mali_pp_job *job)
273 MALI_DEBUG_ASSERT_POINTER(job);
274 job->uargs.wb0_registers[MALI200_REG_ADDR_WB_SOURCE_SELECT] = 0;
277 MALI_STATIC_INLINE void mali_pp_job_disable_wb1(struct mali_pp_job *job)
279 MALI_DEBUG_ASSERT_POINTER(job);
280 job->uargs.wb1_registers[MALI200_REG_ADDR_WB_SOURCE_SELECT] = 0;
283 MALI_STATIC_INLINE void mali_pp_job_disable_wb2(struct mali_pp_job *job)
285 MALI_DEBUG_ASSERT_POINTER(job);
286 job->uargs.wb2_registers[MALI200_REG_ADDR_WB_SOURCE_SELECT] = 0;
289 MALI_STATIC_INLINE mali_bool mali_pp_job_all_writeback_unit_disabled(struct mali_pp_job *job)
291 MALI_DEBUG_ASSERT_POINTER(job);
293 if (job->uargs.wb0_registers[MALI200_REG_ADDR_WB_SOURCE_SELECT] ||
294 job->uargs.wb1_registers[MALI200_REG_ADDR_WB_SOURCE_SELECT] ||
295 job->uargs.wb2_registers[MALI200_REG_ADDR_WB_SOURCE_SELECT]
297 /* At least one output unit active */
301 /* All outputs are disabled - we can abort the job */
305 MALI_STATIC_INLINE void mali_pp_job_fb_lookup_add(struct mali_pp_job *job)
309 MALI_DEBUG_ASSERT_POINTER(job);
310 MALI_DEBUG_ASSERT_SCHEDULER_LOCK_HELD();
312 fb_lookup_id = MALI_PP_JOB_FB_LOOKUP_LIST_MASK & job->uargs.frame_builder_id;
314 MALI_DEBUG_ASSERT(MALI_PP_JOB_FB_LOOKUP_LIST_SIZE > fb_lookup_id);
316 _mali_osk_list_addtail(&job->session_fb_lookup_list,
317 &job->session->pp_job_fb_lookup_list[fb_lookup_id]);
320 MALI_STATIC_INLINE void mali_pp_job_fb_lookup_remove(struct mali_pp_job *job)
322 MALI_DEBUG_ASSERT_POINTER(job);
323 MALI_DEBUG_ASSERT_SCHEDULER_LOCK_HELD();
324 _mali_osk_list_delinit(&job->session_fb_lookup_list);
327 MALI_STATIC_INLINE struct mali_session_data *mali_pp_job_get_session(struct mali_pp_job *job)
329 MALI_DEBUG_ASSERT_POINTER(job);
333 MALI_STATIC_INLINE mali_bool mali_pp_job_has_started_sub_jobs(struct mali_pp_job *job)
335 MALI_DEBUG_ASSERT_POINTER(job);
336 MALI_DEBUG_ASSERT_SCHEDULER_LOCK_HELD();
337 return (0 < job->sub_jobs_started) ? MALI_TRUE : MALI_FALSE;
340 MALI_STATIC_INLINE mali_bool mali_pp_job_has_unstarted_sub_jobs(struct mali_pp_job *job)
342 MALI_DEBUG_ASSERT_POINTER(job);
343 MALI_DEBUG_ASSERT_SCHEDULER_LOCK_HELD();
344 return (job->sub_jobs_started < job->sub_jobs_num) ? MALI_TRUE : MALI_FALSE;
347 /* Function used when we are terminating a session with jobs. Return TRUE if it has a rendering job.
348 Makes sure that no new subjobs are started. */
349 MALI_STATIC_INLINE void mali_pp_job_mark_unstarted_failed(struct mali_pp_job *job)
354 MALI_DEBUG_ASSERT_POINTER(job);
355 MALI_DEBUG_ASSERT_SCHEDULER_LOCK_HELD();
357 jobs_remaining = job->sub_jobs_num - job->sub_jobs_started;
358 job->sub_jobs_started += jobs_remaining;
360 /* Not the most optimal way, but this is only used in error cases */
361 for (i = 0; i < jobs_remaining; i++) {
362 _mali_osk_atomic_inc(&job->sub_jobs_completed);
363 _mali_osk_atomic_inc(&job->sub_job_errors);
367 MALI_STATIC_INLINE mali_bool mali_pp_job_is_complete(struct mali_pp_job *job)
369 MALI_DEBUG_ASSERT_POINTER(job);
370 return (job->sub_jobs_num ==
371 _mali_osk_atomic_read(&job->sub_jobs_completed)) ?
372 MALI_TRUE : MALI_FALSE;
375 MALI_STATIC_INLINE u32 mali_pp_job_get_first_unstarted_sub_job(struct mali_pp_job *job)
377 MALI_DEBUG_ASSERT_POINTER(job);
378 MALI_DEBUG_ASSERT_SCHEDULER_LOCK_HELD();
379 return job->sub_jobs_started;
382 MALI_STATIC_INLINE u32 mali_pp_job_get_sub_job_count(struct mali_pp_job *job)
384 MALI_DEBUG_ASSERT_POINTER(job);
385 return job->sub_jobs_num;
388 MALI_STATIC_INLINE u32 mali_pp_job_unstarted_sub_job_count(struct mali_pp_job *job)
390 MALI_DEBUG_ASSERT_POINTER(job);
391 MALI_DEBUG_ASSERT_SCHEDULER_LOCK_HELD();
392 MALI_DEBUG_ASSERT(job->sub_jobs_num >= job->sub_jobs_started);
393 return (job->sub_jobs_num - job->sub_jobs_started);
396 MALI_STATIC_INLINE u32 mali_pp_job_num_memory_cookies(struct mali_pp_job *job)
398 MALI_DEBUG_ASSERT_POINTER(job);
399 return job->uargs.num_memory_cookies;
402 MALI_STATIC_INLINE u32 mali_pp_job_get_memory_cookie(
403 struct mali_pp_job *job, u32 index)
405 MALI_DEBUG_ASSERT_POINTER(job);
406 MALI_DEBUG_ASSERT(index < job->uargs.num_memory_cookies);
407 MALI_DEBUG_ASSERT_POINTER(job->memory_cookies);
408 return job->memory_cookies[index];
411 MALI_STATIC_INLINE mali_bool mali_pp_job_needs_dma_buf_mapping(struct mali_pp_job *job)
413 MALI_DEBUG_ASSERT_POINTER(job);
415 if (0 < job->uargs.num_memory_cookies) {
422 #if defined(CONFIG_DMA_SHARED_BUFFER) && !defined(CONFIG_MALI_DMA_BUF_MAP_ON_ATTACH)
423 MALI_STATIC_INLINE u32 mali_pp_job_num_dma_bufs(struct mali_pp_job *job)
425 MALI_DEBUG_ASSERT_POINTER(job);
426 return job->uargs.num_memory_cookies;
429 MALI_STATIC_INLINE struct mali_dma_buf_attachment *mali_pp_job_get_dma_buf(
430 struct mali_pp_job *job, u32 index)
432 MALI_DEBUG_ASSERT_POINTER(job);
433 MALI_DEBUG_ASSERT(index < job->uargs.num_memory_cookies);
434 MALI_DEBUG_ASSERT_POINTER(job->dma_bufs);
435 return job->dma_bufs[index];
438 MALI_STATIC_INLINE void mali_pp_job_set_dma_buf(struct mali_pp_job *job,
439 u32 index, struct mali_dma_buf_attachment *mem)
441 MALI_DEBUG_ASSERT_POINTER(job);
442 MALI_DEBUG_ASSERT(index < job->uargs.num_memory_cookies);
443 MALI_DEBUG_ASSERT_POINTER(job->dma_bufs);
444 job->dma_bufs[index] = mem;
448 MALI_STATIC_INLINE void mali_pp_job_mark_sub_job_started(struct mali_pp_job *job, u32 sub_job)
450 MALI_DEBUG_ASSERT_POINTER(job);
451 MALI_DEBUG_ASSERT_SCHEDULER_LOCK_HELD();
453 /* Assert that we are marking the "first unstarted sub job" as started */
454 MALI_DEBUG_ASSERT(job->sub_jobs_started == sub_job);
456 job->sub_jobs_started++;
459 MALI_STATIC_INLINE void mali_pp_job_mark_sub_job_completed(struct mali_pp_job *job, mali_bool success)
461 MALI_DEBUG_ASSERT_POINTER(job);
463 _mali_osk_atomic_inc(&job->sub_jobs_completed);
464 if (MALI_FALSE == success) {
465 _mali_osk_atomic_inc(&job->sub_job_errors);
469 MALI_STATIC_INLINE mali_bool mali_pp_job_was_success(struct mali_pp_job *job)
471 MALI_DEBUG_ASSERT_POINTER(job);
472 if (0 == _mali_osk_atomic_read(&job->sub_job_errors)) {
478 MALI_STATIC_INLINE mali_bool mali_pp_job_use_no_notification(
479 struct mali_pp_job *job)
481 MALI_DEBUG_ASSERT_POINTER(job);
482 return (job->uargs.flags & _MALI_PP_JOB_FLAG_NO_NOTIFICATION) ?
483 MALI_TRUE : MALI_FALSE;
486 MALI_STATIC_INLINE mali_bool mali_pp_job_is_pilot_job(struct mali_pp_job *job)
489 * A pilot job is currently identified as jobs which
490 * require no callback notification.
492 return mali_pp_job_use_no_notification(job);
495 MALI_STATIC_INLINE _mali_osk_notification_t *
496 mali_pp_job_get_finished_notification(struct mali_pp_job *job)
498 _mali_osk_notification_t *notification;
500 MALI_DEBUG_ASSERT_POINTER(job);
501 MALI_DEBUG_ASSERT_POINTER(job->finished_notification);
503 notification = job->finished_notification;
504 job->finished_notification = NULL;
509 MALI_STATIC_INLINE mali_bool mali_pp_job_is_window_surface(
510 struct mali_pp_job *job)
512 MALI_DEBUG_ASSERT_POINTER(job);
513 return (job->uargs.flags & _MALI_PP_JOB_FLAG_IS_WINDOW_SURFACE)
514 ? MALI_TRUE : MALI_FALSE;
517 MALI_STATIC_INLINE u32 mali_pp_job_get_perf_counter_flag(struct mali_pp_job *job)
519 MALI_DEBUG_ASSERT_POINTER(job);
520 return job->uargs.perf_counter_flag;
523 MALI_STATIC_INLINE u32 mali_pp_job_get_perf_counter_value0(struct mali_pp_job *job, u32 sub_job)
525 MALI_DEBUG_ASSERT_POINTER(job);
526 return job->perf_counter_value0[sub_job];
529 MALI_STATIC_INLINE u32 mali_pp_job_get_perf_counter_value1(struct mali_pp_job *job, u32 sub_job)
531 MALI_DEBUG_ASSERT_POINTER(job);
532 return job->perf_counter_value1[sub_job];
535 MALI_STATIC_INLINE void mali_pp_job_set_perf_counter_value0(struct mali_pp_job *job, u32 sub_job, u32 value)
537 MALI_DEBUG_ASSERT_POINTER(job);
538 MALI_DEBUG_ASSERT_EXECUTOR_LOCK_HELD();
539 job->perf_counter_value0[sub_job] = value;
542 MALI_STATIC_INLINE void mali_pp_job_set_perf_counter_value1(struct mali_pp_job *job, u32 sub_job, u32 value)
544 MALI_DEBUG_ASSERT_POINTER(job);
545 MALI_DEBUG_ASSERT_EXECUTOR_LOCK_HELD();
546 job->perf_counter_value1[sub_job] = value;
549 MALI_STATIC_INLINE _mali_osk_errcode_t mali_pp_job_check(struct mali_pp_job *job)
551 MALI_DEBUG_ASSERT_POINTER(job);
552 if (mali_pp_job_is_virtual(job) && job->sub_jobs_num != 1) {
553 return _MALI_OSK_ERR_FAULT;
555 return _MALI_OSK_ERR_OK;
559 * Returns MALI_TRUE if this job has more than two sub jobs and all sub jobs are unstarted.
561 * @param job Job to check.
562 * @return MALI_TRUE if job has more than two sub jobs and all sub jobs are unstarted, MALI_FALSE if not.
564 MALI_STATIC_INLINE mali_bool mali_pp_job_is_large_and_unstarted(struct mali_pp_job *job)
566 MALI_DEBUG_ASSERT_POINTER(job);
567 MALI_DEBUG_ASSERT_SCHEDULER_LOCK_HELD();
568 MALI_DEBUG_ASSERT(!mali_pp_job_is_virtual(job));
570 return (0 == job->sub_jobs_started && 2 < job->sub_jobs_num);
574 * Get PP job's Timeline tracker.
577 * @return Pointer to Timeline tracker for the job.
579 MALI_STATIC_INLINE struct mali_timeline_tracker *mali_pp_job_get_tracker(struct mali_pp_job *job)
581 MALI_DEBUG_ASSERT_POINTER(job);
582 return &(job->tracker);
585 MALI_STATIC_INLINE u32 *mali_pp_job_get_timeline_point_ptr(
586 struct mali_pp_job *job)
588 MALI_DEBUG_ASSERT_POINTER(job);
589 return (u32 __user *)(uintptr_t)job->uargs.timeline_point_ptr;
593 #endif /* __MALI_PP_JOB_H__ */