projects / deliverable / linux.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
[S390] Avoid excessive inlining.
[deliverable/linux.git] / drivers / s390 / scsi / zfcp_qdio.c
CommitLineData
1da177e4 1/*
4a9d2d8b
AH		 2 * This file is part of the zfcp device driver for
3 * FCP adapters for IBM System z9 and zSeries.
1da177e4 4 *
4a9d2d8b 5 * (C) Copyright IBM Corp. 2002, 2006
1da177e4
LT		 6 *
7 * This program is free software; you can redistribute it and/or modify
8 * it under the terms of the GNU General Public License as published by
9 * the Free Software Foundation; either version 2, or (at your option)
10 * any later version.
11 *
12 * This program is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 * GNU General Public License for more details.
16 *
17 * You should have received a copy of the GNU General Public License
18 * along with this program; if not, write to the Free Software
19 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
20 */
21
1da177e4
LT		 22#include "zfcp_ext.h"
23
4d284cac 24static void zfcp_qdio_sbal_limit(struct zfcp_fsf_req *, int);
1da177e4
LT		 25static inline volatile struct qdio_buffer_element *zfcp_qdio_sbale_get
26 (struct zfcp_qdio_queue *, int, int);
27static inline volatile struct qdio_buffer_element *zfcp_qdio_sbale_resp
28 (struct zfcp_fsf_req *, int, int);
4d284cac 29static volatile struct qdio_buffer_element *zfcp_qdio_sbal_chain
1da177e4 30 (struct zfcp_fsf_req *, unsigned long);
4d284cac 31static volatile struct qdio_buffer_element *zfcp_qdio_sbale_next
1da177e4 32 (struct zfcp_fsf_req *, unsigned long);
4d284cac 33static int zfcp_qdio_sbals_zero(struct zfcp_qdio_queue *, int, int);
1da177e4 34static inline int zfcp_qdio_sbals_wipe(struct zfcp_fsf_req *);
4d284cac 35static void zfcp_qdio_sbale_fill
1da177e4 36 (struct zfcp_fsf_req *, unsigned long, void *, int);
4d284cac 37static int zfcp_qdio_sbals_from_segment
1da177e4 38 (struct zfcp_fsf_req *, unsigned long, void *, unsigned long);
4d284cac 39static int zfcp_qdio_sbals_from_buffer
1da177e4
LT		 40 (struct zfcp_fsf_req *, unsigned long, void *, unsigned long, int);
41
42static qdio_handler_t zfcp_qdio_request_handler;
43static qdio_handler_t zfcp_qdio_response_handler;
44static int zfcp_qdio_handler_error_check(struct zfcp_adapter *,
8a36e453 45 unsigned int, unsigned int, unsigned int, int, int);
1da177e4
LT		 46
47#define ZFCP_LOG_AREA ZFCP_LOG_AREA_QDIO
48
49/*
50 * Allocates BUFFER memory to each of the pointers of the qdio_buffer_t
51 * array in the adapter struct.
52 * Cur_buf is the pointer array and count can be any number of required
53 * buffers, the page-fitting arithmetic is done entirely within this funciton.
54 *
55 * returns: number of buffers allocated
56 * locks: must only be called with zfcp_data.config_sema taken
57 */
58static int
59zfcp_qdio_buffers_enqueue(struct qdio_buffer **cur_buf, int count)
60{
61 int buf_pos;
62 int qdio_buffers_per_page;
63 int page_pos = 0;
64 struct qdio_buffer *first_in_page = NULL;
65
66 qdio_buffers_per_page = PAGE_SIZE / sizeof (struct qdio_buffer);
67 ZFCP_LOG_TRACE("buffers_per_page=%d\n", qdio_buffers_per_page);
68
69 for (buf_pos = 0; buf_pos < count; buf_pos++) {
70 if (page_pos == 0) {
71 cur_buf[buf_pos] = (struct qdio_buffer *)
72 get_zeroed_page(GFP_KERNEL);
73 if (cur_buf[buf_pos] == NULL) {
74 ZFCP_LOG_INFO("error: allocation of "
75 "QDIO buffer failed \n");
76 goto out;
77 }
78 first_in_page = cur_buf[buf_pos];
79 } else {
80 cur_buf[buf_pos] = first_in_page + page_pos;
81
82 }
83 /* was initialised to zero */
84 page_pos++;
85 page_pos %= qdio_buffers_per_page;
86 }
87 out:
88 return buf_pos;
89}
90
91/*
92 * Frees BUFFER memory for each of the pointers of the struct qdio_buffer array
93 * in the adapter struct cur_buf is the pointer array and count can be any
94 * number of buffers in the array that should be freed starting from buffer 0
95 *
96 * locks: must only be called with zfcp_data.config_sema taken
97 */
98static void
99zfcp_qdio_buffers_dequeue(struct qdio_buffer **cur_buf, int count)
100{
101 int buf_pos;
102 int qdio_buffers_per_page;
103
104 qdio_buffers_per_page = PAGE_SIZE / sizeof (struct qdio_buffer);
105 ZFCP_LOG_TRACE("buffers_per_page=%d\n", qdio_buffers_per_page);
106
107 for (buf_pos = 0; buf_pos < count; buf_pos += qdio_buffers_per_page)
108 free_page((unsigned long) cur_buf[buf_pos]);
109 return;
110}
111
112/* locks: must only be called with zfcp_data.config_sema taken */
113int
114zfcp_qdio_allocate_queues(struct zfcp_adapter *adapter)
115{
116 int buffer_count;
117 int retval = 0;
118
119 buffer_count =
120 zfcp_qdio_buffers_enqueue(&(adapter->request_queue.buffer[0]),
121 QDIO_MAX_BUFFERS_PER_Q);
122 if (buffer_count < QDIO_MAX_BUFFERS_PER_Q) {
123 ZFCP_LOG_DEBUG("only %d QDIO buffers allocated for request "
124 "queue\n", buffer_count);
125 zfcp_qdio_buffers_dequeue(&(adapter->request_queue.buffer[0]),
126 buffer_count);
127 retval = -ENOMEM;
128 goto out;
129 }
130
131 buffer_count =
132 zfcp_qdio_buffers_enqueue(&(adapter->response_queue.buffer[0]),
133 QDIO_MAX_BUFFERS_PER_Q);
134 if (buffer_count < QDIO_MAX_BUFFERS_PER_Q) {
135 ZFCP_LOG_DEBUG("only %d QDIO buffers allocated for response "
136 "queue", buffer_count);
137 zfcp_qdio_buffers_dequeue(&(adapter->response_queue.buffer[0]),
138 buffer_count);
139 ZFCP_LOG_TRACE("freeing request_queue buffers\n");
140 zfcp_qdio_buffers_dequeue(&(adapter->request_queue.buffer[0]),
141 QDIO_MAX_BUFFERS_PER_Q);
142 retval = -ENOMEM;
143 goto out;
144 }
145 out:
146 return retval;
147}
148
149/* locks: must only be called with zfcp_data.config_sema taken */
150void
151zfcp_qdio_free_queues(struct zfcp_adapter *adapter)
152{
153 ZFCP_LOG_TRACE("freeing request_queue buffers\n");
154 zfcp_qdio_buffers_dequeue(&(adapter->request_queue.buffer[0]),
155 QDIO_MAX_BUFFERS_PER_Q);
156
157 ZFCP_LOG_TRACE("freeing response_queue buffers\n");
158 zfcp_qdio_buffers_dequeue(&(adapter->response_queue.buffer[0]),
159 QDIO_MAX_BUFFERS_PER_Q);
160}
161
162int
163zfcp_qdio_allocate(struct zfcp_adapter *adapter)
164{
165 struct qdio_initialize *init_data;
166
167 init_data = &adapter->qdio_init_data;
168
169 init_data->cdev = adapter->ccw_device;
170 init_data->q_format = QDIO_SCSI_QFMT;
06506d00
AH		 171 memcpy(init_data->adapter_name, zfcp_get_busid_by_adapter(adapter), 8);
172 ASCEBC(init_data->adapter_name, 8);
1da177e4
LT		 173 init_data->qib_param_field_format = 0;
174 init_data->qib_param_field = NULL;
175 init_data->input_slib_elements = NULL;
176 init_data->output_slib_elements = NULL;
177 init_data->min_input_threshold = ZFCP_MIN_INPUT_THRESHOLD;
178 init_data->max_input_threshold = ZFCP_MAX_INPUT_THRESHOLD;
179 init_data->min_output_threshold = ZFCP_MIN_OUTPUT_THRESHOLD;
180 init_data->max_output_threshold = ZFCP_MAX_OUTPUT_THRESHOLD;
181 init_data->no_input_qs = 1;
182 init_data->no_output_qs = 1;
183 init_data->input_handler = zfcp_qdio_response_handler;
184 init_data->output_handler = zfcp_qdio_request_handler;
185 init_data->int_parm = (unsigned long) adapter;
186 init_data->flags = QDIO_INBOUND_0COPY_SBALS |
187 QDIO_OUTBOUND_0COPY_SBALS | QDIO_USE_OUTBOUND_PCIS;
188 init_data->input_sbal_addr_array =
189 (void **) (adapter->response_queue.buffer);
190 init_data->output_sbal_addr_array =
191 (void **) (adapter->request_queue.buffer);
192
193 return qdio_allocate(init_data);
194}
195
196/*
197 * function: zfcp_qdio_handler_error_check
198 *
199 * purpose: called by the response handler to determine error condition
200 *
201 * returns: error flag
202 *
203 */
4d284cac 204static int
8a36e453
MS		 205zfcp_qdio_handler_error_check(struct zfcp_adapter *adapter, unsigned int status,
206 unsigned int qdio_error, unsigned int siga_error,
207 int first_element, int elements_processed)
1da177e4
LT		 208{
209 int retval = 0;
210
1da177e4
LT		 211 if (unlikely(status & QDIO_STATUS_LOOK_FOR_ERROR)) {
212 retval = -EIO;
213
1da177e4
LT		 214 ZFCP_LOG_INFO("QDIO problem occurred (status=0x%x, "
215 "qdio_error=0x%x, siga_error=0x%x)\n",
216 status, qdio_error, siga_error);
217
8a36e453
MS		 218 zfcp_hba_dbf_event_qdio(adapter, status, qdio_error, siga_error,
219 first_element, elements_processed);
1da177e4 220 /*
8a36e453 221 * Restarting IO on the failed adapter from scratch.
1da177e4
LT		 222 * Since we have been using this adapter, it is save to assume
223 * that it is not failed but recoverable. The card seems to
224 * report link-up events by self-initiated queue shutdown.
225 * That is why we need to clear the the link-down flag
226 * which is set again in case we have missed by a mile.
227 */
228 zfcp_erp_adapter_reopen(
229 adapter,
230 ZFCP_STATUS_ADAPTER_LINK_UNPLUGGED |
231 ZFCP_STATUS_COMMON_ERP_FAILED);
232 }
233 return retval;
234}
235
236/*
237 * function: zfcp_qdio_request_handler
238 *
239 * purpose: is called by QDIO layer for completed SBALs in request queue
240 *
241 * returns: (void)
242 */
243static void
244zfcp_qdio_request_handler(struct ccw_device *ccw_device,
245 unsigned int status,
246 unsigned int qdio_error,
247 unsigned int siga_error,
248 unsigned int queue_number,
249 int first_element,
250 int elements_processed,
251 unsigned long int_parm)
252{
253 struct zfcp_adapter *adapter;
254 struct zfcp_qdio_queue *queue;
255
256 adapter = (struct zfcp_adapter *) int_parm;
257 queue = &adapter->request_queue;
258
259 ZFCP_LOG_DEBUG("adapter %s, first=%d, elements_processed=%d\n",
260 zfcp_get_busid_by_adapter(adapter),
261 first_element, elements_processed);
262
263 if (unlikely(zfcp_qdio_handler_error_check(adapter, status, qdio_error,
8a36e453
MS		 264 siga_error, first_element,
265 elements_processed)))
1da177e4
LT		 266 goto out;
267 /*
268 * we stored address of struct zfcp_adapter data structure
269 * associated with irq in int_parm
270 */
271
272 /* cleanup all SBALs being program-owned now */
273 zfcp_qdio_zero_sbals(queue->buffer, first_element, elements_processed);
274
275 /* increase free space in outbound queue */
276 atomic_add(elements_processed, &queue->free_count);
277 ZFCP_LOG_DEBUG("free_count=%d\n", atomic_read(&queue->free_count));
278 wake_up(&adapter->request_wq);
279 ZFCP_LOG_DEBUG("elements_processed=%d, free count=%d\n",
280 elements_processed, atomic_read(&queue->free_count));
281 out:
282 return;
283}
284
fea9d6c7
VS		 285/**
286 * zfcp_qdio_reqid_check - checks for valid reqids or unsolicited status
287 */
288static int zfcp_qdio_reqid_check(struct zfcp_adapter *adapter,
289 unsigned long req_id)
290{
291 struct zfcp_fsf_req *fsf_req;
292 unsigned long flags;
293
294 debug_long_event(adapter->erp_dbf, 4, req_id);
295
296 spin_lock_irqsave(&adapter->req_list_lock, flags);
297 fsf_req = zfcp_reqlist_ismember(adapter, req_id);
298
299 if (!fsf_req) {
300 spin_unlock_irqrestore(&adapter->req_list_lock, flags);
301 ZFCP_LOG_NORMAL("error: unknown request id (%ld).\n", req_id);
302 zfcp_erp_adapter_reopen(adapter, 0);
303 return -EINVAL;
304 }
305
306 zfcp_reqlist_remove(adapter, req_id);
307 atomic_dec(&adapter->reqs_active);
308 spin_unlock_irqrestore(&adapter->req_list_lock, flags);
309
310 /* finish the FSF request */
311 zfcp_fsf_req_complete(fsf_req);
312
313 return 0;
314}
315
1da177e4
LT		 316/*
317 * function: zfcp_qdio_response_handler
318 *
319 * purpose: is called by QDIO layer for completed SBALs in response queue
320 *
321 * returns: (void)
322 */
323static void
324zfcp_qdio_response_handler(struct ccw_device *ccw_device,
325 unsigned int status,
326 unsigned int qdio_error,
327 unsigned int siga_error,
328 unsigned int queue_number,
329 int first_element,
330 int elements_processed,
331 unsigned long int_parm)
332{
333 struct zfcp_adapter *adapter;
334 struct zfcp_qdio_queue *queue;
335 int buffer_index;
336 int i;
337 struct qdio_buffer *buffer;
338 int retval = 0;
339 u8 count;
340 u8 start;
341 volatile struct qdio_buffer_element *buffere = NULL;
342 int buffere_index;
343
344 adapter = (struct zfcp_adapter *) int_parm;
345 queue = &adapter->response_queue;
346
347 if (unlikely(zfcp_qdio_handler_error_check(adapter, status, qdio_error,
8a36e453
MS		 348 siga_error, first_element,
349 elements_processed)))
1da177e4
LT		 350 goto out;
351
352 /*
353 * we stored address of struct zfcp_adapter data structure
354 * associated with irq in int_parm
355 */
356
357 buffere = &(queue->buffer[first_element]->element[0]);
358 ZFCP_LOG_DEBUG("first BUFFERE flags=0x%x\n", buffere->flags);
359 /*
360 * go through all SBALs from input queue currently
361 * returned by QDIO layer
362 */
363
364 for (i = 0; i < elements_processed; i++) {
365
366 buffer_index = first_element + i;
367 buffer_index %= QDIO_MAX_BUFFERS_PER_Q;
368 buffer = queue->buffer[buffer_index];
369
370 /* go through all SBALEs of SBAL */
371 for (buffere_index = 0;
372 buffere_index < QDIO_MAX_ELEMENTS_PER_BUFFER;
373 buffere_index++) {
374
375 /* look for QDIO request identifiers in SB */
376 buffere = &buffer->element[buffere_index];
377 retval = zfcp_qdio_reqid_check(adapter,
fea9d6c7 378 (unsigned long) buffere->addr);
1da177e4
LT		 379
380 if (retval) {
381 ZFCP_LOG_NORMAL("bug: unexpected inbound "
382 "packet on adapter %s "
383 "(reqid=0x%lx, "
384 "first_element=%d, "
385 "elements_processed=%d)\n",
386 zfcp_get_busid_by_adapter(adapter),
387 (unsigned long) buffere->addr,
388 first_element,
389 elements_processed);
390 ZFCP_LOG_NORMAL("hex dump of inbound buffer "
391 "at address %p "
392 "(buffer_index=%d, "
393 "buffere_index=%d)\n", buffer,
394 buffer_index, buffere_index);
395 ZFCP_HEX_DUMP(ZFCP_LOG_LEVEL_NORMAL,
396 (char *) buffer, SBAL_SIZE);
397 }
398 /*
399 * A single used SBALE per inbound SBALE has been
400 * implemented by QDIO so far. Hope they will
401 * do some optimisation. Will need to change to
402 * unlikely() then.
403 */
404 if (likely(buffere->flags & SBAL_FLAGS_LAST_ENTRY))
405 break;
406 };
407
408 if (unlikely(!(buffere->flags & SBAL_FLAGS_LAST_ENTRY))) {
409 ZFCP_LOG_NORMAL("bug: End of inbound data "
410 "not marked!\n");
411 }
412 }
413
414 /*
415 * put range of SBALs back to response queue
416 * (including SBALs which have already been free before)
417 */
418 count = atomic_read(&queue->free_count) + elements_processed;
419 start = queue->free_index;
420
421 ZFCP_LOG_TRACE("calling do_QDIO on adapter %s (flags=0x%x, "
422 "queue_no=%i, index_in_queue=%i, count=%i, "
423 "buffers=0x%lx\n",
424 zfcp_get_busid_by_adapter(adapter),
425 QDIO_FLAG_SYNC_INPUT | QDIO_FLAG_UNDER_INTERRUPT,
426 0, start, count, (unsigned long) &queue->buffer[start]);
427
428 retval = do_QDIO(ccw_device,
429 QDIO_FLAG_SYNC_INPUT | QDIO_FLAG_UNDER_INTERRUPT,
430 0, start, count, NULL);
431
432 if (unlikely(retval)) {
433 atomic_set(&queue->free_count, count);
434 ZFCP_LOG_DEBUG("clearing of inbound data regions failed, "
435 "queues may be down "
436 "(count=%d, start=%d, retval=%d)\n",
437 count, start, retval);
438 } else {
439 queue->free_index += count;
440 queue->free_index %= QDIO_MAX_BUFFERS_PER_Q;
441 atomic_set(&queue->free_count, 0);
442 ZFCP_LOG_TRACE("%i buffers enqueued to response "
443 "queue at position %i\n", count, start);
444 }
445 out:
446 return;
447}
448
1da177e4
LT		 449/**
450 * zfcp_qdio_sbale_get - return pointer to SBALE of qdio_queue
451 * @queue: queue from which SBALE should be returned
452 * @sbal: specifies number of SBAL in queue
453 * @sbale: specifes number of SBALE in SBAL
454 */
455static inline volatile struct qdio_buffer_element *
456zfcp_qdio_sbale_get(struct zfcp_qdio_queue *queue, int sbal, int sbale)
457{
458 return &queue->buffer[sbal]->element[sbale];
459}
460
461/**
462 * zfcp_qdio_sbale_req - return pointer to SBALE of request_queue for
463 * a struct zfcp_fsf_req
464 */
4d284cac 465volatile struct qdio_buffer_element *
1da177e4
LT		 466zfcp_qdio_sbale_req(struct zfcp_fsf_req *fsf_req, int sbal, int sbale)
467{
468 return zfcp_qdio_sbale_get(&fsf_req->adapter->request_queue,
469 sbal, sbale);
470}
471
472/**
473 * zfcp_qdio_sbale_resp - return pointer to SBALE of response_queue for
474 * a struct zfcp_fsf_req
475 */
476static inline volatile struct qdio_buffer_element *
477zfcp_qdio_sbale_resp(struct zfcp_fsf_req *fsf_req, int sbal, int sbale)
478{
479 return zfcp_qdio_sbale_get(&fsf_req->adapter->response_queue,
480 sbal, sbale);
481}
482
483/**
484 * zfcp_qdio_sbale_curr - return current SBALE on request_queue for
485 * a struct zfcp_fsf_req
486 */
4d284cac 487volatile struct qdio_buffer_element *
1da177e4
LT		 488zfcp_qdio_sbale_curr(struct zfcp_fsf_req *fsf_req)
489{
490 return zfcp_qdio_sbale_req(fsf_req, fsf_req->sbal_curr,
491 fsf_req->sbale_curr);
492}
493
494/**
495 * zfcp_qdio_sbal_limit - determine maximum number of SBALs that can be used
496 * on the request_queue for a struct zfcp_fsf_req
497 * @fsf_req: the number of the last SBAL that can be used is stored herein
498 * @max_sbals: used to pass an upper limit for the number of SBALs
499 *
500 * Note: We can assume at least one free SBAL in the request_queue when called.
501 */
4d284cac 502static void
1da177e4
LT		 503zfcp_qdio_sbal_limit(struct zfcp_fsf_req *fsf_req, int max_sbals)
504{
505 int count = atomic_read(&fsf_req->adapter->request_queue.free_count);
506 count = min(count, max_sbals);
507 fsf_req->sbal_last = fsf_req->sbal_first;
508 fsf_req->sbal_last += (count - 1);
509 fsf_req->sbal_last %= QDIO_MAX_BUFFERS_PER_Q;
510}
511
512/**
513 * zfcp_qdio_sbal_chain - chain SBALs if more than one SBAL is needed for a
514 * request
515 * @fsf_req: zfcp_fsf_req to be processed
516 * @sbtype: SBAL flags which have to be set in first SBALE of new SBAL
517 *
518 * This function changes sbal_curr, sbale_curr, sbal_number of fsf_req.
519 */
4d284cac 520static volatile struct qdio_buffer_element *
1da177e4
LT		 521zfcp_qdio_sbal_chain(struct zfcp_fsf_req *fsf_req, unsigned long sbtype)
522{
523 volatile struct qdio_buffer_element *sbale;
524
525 /* set last entry flag in current SBALE of current SBAL */
526 sbale = zfcp_qdio_sbale_curr(fsf_req);
527 sbale->flags |= SBAL_FLAGS_LAST_ENTRY;
528
529 /* don't exceed last allowed SBAL */
530 if (fsf_req->sbal_curr == fsf_req->sbal_last)
531 return NULL;
532
533 /* set chaining flag in first SBALE of current SBAL */
534 sbale = zfcp_qdio_sbale_req(fsf_req, fsf_req->sbal_curr, 0);
535 sbale->flags |= SBAL_FLAGS0_MORE_SBALS;
536
537 /* calculate index of next SBAL */
538 fsf_req->sbal_curr++;
539 fsf_req->sbal_curr %= QDIO_MAX_BUFFERS_PER_Q;
540
541 /* keep this requests number of SBALs up-to-date */
542 fsf_req->sbal_number++;
543
544 /* start at first SBALE of new SBAL */
545 fsf_req->sbale_curr = 0;
546
547 /* set storage-block type for new SBAL */
548 sbale = zfcp_qdio_sbale_curr(fsf_req);
549 sbale->flags |= sbtype;
550
551 return sbale;
552}
553
554/**
555 * zfcp_qdio_sbale_next - switch to next SBALE, chain SBALs if needed
556 */
4d284cac 557static volatile struct qdio_buffer_element *
1da177e4
LT		 558zfcp_qdio_sbale_next(struct zfcp_fsf_req *fsf_req, unsigned long sbtype)
559{
560 if (fsf_req->sbale_curr == ZFCP_LAST_SBALE_PER_SBAL)
561 return zfcp_qdio_sbal_chain(fsf_req, sbtype);
562
563 fsf_req->sbale_curr++;
564
565 return zfcp_qdio_sbale_curr(fsf_req);
566}
567
568/**
569 * zfcp_qdio_sbals_zero - initialize SBALs between first and last in queue
570 * with zero from
571 */
4d284cac 572static int
1da177e4
LT		 573zfcp_qdio_sbals_zero(struct zfcp_qdio_queue *queue, int first, int last)
574{
575 struct qdio_buffer **buf = queue->buffer;
576 int curr = first;
577 int count = 0;
578
579 for(;;) {
580 curr %= QDIO_MAX_BUFFERS_PER_Q;
581 count++;
582 memset(buf[curr], 0, sizeof(struct qdio_buffer));
583 if (curr == last)
584 break;
585 curr++;
586 }
587 return count;
588}
589
590
591/**
592 * zfcp_qdio_sbals_wipe - reset all changes in SBALs for an fsf_req
593 */
594static inline int
595zfcp_qdio_sbals_wipe(struct zfcp_fsf_req *fsf_req)
596{
597 return zfcp_qdio_sbals_zero(&fsf_req->adapter->request_queue,
598 fsf_req->sbal_first, fsf_req->sbal_curr);
599}
600
601
602/**
603 * zfcp_qdio_sbale_fill - set address and lenght in current SBALE
604 * on request_queue
605 */
4d284cac 606static void
1da177e4
LT		 607zfcp_qdio_sbale_fill(struct zfcp_fsf_req *fsf_req, unsigned long sbtype,
608 void *addr, int length)
609{
610 volatile struct qdio_buffer_element *sbale;
611
612 sbale = zfcp_qdio_sbale_curr(fsf_req);
613 sbale->addr = addr;
614 sbale->length = length;
615}
616
617/**
618 * zfcp_qdio_sbals_from_segment - map memory segment to SBALE(s)
619 * @fsf_req: request to be processed
620 * @sbtype: SBALE flags
621 * @start_addr: address of memory segment
622 * @total_length: length of memory segment
623 *
624 * Alignment and length of the segment determine how many SBALEs are needed
625 * for the memory segment.
626 */
4d284cac 627static int
1da177e4
LT		 628zfcp_qdio_sbals_from_segment(struct zfcp_fsf_req *fsf_req, unsigned long sbtype,
629 void *start_addr, unsigned long total_length)
630{
631 unsigned long remaining, length;
632 void *addr;
633
634 /* split segment up heeding page boundaries */
635 for (addr = start_addr, remaining = total_length; remaining > 0;
636 addr += length, remaining -= length) {
637 /* get next free SBALE for new piece */
638 if (NULL == zfcp_qdio_sbale_next(fsf_req, sbtype)) {
639 /* no SBALE left, clean up and leave */
640 zfcp_qdio_sbals_wipe(fsf_req);
641 return -EINVAL;
642 }
643 /* calculate length of new piece */
644 length = min(remaining,
645 (PAGE_SIZE - ((unsigned long) addr &
646 (PAGE_SIZE - 1))));
647 /* fill current SBALE with calculated piece */
648 zfcp_qdio_sbale_fill(fsf_req, sbtype, addr, length);
649 }
650 return total_length;
651}
652
653
654/**
655 * zfcp_qdio_sbals_from_sg - fill SBALs from scatter-gather list
656 * @fsf_req: request to be processed
657 * @sbtype: SBALE flags
658 * @sg: scatter-gather list
659 * @sg_count: number of elements in scatter-gather list
660 * @max_sbals: upper bound for number of SBALs to be used
661 */
4d284cac 662int
1da177e4
LT		 663zfcp_qdio_sbals_from_sg(struct zfcp_fsf_req *fsf_req, unsigned long sbtype,
664 struct scatterlist *sg, int sg_count, int max_sbals)
665{
666 int sg_index;
667 struct scatterlist *sg_segment;
668 int retval;
669 volatile struct qdio_buffer_element *sbale;
670 int bytes = 0;
671
672 /* figure out last allowed SBAL */
673 zfcp_qdio_sbal_limit(fsf_req, max_sbals);
674
675 /* set storage-block type for current SBAL */
676 sbale = zfcp_qdio_sbale_req(fsf_req, fsf_req->sbal_curr, 0);
677 sbale->flags |= sbtype;
678
679 /* process all segements of scatter-gather list */
680 for (sg_index = 0, sg_segment = sg, bytes = 0;
681 sg_index < sg_count;
682 sg_index++, sg_segment++) {
683 retval = zfcp_qdio_sbals_from_segment(
684 fsf_req,
685 sbtype,
686 zfcp_sg_to_address(sg_segment),
687 sg_segment->length);
688 if (retval < 0) {
689 bytes = retval;
690 goto out;
691 } else
692 bytes += retval;
693 }
694 /* assume that no other SBALEs are to follow in the same SBAL */
695 sbale = zfcp_qdio_sbale_curr(fsf_req);
696 sbale->flags |= SBAL_FLAGS_LAST_ENTRY;
697out:
698 return bytes;
699}
700
701
702/**
703 * zfcp_qdio_sbals_from_buffer - fill SBALs from buffer
704 * @fsf_req: request to be processed
705 * @sbtype: SBALE flags
706 * @buffer: data buffer
707 * @length: length of buffer
708 * @max_sbals: upper bound for number of SBALs to be used
709 */
4d284cac 710static int
1da177e4
LT		 711zfcp_qdio_sbals_from_buffer(struct zfcp_fsf_req *fsf_req, unsigned long sbtype,
712 void *buffer, unsigned long length, int max_sbals)
713{
714 struct scatterlist sg_segment;
715
716 zfcp_address_to_sg(buffer, &sg_segment);
717 sg_segment.length = length;
718
719 return zfcp_qdio_sbals_from_sg(fsf_req, sbtype, &sg_segment, 1,
720 max_sbals);
721}
722
723
724/**
725 * zfcp_qdio_sbals_from_scsicmnd - fill SBALs from scsi command
726 * @fsf_req: request to be processed
727 * @sbtype: SBALE flags
728 * @scsi_cmnd: either scatter-gather list or buffer contained herein is used
729 * to fill SBALs
730 */
4d284cac 731int
1da177e4
LT		 732zfcp_qdio_sbals_from_scsicmnd(struct zfcp_fsf_req *fsf_req,
733 unsigned long sbtype, struct scsi_cmnd *scsi_cmnd)
734{
735 if (scsi_cmnd->use_sg) {
736 return zfcp_qdio_sbals_from_sg(fsf_req, sbtype,
737 (struct scatterlist *)
738 scsi_cmnd->request_buffer,
739 scsi_cmnd->use_sg,
740 ZFCP_MAX_SBALS_PER_REQ);
741 } else {
742 return zfcp_qdio_sbals_from_buffer(fsf_req, sbtype,
743 scsi_cmnd->request_buffer,
744 scsi_cmnd->request_bufflen,
745 ZFCP_MAX_SBALS_PER_REQ);
746 }
747}
748
749/**
750 * zfcp_qdio_determine_pci - set PCI flag in first SBALE on qdio queue if needed
751 */
752int
753zfcp_qdio_determine_pci(struct zfcp_qdio_queue *req_queue,
754 struct zfcp_fsf_req *fsf_req)
755{
756 int new_distance_from_int;
757 int pci_pos;
758 volatile struct qdio_buffer_element *sbale;
759
760 new_distance_from_int = req_queue->distance_from_int +
761 fsf_req->sbal_number;
762
763 if (unlikely(new_distance_from_int >= ZFCP_QDIO_PCI_INTERVAL)) {
764 new_distance_from_int %= ZFCP_QDIO_PCI_INTERVAL;
765 pci_pos = fsf_req->sbal_first;
766 pci_pos += fsf_req->sbal_number;
767 pci_pos -= new_distance_from_int;
768 pci_pos -= 1;
769 pci_pos %= QDIO_MAX_BUFFERS_PER_Q;
770 sbale = zfcp_qdio_sbale_req(fsf_req, pci_pos, 0);
771 sbale->flags |= SBAL_FLAGS0_PCI;
772 }
773 return new_distance_from_int;
774}
775
776/*
777 * function: zfcp_zero_sbals
778 *
779 * purpose: zeros specified range of SBALs
780 *
781 * returns:
782 */
783void
784zfcp_qdio_zero_sbals(struct qdio_buffer *buf[], int first, int clean_count)
785{
786 int cur_pos;
787 int index;
788
789 for (cur_pos = first; cur_pos < (first + clean_count); cur_pos++) {
790 index = cur_pos % QDIO_MAX_BUFFERS_PER_Q;
791 memset(buf[index], 0, sizeof (struct qdio_buffer));
792 ZFCP_LOG_TRACE("zeroing BUFFER %d at address %p\n",
793 index, buf[index]);
794 }
795}
796
797#undef ZFCP_LOG_AREA
Linux kernel - Deliverables
This page took 0.374218 seconds and 5 git commands to generate.