add new system file

hc

2024-02-20 102a0743326a03cd1a1202ceda21e175b7d3575c

 kernel/drivers/s390/net/qeth_core_sys.c
..
..
@@ -20,23 +20,16 @@
20
20
 				struct device_attribute *attr, char *buf)
21
21
 {
22
22
 	struct qeth_card *card = dev_get_drvdata(dev);
23
-	if (!card)
24
-		return -EINVAL;
25
23
 
26
24
 	switch (card->state) {
27
25
 	case CARD_STATE_DOWN:
28
26
 		return sprintf(buf, "DOWN\n");
29
-	case CARD_STATE_HARDSETUP:
30
-		return sprintf(buf, "HARDSETUP\n");
31
27
 	case CARD_STATE_SOFTSETUP:
28
+		if (card->dev->flags & IFF_UP)
29
+			return sprintf(buf, "UP (LAN %s)\n",
30
+				       netif_carrier_ok(card->dev) ? "ONLINE" :
31
+								     "OFFLINE");
32
32
 		return sprintf(buf, "SOFTSETUP\n");
33
-	case CARD_STATE_UP:
34
-		if (card->lan_online)
35
-		return sprintf(buf, "UP (LAN ONLINE)\n");
36
-		else
37
-			return sprintf(buf, "UP (LAN OFFLINE)\n");
38
-	case CARD_STATE_RECOVER:
39
-		return sprintf(buf, "RECOVER\n");
40
33
 	default:
41
34
 		return sprintf(buf, "UNKNOWN\n");
42
35
 	}
..
..
@@ -48,8 +41,6 @@
48
41
 				struct device_attribute *attr, char *buf)
49
42
 {
50
43
 	struct qeth_card *card = dev_get_drvdata(dev);
51
-	if (!card)
52
-		return -EINVAL;
53
44
 
54
45
 	return sprintf(buf, "%02X\n", card->info.chpid);
55
46
 }
..
..
@@ -60,9 +51,8 @@
60
51
 				struct device_attribute *attr, char *buf)
61
52
 {
62
53
 	struct qeth_card *card = dev_get_drvdata(dev);
63
-	if (!card)
64
-		return -EINVAL;
65
-	return sprintf(buf, "%s\n", QETH_CARD_IFNAME(card));
54
+
55
+	return sprintf(buf, "%s\n", netdev_name(card->dev));
66
56
 }
67
57
 
68
58
 static DEVICE_ATTR(if_name, 0444, qeth_dev_if_name_show, NULL);
..
..
@@ -71,8 +61,6 @@
71
61
 				struct device_attribute *attr, char *buf)
72
62
 {
73
63
 	struct qeth_card *card = dev_get_drvdata(dev);
74
-	if (!card)
75
-		return -EINVAL;
76
64
 
77
65
 	return sprintf(buf, "%s\n", qeth_get_cardname_short(card));
78
66
 }
..
..
@@ -97,8 +85,6 @@
97
85
 				struct device_attribute *attr, char *buf)
98
86
 {
99
87
 	struct qeth_card *card = dev_get_drvdata(dev);
100
-	if (!card)
101
-		return -EINVAL;
102
88
 
103
89
 	return sprintf(buf, "%s\n", qeth_get_bufsize_str(card));
104
90
 }
..
..
@@ -109,8 +95,6 @@
109
95
 			struct device_attribute *attr, char *buf)
110
96
 {
111
97
 	struct qeth_card *card = dev_get_drvdata(dev);
112
-	if (!card)
113
-		return -EINVAL;
114
98
 
115
99
 	return sprintf(buf, "%i\n", card->dev->dev_port);
116
100
 }
..
..
@@ -119,25 +103,21 @@
119
103
 		struct device_attribute *attr, const char *buf, size_t count)
120
104
 {
121
105
 	struct qeth_card *card = dev_get_drvdata(dev);
122
-	char *tmp;
123
106
 	unsigned int portno, limit;
124
107
 	int rc = 0;
125
108
 
126
-	if (!card)
109
+	rc = kstrtouint(buf, 16, &portno);
110
+	if (rc)
111
+		return rc;
112
+	if (portno > QETH_MAX_PORTNO)
127
113
 		return -EINVAL;
128
114
 
129
115
 	mutex_lock(&card->conf_mutex);
130
-	if ((card->state != CARD_STATE_DOWN) &&
131
-	    (card->state != CARD_STATE_RECOVER)) {
116
+	if (card->state != CARD_STATE_DOWN) {
132
117
 		rc = -EPERM;
133
118
 		goto out;
134
119
 	}
135
120
 
136
-	portno = simple_strtoul(buf, &tmp, 16);
137
-	if (portno > QETH_MAX_PORTNO) {
138
-		rc = -EINVAL;
139
-		goto out;
140
-	}
141
121
 	limit = (card->ssqd.pcnt ? card->ssqd.pcnt - 1 : card->ssqd.pcnt);
142
122
 	if (portno > limit) {
143
123
 		rc = -EINVAL;
..
..
@@ -175,9 +155,6 @@
175
155
 {
176
156
 	struct qeth_card *card = dev_get_drvdata(dev);
177
157
 
178
-	if (!card)
179
-		return -EINVAL;
180
-
181
158
 	switch (card->qdio.do_prio_queueing) {
182
159
 	case QETH_PRIO_Q_ING_PREC:
183
160
 		return sprintf(buf, "%s\n", "by precedence");
..
..
@@ -187,9 +164,11 @@
187
164
 		return sprintf(buf, "%s\n", "by skb-priority");
188
165
 	case QETH_PRIO_Q_ING_VLAN:
189
166
 		return sprintf(buf, "%s\n", "by VLAN headers");
190
-	default:
167
+	case QETH_PRIO_Q_ING_FIXED:
191
168
 		return sprintf(buf, "always queue %i\n",
192
169
 			       card->qdio.default_out_queue);
170
+	default:
171
+		return sprintf(buf, "disabled\n");
193
172
 	}
194
173
 }
195
174
 
..
..
@@ -199,12 +178,11 @@
199
178
 	struct qeth_card *card = dev_get_drvdata(dev);
200
179
 	int rc = 0;
201
180
 
202
-	if (!card)
203
-		return -EINVAL;
181
+	if (IS_IQD(card) || IS_VM_NIC(card))
182
+		return -EOPNOTSUPP;
204
183
 
205
184
 	mutex_lock(&card->conf_mutex);
206
-	if ((card->state != CARD_STATE_DOWN) &&
207
-	    (card->state != CARD_STATE_RECOVER)) {
185
+	if (card->state != CARD_STATE_DOWN) {
208
186
 		rc = -EPERM;
209
187
 		goto out;
210
188
 	}
..
..
@@ -228,27 +206,23 @@
228
206
 		card->qdio.do_prio_queueing = QETH_PRIO_Q_ING_TOS;
229
207
 		card->qdio.default_out_queue = QETH_DEFAULT_QUEUE;
230
208
 	} else if (sysfs_streq(buf, "prio_queueing_vlan")) {
231
-		if (!card->options.layer2) {
232
-			rc = -ENOTSUPP;
209
+		if (IS_LAYER3(card)) {
210
+			rc = -EOPNOTSUPP;
233
211
 			goto out;
234
212
 		}
235
213
 		card->qdio.do_prio_queueing = QETH_PRIO_Q_ING_VLAN;
236
214
 		card->qdio.default_out_queue = QETH_DEFAULT_QUEUE;
237
215
 	} else if (sysfs_streq(buf, "no_prio_queueing:0")) {
238
-		card->qdio.do_prio_queueing = QETH_NO_PRIO_QUEUEING;
216
+		card->qdio.do_prio_queueing = QETH_PRIO_Q_ING_FIXED;
239
217
 		card->qdio.default_out_queue = 0;
240
218
 	} else if (sysfs_streq(buf, "no_prio_queueing:1")) {
241
-		card->qdio.do_prio_queueing = QETH_NO_PRIO_QUEUEING;
219
+		card->qdio.do_prio_queueing = QETH_PRIO_Q_ING_FIXED;
242
220
 		card->qdio.default_out_queue = 1;
243
221
 	} else if (sysfs_streq(buf, "no_prio_queueing:2")) {
244
-		card->qdio.do_prio_queueing = QETH_NO_PRIO_QUEUEING;
222
+		card->qdio.do_prio_queueing = QETH_PRIO_Q_ING_FIXED;
245
223
 		card->qdio.default_out_queue = 2;
246
224
 	} else if (sysfs_streq(buf, "no_prio_queueing:3")) {
247
-		if (card->info.type == QETH_CARD_TYPE_IQD) {
248
-			rc = -EPERM;
249
-			goto out;
250
-		}
251
-		card->qdio.do_prio_queueing = QETH_NO_PRIO_QUEUEING;
225
+		card->qdio.do_prio_queueing = QETH_PRIO_Q_ING_FIXED;
252
226
 		card->qdio.default_out_queue = 3;
253
227
 	} else if (sysfs_streq(buf, "no_prio_queueing")) {
254
228
 		card->qdio.do_prio_queueing = QETH_NO_PRIO_QUEUEING;
..
..
@@ -268,9 +242,6 @@
268
242
 {
269
243
 	struct qeth_card *card = dev_get_drvdata(dev);
270
244
 
271
-	if (!card)
272
-		return -EINVAL;
273
-
274
245
 	return sprintf(buf, "%i\n", card->qdio.in_buf_pool.buf_count);
275
246
 }
276
247
 
..
..
@@ -278,27 +249,22 @@
278
249
 		struct device_attribute *attr, const char *buf, size_t count)
279
250
 {
280
251
 	struct qeth_card *card = dev_get_drvdata(dev);
281
-	char *tmp;
282
-	int cnt, old_cnt;
252
+	unsigned int cnt;
283
253
 	int rc = 0;
284
254
 
285
-	if (!card)
286
-		return -EINVAL;
255
+	rc = kstrtouint(buf, 10, &cnt);
256
+	if (rc)
257
+		return rc;
287
258
 
288
259
 	mutex_lock(&card->conf_mutex);
289
-	if ((card->state != CARD_STATE_DOWN) &&
290
-	    (card->state != CARD_STATE_RECOVER)) {
260
+	if (card->state != CARD_STATE_DOWN) {
291
261
 		rc = -EPERM;
292
262
 		goto out;
293
263
 	}
294
264
 
295
-	old_cnt = card->qdio.in_buf_pool.buf_count;
296
-	cnt = simple_strtoul(buf, &tmp, 10);
297
-	cnt = (cnt < QETH_IN_BUF_COUNT_MIN) ? QETH_IN_BUF_COUNT_MIN :
298
-		((cnt > QETH_IN_BUF_COUNT_MAX) ? QETH_IN_BUF_COUNT_MAX : cnt);
299
-	if (old_cnt != cnt) {
300
-		rc = qeth_realloc_buffer_pool(card, cnt);
301
-	}
265
+	cnt = clamp(cnt, QETH_IN_BUF_COUNT_MIN, QETH_IN_BUF_COUNT_MAX);
266
+	rc = qeth_resize_buffer_pool(card, cnt);
267
+
302
268
 out:
303
269
 	mutex_unlock(&card->conf_mutex);
304
270
 	return rc ? rc : count;
..
..
@@ -311,20 +277,20 @@
311
277
 		struct device_attribute *attr, const char *buf, size_t count)
312
278
 {
313
279
 	struct qeth_card *card = dev_get_drvdata(dev);
314
-	char *tmp;
315
-	int i;
280
+	bool reset;
281
+	int rc;
316
282
 
317
-	if (!card)
318
-		return -EINVAL;
283
+	rc = kstrtobool(buf, &reset);
284
+	if (rc)
285
+		return rc;
319
286
 
320
-	if (card->state != CARD_STATE_UP)
287
+	if (!qeth_card_hw_is_reachable(card))
321
288
 		return -EPERM;
322
289
 
323
-	i = simple_strtoul(buf, &tmp, 16);
324
-	if (i == 1)
325
-		qeth_schedule_recovery(card);
290
+	if (reset)
291
+		rc = qeth_schedule_recovery(card);
326
292
 
327
-	return count;
293
+	return rc ? rc : count;
328
294
 }
329
295
 
330
296
 static DEVICE_ATTR(recover, 0200, NULL, qeth_dev_recover_store);
..
..
@@ -332,40 +298,33 @@
332
298
 static ssize_t qeth_dev_performance_stats_show(struct device *dev,
333
299
 				struct device_attribute *attr, char *buf)
334
300
 {
335
-	struct qeth_card *card = dev_get_drvdata(dev);
336
-
337
-	if (!card)
338
-		return -EINVAL;
339
-
340
-	return sprintf(buf, "%i\n", card->options.performance_stats ? 1:0);
301
+	return sprintf(buf, "1\n");
341
302
 }
342
303
 
343
304
 static ssize_t qeth_dev_performance_stats_store(struct device *dev,
344
305
 		struct device_attribute *attr, const char *buf, size_t count)
345
306
 {
346
307
 	struct qeth_card *card = dev_get_drvdata(dev);
347
-	char *tmp;
348
-	int i, rc = 0;
308
+	struct qeth_qdio_out_q *queue;
309
+	unsigned int i;
310
+	bool reset;
311
+	int rc;
349
312
 
350
-	if (!card)
351
-		return -EINVAL;
313
+	rc = kstrtobool(buf, &reset);
314
+	if (rc)
315
+		return rc;
352
316
 
353
-	mutex_lock(&card->conf_mutex);
354
-	i = simple_strtoul(buf, &tmp, 16);
355
-	if ((i == 0) || (i == 1)) {
356
-		if (i == card->options.performance_stats)
357
-			goto out;
358
-		card->options.performance_stats = i;
359
-		if (i == 0)
360
-			memset(&card->perf_stats, 0,
361
-				sizeof(struct qeth_perf_stats));
362
-		card->perf_stats.initial_rx_packets = card->stats.rx_packets;
363
-		card->perf_stats.initial_tx_packets = card->stats.tx_packets;
364
-	} else
365
-		rc = -EINVAL;
366
-out:
367
-	mutex_unlock(&card->conf_mutex);
368
-	return rc ? rc : count;
317
+	if (reset) {
318
+		memset(&card->stats, 0, sizeof(card->stats));
319
+		for (i = 0; i < card->qdio.no_out_queues; i++) {
320
+			queue = card->qdio.out_qs[i];
321
+			if (!queue)
322
+				break;
323
+			memset(&queue->stats, 0, sizeof(queue->stats));
324
+		}
325
+	}
326
+
327
+	return count;
369
328
 }
370
329
 
371
330
 static DEVICE_ATTR(performance_stats, 0644, qeth_dev_performance_stats_show,
..
..
@@ -376,10 +335,7 @@
376
335
 {
377
336
 	struct qeth_card *card = dev_get_drvdata(dev);
378
337
 
379
-	if (!card)
380
-		return -EINVAL;
381
-
382
-	return sprintf(buf, "%i\n", card->options.layer2);
338
+	return sprintf(buf, "%i\n", card->options.layer);
383
339
 }
384
340
 
385
341
 static ssize_t qeth_dev_layer2_store(struct device *dev,
..
..
@@ -387,21 +343,15 @@
387
343
 {
388
344
 	struct qeth_card *card = dev_get_drvdata(dev);
389
345
 	struct net_device *ndev;
390
-	char *tmp;
391
-	int i, rc = 0;
392
346
 	enum qeth_discipline_id newdis;
347
+	unsigned int input;
348
+	int rc;
393
349
 
394
-	if (!card)
395
-		return -EINVAL;
350
+	rc = kstrtouint(buf, 16, &input);
351
+	if (rc)
352
+		return rc;
396
353
 
397
-	mutex_lock(&card->discipline_mutex);
398
-	if (card->state != CARD_STATE_DOWN) {
399
-		rc = -EPERM;
400
-		goto out;
401
-	}
402
-
403
-	i = simple_strtoul(buf, &tmp, 16);
404
-	switch (i) {
354
+	switch (input) {
405
355
 	case 0:
406
356
 		newdis = QETH_DISCIPLINE_LAYER3;
407
357
 		break;
..
..
@@ -409,11 +359,16 @@
409
359
 		newdis = QETH_DISCIPLINE_LAYER2;
410
360
 		break;
411
361
 	default:
412
-		rc = -EINVAL;
362
+		return -EINVAL;
363
+	}
364
+
365
+	mutex_lock(&card->discipline_mutex);
366
+	if (card->state != CARD_STATE_DOWN) {
367
+		rc = -EPERM;
413
368
 		goto out;
414
369
 	}
415
370
 
416
-	if (card->options.layer2 == newdis)
371
+	if (card->options.layer == newdis)
417
372
 		goto out;
418
373
 	if (card->info.layer_enforced) {
419
374
 		/* fixed layer, can't switch */
..
..
@@ -421,7 +376,6 @@
421
376
 		goto out;
422
377
 	}
423
378
 
424
-	card->info.mac_bits = 0;
425
379
 	if (card->discipline) {
426
380
 		/* start with a new, pristine netdevice: */
427
381
 		ndev = qeth_clone_netdev(card->dev);
..
..
@@ -432,8 +386,6 @@
432
386
 
433
387
 		card->discipline->remove(card->gdev);
434
388
 		qeth_core_free_discipline(card);
435
-		card->options.layer2 = -1;
436
-
437
389
 		free_netdev(card->dev);
438
390
 		card->dev = ndev;
439
391
 	}
..
..
@@ -462,9 +414,6 @@
462
414
 {
463
415
 	struct qeth_card *card = dev_get_drvdata(dev);
464
416
 
465
-	if (!card)
466
-		return -EINVAL;
467
-
468
417
 	switch (card->options.isolation) {
469
418
 	case ISOLATION_MODE_NONE:
470
419
 		return snprintf(buf, 6, "%s\n", ATTR_QETH_ISOLATION_NONE);
..
..
@@ -484,12 +433,8 @@
484
433
 	enum qeth_ipa_isolation_modes isolation;
485
434
 	int rc = 0;
486
435
 
487
-	if (!card)
488
-		return -EINVAL;
489
-
490
436
 	mutex_lock(&card->conf_mutex);
491
-	if (card->info.type != QETH_CARD_TYPE_OSD &&
492
-	    card->info.type != QETH_CARD_TYPE_OSX) {
437
+	if (!IS_OSD(card) && !IS_OSX(card)) {
493
438
 		rc = -EOPNOTSUPP;
494
439
 		dev_err(&card->gdev->dev, "Adapter does not "
495
440
 			"support QDIO data connection isolation\n");
..
..
@@ -507,19 +452,17 @@
507
452
 		rc = -EINVAL;
508
453
 		goto out;
509
454
 	}
510
-	rc = count;
511
455
 
512
-	/* defer IP assist if device is offline (until discipline->set_online)*/
513
-	card->options.prev_isolation = card->options.isolation;
514
-	card->options.isolation = isolation;
515
-	if (qeth_card_hw_is_reachable(card)) {
516
-		int ipa_rc = qeth_set_access_ctrl_online(card, 1);
517
-		if (ipa_rc != 0)
518
-			rc = ipa_rc;
519
-	}
456
+	if (qeth_card_hw_is_reachable(card))
457
+		rc = qeth_setadpparms_set_access_ctrl(card, isolation);
458
+
459
+	if (!rc)
460
+		WRITE_ONCE(card->options.isolation, isolation);
461
+
520
462
 out:
521
463
 	mutex_unlock(&card->conf_mutex);
522
-	return rc;
464
+
465
+	return rc ? rc : count;
523
466
 }
524
467
 
525
468
 static DEVICE_ATTR(isolation, 0644, qeth_dev_isolation_show,
..
..
@@ -531,9 +474,6 @@
531
474
 	struct qeth_card *card = dev_get_drvdata(dev);
532
475
 	struct qeth_switch_info sw_info;
533
476
 	int	rc = 0;
534
-
535
-	if (!card)
536
-		return -EINVAL;
537
477
 
538
478
 	if (!qeth_card_hw_is_reachable(card))
539
479
 		return sprintf(buf, "n/a\n");
..
..
@@ -565,8 +505,6 @@
565
505
 {
566
506
 	struct qeth_card *card = dev_get_drvdata(dev);
567
507
 
568
-	if (!card)
569
-		return -EINVAL;
570
508
 	if (card->info.hwtrap)
571
509
 		return snprintf(buf, 5, "arm\n");
572
510
 	else
..
..
@@ -579,9 +517,6 @@
579
517
 	struct qeth_card *card = dev_get_drvdata(dev);
580
518
 	int rc = 0;
581
519
 	int state = 0;
582
-
583
-	if (!card)
584
-		return -EINVAL;
585
520
 
586
521
 	mutex_lock(&card->conf_mutex);
587
522
 	if (qeth_card_hw_is_reachable(card))
..
..
@@ -617,36 +552,24 @@
617
552
 static DEVICE_ATTR(hw_trap, 0644, qeth_hw_trap_show,
618
553
 		   qeth_hw_trap_store);
619
554
 
620
-static ssize_t qeth_dev_blkt_show(char *buf, struct qeth_card *card, int value)
621
-{
622
-
623
-	if (!card)
624
-		return -EINVAL;
625
-
626
-	return sprintf(buf, "%i\n", value);
627
-}
628
-
629
555
 static ssize_t qeth_dev_blkt_store(struct qeth_card *card,
630
556
 		const char *buf, size_t count, int *value, int max_value)
631
557
 {
632
-	char *tmp;
633
-	int i, rc = 0;
558
+	unsigned int input;
559
+	int rc;
634
560
 
635
-	if (!card)
561
+	rc = kstrtouint(buf, 10, &input);
562
+	if (rc)
563
+		return rc;
564
+
565
+	if (input > max_value)
636
566
 		return -EINVAL;
637
567
 
638
568
 	mutex_lock(&card->conf_mutex);
639
-	if ((card->state != CARD_STATE_DOWN) &&
640
-	    (card->state != CARD_STATE_RECOVER)) {
569
+	if (card->state != CARD_STATE_DOWN)
641
570
 		rc = -EPERM;
642
-		goto out;
643
-	}
644
-	i = simple_strtoul(buf, &tmp, 10);
645
-	if (i <= max_value)
646
-		*value = i;
647
571
 	else
648
-		rc = -EINVAL;
649
-out:
572
+		*value = input;
650
573
 	mutex_unlock(&card->conf_mutex);
651
574
 	return rc ? rc : count;
652
575
 }
..
..
@@ -656,7 +579,7 @@
656
579
 {
657
580
 	struct qeth_card *card = dev_get_drvdata(dev);
658
581
 
659
-	return qeth_dev_blkt_show(buf, card, card->info.blkt.time_total);
582
+	return sprintf(buf, "%i\n", card->info.blkt.time_total);
660
583
 }
661
584
 
662
585
 static ssize_t qeth_dev_blkt_total_store(struct device *dev,
..
..
@@ -668,8 +591,6 @@
668
591
 				   &card->info.blkt.time_total, 5000);
669
592
 }
670
593
 
671
-
672
-
673
594
 static DEVICE_ATTR(total, 0644, qeth_dev_blkt_total_show,
674
595
 		   qeth_dev_blkt_total_store);
675
596
 
..
..
@@ -678,7 +599,7 @@
678
599
 {
679
600
 	struct qeth_card *card = dev_get_drvdata(dev);
680
601
 
681
-	return qeth_dev_blkt_show(buf, card, card->info.blkt.inter_packet);
602
+	return sprintf(buf, "%i\n", card->info.blkt.inter_packet);
682
603
 }
683
604
 
684
605
 static ssize_t qeth_dev_blkt_inter_store(struct device *dev,
..
..
@@ -698,8 +619,7 @@
698
619
 {
699
620
 	struct qeth_card *card = dev_get_drvdata(dev);
700
621
 
701
-	return qeth_dev_blkt_show(buf, card,
702
-				  card->info.blkt.inter_packet_jumbo);
622
+	return sprintf(buf, "%i\n", card->info.blkt.inter_packet_jumbo);
703
623
 }
704
624
 
705
625
 static ssize_t qeth_dev_blkt_inter_jumbo_store(struct device *dev,