projects/linux·blob master · refs

177 lines · 5.2 KiB

1// SPDX-License-Identifier: GPL-2.0
2
3/* Copyright (c) 2012-2018, The Linux Foundation. All rights reserved.
4 * Copyright (C) 2018-2024 Linaro Ltd.
5 */
6
7#include <linux/types.h>
8
9#include "ipa.h"
10#include "ipa_data.h"
11#include "ipa_reg.h"
12#include "ipa_resource.h"
13
14/**
15 * DOC: IPA Resources
16 *
17 * The IPA manages a set of resources internally for various purposes.
18 * A given IPA version has a fixed number of resource types, and a fixed
19 * total number of resources of each type. "Source" resource types
20 * are separate from "destination" resource types.
21 *
22 * Each version of IPA also has some number of resource groups. Each
23 * endpoint is assigned to a resource group, and all endpoints in the
24 * same group share pools of each type of resource. A subset of the
25 * total resources of each type is assigned for use by each group.
26 */
27
28static bool ipa_resource_limits_valid(struct ipa *ipa,
29 const struct ipa_resource_data *data)
30{
31 u32 group_count;
32 u32 i;
33 u32 j;
34
35 /* We program at most 8 source or destination resource group limits */
36 BUILD_BUG_ON(IPA_RESOURCE_GROUP_MAX > 8);
37
38 group_count = data->rsrc_group_src_count;
39 if (!group_count || group_count > IPA_RESOURCE_GROUP_MAX)
40 return false;
41
42 /* Return an error if a non-zero resource limit is specified
43 * for a resource group not supported by hardware.
44 */
45 for (i = 0; i < data->resource_src_count; i++) {
46 const struct ipa_resource *resource;
47
48 resource = &data->resource_src[i];
49 for (j = group_count; j < IPA_RESOURCE_GROUP_MAX; j++)
50 if (resource->limits[j].min || resource->limits[j].max)
51 return false;
52 }
53
54 group_count = data->rsrc_group_dst_count;
55 if (!group_count || group_count > IPA_RESOURCE_GROUP_MAX)
56 return false;
57
58 for (i = 0; i < data->resource_dst_count; i++) {
59 const struct ipa_resource *resource;
60
61 resource = &data->resource_dst[i];
62 for (j = group_count; j < IPA_RESOURCE_GROUP_MAX; j++)
63 if (resource->limits[j].min || resource->limits[j].max)
64 return false;
65 }
66
67 return true;
68}
69
70static void
71ipa_resource_config_common(struct ipa *ipa, u32 resource_type,
72 const struct reg *reg,
73 const struct ipa_resource_limits *xlimits,
74 const struct ipa_resource_limits *ylimits)
75{
76 u32 val;
77
78 val = reg_encode(reg, X_MIN_LIM, xlimits->min);
79 val |= reg_encode(reg, X_MAX_LIM, xlimits->max);
80 if (ylimits) {
81 val |= reg_encode(reg, Y_MIN_LIM, ylimits->min);
82 val |= reg_encode(reg, Y_MAX_LIM, ylimits->max);
83 }
84
85 iowrite32(val, ipa->reg_virt + reg_n_offset(reg, resource_type));
86}
87
88static void ipa_resource_config_src(struct ipa *ipa, u32 resource_type,
89 const struct ipa_resource_data *data)
90{
91 u32 group_count = data->rsrc_group_src_count;
92 const struct ipa_resource_limits *ylimits;
93 const struct ipa_resource *resource;
94 const struct reg *reg;
95
96 resource = &data->resource_src[resource_type];
97
98 reg = ipa_reg(ipa, SRC_RSRC_GRP_01_RSRC_TYPE);
99 ylimits = group_count == 1 ? NULL : &resource->limits[1];
100 ipa_resource_config_common(ipa, resource_type, reg,
101 &resource->limits[0], ylimits);
102 if (group_count < 3)
103 return;
104
105 reg = ipa_reg(ipa, SRC_RSRC_GRP_23_RSRC_TYPE);
106 ylimits = group_count == 3 ? NULL : &resource->limits[3];
107 ipa_resource_config_common(ipa, resource_type, reg,
108 &resource->limits[2], ylimits);
109 if (group_count < 5)
110 return;
111
112 reg = ipa_reg(ipa, SRC_RSRC_GRP_45_RSRC_TYPE);
113 ylimits = group_count == 5 ? NULL : &resource->limits[5];
114 ipa_resource_config_common(ipa, resource_type, reg,
115 &resource->limits[4], ylimits);
116 if (group_count < 7)
117 return;
118
119 reg = ipa_reg(ipa, SRC_RSRC_GRP_67_RSRC_TYPE);
120 ylimits = group_count == 7 ? NULL : &resource->limits[7];
121 ipa_resource_config_common(ipa, resource_type, reg,
122 &resource->limits[6], ylimits);
123}
124
125static void ipa_resource_config_dst(struct ipa *ipa, u32 resource_type,
126 const struct ipa_resource_data *data)
127{
128 u32 group_count = data->rsrc_group_dst_count;
129 const struct ipa_resource_limits *ylimits;
130 const struct ipa_resource *resource;
131 const struct reg *reg;
132
133 resource = &data->resource_dst[resource_type];
134
135 reg = ipa_reg(ipa, DST_RSRC_GRP_01_RSRC_TYPE);
136 ylimits = group_count == 1 ? NULL : &resource->limits[1];
137 ipa_resource_config_common(ipa, resource_type, reg,
138 &resource->limits[0], ylimits);
139 if (group_count < 3)
140 return;
141
142 reg = ipa_reg(ipa, DST_RSRC_GRP_23_RSRC_TYPE);
143 ylimits = group_count == 3 ? NULL : &resource->limits[3];
144 ipa_resource_config_common(ipa, resource_type, reg,
145 &resource->limits[2], ylimits);
146 if (group_count < 5)
147 return;
148
149 reg = ipa_reg(ipa, DST_RSRC_GRP_45_RSRC_TYPE);
150 ylimits = group_count == 5 ? NULL : &resource->limits[5];
151 ipa_resource_config_common(ipa, resource_type, reg,
152 &resource->limits[4], ylimits);
153 if (group_count < 7)
154 return;
155
156 reg = ipa_reg(ipa, DST_RSRC_GRP_67_RSRC_TYPE);
157 ylimits = group_count == 7 ? NULL : &resource->limits[7];
158 ipa_resource_config_common(ipa, resource_type, reg,
159 &resource->limits[6], ylimits);
160}
161
162/* Configure resources; there is no ipa_resource_deconfig() */
163int ipa_resource_config(struct ipa *ipa, const struct ipa_resource_data *data)
164{
165 u32 i;
166
167 if (!ipa_resource_limits_valid(ipa, data))
168 return -EINVAL;
169
170 for (i = 0; i < data->resource_src_count; i++)
171 ipa_resource_config_src(ipa, i, data);
172
173 for (i = 0; i < data->resource_dst_count; i++)
174 ipa_resource_config_dst(ipa, i, data);
175
176 return 0;
177}