1/* SPDX-License-Identifier: MIT */
  2/*
  3 * Copyright © 2021 Intel Corporation
  4 */
  5
  6#ifndef _XE_DEVICE_H_
  7#define _XE_DEVICE_H_
  8
  9struct xe_exec_queue;
 10struct xe_file;
 11
 12#include <drm/drm_util.h>
 13
 14#include "regs/xe_gpu_commands.h"
 15#include "xe_device_types.h"
 16#include "xe_force_wake.h"
 17#include "xe_macros.h"
 18
 19#ifdef CONFIG_LOCKDEP
 20extern struct lockdep_map xe_device_mem_access_lockdep_map;
 21#endif
 22
 23static inline struct xe_device *to_xe_device(const struct drm_device *dev)
 24{
 25	return container_of(dev, struct xe_device, drm);
 26}
 27
 28static inline struct xe_device *pdev_to_xe_device(struct pci_dev *pdev)
 29{
 30	return pci_get_drvdata(pdev);
 31}
 32
 33static inline struct xe_device *ttm_to_xe_device(struct ttm_device *ttm)
 34{
 35	return container_of(ttm, struct xe_device, ttm);
 36}
 37
 38struct xe_device *xe_device_create(struct pci_dev *pdev,
 39				   const struct pci_device_id *ent);
 40int xe_device_probe_early(struct xe_device *xe);
 41int xe_device_probe(struct xe_device *xe);
 42void xe_device_remove(struct xe_device *xe);
 43void xe_device_shutdown(struct xe_device *xe);
 44
 45void xe_device_wmb(struct xe_device *xe);
 46
 47static inline struct xe_file *to_xe_file(const struct drm_file *file)
 48{
 49	return file->driver_priv;
 50}
 51
 52static inline struct xe_tile *xe_device_get_root_tile(struct xe_device *xe)
 53{
 54	return &xe->tiles[0];
 55}
 56
 57#define XE_MAX_GT_PER_TILE 2
 58
 59static inline struct xe_gt *xe_tile_get_gt(struct xe_tile *tile, u8 gt_id)
 60{
 61	if (drm_WARN_ON(&tile_to_xe(tile)->drm, gt_id > XE_MAX_GT_PER_TILE))
 62		gt_id = 0;
 63
 64	return gt_id ? tile->media_gt : tile->primary_gt;
 65}
 66
 67static inline struct xe_gt *xe_device_get_gt(struct xe_device *xe, u8 gt_id)
 68{
 69	struct xe_tile *root_tile = xe_device_get_root_tile(xe);
 70	struct xe_gt *gt;
 71
 72	/*
 73	 * FIXME: This only works for now because multi-tile and standalone
 74	 * media are mutually exclusive on the platforms we have today.
 75	 *
 76	 * id => GT mapping may change once we settle on how we want to handle
 77	 * our UAPI.
 78	 */
 79	if (MEDIA_VER(xe) >= 13) {
 80		gt = xe_tile_get_gt(root_tile, gt_id);
 81	} else {
 82		if (drm_WARN_ON(&xe->drm, gt_id > XE_MAX_TILES_PER_DEVICE))
 83			gt_id = 0;
 84
 85		gt = xe->tiles[gt_id].primary_gt;
 86	}
 87
 88	if (!gt)
 89		return NULL;
 90
 91	drm_WARN_ON(&xe->drm, gt->info.id != gt_id);
 92	drm_WARN_ON(&xe->drm, gt->info.type == XE_GT_TYPE_UNINITIALIZED);
 93
 94	return gt;
 95}
 96
 97/*
 98 * Provide a GT structure suitable for performing non-GT MMIO operations against
 99 * the primary tile.  Primarily intended for early tile initialization, display
100 * handling, top-most interrupt enable/disable, etc.  Since anything using the
101 * MMIO handle returned by this function doesn't need GSI offset translation,
102 * we'll return the primary GT from the root tile.
103 *
104 * FIXME: Fix the driver design so that 'gt' isn't the target of all MMIO
105 * operations.
106 *
107 * Returns the primary gt of the root tile.
108 */
109static inline struct xe_gt *xe_root_mmio_gt(struct xe_device *xe)
110{
111	return xe_device_get_root_tile(xe)->primary_gt;
112}
113
114static inline bool xe_device_uc_enabled(struct xe_device *xe)
115{
116	return !xe->info.force_execlist;
117}
118
119#define for_each_tile(tile__, xe__, id__) \
120	for ((id__) = 0; (id__) < (xe__)->info.tile_count; (id__)++) \
121		for_each_if((tile__) = &(xe__)->tiles[(id__)])
122
123#define for_each_remote_tile(tile__, xe__, id__) \
124	for ((id__) = 1; (id__) < (xe__)->info.tile_count; (id__)++) \
125		for_each_if((tile__) = &(xe__)->tiles[(id__)])
126
127/*
128 * FIXME: This only works for now since multi-tile and standalone media
129 * happen to be mutually exclusive.  Future platforms may change this...
130 */
131#define for_each_gt(gt__, xe__, id__) \
132	for ((id__) = 0; (id__) < (xe__)->info.gt_count; (id__)++) \
133		for_each_if((gt__) = xe_device_get_gt((xe__), (id__)))
134
135static inline struct xe_force_wake *gt_to_fw(struct xe_gt *gt)
136{
137	return &gt->mmio.fw;
138}
139
140void xe_device_mem_access_get(struct xe_device *xe);
141bool xe_device_mem_access_get_if_ongoing(struct xe_device *xe);
142void xe_device_mem_access_put(struct xe_device *xe);
143
144void xe_device_assert_mem_access(struct xe_device *xe);
145bool xe_device_mem_access_ongoing(struct xe_device *xe);
146
147static inline bool xe_device_in_fault_mode(struct xe_device *xe)
148{
149	return xe->usm.num_vm_in_fault_mode != 0;
150}
151
152static inline bool xe_device_in_non_fault_mode(struct xe_device *xe)
153{
154	return xe->usm.num_vm_in_non_fault_mode != 0;
155}
156
157static inline bool xe_device_has_flat_ccs(struct xe_device *xe)
158{
159	return xe->info.has_flat_ccs;
160}
161
162static inline bool xe_device_has_sriov(struct xe_device *xe)
163{
164	return xe->info.has_sriov;
165}
166
167u32 xe_device_ccs_bytes(struct xe_device *xe, u64 size);
168
169#endif