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