// SPDX-License-Identifier: MIT /* * Copyright © 2016-2019 Intel Corporation */ #include <linux/circ_buf.h> #include <linux/ktime.h> #include <linux/time64.h> #include <linux/string_helpers.h> #include <linux/timekeeping.h> #include "i915_drv.h" #include "intel_guc_ct.h" #include "intel_guc_print.h" #if IS_ENABLED(CONFIG_DRM_I915_DEBUG_GUC) enum { … }; static void ct_dead_ct_worker_func(struct work_struct *w); #define CT_DEAD(ct, reason) … #else #define CT_DEAD … #endif static inline struct intel_guc *ct_to_guc(struct intel_guc_ct *ct) { … } #define CT_ERROR(_ct, _fmt, ...) … #ifdef CONFIG_DRM_I915_DEBUG_GUC #define CT_DEBUG(_ct, _fmt, ...) … #else #define CT_DEBUG … #endif #define CT_PROBE_ERROR(_ct, _fmt, ...) … /** * DOC: CTB Blob * * We allocate single blob to hold both CTB descriptors and buffers: * * +--------+-----------------------------------------------+------+ * | offset | contents | size | * +========+===============================================+======+ * | 0x0000 | H2G `CTB Descriptor`_ (send) | | * +--------+-----------------------------------------------+ 4K | * | 0x0800 | G2H `CTB Descriptor`_ (recv) | | * +--------+-----------------------------------------------+------+ * | 0x1000 | H2G `CT Buffer`_ (send) | n*4K | * | | | | * +--------+-----------------------------------------------+------+ * | 0x1000 | G2H `CT Buffer`_ (recv) | m*4K | * | + n*4K | | | * +--------+-----------------------------------------------+------+ * * Size of each `CT Buffer`_ must be multiple of 4K. * We don't expect too many messages in flight at any time, unless we are * using the GuC submission. In that case each request requires a minimum * 2 dwords which gives us a maximum 256 queue'd requests. Hopefully this * enough space to avoid backpressure on the driver. We increase the size * of the receive buffer (relative to the send) to ensure a G2H response * CTB has a landing spot. */ #define CTB_DESC_SIZE … #define CTB_H2G_BUFFER_SIZE … #define CTB_G2H_BUFFER_SIZE … #define G2H_ROOM_BUFFER_SIZE … struct ct_request { … }; struct ct_incoming_msg { … }; enum { … }; enum { … }; /* * Some H2G commands involve a synchronous response that the driver needs * to wait for. In such cases, a timeout is required to prevent the driver * from waiting forever in the case of an error (either no error response * is defined in the protocol or something has died and requires a reset). * The specific command may be defined as having a time bound response but * the CT is a queue and that time guarantee only starts from the point * when the command reaches the head of the queue and is processed by GuC. * * Ideally there would be a helper to report the progress of a given * command through the CT. However, that would require a significant * amount of work in the CT layer. In the meantime, provide a reasonable * estimation of the worst case latency it should take for the entire * queue to drain. And therefore, how long a caller should wait before * giving up on their request. The current estimate is based on empirical * measurement of a test that fills the buffer with context creation and * destruction requests as they seem to be the slowest operation. */ long intel_guc_ct_max_queue_time_jiffies(void) { … } static void ct_receive_tasklet_func(struct tasklet_struct *t); static void ct_incoming_request_worker_func(struct work_struct *w); /** * intel_guc_ct_init_early - Initialize CT state without requiring device access * @ct: pointer to CT struct */ void intel_guc_ct_init_early(struct intel_guc_ct *ct) { … } static void guc_ct_buffer_desc_init(struct guc_ct_buffer_desc *desc) { … } static void guc_ct_buffer_reset(struct intel_guc_ct_buffer *ctb) { … } static void guc_ct_buffer_init(struct intel_guc_ct_buffer *ctb, struct guc_ct_buffer_desc *desc, u32 *cmds, u32 size_in_bytes, u32 resv_space) { … } static int guc_action_control_ctb(struct intel_guc *guc, u32 control) { … } static int ct_control_enable(struct intel_guc_ct *ct, bool enable) { … } static int ct_register_buffer(struct intel_guc_ct *ct, bool send, u32 desc_addr, u32 buff_addr, u32 size) { … } /** * intel_guc_ct_init - Init buffer-based communication * @ct: pointer to CT struct * * Allocate memory required for buffer-based communication. * * Return: 0 on success, a negative errno code on failure. */ int intel_guc_ct_init(struct intel_guc_ct *ct) { … } /** * intel_guc_ct_fini - Fini buffer-based communication * @ct: pointer to CT struct * * Deallocate memory required for buffer-based communication. */ void intel_guc_ct_fini(struct intel_guc_ct *ct) { … } /** * intel_guc_ct_enable - Enable buffer based command transport. * @ct: pointer to CT struct * * Return: 0 on success, a negative errno code on failure. */ int intel_guc_ct_enable(struct intel_guc_ct *ct) { … } /** * intel_guc_ct_disable - Disable buffer based command transport. * @ct: pointer to CT struct */ void intel_guc_ct_disable(struct intel_guc_ct *ct) { … } #if IS_ENABLED(CONFIG_DRM_I915_DEBUG_GEM) static void ct_track_lost_and_found(struct intel_guc_ct *ct, u32 fence, u32 action) { unsigned int lost = fence % ARRAY_SIZE(ct->requests.lost_and_found); #if IS_ENABLED(CONFIG_DRM_I915_DEBUG_GUC) unsigned long entries[SZ_32]; unsigned int n; n = stack_trace_save(entries, ARRAY_SIZE(entries), 1); /* May be called under spinlock, so avoid sleeping */ ct->requests.lost_and_found[lost].stack = stack_depot_save(entries, n, GFP_NOWAIT); #endif ct->requests.lost_and_found[lost].fence = fence; ct->requests.lost_and_found[lost].action = action; } #endif static u32 ct_get_next_fence(struct intel_guc_ct *ct) { … } static int ct_write(struct intel_guc_ct *ct, const u32 *action, u32 len /* in dwords */, u32 fence, u32 flags) { … } /** * wait_for_ct_request_update - Wait for CT request state update. * @ct: pointer to CT * @req: pointer to pending request * @status: placeholder for status * * For each sent request, GuC shall send back CT response message. * Our message handler will update status of tracked request once * response message with given fence is received. Wait here and * check for valid response status value. * * Return: * * 0 response received (status is valid) * * -ETIMEDOUT no response within hardcoded timeout */ static int wait_for_ct_request_update(struct intel_guc_ct *ct, struct ct_request *req, u32 *status) { … } #define GUC_CTB_TIMEOUT_MS … static inline bool ct_deadlocked(struct intel_guc_ct *ct) { … } static inline bool g2h_has_room(struct intel_guc_ct *ct, u32 g2h_len_dw) { … } static inline void g2h_reserve_space(struct intel_guc_ct *ct, u32 g2h_len_dw) { … } static inline void g2h_release_space(struct intel_guc_ct *ct, u32 g2h_len_dw) { … } static inline bool h2g_has_room(struct intel_guc_ct *ct, u32 len_dw) { … } static int has_room_nb(struct intel_guc_ct *ct, u32 h2g_dw, u32 g2h_dw) { … } #define G2H_LEN_DW(f) … static int ct_send_nb(struct intel_guc_ct *ct, const u32 *action, u32 len, u32 flags) { … } static int ct_send(struct intel_guc_ct *ct, const u32 *action, u32 len, u32 *response_buf, u32 response_buf_size, u32 *status) { … } /* * Command Transport (CT) buffer based GuC send function. */ int intel_guc_ct_send(struct intel_guc_ct *ct, const u32 *action, u32 len, u32 *response_buf, u32 response_buf_size, u32 flags) { … } static struct ct_incoming_msg *ct_alloc_msg(u32 num_dwords) { … } static void ct_free_msg(struct ct_incoming_msg *msg) { … } /* * Return: number available remaining dwords to read (0 if empty) * or a negative error code on failure */ static int ct_read(struct intel_guc_ct *ct, struct ct_incoming_msg **msg) { … } #if IS_ENABLED(CONFIG_DRM_I915_DEBUG_GEM) static bool ct_check_lost_and_found(struct intel_guc_ct *ct, u32 fence) { unsigned int n; char *buf = NULL; bool found = false; lockdep_assert_held(&ct->requests.lock); for (n = 0; n < ARRAY_SIZE(ct->requests.lost_and_found); n++) { if (ct->requests.lost_and_found[n].fence != fence) continue; found = true; #if IS_ENABLED(CONFIG_DRM_I915_DEBUG_GUC) buf = kmalloc(SZ_4K, GFP_NOWAIT); if (buf && stack_depot_snprint(ct->requests.lost_and_found[n].stack, buf, SZ_4K, 0)) { CT_ERROR(ct, "Fence %u was used by action %#04x sent at\n%s", fence, ct->requests.lost_and_found[n].action, buf); break; } #endif CT_ERROR(ct, "Fence %u was used by action %#04x\n", fence, ct->requests.lost_and_found[n].action); break; } kfree(buf); return found; } #else static bool ct_check_lost_and_found(struct intel_guc_ct *ct, u32 fence) { … } #endif static int ct_handle_response(struct intel_guc_ct *ct, struct ct_incoming_msg *response) { … } static int ct_process_request(struct intel_guc_ct *ct, struct ct_incoming_msg *request) { … } static bool ct_process_incoming_requests(struct intel_guc_ct *ct) { … } static void ct_incoming_request_worker_func(struct work_struct *w) { … } static int ct_handle_event(struct intel_guc_ct *ct, struct ct_incoming_msg *request) { … } static int ct_handle_hxg(struct intel_guc_ct *ct, struct ct_incoming_msg *msg) { … } static void ct_handle_msg(struct intel_guc_ct *ct, struct ct_incoming_msg *msg) { … } /* * Return: number available remaining dwords to read (0 if empty) * or a negative error code on failure */ static int ct_receive(struct intel_guc_ct *ct) { … } static void ct_try_receive_message(struct intel_guc_ct *ct) { … } static void ct_receive_tasklet_func(struct tasklet_struct *t) { … } /* * When we're communicating with the GuC over CT, GuC uses events * to notify us about new messages being posted on the RECV buffer. */ void intel_guc_ct_event_handler(struct intel_guc_ct *ct) { … } void intel_guc_ct_print_info(struct intel_guc_ct *ct, struct drm_printer *p) { … } #if IS_ENABLED(CONFIG_DRM_I915_DEBUG_GUC) static void ct_dead_ct_worker_func(struct work_struct *w) { … } #endif
Codebase Browser
linux