drivers/gpu/drm/i915/selftests/intel_uncore.c

Source file repositories/reference/linux-study-clean/drivers/gpu/drm/i915/selftests/intel_uncore.c

File Facts

System
Linux kernel
Corpus path
drivers/gpu/drm/i915/selftests/intel_uncore.c
Extension
.c
Size
8211 bytes
Lines
294
Domain
Driver Families
Bucket
drivers/gpu
Inferred role
Driver Families: implementation source
Status
source implementation candidate

Why This File Exists

Repeatable hardware-adapter layer. Deep compatibility for every driver is out of scope; this atlas records patterns, probe lifecycles, bus glue, IRQ/DMA usage, and links back to core abstractions.

Dependency Surface

Detected Declarations

Annotated Snippet

if (is_watertight && (prev + 1) != (s32)ranges->start) {
			pr_err("%s: entry[%d]:(%x, %x) is not watertight to previous (%x)\n",
			       __func__, i, ranges->start, ranges->end, prev);
			return -EINVAL;
		}

		/* Check that the table never goes backwards */
		if (prev >= (s32)ranges->start) {
			pr_err("%s: entry[%d]:(%x, %x) is less than the previous (%x)\n",
			       __func__, i, ranges->start, ranges->end, prev);
			return -EINVAL;
		}

		/* Check that the entry is valid */
		if (ranges->start >= ranges->end) {
			pr_err("%s: entry[%d]:(%x, %x) has negative length\n",
			       __func__, i, ranges->start, ranges->end);
			return -EINVAL;
		}

		prev = ranges->end;
	}

	return 0;
}

static int intel_shadow_table_check(void)
{
	struct {
		const struct i915_mmio_range *regs;
		unsigned int size;
	} range_lists[] = {
		{ gen8_shadowed_regs, ARRAY_SIZE(gen8_shadowed_regs) },
		{ gen11_shadowed_regs, ARRAY_SIZE(gen11_shadowed_regs) },
		{ gen12_shadowed_regs, ARRAY_SIZE(gen12_shadowed_regs) },
		{ dg2_shadowed_regs, ARRAY_SIZE(dg2_shadowed_regs) },
		{ mtl_shadowed_regs, ARRAY_SIZE(mtl_shadowed_regs) },
		{ xelpmp_shadowed_regs, ARRAY_SIZE(xelpmp_shadowed_regs) },
	};
	const struct i915_mmio_range *range;
	unsigned int i, j;
	s32 prev;

	for (j = 0; j < ARRAY_SIZE(range_lists); ++j) {
		range = range_lists[j].regs;
		for (i = 0, prev = -1; i < range_lists[j].size; i++, range++) {
			if (range->end < range->start) {
				pr_err("%s: range[%d]:(%06x-%06x) has end before start\n",
				       __func__, i, range->start, range->end);
				return -EINVAL;
			}

			if (prev >= (s32)range->start) {
				pr_err("%s: range[%d]:(%06x-%06x) is before end of previous (%06x)\n",
				       __func__, i, range->start, range->end, prev);
				return -EINVAL;
			}

			if (range->start % 4) {
				pr_err("%s: range[%d]:(%06x-%06x) has non-dword-aligned start\n",
				       __func__, i, range->start, range->end);
				return -EINVAL;
			}

			prev = range->end;
		}
	}

	return 0;
}

int intel_uncore_mock_selftests(void)
{
	struct {
		const struct intel_forcewake_range *ranges;
		unsigned int num_ranges;
		bool is_watertight;
	} fw[] = {
		{ __vlv_fw_ranges, ARRAY_SIZE(__vlv_fw_ranges), false },
		{ __chv_fw_ranges, ARRAY_SIZE(__chv_fw_ranges), false },
		{ __gen9_fw_ranges, ARRAY_SIZE(__gen9_fw_ranges), true },
		{ __gen11_fw_ranges, ARRAY_SIZE(__gen11_fw_ranges), true },
		{ __gen12_fw_ranges, ARRAY_SIZE(__gen12_fw_ranges), true },
		{ __mtl_fw_ranges, ARRAY_SIZE(__mtl_fw_ranges), true },
		{ __xelpmp_fw_ranges, ARRAY_SIZE(__xelpmp_fw_ranges), true },
	};
	int err, i;

	for (i = 0; i < ARRAY_SIZE(fw); i++) {
		err = intel_fw_table_check(fw[i].ranges,

Annotation

Implementation Notes