update kernel to 5.10.198

hc

2024-01-03 2f7c68cb55ecb7331f2381deb497c27155f32faf

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
// SPDX-License-Identifier: GPL-2.0
/*
 * Copyright © 2020 Intel Corporation
 */
 
static struct intel_ring *mock_ring(unsigned long sz)
{
    struct intel_ring *ring;
 
    ring = kzalloc(sizeof(*ring) + sz, GFP_KERNEL);
    if (!ring)
        return NULL;
 
    kref_init(&ring->ref);
    ring->size = sz;
    ring->wrap = BITS_PER_TYPE(ring->size) - ilog2(sz);
    ring->effective_size = sz;
    ring->vaddr = (void *)(ring + 1);
    atomic_set(&ring->pin_count, 1);
 
    intel_ring_update_space(ring);
 
    return ring;
}
 
static void mock_ring_free(struct intel_ring *ring)
{
    kfree(ring);
}
 
static int check_ring_direction(struct intel_ring *ring,
                u32 next, u32 prev,
                int expected)
{
    int result;
 
    result = intel_ring_direction(ring, next, prev);
    if (result < 0)
        result = -1;
    else if (result > 0)
        result = 1;
 
    if (result != expected) {
        pr_err("intel_ring_direction(%u, %u):%d != %d\n",
               next, prev, result, expected);
        return -EINVAL;
    }
 
    return 0;
}
 
static int check_ring_step(struct intel_ring *ring, u32 x, u32 step)
{
    u32 prev = x, next = intel_ring_wrap(ring, x + step);
    int err = 0;
 
    err |= check_ring_direction(ring, next, next,  0);
    err |= check_ring_direction(ring, prev, prev,  0);
    err |= check_ring_direction(ring, next, prev,  1);
    err |= check_ring_direction(ring, prev, next, -1);
 
    return err;
}
 
static int check_ring_offset(struct intel_ring *ring, u32 x, u32 step)
{
    int err = 0;
 
    err |= check_ring_step(ring, x, step);
    err |= check_ring_step(ring, intel_ring_wrap(ring, x + 1), step);
    err |= check_ring_step(ring, intel_ring_wrap(ring, x - 1), step);
 
    return err;
}
 
static int igt_ring_direction(void *dummy)
{
    struct intel_ring *ring;
    unsigned int half = 2048;
    int step, err = 0;
 
    ring = mock_ring(2 * half);
    if (!ring)
        return -ENOMEM;
 
    GEM_BUG_ON(ring->size != 2 * half);
 
    /* Precision of wrap detection is limited to ring->size / 2 */
    for (step = 1; step < half; step <<= 1) {
        err |= check_ring_offset(ring, 0, step);
        err |= check_ring_offset(ring, half, step);
    }
    err |= check_ring_step(ring, 0, half - 64);
 
    /* And check unwrapped handling for good measure */
    err |= check_ring_offset(ring, 0, 2 * half + 64);
    err |= check_ring_offset(ring, 3 * half, 1);
 
    mock_ring_free(ring);
    return err;
}
 
int intel_ring_mock_selftests(void)
{
    static const struct i915_subtest tests[] = {
        SUBTEST(igt_ring_direction),
    };
 
    return i915_subtests(tests, NULL);
}