write in 30M

hc

2024-02-20 ea08eeccae9297f7aabd2ef7f0c2517ac4549acc

 kernel/drivers/s390/scsi/zfcp_qdio.c
..
..
@@ -4,7 +4,7 @@
4
4
  *
5
5
  * Setup and helper functions to access QDIO.
6
6
  *
7
- * Copyright IBM Corp. 2002, 2010
7
+ * Copyright IBM Corp. 2002, 2020
8
8
  */
9
9
 
10
10
 #define KMSG_COMPONENT "zfcp"
..
..
@@ -19,7 +19,7 @@
19
19
 module_param_named(datarouter, enable_multibuffer, bool, 0400);
20
20
 MODULE_PARM_DESC(datarouter, "Enable hardware data router support (default on)");
21
21
 
22
-static void zfcp_qdio_handler_error(struct zfcp_qdio *qdio, char *id,
22
+static void zfcp_qdio_handler_error(struct zfcp_qdio *qdio, char *dbftag,
23
23
 				    unsigned int qdio_err)
24
24
 {
25
25
 	struct zfcp_adapter *adapter = qdio->adapter;
..
..
@@ -28,12 +28,12 @@
28
28
 
29
29
 	if (qdio_err & QDIO_ERROR_SLSB_STATE) {
30
30
 		zfcp_qdio_siosl(adapter);
31
-		zfcp_erp_adapter_shutdown(adapter, 0, id);
31
+		zfcp_erp_adapter_shutdown(adapter, 0, dbftag);
32
32
 		return;
33
33
 	}
34
34
 	zfcp_erp_adapter_reopen(adapter,
35
35
 				ZFCP_STATUS_ADAPTER_LINK_UNPLUGGED |
36
-				ZFCP_STATUS_COMMON_ERP_FAILED, id);
36
+				ZFCP_STATUS_COMMON_ERP_FAILED, dbftag);
37
37
 }
38
38
 
39
39
 static void zfcp_qdio_zero_sbals(struct qdio_buffer *sbal[], int first, int cnt)
..
..
@@ -98,7 +98,7 @@
98
98
 			memset(pl, 0,
99
99
 			       ZFCP_QDIO_MAX_SBALS_PER_REQ * sizeof(void *));
100
100
 			sbale = qdio->res_q[idx]->element;
101
-			req_id = (u64) sbale->addr;
101
+			req_id = sbale->addr;
102
102
 			scount = min(sbale->scount + 1,
103
103
 				     ZFCP_QDIO_MAX_SBALS_PER_REQ + 1);
104
104
 				     /* incl. signaling SBAL */
..
..
@@ -180,7 +180,6 @@
180
180
  * @qdio: pointer to struct zfcp_qdio
181
181
  * @q_req: pointer to struct zfcp_qdio_req
182
182
  * @sg: scatter-gather list
183
- * @max_sbals: upper bound for number of SBALs to be used
184
183
  * Returns: zero or -EINVAL on error
185
184
  */
186
185
 int zfcp_qdio_sbals_from_sg(struct zfcp_qdio *qdio, struct zfcp_qdio_req *q_req,
..
..
@@ -200,7 +199,7 @@
200
199
 					     q_req->sbal_number);
201
200
 			return -EINVAL;
202
201
 		}
203
-		sbale->addr = sg_virt(sg);
202
+		sbale->addr = sg_phys(sg);
204
203
 		sbale->length = sg->length;
205
204
 	}
206
205
 	return 0;
..
..
@@ -247,7 +246,7 @@
247
246
 }
248
247
 
249
248
 /**
250
- * zfcp_qdio_send - set PCI flag in first SBALE and send req to QDIO
249
+ * zfcp_qdio_send - send req to QDIO
251
250
  * @qdio: pointer to struct zfcp_qdio
252
251
  * @q_req: pointer to struct zfcp_qdio_req
253
252
  * Returns: 0 on success, error otherwise
..
..
@@ -261,55 +260,34 @@
261
260
 	zfcp_qdio_account(qdio);
262
261
 	spin_unlock(&qdio->stat_lock);
263
262
 
263
+	atomic_sub(sbal_number, &qdio->req_q_free);
264
+
264
265
 	retval = do_QDIO(qdio->adapter->ccw_device, QDIO_FLAG_SYNC_OUTPUT, 0,
265
266
 			 q_req->sbal_first, sbal_number);
266
267
 
267
268
 	if (unlikely(retval)) {
269
+		/* Failed to submit the IO, roll back our modifications. */
270
+		atomic_add(sbal_number, &qdio->req_q_free);
268
271
 		zfcp_qdio_zero_sbals(qdio->req_q, q_req->sbal_first,
269
272
 				     sbal_number);
270
273
 		return retval;
271
274
 	}
272
275
 
273
276
 	/* account for transferred buffers */
274
-	atomic_sub(sbal_number, &qdio->req_q_free);
275
277
 	qdio->req_q_idx += sbal_number;
276
278
 	qdio->req_q_idx %= QDIO_MAX_BUFFERS_PER_Q;
277
279
 
278
280
 	return 0;
279
281
 }
280
282
 
281
-
282
-static void zfcp_qdio_setup_init_data(struct qdio_initialize *id,
283
-				      struct zfcp_qdio *qdio)
284
-{
285
-	memset(id, 0, sizeof(*id));
286
-	id->cdev = qdio->adapter->ccw_device;
287
-	id->q_format = QDIO_ZFCP_QFMT;
288
-	memcpy(id->adapter_name, dev_name(&id->cdev->dev), 8);
289
-	ASCEBC(id->adapter_name, 8);
290
-	id->qib_rflags = QIB_RFLAGS_ENABLE_DATA_DIV;
291
-	if (enable_multibuffer)
292
-		id->qdr_ac |= QDR_AC_MULTI_BUFFER_ENABLE;
293
-	id->no_input_qs = 1;
294
-	id->no_output_qs = 1;
295
-	id->input_handler = zfcp_qdio_int_resp;
296
-	id->output_handler = zfcp_qdio_int_req;
297
-	id->int_parm = (unsigned long) qdio;
298
-	id->input_sbal_addr_array = (void **) (qdio->res_q);
299
-	id->output_sbal_addr_array = (void **) (qdio->req_q);
300
-	id->scan_threshold =
301
-		QDIO_MAX_BUFFERS_PER_Q - ZFCP_QDIO_MAX_SBALS_PER_REQ * 2;
302
-}
303
-
304
283
 /**
305
284
  * zfcp_qdio_allocate - allocate queue memory and initialize QDIO data
306
- * @adapter: pointer to struct zfcp_adapter
285
+ * @qdio: pointer to struct zfcp_qdio
307
286
  * Returns: -ENOMEM on memory allocation error or return value from
308
287
  *          qdio_allocate
309
288
  */
310
289
 static int zfcp_qdio_allocate(struct zfcp_qdio *qdio)
311
290
 {
312
-	struct qdio_initialize init_data;
313
291
 	int ret;
314
292
 
315
293
 	ret = qdio_alloc_buffers(qdio->req_q, QDIO_MAX_BUFFERS_PER_Q);
..
..
@@ -320,10 +298,9 @@
320
298
 	if (ret)
321
299
 		goto free_req_q;
322
300
 
323
-	zfcp_qdio_setup_init_data(&init_data, qdio);
324
301
 	init_waitqueue_head(&qdio->req_q_wq);
325
302
 
326
-	ret = qdio_allocate(&init_data);
303
+	ret = qdio_allocate(qdio->adapter->ccw_device, 1, 1);
327
304
 	if (ret)
328
305
 		goto free_res_q;
329
306
 
..
..
@@ -368,6 +345,18 @@
368
345
 	atomic_set(&qdio->req_q_free, 0);
369
346
 }
370
347
 
348
+void zfcp_qdio_shost_update(struct zfcp_adapter *const adapter,
349
+			    const struct zfcp_qdio *const qdio)
350
+{
351
+	struct Scsi_Host *const shost = adapter->scsi_host;
352
+
353
+	if (shost == NULL)
354
+		return;
355
+
356
+	shost->sg_tablesize = qdio->max_sbale_per_req;
357
+	shost->max_sectors = qdio->max_sbale_per_req * 8;
358
+}
359
+
371
360
 /**
372
361
  * zfcp_qdio_open - prepare and initialize response queue
373
362
  * @qdio: pointer to struct zfcp_qdio
..
..
@@ -375,8 +364,10 @@
375
364
  */
376
365
 int zfcp_qdio_open(struct zfcp_qdio *qdio)
377
366
 {
367
+	struct qdio_buffer **input_sbals[1] = {qdio->res_q};
368
+	struct qdio_buffer **output_sbals[1] = {qdio->req_q};
378
369
 	struct qdio_buffer_element *sbale;
379
-	struct qdio_initialize init_data;
370
+	struct qdio_initialize init_data = {0};
380
371
 	struct zfcp_adapter *adapter = qdio->adapter;
381
372
 	struct ccw_device *cdev = adapter->ccw_device;
382
373
 	struct qdio_ssqd_desc ssqd;
..
..
@@ -388,12 +379,24 @@
388
379
 	atomic_andnot(ZFCP_STATUS_ADAPTER_SIOSL_ISSUED,
389
380
 			  &qdio->adapter->status);
390
381
 
391
-	zfcp_qdio_setup_init_data(&init_data, qdio);
382
+	init_data.q_format = QDIO_ZFCP_QFMT;
383
+	init_data.qib_rflags = QIB_RFLAGS_ENABLE_DATA_DIV;
384
+	if (enable_multibuffer)
385
+		init_data.qdr_ac |= QDR_AC_MULTI_BUFFER_ENABLE;
386
+	init_data.no_input_qs = 1;
387
+	init_data.no_output_qs = 1;
388
+	init_data.input_handler = zfcp_qdio_int_resp;
389
+	init_data.output_handler = zfcp_qdio_int_req;
390
+	init_data.int_parm = (unsigned long) qdio;
391
+	init_data.input_sbal_addr_array = input_sbals;
392
+	init_data.output_sbal_addr_array = output_sbals;
393
+	init_data.scan_threshold =
394
+		QDIO_MAX_BUFFERS_PER_Q - ZFCP_QDIO_MAX_SBALS_PER_REQ * 2;
392
395
 
393
-	if (qdio_establish(&init_data))
396
+	if (qdio_establish(cdev, &init_data))
394
397
 		goto failed_establish;
395
398
 
396
-	if (qdio_get_ssqd_desc(init_data.cdev, &ssqd))
399
+	if (qdio_get_ssqd_desc(cdev, &ssqd))
397
400
 		goto failed_qdio;
398
401
 
399
402
 	if (ssqd.qdioac2 & CHSC_AC2_DATA_DIV_ENABLED)
..
..
@@ -419,7 +422,7 @@
419
422
 		sbale->length = 0;
420
423
 		sbale->eflags = SBAL_EFLAGS_LAST_ENTRY;
421
424
 		sbale->sflags = 0;
422
-		sbale->addr = NULL;
425
+		sbale->addr = 0;
423
426
 	}
424
427
 
425
428
 	if (do_QDIO(cdev, QDIO_FLAG_SYNC_INPUT, 0, 0, QDIO_MAX_BUFFERS_PER_Q))
..
..
@@ -430,10 +433,7 @@
430
433
 	atomic_set(&qdio->req_q_free, QDIO_MAX_BUFFERS_PER_Q);
431
434
 	atomic_or(ZFCP_STATUS_ADAPTER_QDIOUP, &qdio->adapter->status);
432
435
 
433
-	if (adapter->scsi_host) {
434
-		adapter->scsi_host->sg_tablesize = qdio->max_sbale_per_req;
435
-		adapter->scsi_host->max_sectors = qdio->max_sbale_per_req * 8;
436
-	}
436
+	zfcp_qdio_shost_update(adapter, qdio);
437
437
 
438
438
 	return 0;
439
439