mk-rootfs.sh

hc

2023-12-11 072de836f53be56a70cecf70b43ae43b7ce17376

 kernel/drivers/soundwire/mipi_disco.c
..
..
@@ -35,11 +35,12 @@
35
35
 	int nval, i;
36
36
 
37
37
 	device_property_read_u32(bus->dev,
38
-			"mipi-sdw-sw-interface-revision", &prop->revision);
38
+				 "mipi-sdw-sw-interface-revision",
39
+				 &prop->revision);
39
40
 
40
41
 	/* Find master handle */
41
42
 	snprintf(name, sizeof(name),
42
-			"mipi-sdw-master-%d-subproperties", bus->link_id);
43
+		 "mipi-sdw-link-%d-subproperties", bus->link_id);
43
44
 
44
45
 	link = device_get_named_child_node(bus->dev, name);
45
46
 	if (!link) {
..
..
@@ -48,96 +49,96 @@
48
49
 	}
49
50
 
50
51
 	if (fwnode_property_read_bool(link,
51
-			"mipi-sdw-clock-stop-mode0-supported") == true)
52
-		prop->clk_stop_mode = SDW_CLK_STOP_MODE0;
52
+				      "mipi-sdw-clock-stop-mode0-supported"))
53
+		prop->clk_stop_modes |= BIT(SDW_CLK_STOP_MODE0);
53
54
 
54
55
 	if (fwnode_property_read_bool(link,
55
-			"mipi-sdw-clock-stop-mode1-supported") == true)
56
-		prop->clk_stop_mode |= SDW_CLK_STOP_MODE1;
56
+				      "mipi-sdw-clock-stop-mode1-supported"))
57
+		prop->clk_stop_modes |= BIT(SDW_CLK_STOP_MODE1);
57
58
 
58
59
 	fwnode_property_read_u32(link,
59
-			"mipi-sdw-max-clock-frequency", &prop->max_freq);
60
+				 "mipi-sdw-max-clock-frequency",
61
+				 &prop->max_clk_freq);
60
62
 
61
-	nval = fwnode_property_read_u32_array(link,
62
-			"mipi-sdw-clock-frequencies-supported", NULL, 0);
63
+	nval = fwnode_property_count_u32(link, "mipi-sdw-clock-frequencies-supported");
63
64
 	if (nval > 0) {
64
-
65
-		prop->num_freq = nval;
66
-		prop->freq = devm_kcalloc(bus->dev, prop->num_freq,
67
-				sizeof(*prop->freq), GFP_KERNEL);
68
-		if (!prop->freq)
65
+		prop->num_clk_freq = nval;
66
+		prop->clk_freq = devm_kcalloc(bus->dev, prop->num_clk_freq,
67
+					      sizeof(*prop->clk_freq),
68
+					      GFP_KERNEL);
69
+		if (!prop->clk_freq)
69
70
 			return -ENOMEM;
70
71
 
71
72
 		fwnode_property_read_u32_array(link,
72
73
 				"mipi-sdw-clock-frequencies-supported",
73
-				prop->freq, prop->num_freq);
74
+				prop->clk_freq, prop->num_clk_freq);
74
75
 	}
75
76
 
76
77
 	/*
77
78
 	 * Check the frequencies supported. If FW doesn't provide max
78
79
 	 * freq, then populate here by checking values.
79
80
 	 */
80
-	if (!prop->max_freq && prop->freq) {
81
-		prop->max_freq = prop->freq[0];
82
-		for (i = 1; i < prop->num_freq; i++) {
83
-			if (prop->freq[i] > prop->max_freq)
84
-				prop->max_freq = prop->freq[i];
81
+	if (!prop->max_clk_freq && prop->clk_freq) {
82
+		prop->max_clk_freq = prop->clk_freq[0];
83
+		for (i = 1; i < prop->num_clk_freq; i++) {
84
+			if (prop->clk_freq[i] > prop->max_clk_freq)
85
+				prop->max_clk_freq = prop->clk_freq[i];
85
86
 		}
86
87
 	}
87
88
 
88
-	nval = fwnode_property_read_u32_array(link,
89
-			"mipi-sdw-supported-clock-gears", NULL, 0);
89
+	nval = fwnode_property_count_u32(link, "mipi-sdw-supported-clock-gears");
90
90
 	if (nval > 0) {
91
-
92
91
 		prop->num_clk_gears = nval;
93
92
 		prop->clk_gears = devm_kcalloc(bus->dev, prop->num_clk_gears,
94
-				sizeof(*prop->clk_gears), GFP_KERNEL);
93
+					       sizeof(*prop->clk_gears),
94
+					       GFP_KERNEL);
95
95
 		if (!prop->clk_gears)
96
96
 			return -ENOMEM;
97
97
 
98
98
 		fwnode_property_read_u32_array(link,
99
-				"mipi-sdw-supported-clock-gears",
100
-				prop->clk_gears, prop->num_clk_gears);
99
+					       "mipi-sdw-supported-clock-gears",
100
+					       prop->clk_gears,
101
+					       prop->num_clk_gears);
101
102
 	}
102
103
 
103
104
 	fwnode_property_read_u32(link, "mipi-sdw-default-frame-rate",
104
-			&prop->default_frame_rate);
105
+				 &prop->default_frame_rate);
105
106
 
106
107
 	fwnode_property_read_u32(link, "mipi-sdw-default-frame-row-size",
107
-			&prop->default_row);
108
+				 &prop->default_row);
108
109
 
109
110
 	fwnode_property_read_u32(link, "mipi-sdw-default-frame-col-size",
110
-			&prop->default_col);
111
+				 &prop->default_col);
111
112
 
112
113
 	prop->dynamic_frame =  fwnode_property_read_bool(link,
113
114
 			"mipi-sdw-dynamic-frame-shape");
114
115
 
115
116
 	fwnode_property_read_u32(link, "mipi-sdw-command-error-threshold",
116
-			&prop->err_threshold);
117
+				 &prop->err_threshold);
117
118
 
118
119
 	return 0;
119
120
 }
120
121
 EXPORT_SYMBOL(sdw_master_read_prop);
121
122
 
122
123
 static int sdw_slave_read_dp0(struct sdw_slave *slave,
123
-		struct fwnode_handle *port, struct sdw_dp0_prop *dp0)
124
+			      struct fwnode_handle *port,
125
+			      struct sdw_dp0_prop *dp0)
124
126
 {
125
127
 	int nval;
126
128
 
127
129
 	fwnode_property_read_u32(port, "mipi-sdw-port-max-wordlength",
128
-			&dp0->max_word);
130
+				 &dp0->max_word);
129
131
 
130
132
 	fwnode_property_read_u32(port, "mipi-sdw-port-min-wordlength",
131
-			&dp0->min_word);
133
+				 &dp0->min_word);
132
134
 
133
-	nval = fwnode_property_read_u32_array(port,
134
-			"mipi-sdw-port-wordlength-configs", NULL, 0);
135
+	nval = fwnode_property_count_u32(port, "mipi-sdw-port-wordlength-configs");
135
136
 	if (nval > 0) {
136
137
 
137
138
 		dp0->num_words = nval;
138
139
 		dp0->words = devm_kcalloc(&slave->dev,
139
-				dp0->num_words, sizeof(*dp0->words),
140
-				GFP_KERNEL);
140
+					  dp0->num_words, sizeof(*dp0->words),
141
+					  GFP_KERNEL);
141
142
 		if (!dp0->words)
142
143
 			return -ENOMEM;
143
144
 
..
..
@@ -146,20 +147,21 @@
146
147
 				dp0->words, dp0->num_words);
147
148
 	}
148
149
 
149
-	dp0->flow_controlled = fwnode_property_read_bool(
150
-			port, "mipi-sdw-bra-flow-controlled");
150
+	dp0->BRA_flow_controlled = fwnode_property_read_bool(port,
151
+				"mipi-sdw-bra-flow-controlled");
151
152
 
152
-	dp0->simple_ch_prep_sm = fwnode_property_read_bool(
153
-			port, "mipi-sdw-simplified-channel-prepare-sm");
153
+	dp0->simple_ch_prep_sm = fwnode_property_read_bool(port,
154
+				"mipi-sdw-simplified-channel-prepare-sm");
154
155
 
155
-	dp0->device_interrupts = fwnode_property_read_bool(
156
-			port, "mipi-sdw-imp-def-dp0-interrupts-supported");
156
+	dp0->imp_def_interrupts = fwnode_property_read_bool(port,
157
+				"mipi-sdw-imp-def-dp0-interrupts-supported");
157
158
 
158
159
 	return 0;
159
160
 }
160
161
 
161
162
 static int sdw_slave_read_dpn(struct sdw_slave *slave,
162
-		struct sdw_dpn_prop *dpn, int count, int ports, char *type)
163
+			      struct sdw_dpn_prop *dpn, int count, int ports,
164
+			      char *type)
163
165
 {
164
166
 	struct fwnode_handle *node;
165
167
 	u32 bit, i = 0;
..
..
@@ -173,7 +175,7 @@
173
175
 
174
176
 	for_each_set_bit(bit, &addr, 32) {
175
177
 		snprintf(name, sizeof(name),
176
-			"mipi-sdw-dp-%d-%s-subproperties", bit, type);
178
+			 "mipi-sdw-dp-%d-%s-subproperties", bit, type);
177
179
 
178
180
 		dpn[i].num = bit;
179
181
 
..
..
@@ -184,18 +186,17 @@
184
186
 		}
185
187
 
186
188
 		fwnode_property_read_u32(node, "mipi-sdw-port-max-wordlength",
187
-					&dpn[i].max_word);
189
+					 &dpn[i].max_word);
188
190
 		fwnode_property_read_u32(node, "mipi-sdw-port-min-wordlength",
189
-					&dpn[i].min_word);
191
+					 &dpn[i].min_word);
190
192
 
191
-		nval = fwnode_property_read_u32_array(node,
192
-				"mipi-sdw-port-wordlength-configs", NULL, 0);
193
+		nval = fwnode_property_count_u32(node, "mipi-sdw-port-wordlength-configs");
193
194
 		if (nval > 0) {
194
-
195
195
 			dpn[i].num_words = nval;
196
196
 			dpn[i].words = devm_kcalloc(&slave->dev,
197
-					dpn[i].num_words,
198
-					sizeof(*dpn[i].words), GFP_KERNEL);
197
+						    dpn[i].num_words,
198
+						    sizeof(*dpn[i].words),
199
+						    GFP_KERNEL);
199
200
 			if (!dpn[i].words)
200
201
 				return -ENOMEM;
201
202
 
..
..
@@ -205,48 +206,46 @@
205
206
 		}
206
207
 
207
208
 		fwnode_property_read_u32(node, "mipi-sdw-data-port-type",
208
-				&dpn[i].type);
209
+					 &dpn[i].type);
209
210
 
210
211
 		fwnode_property_read_u32(node,
211
-				"mipi-sdw-max-grouping-supported",
212
-				&dpn[i].max_grouping);
212
+					 "mipi-sdw-max-grouping-supported",
213
+					 &dpn[i].max_grouping);
213
214
 
214
215
 		dpn[i].simple_ch_prep_sm = fwnode_property_read_bool(node,
215
216
 				"mipi-sdw-simplified-channelprepare-sm");
216
217
 
217
218
 		fwnode_property_read_u32(node,
218
-				"mipi-sdw-port-channelprepare-timeout",
219
-				&dpn[i].ch_prep_timeout);
219
+					 "mipi-sdw-port-channelprepare-timeout",
220
+					 &dpn[i].ch_prep_timeout);
220
221
 
221
222
 		fwnode_property_read_u32(node,
222
223
 				"mipi-sdw-imp-def-dpn-interrupts-supported",
223
-				&dpn[i].device_interrupts);
224
+				&dpn[i].imp_def_interrupts);
224
225
 
225
226
 		fwnode_property_read_u32(node, "mipi-sdw-min-channel-number",
226
-				&dpn[i].min_ch);
227
+					 &dpn[i].min_ch);
227
228
 
228
229
 		fwnode_property_read_u32(node, "mipi-sdw-max-channel-number",
229
-				&dpn[i].max_ch);
230
+					 &dpn[i].max_ch);
230
231
 
231
-		nval = fwnode_property_read_u32_array(node,
232
-				"mipi-sdw-channel-number-list", NULL, 0);
232
+		nval = fwnode_property_count_u32(node, "mipi-sdw-channel-number-list");
233
233
 		if (nval > 0) {
234
-
235
-			dpn[i].num_ch = nval;
236
-			dpn[i].ch = devm_kcalloc(&slave->dev, dpn[i].num_ch,
237
-					sizeof(*dpn[i].ch), GFP_KERNEL);
238
-			if (!dpn[i].ch)
234
+			dpn[i].num_channels = nval;
235
+			dpn[i].channels = devm_kcalloc(&slave->dev,
236
+						       dpn[i].num_channels,
237
+						       sizeof(*dpn[i].channels),
238
+						 GFP_KERNEL);
239
+			if (!dpn[i].channels)
239
240
 				return -ENOMEM;
240
241
 
241
242
 			fwnode_property_read_u32_array(node,
242
243
 					"mipi-sdw-channel-number-list",
243
-					dpn[i].ch, dpn[i].num_ch);
244
+					dpn[i].channels, dpn[i].num_channels);
244
245
 		}
245
246
 
246
-		nval = fwnode_property_read_u32_array(node,
247
-				"mipi-sdw-channel-combination-list", NULL, 0);
247
+		nval = fwnode_property_count_u32(node, "mipi-sdw-channel-combination-list");
248
248
 		if (nval > 0) {
249
-
250
249
 			dpn[i].num_ch_combinations = nval;
251
250
 			dpn[i].ch_combinations = devm_kcalloc(&slave->dev,
252
251
 					dpn[i].num_ch_combinations,
..
..
@@ -265,13 +264,13 @@
265
264
 				"mipi-sdw-modes-supported", &dpn[i].modes);
266
265
 
267
266
 		fwnode_property_read_u32(node, "mipi-sdw-max-async-buffer",
268
-				&dpn[i].max_async_buffer);
267
+					 &dpn[i].max_async_buffer);
269
268
 
270
269
 		dpn[i].block_pack_mode = fwnode_property_read_bool(node,
271
270
 				"mipi-sdw-block-packing-mode");
272
271
 
273
272
 		fwnode_property_read_u32(node, "mipi-sdw-port-encoding-type",
274
-				&dpn[i].port_encoding);
273
+					 &dpn[i].port_encoding);
275
274
 
276
275
 		/* TODO: Read audio mode */
277
276
 
..
..
@@ -290,10 +289,10 @@
290
289
 	struct sdw_slave_prop *prop = &slave->prop;
291
290
 	struct device *dev = &slave->dev;
292
291
 	struct fwnode_handle *port;
293
-	int num_of_ports, nval, i, dp0 = 0;
292
+	int nval;
294
293
 
295
294
 	device_property_read_u32(dev, "mipi-sdw-sw-interface-revision",
296
-				&prop->mipi_revision);
295
+				 &prop->mipi_revision);
297
296
 
298
297
 	prop->wake_capable = device_property_read_bool(dev,
299
298
 				"mipi-sdw-wake-up-unavailable");
..
..
@@ -311,10 +310,10 @@
311
310
 			"mipi-sdw-simplified-clockstopprepare-sm-supported");
312
311
 
313
312
 	device_property_read_u32(dev, "mipi-sdw-clockstopprepare-timeout",
314
-			&prop->clk_stop_timeout);
313
+				 &prop->clk_stop_timeout);
315
314
 
316
315
 	device_property_read_u32(dev, "mipi-sdw-slave-channelprepare-timeout",
317
-			&prop->ch_prep_timeout);
316
+				 &prop->ch_prep_timeout);
318
317
 
319
318
 	device_property_read_u32(dev,
320
319
 			"mipi-sdw-clockstopprepare-hard-reset-behavior",
..
..
@@ -333,27 +332,26 @@
333
332
 			"mipi-sdw-port15-read-behavior", &prop->p15_behave);
334
333
 
335
334
 	device_property_read_u32(dev, "mipi-sdw-master-count",
336
-				&prop->master_count);
335
+				 &prop->master_count);
337
336
 
338
337
 	device_property_read_u32(dev, "mipi-sdw-source-port-list",
339
-				&prop->source_ports);
338
+				 &prop->source_ports);
340
339
 
341
340
 	device_property_read_u32(dev, "mipi-sdw-sink-port-list",
342
-				&prop->sink_ports);
341
+				 &prop->sink_ports);
343
342
 
344
343
 	/* Read dp0 properties */
345
344
 	port = device_get_named_child_node(dev, "mipi-sdw-dp-0-subproperties");
346
345
 	if (!port) {
347
346
 		dev_dbg(dev, "DP0 node not found!!\n");
348
347
 	} else {
349
-
350
348
 		prop->dp0_prop = devm_kzalloc(&slave->dev,
351
-				sizeof(*prop->dp0_prop), GFP_KERNEL);
349
+					      sizeof(*prop->dp0_prop),
350
+					      GFP_KERNEL);
352
351
 		if (!prop->dp0_prop)
353
352
 			return -ENOMEM;
354
353
 
355
354
 		sdw_slave_read_dp0(slave, port, prop->dp0_prop);
356
-		dp0 = 1;
357
355
 	}
358
356
 
359
357
 	/*
..
..
@@ -364,37 +362,25 @@
364
362
 	/* Allocate memory for set bits in port lists */
365
363
 	nval = hweight32(prop->source_ports);
366
364
 	prop->src_dpn_prop = devm_kcalloc(&slave->dev, nval,
367
-				sizeof(*prop->src_dpn_prop), GFP_KERNEL);
365
+					  sizeof(*prop->src_dpn_prop),
366
+					  GFP_KERNEL);
368
367
 	if (!prop->src_dpn_prop)
369
368
 		return -ENOMEM;
370
369
 
371
370
 	/* Read dpn properties for source port(s) */
372
371
 	sdw_slave_read_dpn(slave, prop->src_dpn_prop, nval,
373
-			prop->source_ports, "source");
372
+			   prop->source_ports, "source");
374
373
 
375
374
 	nval = hweight32(prop->sink_ports);
376
375
 	prop->sink_dpn_prop = devm_kcalloc(&slave->dev, nval,
377
-				sizeof(*prop->sink_dpn_prop), GFP_KERNEL);
376
+					   sizeof(*prop->sink_dpn_prop),
377
+					   GFP_KERNEL);
378
378
 	if (!prop->sink_dpn_prop)
379
379
 		return -ENOMEM;
380
380
 
381
381
 	/* Read dpn properties for sink port(s) */
382
382
 	sdw_slave_read_dpn(slave, prop->sink_dpn_prop, nval,
383
-			prop->sink_ports, "sink");
384
-
385
-	/* some ports are bidirectional so check total ports by ORing */
386
-	nval = prop->source_ports | prop->sink_ports;
387
-	num_of_ports = hweight32(nval) + dp0; /* add DP0 */
388
-
389
-	/* Allocate port_ready based on num_of_ports */
390
-	slave->port_ready = devm_kcalloc(&slave->dev, num_of_ports,
391
-				sizeof(*slave->port_ready), GFP_KERNEL);
392
-	if (!slave->port_ready)
393
-		return -ENOMEM;
394
-
395
-	/* Initialize completion */
396
-	for (i = 0; i < num_of_ports; i++)
397
-		init_completion(&slave->port_ready[i]);
383
+			   prop->sink_ports, "sink");
398
384
 
399
385
 	return 0;
400
386
 }