update kernel to 5.10.198

hc

2024-01-03 2f7c68cb55ecb7331f2381deb497c27155f32faf

 kernel/drivers/s390/cio/qdio_setup.c
..
..
@@ -9,6 +9,8 @@
9
9
 #include <linux/slab.h>
10
10
 #include <linux/export.h>
11
11
 #include <linux/io.h>
12
+
13
+#include <asm/ebcdic.h>
12
14
 #include <asm/qdio.h>
13
15
 
14
16
 #include "cio.h"
..
..
@@ -28,7 +30,6 @@
28
30
 {
29
31
 	return kmem_cache_zalloc(qdio_aob_cache, GFP_ATOMIC);
30
32
 }
31
-EXPORT_SYMBOL_GPL(qdio_allocate_aob);
32
33
 
33
34
 void qdio_release_aob(struct qaob *aob)
34
35
 {
..
..
@@ -115,7 +116,7 @@
115
116
 	irq_ptr->qib.pfmt = qib_param_field_format;
116
117
 	if (qib_param_field)
117
118
 		memcpy(irq_ptr->qib.parm, qib_param_field,
118
-		       QDIO_MAX_BUFFERS_PER_Q);
119
+		       sizeof(irq_ptr->qib.parm));
119
120
 
120
121
 	if (!input_slib_elements)
121
122
 		goto output;
..
..
@@ -136,6 +137,27 @@
136
137
 	}
137
138
 }
138
139
 
140
+static void __qdio_free_queues(struct qdio_q **queues, unsigned int count)
141
+{
142
+	struct qdio_q *q;
143
+	unsigned int i;
144
+
145
+	for (i = 0; i < count; i++) {
146
+		q = queues[i];
147
+		free_page((unsigned long) q->slib);
148
+		kmem_cache_free(qdio_q_cache, q);
149
+	}
150
+}
151
+
152
+void qdio_free_queues(struct qdio_irq *irq_ptr)
153
+{
154
+	__qdio_free_queues(irq_ptr->input_qs, irq_ptr->max_input_qs);
155
+	irq_ptr->max_input_qs = 0;
156
+
157
+	__qdio_free_queues(irq_ptr->output_qs, irq_ptr->max_output_qs);
158
+	irq_ptr->max_output_qs = 0;
159
+}
160
+
139
161
 static int __qdio_allocate_qs(struct qdio_q **irq_ptr_qs, int nr_queues)
140
162
 {
141
163
 	struct qdio_q *q;
..
..
@@ -143,16 +165,18 @@
143
165
 
144
166
 	for (i = 0; i < nr_queues; i++) {
145
167
 		q = kmem_cache_zalloc(qdio_q_cache, GFP_KERNEL);
146
-		if (!q)
168
+		if (!q) {
169
+			__qdio_free_queues(irq_ptr_qs, i);
147
170
 			return -ENOMEM;
171
+		}
148
172
 
149
173
 		q->slib = (struct slib *) __get_free_page(GFP_KERNEL);
150
174
 		if (!q->slib) {
151
175
 			kmem_cache_free(qdio_q_cache, q);
176
+			__qdio_free_queues(irq_ptr_qs, i);
152
177
 			return -ENOMEM;
153
178
 		}
154
179
 		irq_ptr_qs[i] = q;
155
-		INIT_LIST_HEAD(&q->entry);
156
180
 	}
157
181
 	return 0;
158
182
 }
..
..
@@ -164,8 +188,16 @@
164
188
 	rc = __qdio_allocate_qs(irq_ptr->input_qs, nr_input_qs);
165
189
 	if (rc)
166
190
 		return rc;
191
+
167
192
 	rc = __qdio_allocate_qs(irq_ptr->output_qs, nr_output_qs);
168
-	return rc;
193
+	if (rc) {
194
+		__qdio_free_queues(irq_ptr->input_qs, nr_input_qs);
195
+		return rc;
196
+	}
197
+
198
+	irq_ptr->max_input_qs = nr_input_qs;
199
+	irq_ptr->max_output_qs = nr_output_qs;
200
+	return 0;
169
201
 }
170
202
 
171
203
 static void setup_queues_misc(struct qdio_q *q, struct qdio_irq *irq_ptr,
..
..
@@ -181,11 +213,10 @@
181
213
 	q->mask = 1 << (31 - i);
182
214
 	q->nr = i;
183
215
 	q->handler = handler;
184
-	INIT_LIST_HEAD(&q->entry);
185
216
 }
186
217
 
187
218
 static void setup_storage_lists(struct qdio_q *q, struct qdio_irq *irq_ptr,
188
-				void **sbals_array, int i)
219
+				struct qdio_buffer **sbals_array, int i)
189
220
 {
190
221
 	struct qdio_q *prev;
191
222
 	int j;
..
..
@@ -216,8 +247,6 @@
216
247
 			 struct qdio_initialize *qdio_init)
217
248
 {
218
249
 	struct qdio_q *q;
219
-	void **input_sbal_array = qdio_init->input_sbal_addr_array;
220
-	void **output_sbal_array = qdio_init->output_sbal_addr_array;
221
250
 	struct qdio_outbuf_state *output_sbal_state_array =
222
251
 				  qdio_init->output_sbal_state_array;
223
252
 	int i;
..
..
@@ -227,11 +256,9 @@
227
256
 		setup_queues_misc(q, irq_ptr, qdio_init->input_handler, i);
228
257
 
229
258
 		q->is_input_q = 1;
230
-		q->u.in.queue_start_poll = qdio_init->queue_start_poll_array ?
231
-				qdio_init->queue_start_poll_array[i] : NULL;
232
259
 
233
-		setup_storage_lists(q, irq_ptr, input_sbal_array, i);
234
-		input_sbal_array += QDIO_MAX_BUFFERS_PER_Q;
260
+		setup_storage_lists(q, irq_ptr,
261
+				    qdio_init->input_sbal_addr_array[i], i);
235
262
 
236
263
 		if (is_thinint_irq(irq_ptr)) {
237
264
 			tasklet_init(&q->tasklet, tiqdio_inbound_processing,
..
..
@@ -250,9 +277,8 @@
250
277
 		output_sbal_state_array += QDIO_MAX_BUFFERS_PER_Q;
251
278
 
252
279
 		q->is_input_q = 0;
253
-		q->u.out.scan_threshold = qdio_init->scan_threshold;
254
-		setup_storage_lists(q, irq_ptr, output_sbal_array, i);
255
-		output_sbal_array += QDIO_MAX_BUFFERS_PER_Q;
280
+		setup_storage_lists(q, irq_ptr,
281
+				    qdio_init->output_sbal_addr_array[i], i);
256
282
 
257
283
 		tasklet_init(&q->tasklet, qdio_outbound_processing,
258
284
 			     (unsigned long) q);
..
..
@@ -355,69 +381,46 @@
355
381
 	DBF_EVENT("3:%4x qib:%4x", irq_ptr->ssqd_desc.qdioac3, irq_ptr->qib.ac);
356
382
 }
357
383
 
358
-void qdio_release_memory(struct qdio_irq *irq_ptr)
384
+void qdio_free_async_data(struct qdio_irq *irq_ptr)
359
385
 {
360
386
 	struct qdio_q *q;
361
387
 	int i;
362
388
 
363
-	/*
364
-	 * Must check queue array manually since irq_ptr->nr_input_queues /
365
-	 * irq_ptr->nr_input_queues may not yet be set.
366
-	 */
367
-	for (i = 0; i < QDIO_MAX_QUEUES_PER_IRQ; i++) {
368
-		q = irq_ptr->input_qs[i];
369
-		if (q) {
370
-			free_page((unsigned long) q->slib);
371
-			kmem_cache_free(qdio_q_cache, q);
372
-		}
373
-	}
374
-	for (i = 0; i < QDIO_MAX_QUEUES_PER_IRQ; i++) {
389
+	for (i = 0; i < irq_ptr->max_output_qs; i++) {
375
390
 		q = irq_ptr->output_qs[i];
376
-		if (q) {
377
-			if (q->u.out.use_cq) {
378
-				int n;
391
+		if (q->u.out.use_cq) {
392
+			unsigned int n;
379
393
 
380
-				for (n = 0; n < QDIO_MAX_BUFFERS_PER_Q; ++n) {
381
-					struct qaob *aob = q->u.out.aobs[n];
382
-					if (aob) {
383
-						qdio_release_aob(aob);
384
-						q->u.out.aobs[n] = NULL;
385
-					}
394
+			for (n = 0; n < QDIO_MAX_BUFFERS_PER_Q; n++) {
395
+				struct qaob *aob = q->u.out.aobs[n];
396
+
397
+				if (aob) {
398
+					qdio_release_aob(aob);
399
+					q->u.out.aobs[n] = NULL;
386
400
 				}
387
-
388
-				qdio_disable_async_operation(&q->u.out);
389
401
 			}
390
-			free_page((unsigned long) q->slib);
391
-			kmem_cache_free(qdio_q_cache, q);
402
+
403
+			qdio_disable_async_operation(&q->u.out);
392
404
 		}
393
405
 	}
394
-	free_page((unsigned long) irq_ptr->qdr);
395
-	free_page(irq_ptr->chsc_page);
396
-	free_page((unsigned long) irq_ptr);
397
406
 }
398
407
 
399
-static void __qdio_allocate_fill_qdr(struct qdio_irq *irq_ptr,
400
-				     struct qdio_q **irq_ptr_qs,
401
-				     int i, int nr)
408
+static void qdio_fill_qdr_desc(struct qdesfmt0 *desc, struct qdio_q *queue)
402
409
 {
403
-	irq_ptr->qdr->qdf0[i + nr].sliba =
404
-		(unsigned long)irq_ptr_qs[i]->slib;
410
+	desc->sliba = virt_to_phys(queue->slib);
411
+	desc->sla = virt_to_phys(queue->sl);
412
+	desc->slsba = virt_to_phys(&queue->slsb);
405
413
 
406
-	irq_ptr->qdr->qdf0[i + nr].sla =
407
-		(unsigned long)irq_ptr_qs[i]->sl;
408
-
409
-	irq_ptr->qdr->qdf0[i + nr].slsba =
410
-		(unsigned long)&irq_ptr_qs[i]->slsb.val[0];
411
-
412
-	irq_ptr->qdr->qdf0[i + nr].akey = PAGE_DEFAULT_KEY >> 4;
413
-	irq_ptr->qdr->qdf0[i + nr].bkey = PAGE_DEFAULT_KEY >> 4;
414
-	irq_ptr->qdr->qdf0[i + nr].ckey = PAGE_DEFAULT_KEY >> 4;
415
-	irq_ptr->qdr->qdf0[i + nr].dkey = PAGE_DEFAULT_KEY >> 4;
414
+	desc->akey = PAGE_DEFAULT_KEY >> 4;
415
+	desc->bkey = PAGE_DEFAULT_KEY >> 4;
416
+	desc->ckey = PAGE_DEFAULT_KEY >> 4;
417
+	desc->dkey = PAGE_DEFAULT_KEY >> 4;
416
418
 }
417
419
 
418
420
 static void setup_qdr(struct qdio_irq *irq_ptr,
419
421
 		      struct qdio_initialize *qdio_init)
420
422
 {
423
+	struct qdesfmt0 *desc = &irq_ptr->qdr->qdf0[0];
421
424
 	int i;
422
425
 
423
426
 	irq_ptr->qdr->qfmt = qdio_init->q_format;
..
..
@@ -426,15 +429,14 @@
426
429
 	irq_ptr->qdr->oqdcnt = qdio_init->no_output_qs;
427
430
 	irq_ptr->qdr->iqdsz = sizeof(struct qdesfmt0) / 4; /* size in words */
428
431
 	irq_ptr->qdr->oqdsz = sizeof(struct qdesfmt0) / 4;
429
-	irq_ptr->qdr->qiba = (unsigned long)&irq_ptr->qib;
432
+	irq_ptr->qdr->qiba = virt_to_phys(&irq_ptr->qib);
430
433
 	irq_ptr->qdr->qkey = PAGE_DEFAULT_KEY >> 4;
431
434
 
432
435
 	for (i = 0; i < qdio_init->no_input_qs; i++)
433
-		__qdio_allocate_fill_qdr(irq_ptr, irq_ptr->input_qs, i, 0);
436
+		qdio_fill_qdr_desc(desc++, irq_ptr->input_qs[i]);
434
437
 
435
438
 	for (i = 0; i < qdio_init->no_output_qs; i++)
436
-		__qdio_allocate_fill_qdr(irq_ptr, irq_ptr->output_qs, i,
437
-					 qdio_init->no_input_qs);
439
+		qdio_fill_qdr_desc(desc++, irq_ptr->output_qs[i]);
438
440
 }
439
441
 
440
442
 static void setup_qib(struct qdio_irq *irq_ptr,
..
..
@@ -452,13 +454,14 @@
452
454
 	if (init_data->no_output_qs)
453
455
 		irq_ptr->qib.osliba =
454
456
 			(unsigned long)(irq_ptr->output_qs[0]->slib);
455
-	memcpy(irq_ptr->qib.ebcnam, init_data->adapter_name, 8);
457
+	memcpy(irq_ptr->qib.ebcnam, dev_name(&irq_ptr->cdev->dev), 8);
458
+	ASCEBC(irq_ptr->qib.ebcnam, 8);
456
459
 }
457
460
 
458
-int qdio_setup_irq(struct qdio_initialize *init_data)
461
+int qdio_setup_irq(struct qdio_irq *irq_ptr, struct qdio_initialize *init_data)
459
462
 {
463
+	struct ccw_device *cdev = irq_ptr->cdev;
460
464
 	struct ciw *ciw;
461
-	struct qdio_irq *irq_ptr = init_data->cdev->private->qdio_data;
462
465
 
463
466
 	memset(&irq_ptr->qib, 0, sizeof(irq_ptr->qib));
464
467
 	memset(&irq_ptr->siga_flag, 0, sizeof(irq_ptr->siga_flag));
..
..
@@ -466,8 +469,9 @@
466
469
 	memset(&irq_ptr->ssqd_desc, 0, sizeof(irq_ptr->ssqd_desc));
467
470
 	memset(&irq_ptr->perf_stat, 0, sizeof(irq_ptr->perf_stat));
468
471
 
469
-	irq_ptr->debugfs_dev = irq_ptr->debugfs_perf = NULL;
470
-	irq_ptr->sch_token = irq_ptr->state = irq_ptr->perf_stat_enabled = 0;
472
+	irq_ptr->debugfs_dev = NULL;
473
+	irq_ptr->sch_token = irq_ptr->perf_stat_enabled = 0;
474
+	irq_ptr->state = QDIO_IRQ_STATE_INACTIVE;
471
475
 
472
476
 	/* wipes qib.ac, required by ar7063 */
473
477
 	memset(irq_ptr->qdr, 0, sizeof(struct qdr));
..
..
@@ -475,9 +479,16 @@
475
479
 	irq_ptr->int_parm = init_data->int_parm;
476
480
 	irq_ptr->nr_input_qs = init_data->no_input_qs;
477
481
 	irq_ptr->nr_output_qs = init_data->no_output_qs;
478
-	irq_ptr->cdev = init_data->cdev;
479
-	ccw_device_get_schid(irq_ptr->cdev, &irq_ptr->schid);
482
+	irq_ptr->scan_threshold = init_data->scan_threshold;
483
+	ccw_device_get_schid(cdev, &irq_ptr->schid);
480
484
 	setup_queues(irq_ptr, init_data);
485
+
486
+	if (init_data->irq_poll) {
487
+		irq_ptr->irq_poll = init_data->irq_poll;
488
+		set_bit(QDIO_IRQ_DISABLED, &irq_ptr->poll_state);
489
+	} else {
490
+		irq_ptr->irq_poll = NULL;
491
+	}
481
492
 
482
493
 	setup_qib(irq_ptr, init_data);
483
494
 	set_impl_params(irq_ptr, init_data->qib_param_field_format,
..
..
@@ -490,43 +501,54 @@
490
501
 
491
502
 	/* qdr, qib, sls, slsbs, slibs, sbales are filled now */
492
503
 
504
+	/* set our IRQ handler */
505
+	spin_lock_irq(get_ccwdev_lock(cdev));
506
+	irq_ptr->orig_handler = cdev->handler;
507
+	cdev->handler = qdio_int_handler;
508
+	spin_unlock_irq(get_ccwdev_lock(cdev));
509
+
493
510
 	/* get qdio commands */
494
-	ciw = ccw_device_get_ciw(init_data->cdev, CIW_TYPE_EQUEUE);
511
+	ciw = ccw_device_get_ciw(cdev, CIW_TYPE_EQUEUE);
495
512
 	if (!ciw) {
496
513
 		DBF_ERROR("%4x NO EQ", irq_ptr->schid.sch_no);
497
514
 		return -EINVAL;
498
515
 	}
499
516
 	irq_ptr->equeue = *ciw;
500
517
 
501
-	ciw = ccw_device_get_ciw(init_data->cdev, CIW_TYPE_AQUEUE);
518
+	ciw = ccw_device_get_ciw(cdev, CIW_TYPE_AQUEUE);
502
519
 	if (!ciw) {
503
520
 		DBF_ERROR("%4x NO AQ", irq_ptr->schid.sch_no);
504
521
 		return -EINVAL;
505
522
 	}
506
523
 	irq_ptr->aqueue = *ciw;
507
524
 
508
-	/* set new interrupt handler */
509
-	spin_lock_irq(get_ccwdev_lock(irq_ptr->cdev));
510
-	irq_ptr->orig_handler = init_data->cdev->handler;
511
-	init_data->cdev->handler = qdio_int_handler;
512
-	spin_unlock_irq(get_ccwdev_lock(irq_ptr->cdev));
513
525
 	return 0;
514
526
 }
515
527
 
516
-void qdio_print_subchannel_info(struct qdio_irq *irq_ptr,
517
-				struct ccw_device *cdev)
528
+void qdio_shutdown_irq(struct qdio_irq *irq)
529
+{
530
+	struct ccw_device *cdev = irq->cdev;
531
+
532
+	/* restore IRQ handler */
533
+	spin_lock_irq(get_ccwdev_lock(cdev));
534
+	cdev->handler = irq->orig_handler;
535
+	cdev->private->intparm = 0;
536
+	spin_unlock_irq(get_ccwdev_lock(cdev));
537
+}
538
+
539
+void qdio_print_subchannel_info(struct qdio_irq *irq_ptr)
518
540
 {
519
541
 	char s[80];
520
542
 
521
543
 	snprintf(s, 80, "qdio: %s %s on SC %x using "
522
544
 		 "AI:%d QEBSM:%d PRI:%d TDD:%d SIGA:%s%s%s%s%s\n",
523
-		 dev_name(&cdev->dev),
545
+		 dev_name(&irq_ptr->cdev->dev),
524
546
 		 (irq_ptr->qib.qfmt == QDIO_QETH_QFMT) ? "OSA" :
525
547
 			((irq_ptr->qib.qfmt == QDIO_ZFCP_QFMT) ? "ZFCP" : "HS"),
526
548
 		 irq_ptr->schid.sch_no,
527
549
 		 is_thinint_irq(irq_ptr),
528
550
 		 (irq_ptr->sch_token) ? 1 : 0,
529
-		 (irq_ptr->qib.ac & QIB_AC_OUTBOUND_PCI_SUPPORTED) ? 1 : 0,
551
+		 pci_out_supported(irq_ptr) ? 1 : 0,
530
552
 		 css_general_characteristics.aif_tdd,
531
553
 		 (irq_ptr->siga_flag.input) ? "R" : " ",
532
554
 		 (irq_ptr->siga_flag.output) ? "W" : " ",
..
..
@@ -539,7 +561,7 @@
539
561
 int qdio_enable_async_operation(struct qdio_output_q *outq)
540
562
 {
541
563
 	outq->aobs = kcalloc(QDIO_MAX_BUFFERS_PER_Q, sizeof(struct qaob *),
542
-			     GFP_ATOMIC);
564
+			     GFP_KERNEL);
543
565
 	if (!outq->aobs) {
544
566
 		outq->use_cq = 0;
545
567
 		return -ENOMEM;