zfcp_qdio.c 13.8 KB
Newer Older
L
Linus Torvalds 已提交
1
/*
S
Swen Schillig 已提交
2
 * zfcp device driver
L
Linus Torvalds 已提交
3
 *
S
Swen Schillig 已提交
4
 * Setup and helper functions to access QDIO.
L
Linus Torvalds 已提交
5
 *
S
Swen Schillig 已提交
6
 * Copyright IBM Corporation 2002, 2008
L
Linus Torvalds 已提交
7 8 9 10
 */

#include "zfcp_ext.h"

S
Swen Schillig 已提交
11 12
/* FIXME(tune): free space should be one max. SBAL chain plus what? */
#define ZFCP_QDIO_PCI_INTERVAL	(QDIO_MAX_BUFFERS_PER_Q \
S
Swen Schillig 已提交
13
				- (FSF_MAX_SBALS_PER_REQ + 4))
14
#define QBUFF_PER_PAGE		(PAGE_SIZE / sizeof(struct qdio_buffer))
L
Linus Torvalds 已提交
15

S
Swen Schillig 已提交
16
static int zfcp_qdio_buffers_enqueue(struct qdio_buffer **sbal)
L
Linus Torvalds 已提交
17
{
S
Swen Schillig 已提交
18
	int pos;
L
Linus Torvalds 已提交
19

S
Swen Schillig 已提交
20
	for (pos = 0; pos < QDIO_MAX_BUFFERS_PER_Q; pos += QBUFF_PER_PAGE) {
S
Swen Schillig 已提交
21 22
		sbal[pos] = (struct qdio_buffer *) get_zeroed_page(GFP_KERNEL);
		if (!sbal[pos])
S
Swen Schillig 已提交
23 24 25 26
			return -ENOMEM;
	}
	for (pos = 0; pos < QDIO_MAX_BUFFERS_PER_Q; pos++)
		if (pos % QBUFF_PER_PAGE)
S
Swen Schillig 已提交
27
			sbal[pos] = sbal[pos - 1] + 1;
S
Swen Schillig 已提交
28
	return 0;
L
Linus Torvalds 已提交
29 30
}

S
Swen Schillig 已提交
31 32
static volatile struct qdio_buffer_element *
zfcp_qdio_sbale(struct zfcp_qdio_queue *q, int sbal_idx, int sbale_idx)
L
Linus Torvalds 已提交
33
{
S
Swen Schillig 已提交
34
	return &q->sbal[sbal_idx]->element[sbale_idx];
L
Linus Torvalds 已提交
35 36
}

S
Swen Schillig 已提交
37 38 39 40 41
/**
 * zfcp_qdio_free - free memory used by request- and resposne queue
 * @adapter: pointer to the zfcp_adapter structure
 */
void zfcp_qdio_free(struct zfcp_adapter *adapter)
L
Linus Torvalds 已提交
42
{
S
Swen Schillig 已提交
43 44
	struct qdio_buffer **sbal_req, **sbal_resp;
	int p;
L
Linus Torvalds 已提交
45

S
Swen Schillig 已提交
46 47
	if (adapter->ccw_device)
		qdio_free(adapter->ccw_device);
L
Linus Torvalds 已提交
48

S
Swen Schillig 已提交
49 50
	sbal_req = adapter->req_q.sbal;
	sbal_resp = adapter->resp_q.sbal;
L
Linus Torvalds 已提交
51

S
Swen Schillig 已提交
52 53 54 55
	for (p = 0; p < QDIO_MAX_BUFFERS_PER_Q; p += QBUFF_PER_PAGE) {
		free_page((unsigned long) sbal_req[p]);
		free_page((unsigned long) sbal_resp[p]);
	}
L
Linus Torvalds 已提交
56 57
}

S
Swen Schillig 已提交
58
static void zfcp_qdio_handler_error(struct zfcp_adapter *adapter, u8 id)
L
Linus Torvalds 已提交
59
{
S
Swen Schillig 已提交
60
	dev_warn(&adapter->ccw_device->dev, "QDIO problem occurred.\n");
L
Linus Torvalds 已提交
61

S
Swen Schillig 已提交
62 63 64
	zfcp_erp_adapter_reopen(adapter,
				ZFCP_STATUS_ADAPTER_LINK_UNPLUGGED |
				ZFCP_STATUS_COMMON_ERP_FAILED, id, NULL);
L
Linus Torvalds 已提交
65 66
}

67 68 69 70 71 72 73 74 75 76
static void zfcp_qdio_zero_sbals(struct qdio_buffer *sbal[], int first, int cnt)
{
	int i, sbal_idx;

	for (i = first; i < first + cnt; i++) {
		sbal_idx = i % QDIO_MAX_BUFFERS_PER_Q;
		memset(sbal[sbal_idx], 0, sizeof(struct qdio_buffer));
	}
}

J
Jan Glauber 已提交
77 78
static void zfcp_qdio_int_req(struct ccw_device *cdev, unsigned int qdio_err,
			      int queue_no, int first, int count,
S
Swen Schillig 已提交
79
			      unsigned long parm)
L
Linus Torvalds 已提交
80
{
S
Swen Schillig 已提交
81 82
	struct zfcp_adapter *adapter = (struct zfcp_adapter *) parm;
	struct zfcp_qdio_queue *queue = &adapter->req_q;
L
Linus Torvalds 已提交
83

J
Jan Glauber 已提交
84 85
	if (unlikely(qdio_err)) {
		zfcp_hba_dbf_event_qdio(adapter, qdio_err, first, count);
S
Swen Schillig 已提交
86 87 88
		zfcp_qdio_handler_error(adapter, 140);
		return;
	}
L
Linus Torvalds 已提交
89 90

	/* cleanup all SBALs being program-owned now */
S
Swen Schillig 已提交
91
	zfcp_qdio_zero_sbals(queue->sbal, first, count);
L
Linus Torvalds 已提交
92

S
Swen Schillig 已提交
93
	atomic_add(count, &queue->count);
L
Linus Torvalds 已提交
94 95 96
	wake_up(&adapter->request_wq);
}

97
static void zfcp_qdio_reqid_check(struct zfcp_adapter *adapter,
S
Swen Schillig 已提交
98
				  unsigned long req_id, int sbal_idx)
99 100 101 102 103
{
	struct zfcp_fsf_req *fsf_req;
	unsigned long flags;

	spin_lock_irqsave(&adapter->req_list_lock, flags);
104
	fsf_req = zfcp_reqlist_find(adapter, req_id);
105

106 107 108 109 110
	if (!fsf_req)
		/*
		 * Unknown request means that we have potentially memory
		 * corruption and must stop the machine immediatly.
		 */
S
Swen Schillig 已提交
111
		panic("error: unknown request id (%lx) on adapter %s.\n",
112
		      req_id, zfcp_get_busid_by_adapter(adapter));
113

114
	zfcp_reqlist_remove(adapter, fsf_req);
115 116
	spin_unlock_irqrestore(&adapter->req_list_lock, flags);

S
Swen Schillig 已提交
117
	fsf_req->sbal_response = sbal_idx;
118 119 120
	zfcp_fsf_req_complete(fsf_req);
}

S
Swen Schillig 已提交
121
static void zfcp_qdio_resp_put_back(struct zfcp_adapter *adapter, int processed)
L
Linus Torvalds 已提交
122
{
S
Swen Schillig 已提交
123 124 125 126
	struct zfcp_qdio_queue *queue = &adapter->resp_q;
	struct ccw_device *cdev = adapter->ccw_device;
	u8 count, start = queue->first;
	unsigned int retval;
L
Linus Torvalds 已提交
127

S
Swen Schillig 已提交
128 129
	count = atomic_read(&queue->count) + processed;

J
Jan Glauber 已提交
130
	retval = do_QDIO(cdev, QDIO_FLAG_SYNC_INPUT, 0, start, count);
S
Swen Schillig 已提交
131 132 133 134 135 136 137 138 139 140 141

	if (unlikely(retval)) {
		atomic_set(&queue->count, count);
		/* FIXME: Recover this with an adapter reopen? */
	} else {
		queue->first += count;
		queue->first %= QDIO_MAX_BUFFERS_PER_Q;
		atomic_set(&queue->count, 0);
	}
}

J
Jan Glauber 已提交
142 143
static void zfcp_qdio_int_resp(struct ccw_device *cdev, unsigned int qdio_err,
			       int queue_no, int first, int count,
S
Swen Schillig 已提交
144 145 146 147 148 149 150
			       unsigned long parm)
{
	struct zfcp_adapter *adapter = (struct zfcp_adapter *) parm;
	struct zfcp_qdio_queue *queue = &adapter->resp_q;
	volatile struct qdio_buffer_element *sbale;
	int sbal_idx, sbale_idx, sbal_no;

J
Jan Glauber 已提交
151 152
	if (unlikely(qdio_err)) {
		zfcp_hba_dbf_event_qdio(adapter, qdio_err, first, count);
S
Swen Schillig 已提交
153 154 155
		zfcp_qdio_handler_error(adapter, 147);
		return;
	}
L
Linus Torvalds 已提交
156 157 158 159 160

	/*
	 * go through all SBALs from input queue currently
	 * returned by QDIO layer
	 */
S
Swen Schillig 已提交
161 162
	for (sbal_no = 0; sbal_no < count; sbal_no++) {
		sbal_idx = (first + sbal_no) % QDIO_MAX_BUFFERS_PER_Q;
L
Linus Torvalds 已提交
163 164

		/* go through all SBALEs of SBAL */
S
Swen Schillig 已提交
165 166 167
		for (sbale_idx = 0; sbale_idx < QDIO_MAX_ELEMENTS_PER_BUFFER;
		     sbale_idx++) {
			sbale = zfcp_qdio_sbale(queue, sbal_idx, sbale_idx);
168
			zfcp_qdio_reqid_check(adapter,
S
Swen Schillig 已提交
169 170 171
					      (unsigned long) sbale->addr,
					      sbal_idx);
			if (likely(sbale->flags & SBAL_FLAGS_LAST_ENTRY))
L
Linus Torvalds 已提交
172 173 174
				break;
		};

S
Swen Schillig 已提交
175 176 177 178
		if (unlikely(!(sbale->flags & SBAL_FLAGS_LAST_ENTRY)))
			dev_warn(&adapter->ccw_device->dev,
				 "Protocol violation by adapter. "
				 "Continuing operations.\n");
L
Linus Torvalds 已提交
179 180 181 182 183 184
	}

	/*
	 * put range of SBALs back to response queue
	 * (including SBALs which have already been free before)
	 */
S
Swen Schillig 已提交
185
	zfcp_qdio_resp_put_back(adapter, count);
L
Linus Torvalds 已提交
186 187 188
}

/**
S
Swen Schillig 已提交
189 190 191
 * zfcp_qdio_sbale_req - return ptr to SBALE of req_q for a struct zfcp_fsf_req
 * @fsf_req: pointer to struct fsf_req
 * Returns: pointer to qdio_buffer_element (SBALE) structure
L
Linus Torvalds 已提交
192
 */
193
volatile struct qdio_buffer_element *
S
Swen Schillig 已提交
194
zfcp_qdio_sbale_req(struct zfcp_fsf_req *req)
L
Linus Torvalds 已提交
195
{
S
Swen Schillig 已提交
196
	return zfcp_qdio_sbale(&req->adapter->req_q, req->sbal_last, 0);
L
Linus Torvalds 已提交
197 198 199
}

/**
S
Swen Schillig 已提交
200 201 202
 * zfcp_qdio_sbale_curr - return curr SBALE on req_q for a struct zfcp_fsf_req
 * @fsf_req: pointer to struct fsf_req
 * Returns: pointer to qdio_buffer_element (SBALE) structure
L
Linus Torvalds 已提交
203
 */
204
volatile struct qdio_buffer_element *
S
Swen Schillig 已提交
205
zfcp_qdio_sbale_curr(struct zfcp_fsf_req *req)
L
Linus Torvalds 已提交
206
{
S
Swen Schillig 已提交
207 208
	return zfcp_qdio_sbale(&req->adapter->req_q, req->sbal_last,
			       req->sbale_curr);
L
Linus Torvalds 已提交
209 210
}

S
Swen Schillig 已提交
211
static void zfcp_qdio_sbal_limit(struct zfcp_fsf_req *fsf_req, int max_sbals)
L
Linus Torvalds 已提交
212
{
S
Swen Schillig 已提交
213
	int count = atomic_read(&fsf_req->adapter->req_q.count);
L
Linus Torvalds 已提交
214
	count = min(count, max_sbals);
S
Swen Schillig 已提交
215 216
	fsf_req->sbal_limit = (fsf_req->sbal_first + count - 1)
					% QDIO_MAX_BUFFERS_PER_Q;
L
Linus Torvalds 已提交
217 218
}

219
static volatile struct qdio_buffer_element *
L
Linus Torvalds 已提交
220 221 222 223 224 225 226 227 228
zfcp_qdio_sbal_chain(struct zfcp_fsf_req *fsf_req, unsigned long sbtype)
{
	volatile struct qdio_buffer_element *sbale;

	/* set last entry flag in current SBALE of current SBAL */
	sbale = zfcp_qdio_sbale_curr(fsf_req);
	sbale->flags |= SBAL_FLAGS_LAST_ENTRY;

	/* don't exceed last allowed SBAL */
229
	if (fsf_req->sbal_last == fsf_req->sbal_limit)
L
Linus Torvalds 已提交
230 231 232
		return NULL;

	/* set chaining flag in first SBALE of current SBAL */
S
Swen Schillig 已提交
233
	sbale = zfcp_qdio_sbale_req(fsf_req);
L
Linus Torvalds 已提交
234 235 236
	sbale->flags |= SBAL_FLAGS0_MORE_SBALS;

	/* calculate index of next SBAL */
237 238
	fsf_req->sbal_last++;
	fsf_req->sbal_last %= QDIO_MAX_BUFFERS_PER_Q;
L
Linus Torvalds 已提交
239 240 241 242 243 244 245 246 247 248 249 250 251 252

	/* keep this requests number of SBALs up-to-date */
	fsf_req->sbal_number++;

	/* start at first SBALE of new SBAL */
	fsf_req->sbale_curr = 0;

	/* set storage-block type for new SBAL */
	sbale = zfcp_qdio_sbale_curr(fsf_req);
	sbale->flags |= sbtype;

	return sbale;
}

253
static volatile struct qdio_buffer_element *
L
Linus Torvalds 已提交
254 255 256 257 258 259 260 261
zfcp_qdio_sbale_next(struct zfcp_fsf_req *fsf_req, unsigned long sbtype)
{
	if (fsf_req->sbale_curr == ZFCP_LAST_SBALE_PER_SBAL)
		return zfcp_qdio_sbal_chain(fsf_req, sbtype);
	fsf_req->sbale_curr++;
	return zfcp_qdio_sbale_curr(fsf_req);
}

S
Swen Schillig 已提交
262
static void zfcp_qdio_undo_sbals(struct zfcp_fsf_req *fsf_req)
L
Linus Torvalds 已提交
263
{
S
Swen Schillig 已提交
264 265 266 267 268 269
	struct qdio_buffer **sbal = fsf_req->adapter->req_q.sbal;
	int first = fsf_req->sbal_first;
	int last = fsf_req->sbal_last;
	int count = (last - first + QDIO_MAX_BUFFERS_PER_Q) %
		QDIO_MAX_BUFFERS_PER_Q + 1;
	zfcp_qdio_zero_sbals(sbal, first, count);
L
Linus Torvalds 已提交
270 271
}

S
Swen Schillig 已提交
272 273 274
static int zfcp_qdio_fill_sbals(struct zfcp_fsf_req *fsf_req,
				unsigned int sbtype, void *start_addr,
				unsigned int total_length)
L
Linus Torvalds 已提交
275 276 277 278 279
{
	volatile struct qdio_buffer_element *sbale;
	unsigned long remaining, length;
	void *addr;

S
Swen Schillig 已提交
280
	/* split segment up */
L
Linus Torvalds 已提交
281 282
	for (addr = start_addr, remaining = total_length; remaining > 0;
	     addr += length, remaining -= length) {
S
Swen Schillig 已提交
283 284 285
		sbale = zfcp_qdio_sbale_next(fsf_req, sbtype);
		if (!sbale) {
			zfcp_qdio_undo_sbals(fsf_req);
L
Linus Torvalds 已提交
286 287
			return -EINVAL;
		}
S
Swen Schillig 已提交
288 289

		/* new piece must not exceed next page boundary */
L
Linus Torvalds 已提交
290
		length = min(remaining,
S
Swen Schillig 已提交
291
			     (PAGE_SIZE - ((unsigned long)addr &
L
Linus Torvalds 已提交
292
					   (PAGE_SIZE - 1))));
S
Swen Schillig 已提交
293 294
		sbale->addr = addr;
		sbale->length = length;
L
Linus Torvalds 已提交
295
	}
S
Swen Schillig 已提交
296
	return 0;
L
Linus Torvalds 已提交
297 298 299 300 301 302 303 304
}

/**
 * zfcp_qdio_sbals_from_sg - fill SBALs from scatter-gather list
 * @fsf_req: request to be processed
 * @sbtype: SBALE flags
 * @sg: scatter-gather list
 * @max_sbals: upper bound for number of SBALs to be used
S
Swen Schillig 已提交
305
 * Returns: number of bytes, or error (negativ)
L
Linus Torvalds 已提交
306
 */
S
Swen Schillig 已提交
307 308
int zfcp_qdio_sbals_from_sg(struct zfcp_fsf_req *fsf_req, unsigned long sbtype,
			    struct scatterlist *sg, int max_sbals)
L
Linus Torvalds 已提交
309 310
{
	volatile struct qdio_buffer_element *sbale;
S
Swen Schillig 已提交
311
	int retval, bytes = 0;
L
Linus Torvalds 已提交
312 313 314 315

	/* figure out last allowed SBAL */
	zfcp_qdio_sbal_limit(fsf_req, max_sbals);

S
Swen Schillig 已提交
316 317
	/* set storage-block type for this request */
	sbale = zfcp_qdio_sbale_req(fsf_req);
L
Linus Torvalds 已提交
318 319
	sbale->flags |= sbtype;

S
Swen Schillig 已提交
320 321 322 323 324 325
	for (; sg; sg = sg_next(sg)) {
		retval = zfcp_qdio_fill_sbals(fsf_req, sbtype, sg_virt(sg),
					      sg->length);
		if (retval < 0)
			return retval;
		bytes += sg->length;
L
Linus Torvalds 已提交
326
	}
S
Swen Schillig 已提交
327

L
Linus Torvalds 已提交
328 329 330
	/* assume that no other SBALEs are to follow in the same SBAL */
	sbale = zfcp_qdio_sbale_curr(fsf_req);
	sbale->flags |= SBAL_FLAGS_LAST_ENTRY;
S
Swen Schillig 已提交
331

L
Linus Torvalds 已提交
332 333 334 335
	return bytes;
}

/**
S
Swen Schillig 已提交
336 337 338
 * zfcp_qdio_send - set PCI flag in first SBALE and send req to QDIO
 * @fsf_req: pointer to struct zfcp_fsf_req
 * Returns: 0 on success, error otherwise
L
Linus Torvalds 已提交
339
 */
S
Swen Schillig 已提交
340
int zfcp_qdio_send(struct zfcp_fsf_req *fsf_req)
L
Linus Torvalds 已提交
341
{
S
Swen Schillig 已提交
342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359
	struct zfcp_adapter *adapter = fsf_req->adapter;
	struct zfcp_qdio_queue *req_q = &adapter->req_q;
	int first = fsf_req->sbal_first;
	int count = fsf_req->sbal_number;
	int retval, pci, pci_batch;
	volatile struct qdio_buffer_element *sbale;

	/* acknowledgements for transferred buffers */
	pci_batch = req_q->pci_batch + count;
	if (unlikely(pci_batch >= ZFCP_QDIO_PCI_INTERVAL)) {
		pci_batch %= ZFCP_QDIO_PCI_INTERVAL;
		pci = first + count - (pci_batch + 1);
		pci %= QDIO_MAX_BUFFERS_PER_Q;
		sbale = zfcp_qdio_sbale(req_q, pci, 0);
		sbale->flags |= SBAL_FLAGS0_PCI;
	}

	retval = do_QDIO(adapter->ccw_device, QDIO_FLAG_SYNC_OUTPUT, 0, first,
J
Jan Glauber 已提交
360
			 count);
S
Swen Schillig 已提交
361 362 363 364 365 366 367 368 369 370 371
	if (unlikely(retval)) {
		zfcp_qdio_zero_sbals(req_q->sbal, first, count);
		return retval;
	}

	/* account for transferred buffers */
	atomic_sub(count, &req_q->count);
	req_q->first += count;
	req_q->first %= QDIO_MAX_BUFFERS_PER_Q;
	req_q->pci_batch = pci_batch;
	return 0;
L
Linus Torvalds 已提交
372 373
}

S
Swen Schillig 已提交
374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414
/**
 * zfcp_qdio_allocate - allocate queue memory and initialize QDIO data
 * @adapter: pointer to struct zfcp_adapter
 * Returns: -ENOMEM on memory allocation error or return value from
 *          qdio_allocate
 */
int zfcp_qdio_allocate(struct zfcp_adapter *adapter)
{
	struct qdio_initialize *init_data;

	if (zfcp_qdio_buffers_enqueue(adapter->req_q.sbal) ||
		   zfcp_qdio_buffers_enqueue(adapter->resp_q.sbal))
		return -ENOMEM;

	init_data = &adapter->qdio_init_data;

	init_data->cdev = adapter->ccw_device;
	init_data->q_format = QDIO_ZFCP_QFMT;
	memcpy(init_data->adapter_name, zfcp_get_busid_by_adapter(adapter), 8);
	ASCEBC(init_data->adapter_name, 8);
	init_data->qib_param_field_format = 0;
	init_data->qib_param_field = NULL;
	init_data->input_slib_elements = NULL;
	init_data->output_slib_elements = NULL;
	init_data->no_input_qs = 1;
	init_data->no_output_qs = 1;
	init_data->input_handler = zfcp_qdio_int_resp;
	init_data->output_handler = zfcp_qdio_int_req;
	init_data->int_parm = (unsigned long) adapter;
	init_data->flags = QDIO_INBOUND_0COPY_SBALS |
			QDIO_OUTBOUND_0COPY_SBALS | QDIO_USE_OUTBOUND_PCIS;
	init_data->input_sbal_addr_array =
			(void **) (adapter->resp_q.sbal);
	init_data->output_sbal_addr_array =
			(void **) (adapter->req_q.sbal);

	return qdio_allocate(init_data);
}

/**
 * zfcp_close_qdio - close qdio queues for an adapter
L
Linus Torvalds 已提交
415
 */
S
Swen Schillig 已提交
416
void zfcp_qdio_close(struct zfcp_adapter *adapter)
L
Linus Torvalds 已提交
417
{
S
Swen Schillig 已提交
418 419 420 421 422 423 424 425
	struct zfcp_qdio_queue *req_q;
	int first, count;

	if (!atomic_test_mask(ZFCP_STATUS_ADAPTER_QDIOUP, &adapter->status))
		return;

	/* clear QDIOUP flag, thus do_QDIO is not called during qdio_shutdown */
	req_q = &adapter->req_q;
426
	spin_lock_bh(&req_q->lock);
S
Swen Schillig 已提交
427
	atomic_clear_mask(ZFCP_STATUS_ADAPTER_QDIOUP, &adapter->status);
428
	spin_unlock_bh(&req_q->lock);
S
Swen Schillig 已提交
429

J
Jan Glauber 已提交
430
	qdio_shutdown(adapter->ccw_device, QDIO_FLAG_CLEANUP_USING_CLEAR);
S
Swen Schillig 已提交
431 432 433 434 435 436 437

	/* cleanup used outbound sbals */
	count = atomic_read(&req_q->count);
	if (count < QDIO_MAX_BUFFERS_PER_Q) {
		first = (req_q->first + count) % QDIO_MAX_BUFFERS_PER_Q;
		count = QDIO_MAX_BUFFERS_PER_Q - count;
		zfcp_qdio_zero_sbals(req_q->sbal, first, count);
L
Linus Torvalds 已提交
438
	}
S
Swen Schillig 已提交
439 440 441 442 443
	req_q->first = 0;
	atomic_set(&req_q->count, 0);
	req_q->pci_batch = 0;
	adapter->resp_q.first = 0;
	atomic_set(&adapter->resp_q.count, 0);
L
Linus Torvalds 已提交
444 445
}

S
Swen Schillig 已提交
446 447 448 449 450 451 452 453 454 455 456 457 458 459 460 461 462 463 464
/**
 * zfcp_qdio_open - prepare and initialize response queue
 * @adapter: pointer to struct zfcp_adapter
 * Returns: 0 on success, otherwise -EIO
 */
int zfcp_qdio_open(struct zfcp_adapter *adapter)
{
	volatile struct qdio_buffer_element *sbale;
	int cc;

	if (atomic_test_mask(ZFCP_STATUS_ADAPTER_QDIOUP, &adapter->status))
		return -EIO;

	if (qdio_establish(&adapter->qdio_init_data)) {
		dev_err(&adapter->ccw_device->dev,
			 "Establish of QDIO queues failed.\n");
		return -EIO;
	}

J
Jan Glauber 已提交
465
	if (qdio_activate(adapter->ccw_device)) {
S
Swen Schillig 已提交
466 467 468 469 470 471 472 473 474 475 476 477 478
		dev_err(&adapter->ccw_device->dev,
			 "Activate of QDIO queues failed.\n");
		goto failed_qdio;
	}

	for (cc = 0; cc < QDIO_MAX_BUFFERS_PER_Q; cc++) {
		sbale = &(adapter->resp_q.sbal[cc]->element[0]);
		sbale->length = 0;
		sbale->flags = SBAL_FLAGS_LAST_ENTRY;
		sbale->addr = NULL;
	}

	if (do_QDIO(adapter->ccw_device, QDIO_FLAG_SYNC_INPUT, 0, 0,
J
Jan Glauber 已提交
479
		     QDIO_MAX_BUFFERS_PER_Q)) {
S
Swen Schillig 已提交
480 481 482 483 484 485 486 487 488 489 490 491 492
		dev_err(&adapter->ccw_device->dev,
			 "Init of QDIO response queue failed.\n");
		goto failed_qdio;
	}

	/* set index of first avalable SBALS / number of available SBALS */
	adapter->req_q.first = 0;
	atomic_set(&adapter->req_q.count, QDIO_MAX_BUFFERS_PER_Q);
	adapter->req_q.pci_batch = 0;

	return 0;

failed_qdio:
J
Jan Glauber 已提交
493
	qdio_shutdown(adapter->ccw_device, QDIO_FLAG_CLEANUP_USING_CLEAR);
S
Swen Schillig 已提交
494 495
	return -EIO;
}