1 /* SPDX-License-Identifier: MIT */ 2 /* 3 * Copyright © 2021 Intel Corporation 4 */ 5 6 #ifndef _XE_DEVICE_H_ 7 #define _XE_DEVICE_H_ 8 9 struct xe_exec_queue; 10 struct 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 static inline struct xe_device *to_xe_device(const struct drm_device *dev) 20 { 21 return container_of(dev, struct xe_device, drm); 22 } 23 24 static inline struct xe_device *pdev_to_xe_device(struct pci_dev *pdev) 25 { 26 return pci_get_drvdata(pdev); 27 } 28 29 static inline struct xe_device *ttm_to_xe_device(struct ttm_device *ttm) 30 { 31 return container_of(ttm, struct xe_device, ttm); 32 } 33 34 struct xe_device *xe_device_create(struct pci_dev *pdev, 35 const struct pci_device_id *ent); 36 int xe_device_probe_early(struct xe_device *xe); 37 int xe_device_probe(struct xe_device *xe); 38 void xe_device_remove(struct xe_device *xe); 39 void xe_device_shutdown(struct xe_device *xe); 40 41 void xe_device_wmb(struct xe_device *xe); 42 43 static inline struct xe_file *to_xe_file(const struct drm_file *file) 44 { 45 return file->driver_priv; 46 } 47 48 static inline struct xe_tile *xe_device_get_root_tile(struct xe_device *xe) 49 { 50 return &xe->tiles[0]; 51 } 52 53 #define XE_MAX_GT_PER_TILE 2 54 55 static inline struct xe_gt *xe_tile_get_gt(struct xe_tile *tile, u8 gt_id) 56 { 57 if (drm_WARN_ON(&tile_to_xe(tile)->drm, gt_id >= XE_MAX_GT_PER_TILE)) 58 gt_id = 0; 59 60 return gt_id ? tile->media_gt : tile->primary_gt; 61 } 62 63 static inline struct xe_gt *xe_device_get_gt(struct xe_device *xe, u8 gt_id) 64 { 65 struct xe_tile *root_tile = xe_device_get_root_tile(xe); 66 struct xe_gt *gt; 67 68 /* 69 * FIXME: This only works for now because multi-tile and standalone 70 * media are mutually exclusive on the platforms we have today. 71 * 72 * id => GT mapping may change once we settle on how we want to handle 73 * our UAPI. 74 */ 75 if (MEDIA_VER(xe) >= 13) { 76 gt = xe_tile_get_gt(root_tile, gt_id); 77 } else { 78 if (drm_WARN_ON(&xe->drm, gt_id >= XE_MAX_TILES_PER_DEVICE)) 79 gt_id = 0; 80 81 gt = xe->tiles[gt_id].primary_gt; 82 } 83 84 if (!gt) 85 return NULL; 86 87 drm_WARN_ON(&xe->drm, gt->info.id != gt_id); 88 drm_WARN_ON(&xe->drm, gt->info.type == XE_GT_TYPE_UNINITIALIZED); 89 90 return gt; 91 } 92 93 /* 94 * Provide a GT structure suitable for performing non-GT MMIO operations against 95 * the primary tile. Primarily intended for early tile initialization, display 96 * handling, top-most interrupt enable/disable, etc. Since anything using the 97 * MMIO handle returned by this function doesn't need GSI offset translation, 98 * we'll return the primary GT from the root tile. 99 * 100 * FIXME: Fix the driver design so that 'gt' isn't the target of all MMIO 101 * operations. 102 * 103 * Returns the primary gt of the root tile. 104 */ 105 static inline struct xe_gt *xe_root_mmio_gt(struct xe_device *xe) 106 { 107 return xe_device_get_root_tile(xe)->primary_gt; 108 } 109 110 static inline bool xe_device_uc_enabled(struct xe_device *xe) 111 { 112 return !xe->info.force_execlist; 113 } 114 115 #define for_each_tile(tile__, xe__, id__) \ 116 for ((id__) = 0; (id__) < (xe__)->info.tile_count; (id__)++) \ 117 for_each_if((tile__) = &(xe__)->tiles[(id__)]) 118 119 #define for_each_remote_tile(tile__, xe__, id__) \ 120 for ((id__) = 1; (id__) < (xe__)->info.tile_count; (id__)++) \ 121 for_each_if((tile__) = &(xe__)->tiles[(id__)]) 122 123 /* 124 * FIXME: This only works for now since multi-tile and standalone media 125 * happen to be mutually exclusive. Future platforms may change this... 126 */ 127 #define for_each_gt(gt__, xe__, id__) \ 128 for ((id__) = 0; (id__) < (xe__)->info.gt_count; (id__)++) \ 129 for_each_if((gt__) = xe_device_get_gt((xe__), (id__))) 130 131 static inline struct xe_force_wake *gt_to_fw(struct xe_gt *gt) 132 { 133 return >->mmio.fw; 134 } 135 136 void xe_device_assert_mem_access(struct xe_device *xe); 137 138 static inline bool xe_device_in_fault_mode(struct xe_device *xe) 139 { 140 return xe->usm.num_vm_in_fault_mode != 0; 141 } 142 143 static inline bool xe_device_in_non_fault_mode(struct xe_device *xe) 144 { 145 return xe->usm.num_vm_in_non_fault_mode != 0; 146 } 147 148 static inline bool xe_device_has_flat_ccs(struct xe_device *xe) 149 { 150 return xe->info.has_flat_ccs; 151 } 152 153 static inline bool xe_device_has_sriov(struct xe_device *xe) 154 { 155 return xe->info.has_sriov; 156 } 157 158 static inline bool xe_device_has_memirq(struct xe_device *xe) 159 { 160 return GRAPHICS_VERx100(xe) >= 1250; 161 } 162 163 u32 xe_device_ccs_bytes(struct xe_device *xe, u64 size); 164 165 void xe_device_snapshot_print(struct xe_device *xe, struct drm_printer *p); 166 167 u64 xe_device_canonicalize_addr(struct xe_device *xe, u64 address); 168 u64 xe_device_uncanonicalize_addr(struct xe_device *xe, u64 address); 169 170 static inline bool xe_device_wedged(struct xe_device *xe) 171 { 172 return atomic_read(&xe->wedged); 173 } 174 175 static inline void xe_device_declare_wedged(struct xe_device *xe) 176 { 177 if (!atomic_xchg(&xe->wedged, 1)) { 178 xe->needs_flr_on_fini = true; 179 drm_err(&xe->drm, 180 "CRITICAL: Xe has declared device %s as wedged.\n" 181 "IOCTLs and executions are blocked until device is probed again with unbind and bind operations:\n" 182 "echo '%s' > /sys/bus/pci/drivers/xe/unbind\n" 183 "echo '%s' > /sys/bus/pci/drivers/xe/bind\n" 184 "Please file a _new_ bug report at https://gitlab.freedesktop.org/drm/xe/kernel/issues/new\n", 185 dev_name(xe->drm.dev), dev_name(xe->drm.dev), 186 dev_name(xe->drm.dev)); 187 } 188 } 189 190 #endif 191