1 // SPDX-License-Identifier: GPL-2.0-only
2 // Copyright(c) 2015-2020 Intel Corporation.
3
4 #include <linux/device.h>
5 #include <linux/mod_devicetable.h>
6 #include <linux/slab.h>
7 #include <linux/sysfs.h>
8 #include <linux/soundwire/sdw.h>
9 #include <linux/soundwire/sdw_type.h>
10 #include "bus.h"
11 #include "sysfs_local.h"
12
13 struct dpn_attribute {
14 struct device_attribute dev_attr;
15 int N;
16 int dir;
17 const char *format_string;
18 };
19
20 /*
21 * Since we can't use ARRAY_SIZE, hard-code number of dpN attributes.
22 * This needs to be updated when adding new attributes - an error will be
23 * flagged on a mismatch.
24 */
25 #define SDW_DPN_ATTRIBUTES 15
26
27 #define sdw_dpn_attribute_alloc(field) \
28 static int field##_attribute_alloc(struct device *dev, \
29 struct attribute **res, \
30 int N, int dir, \
31 const char *format_string) \
32 { \
33 struct dpn_attribute *dpn_attr; \
34 \
35 dpn_attr = devm_kzalloc(dev, sizeof(*dpn_attr), GFP_KERNEL); \
36 if (!dpn_attr) \
37 return -ENOMEM; \
38 dpn_attr->N = N; \
39 dpn_attr->dir = dir; \
40 sysfs_attr_init(&dpn_attr->dev_attr.attr); \
41 dpn_attr->format_string = format_string; \
42 dpn_attr->dev_attr.attr.name = __stringify(field); \
43 dpn_attr->dev_attr.attr.mode = 0444; \
44 dpn_attr->dev_attr.show = field##_show; \
45 \
46 *res = &dpn_attr->dev_attr.attr; \
47 \
48 return 0; \
49 }
50
51 #define sdw_dpn_attr(field) \
52 \
53 static ssize_t field##_dpn_show(struct sdw_slave *slave, \
54 int N, \
55 int dir, \
56 const char *format_string, \
57 char *buf) \
58 { \
59 struct sdw_dpn_prop *dpn; \
60 unsigned long mask; \
61 int bit; \
62 int i; \
63 \
64 if (dir) { \
65 dpn = slave->prop.src_dpn_prop; \
66 mask = slave->prop.source_ports; \
67 } else { \
68 dpn = slave->prop.sink_dpn_prop; \
69 mask = slave->prop.sink_ports; \
70 } \
71 \
72 i = 0; \
73 for_each_set_bit(bit, &mask, 32) { \
74 if (bit == N) { \
75 return sprintf(buf, format_string, \
76 dpn[i].field); \
77 } \
78 i++; \
79 } \
80 return -EINVAL; \
81 } \
82 \
83 static ssize_t field##_show(struct device *dev, \
84 struct device_attribute *attr, \
85 char *buf) \
86 { \
87 struct sdw_slave *slave = dev_to_sdw_dev(dev); \
88 struct dpn_attribute *dpn_attr = \
89 container_of(attr, struct dpn_attribute, dev_attr); \
90 \
91 return field##_dpn_show(slave, \
92 dpn_attr->N, dpn_attr->dir, \
93 dpn_attr->format_string, \
94 buf); \
95 } \
96 sdw_dpn_attribute_alloc(field)
97
98 sdw_dpn_attr(imp_def_interrupts);
99 sdw_dpn_attr(max_word);
100 sdw_dpn_attr(min_word);
101 sdw_dpn_attr(type);
102 sdw_dpn_attr(max_grouping);
103 sdw_dpn_attr(simple_ch_prep_sm);
104 sdw_dpn_attr(ch_prep_timeout);
105 sdw_dpn_attr(max_ch);
106 sdw_dpn_attr(min_ch);
107 sdw_dpn_attr(max_async_buffer);
108 sdw_dpn_attr(block_pack_mode);
109 sdw_dpn_attr(port_encoding);
110
111 #define sdw_dpn_array_attr(field) \
112 \
113 static ssize_t field##_dpn_show(struct sdw_slave *slave, \
114 int N, \
115 int dir, \
116 const char *format_string, \
117 char *buf) \
118 { \
119 struct sdw_dpn_prop *dpn; \
120 unsigned long mask; \
121 ssize_t size = 0; \
122 int bit; \
123 int i; \
124 int j; \
125 \
126 if (dir) { \
127 dpn = slave->prop.src_dpn_prop; \
128 mask = slave->prop.source_ports; \
129 } else { \
130 dpn = slave->prop.sink_dpn_prop; \
131 mask = slave->prop.sink_ports; \
132 } \
133 \
134 i = 0; \
135 for_each_set_bit(bit, &mask, 32) { \
136 if (bit == N) { \
137 for (j = 0; j < dpn[i].num_##field; j++) \
138 size += sprintf(buf + size, \
139 format_string, \
140 dpn[i].field[j]); \
141 size += sprintf(buf + size, "\n"); \
142 return size; \
143 } \
144 i++; \
145 } \
146 return -EINVAL; \
147 } \
148 static ssize_t field##_show(struct device *dev, \
149 struct device_attribute *attr, \
150 char *buf) \
151 { \
152 struct sdw_slave *slave = dev_to_sdw_dev(dev); \
153 struct dpn_attribute *dpn_attr = \
154 container_of(attr, struct dpn_attribute, dev_attr); \
155 \
156 return field##_dpn_show(slave, \
157 dpn_attr->N, dpn_attr->dir, \
158 dpn_attr->format_string, \
159 buf); \
160 } \
161 sdw_dpn_attribute_alloc(field)
162
163 sdw_dpn_array_attr(words);
164 sdw_dpn_array_attr(ch_combinations);
165 sdw_dpn_array_attr(channels);
166
add_all_attributes(struct device * dev,int N,int dir)167 static int add_all_attributes(struct device *dev, int N, int dir)
168 {
169 struct attribute **dpn_attrs;
170 struct attribute_group *dpn_group;
171 int i = 0;
172 int ret;
173
174 /* allocate attributes, last one is NULL */
175 dpn_attrs = devm_kcalloc(dev, SDW_DPN_ATTRIBUTES + 1,
176 sizeof(struct attribute *),
177 GFP_KERNEL);
178 if (!dpn_attrs)
179 return -ENOMEM;
180
181 ret = max_word_attribute_alloc(dev, &dpn_attrs[i++],
182 N, dir, "%d\n");
183 if (ret < 0)
184 return ret;
185
186 ret = min_word_attribute_alloc(dev, &dpn_attrs[i++],
187 N, dir, "%d\n");
188 if (ret < 0)
189 return ret;
190
191 ret = words_attribute_alloc(dev, &dpn_attrs[i++],
192 N, dir, "%d\n");
193 if (ret < 0)
194 return ret;
195
196 ret = type_attribute_alloc(dev, &dpn_attrs[i++],
197 N, dir, "%d\n");
198 if (ret < 0)
199 return ret;
200
201 ret = max_grouping_attribute_alloc(dev, &dpn_attrs[i++],
202 N, dir, "%d\n");
203 if (ret < 0)
204 return ret;
205
206 ret = simple_ch_prep_sm_attribute_alloc(dev, &dpn_attrs[i++],
207 N, dir, "%d\n");
208 if (ret < 0)
209 return ret;
210
211 ret = ch_prep_timeout_attribute_alloc(dev, &dpn_attrs[i++],
212 N, dir, "%d\n");
213 if (ret < 0)
214 return ret;
215
216 ret = imp_def_interrupts_attribute_alloc(dev, &dpn_attrs[i++],
217 N, dir, "0x%x\n");
218 if (ret < 0)
219 return ret;
220
221 ret = min_ch_attribute_alloc(dev, &dpn_attrs[i++],
222 N, dir, "%d\n");
223 if (ret < 0)
224 return ret;
225
226 ret = max_ch_attribute_alloc(dev, &dpn_attrs[i++],
227 N, dir, "%d\n");
228 if (ret < 0)
229 return ret;
230
231 ret = channels_attribute_alloc(dev, &dpn_attrs[i++],
232 N, dir, "%d\n");
233 if (ret < 0)
234 return ret;
235
236 ret = ch_combinations_attribute_alloc(dev, &dpn_attrs[i++],
237 N, dir, "%d\n");
238 if (ret < 0)
239 return ret;
240
241 ret = max_async_buffer_attribute_alloc(dev, &dpn_attrs[i++],
242 N, dir, "%d\n");
243 if (ret < 0)
244 return ret;
245
246 ret = block_pack_mode_attribute_alloc(dev, &dpn_attrs[i++],
247 N, dir, "%d\n");
248 if (ret < 0)
249 return ret;
250
251 ret = port_encoding_attribute_alloc(dev, &dpn_attrs[i++],
252 N, dir, "%d\n");
253 if (ret < 0)
254 return ret;
255
256 /* paranoia check for editing mistakes */
257 if (i != SDW_DPN_ATTRIBUTES) {
258 dev_err(dev, "mismatch in attributes, allocated %d got %d\n",
259 SDW_DPN_ATTRIBUTES, i);
260 return -EINVAL;
261 }
262
263 dpn_group = devm_kzalloc(dev, sizeof(*dpn_group), GFP_KERNEL);
264 if (!dpn_group)
265 return -ENOMEM;
266
267 dpn_group->attrs = dpn_attrs;
268 dpn_group->name = devm_kasprintf(dev, GFP_KERNEL, "dp%d_%s",
269 N, dir ? "src" : "sink");
270 if (!dpn_group->name)
271 return -ENOMEM;
272
273 ret = devm_device_add_group(dev, dpn_group);
274 if (ret < 0)
275 return ret;
276
277 return 0;
278 }
279
sdw_slave_sysfs_dpn_init(struct sdw_slave * slave)280 int sdw_slave_sysfs_dpn_init(struct sdw_slave *slave)
281 {
282 unsigned long mask;
283 int ret;
284 int i;
285
286 mask = slave->prop.source_ports;
287 for_each_set_bit(i, &mask, 32) {
288 ret = add_all_attributes(&slave->dev, i, 1);
289 if (ret < 0)
290 return ret;
291 }
292
293 mask = slave->prop.sink_ports;
294 for_each_set_bit(i, &mask, 32) {
295 ret = add_all_attributes(&slave->dev, i, 0);
296 if (ret < 0)
297 return ret;
298 }
299
300 return 0;
301 }
302