drivers/gpu/drm/xe/xe_device.h

   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 &gt->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