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 #include <drm/drm_util.h> 10 11 #include "xe_device_types.h" 12 #include "xe_gt_types.h" 13 #include "xe_sriov.h" 14 15 static inline struct xe_device *to_xe_device(const struct drm_device *dev) 16 { 17 return container_of(dev, struct xe_device, drm); 18 } 19 20 static inline struct xe_device *kdev_to_xe_device(struct device *kdev) 21 { 22 struct drm_device *drm = dev_get_drvdata(kdev); 23 24 return drm ? to_xe_device(drm) : NULL; 25 } 26 27 static inline struct xe_device *pdev_to_xe_device(struct pci_dev *pdev) 28 { 29 struct drm_device *drm = pci_get_drvdata(pdev); 30 31 return drm ? to_xe_device(drm) : NULL; 32 } 33 34 static inline struct xe_device *xe_device_const_cast(const struct xe_device *xe) 35 { 36 return (struct xe_device *)xe; 37 } 38 39 static inline struct xe_device *ttm_to_xe_device(struct ttm_device *ttm) 40 { 41 return container_of(ttm, struct xe_device, ttm); 42 } 43 44 struct xe_device *xe_device_create(struct pci_dev *pdev, 45 const struct pci_device_id *ent); 46 int xe_device_probe_early(struct xe_device *xe); 47 int xe_device_probe(struct xe_device *xe); 48 void xe_device_remove(struct xe_device *xe); 49 void xe_device_shutdown(struct xe_device *xe); 50 51 void xe_device_wmb(struct xe_device *xe); 52 53 static inline struct xe_file *to_xe_file(const struct drm_file *file) 54 { 55 return file->driver_priv; 56 } 57 58 static inline struct xe_tile *xe_device_get_root_tile(struct xe_device *xe) 59 { 60 return &xe->tiles[0]; 61 } 62 63 #define XE_MAX_GT_PER_TILE 2 64 65 static inline struct xe_gt *xe_tile_get_gt(struct xe_tile *tile, u8 gt_id) 66 { 67 if (drm_WARN_ON(&tile_to_xe(tile)->drm, gt_id >= XE_MAX_GT_PER_TILE)) 68 gt_id = 0; 69 70 return gt_id ? tile->media_gt : tile->primary_gt; 71 } 72 73 static inline struct xe_gt *xe_device_get_gt(struct xe_device *xe, u8 gt_id) 74 { 75 struct xe_tile *root_tile = xe_device_get_root_tile(xe); 76 struct xe_gt *gt; 77 78 /* 79 * FIXME: This only works for now because multi-tile and standalone 80 * media are mutually exclusive on the platforms we have today. 81 * 82 * id => GT mapping may change once we settle on how we want to handle 83 * our UAPI. 84 */ 85 if (MEDIA_VER(xe) >= 13) { 86 gt = xe_tile_get_gt(root_tile, gt_id); 87 } else { 88 if (drm_WARN_ON(&xe->drm, gt_id >= XE_MAX_TILES_PER_DEVICE)) 89 gt_id = 0; 90 91 gt = xe->tiles[gt_id].primary_gt; 92 } 93 94 if (!gt) 95 return NULL; 96 97 drm_WARN_ON(&xe->drm, gt->info.id != gt_id); 98 drm_WARN_ON(&xe->drm, gt->info.type == XE_GT_TYPE_UNINITIALIZED); 99 100 return gt; 101 } 102 103 /* 104 * Provide a GT structure suitable for performing non-GT MMIO operations against 105 * the primary tile. Primarily intended for early tile initialization, display 106 * handling, top-most interrupt enable/disable, etc. Since anything using the 107 * MMIO handle returned by this function doesn't need GSI offset translation, 108 * we'll return the primary GT from the root tile. 109 * 110 * FIXME: Fix the driver design so that 'gt' isn't the target of all MMIO 111 * operations. 112 * 113 * Returns the primary gt of the root tile. 114 */ 115 static inline struct xe_gt *xe_root_mmio_gt(struct xe_device *xe) 116 { 117 return xe_device_get_root_tile(xe)->primary_gt; 118 } 119 120 static inline bool xe_device_uc_enabled(struct xe_device *xe) 121 { 122 return !xe->info.force_execlist; 123 } 124 125 #define for_each_tile(tile__, xe__, id__) \ 126 for ((id__) = 0; (id__) < (xe__)->info.tile_count; (id__)++) \ 127 for_each_if((tile__) = &(xe__)->tiles[(id__)]) 128 129 #define for_each_remote_tile(tile__, xe__, id__) \ 130 for ((id__) = 1; (id__) < (xe__)->info.tile_count; (id__)++) \ 131 for_each_if((tile__) = &(xe__)->tiles[(id__)]) 132 133 /* 134 * FIXME: This only works for now since multi-tile and standalone media 135 * happen to be mutually exclusive. Future platforms may change this... 136 */ 137 #define for_each_gt(gt__, xe__, id__) \ 138 for ((id__) = 0; (id__) < (xe__)->info.gt_count; (id__)++) \ 139 for_each_if((gt__) = xe_device_get_gt((xe__), (id__))) 140 141 static inline struct xe_force_wake *gt_to_fw(struct xe_gt *gt) 142 { 143 return >->pm.fw; 144 } 145 146 void xe_device_assert_mem_access(struct xe_device *xe); 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_msix(struct xe_device *xe) 159 { 160 /* TODO: change this when MSI-X support is fully integrated */ 161 return false; 162 } 163 164 static inline bool xe_device_has_memirq(struct xe_device *xe) 165 { 166 return GRAPHICS_VERx100(xe) >= 1250; 167 } 168 169 static inline bool xe_device_uses_memirq(struct xe_device *xe) 170 { 171 return xe_device_has_memirq(xe) && (IS_SRIOV_VF(xe) || xe_device_has_msix(xe)); 172 } 173 174 u32 xe_device_ccs_bytes(struct xe_device *xe, u64 size); 175 176 void xe_device_snapshot_print(struct xe_device *xe, struct drm_printer *p); 177 178 u64 xe_device_canonicalize_addr(struct xe_device *xe, u64 address); 179 u64 xe_device_uncanonicalize_addr(struct xe_device *xe, u64 address); 180 181 void xe_device_td_flush(struct xe_device *xe); 182 void xe_device_l2_flush(struct xe_device *xe); 183 184 static inline bool xe_device_wedged(struct xe_device *xe) 185 { 186 return atomic_read(&xe->wedged.flag); 187 } 188 189 void xe_device_declare_wedged(struct xe_device *xe); 190 191 struct xe_file *xe_file_get(struct xe_file *xef); 192 void xe_file_put(struct xe_file *xef); 193 194 /* 195 * Occasionally it is seen that the G2H worker starts running after a delay of more than 196 * a second even after being queued and activated by the Linux workqueue subsystem. This 197 * leads to G2H timeout error. The root cause of issue lies with scheduling latency of 198 * Lunarlake Hybrid CPU. Issue disappears if we disable Lunarlake atom cores from BIOS 199 * and this is beyond xe kmd. 200 * 201 * TODO: Drop this change once workqueue scheduling delay issue is fixed on LNL Hybrid CPU. 202 */ 203 #define LNL_FLUSH_WORKQUEUE(wq__) \ 204 flush_workqueue(wq__) 205 #define LNL_FLUSH_WORK(wrk__) \ 206 flush_work(wrk__) 207 208 #endif 209