2 * linux/drivers/s390/scsi/zfcp_qdio.c
4 * FCP adapter driver for IBM eServer zSeries
6 * QDIO related routines
8 * (C) Copyright IBM Corp. 2002, 2004
11 * Martin Peschke <mpeschke@de.ibm.com>
12 * Raimund Schroeder <raimund.schroeder@de.ibm.com>
14 * Heiko Carstens <heiko.carstens@de.ibm.com>
16 * This program is free software; you can redistribute it and/or modify
17 * it under the terms of the GNU General Public License as published by
18 * the Free Software Foundation; either version 2, or (at your option)
21 * This program is distributed in the hope that it will be useful,
22 * but WITHOUT ANY WARRANTY; without even the implied warranty of
23 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
24 * GNU General Public License for more details.
26 * You should have received a copy of the GNU General Public License
27 * along with this program; if not, write to the Free Software
28 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
31 #define ZFCP_QDIO_C_REVISION "$Revision: 1.19 $"
35 static inline void zfcp_qdio_sbal_limit(struct zfcp_fsf_req *, int);
36 static inline volatile struct qdio_buffer_element *zfcp_qdio_sbale_get
37 (struct zfcp_qdio_queue *, int, int);
38 static inline volatile struct qdio_buffer_element *zfcp_qdio_sbale_resp
39 (struct zfcp_fsf_req *, int, int);
40 static inline volatile struct qdio_buffer_element *zfcp_qdio_sbal_chain
41 (struct zfcp_fsf_req *, unsigned long);
42 static inline volatile struct qdio_buffer_element *zfcp_qdio_sbale_next
43 (struct zfcp_fsf_req *, unsigned long);
44 static inline int zfcp_qdio_sbals_zero(struct zfcp_qdio_queue *, int, int);
45 static inline int zfcp_qdio_sbals_wipe(struct zfcp_fsf_req *);
46 static inline void zfcp_qdio_sbale_fill
47 (struct zfcp_fsf_req *, unsigned long, void *, int);
48 static inline int zfcp_qdio_sbals_from_segment
49 (struct zfcp_fsf_req *, unsigned long, void *, unsigned long);
50 static inline int zfcp_qdio_sbals_from_buffer
51 (struct zfcp_fsf_req *, unsigned long, void *, unsigned long, int);
53 static qdio_handler_t zfcp_qdio_request_handler;
54 static qdio_handler_t zfcp_qdio_response_handler;
55 static int zfcp_qdio_handler_error_check(struct zfcp_adapter *,
57 unsigned int, unsigned int);
59 #define ZFCP_LOG_AREA ZFCP_LOG_AREA_QDIO
62 * Allocates BUFFER memory to each of the pointers of the qdio_buffer_t
63 * array in the adapter struct.
64 * Cur_buf is the pointer array and count can be any number of required
65 * buffers, the page-fitting arithmetic is done entirely within this funciton.
67 * returns: number of buffers allocated
68 * locks: must only be called with zfcp_data.config_sema taken
71 zfcp_qdio_buffers_enqueue(struct qdio_buffer **cur_buf, int count)
74 int qdio_buffers_per_page;
76 struct qdio_buffer *first_in_page = NULL;
78 qdio_buffers_per_page = PAGE_SIZE / sizeof (struct qdio_buffer);
79 ZFCP_LOG_TRACE("buffers_per_page=%d\n", qdio_buffers_per_page);
81 for (buf_pos = 0; buf_pos < count; buf_pos++) {
83 cur_buf[buf_pos] = (struct qdio_buffer *)
84 get_zeroed_page(GFP_KERNEL);
85 if (cur_buf[buf_pos] == NULL) {
86 ZFCP_LOG_INFO("error: allocation of "
87 "QDIO buffer failed \n");
90 first_in_page = cur_buf[buf_pos];
92 cur_buf[buf_pos] = first_in_page + page_pos;
95 /* was initialised to zero */
97 page_pos %= qdio_buffers_per_page;
104 * Frees BUFFER memory for each of the pointers of the struct qdio_buffer array
105 * in the adapter struct cur_buf is the pointer array and count can be any
106 * number of buffers in the array that should be freed starting from buffer 0
108 * locks: must only be called with zfcp_data.config_sema taken
111 zfcp_qdio_buffers_dequeue(struct qdio_buffer **cur_buf, int count)
114 int qdio_buffers_per_page;
116 qdio_buffers_per_page = PAGE_SIZE / sizeof (struct qdio_buffer);
117 ZFCP_LOG_TRACE("buffers_per_page=%d\n", qdio_buffers_per_page);
119 for (buf_pos = 0; buf_pos < count; buf_pos += qdio_buffers_per_page)
120 free_page((unsigned long) cur_buf[buf_pos]);
124 /* locks: must only be called with zfcp_data.config_sema taken */
126 zfcp_qdio_allocate_queues(struct zfcp_adapter *adapter)
132 zfcp_qdio_buffers_enqueue(&(adapter->request_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 request "
136 "queue\n", buffer_count);
137 zfcp_qdio_buffers_dequeue(&(adapter->request_queue.buffer[0]),
144 zfcp_qdio_buffers_enqueue(&(adapter->response_queue.buffer[0]),
145 QDIO_MAX_BUFFERS_PER_Q);
146 if (buffer_count < QDIO_MAX_BUFFERS_PER_Q) {
147 ZFCP_LOG_DEBUG("only %d QDIO buffers allocated for response "
148 "queue", buffer_count);
149 zfcp_qdio_buffers_dequeue(&(adapter->response_queue.buffer[0]),
151 ZFCP_LOG_TRACE("freeing request_queue buffers\n");
152 zfcp_qdio_buffers_dequeue(&(adapter->request_queue.buffer[0]),
153 QDIO_MAX_BUFFERS_PER_Q);
161 /* locks: must only be called with zfcp_data.config_sema taken */
163 zfcp_qdio_free_queues(struct zfcp_adapter *adapter)
165 ZFCP_LOG_TRACE("freeing request_queue buffers\n");
166 zfcp_qdio_buffers_dequeue(&(adapter->request_queue.buffer[0]),
167 QDIO_MAX_BUFFERS_PER_Q);
169 ZFCP_LOG_TRACE("freeing response_queue buffers\n");
170 zfcp_qdio_buffers_dequeue(&(adapter->response_queue.buffer[0]),
171 QDIO_MAX_BUFFERS_PER_Q);
175 zfcp_qdio_allocate(struct zfcp_adapter *adapter)
177 struct qdio_initialize *init_data;
179 init_data = &adapter->qdio_init_data;
181 init_data->cdev = adapter->ccw_device;
182 init_data->q_format = QDIO_SCSI_QFMT;
183 memcpy(init_data->adapter_name, &adapter->name, 8);
184 init_data->qib_param_field_format = 0;
185 init_data->qib_param_field = NULL;
186 init_data->input_slib_elements = NULL;
187 init_data->output_slib_elements = NULL;
188 init_data->min_input_threshold = ZFCP_MIN_INPUT_THRESHOLD;
189 init_data->max_input_threshold = ZFCP_MAX_INPUT_THRESHOLD;
190 init_data->min_output_threshold = ZFCP_MIN_OUTPUT_THRESHOLD;
191 init_data->max_output_threshold = ZFCP_MAX_OUTPUT_THRESHOLD;
192 init_data->no_input_qs = 1;
193 init_data->no_output_qs = 1;
194 init_data->input_handler = zfcp_qdio_response_handler;
195 init_data->output_handler = zfcp_qdio_request_handler;
196 init_data->int_parm = (unsigned long) adapter;
197 init_data->flags = QDIO_INBOUND_0COPY_SBALS |
198 QDIO_OUTBOUND_0COPY_SBALS | QDIO_USE_OUTBOUND_PCIS;
199 init_data->input_sbal_addr_array =
200 (void **) (adapter->response_queue.buffer);
201 init_data->output_sbal_addr_array =
202 (void **) (adapter->request_queue.buffer);
204 return qdio_allocate(init_data);
208 * function: zfcp_qdio_handler_error_check
210 * purpose: called by the response handler to determine error condition
212 * returns: error flag
216 zfcp_qdio_handler_error_check(struct zfcp_adapter *adapter,
218 unsigned int qdio_error, unsigned int siga_error)
222 if (ZFCP_LOG_CHECK(ZFCP_LOG_LEVEL_TRACE)) {
223 if (status & QDIO_STATUS_INBOUND_INT) {
224 ZFCP_LOG_TRACE("status is"
225 " QDIO_STATUS_INBOUND_INT \n");
227 if (status & QDIO_STATUS_OUTBOUND_INT) {
228 ZFCP_LOG_TRACE("status is"
229 " QDIO_STATUS_OUTBOUND_INT \n");
231 } // if (ZFCP_LOG_CHECK(ZFCP_LOG_LEVEL_TRACE))
232 if (unlikely(status & QDIO_STATUS_LOOK_FOR_ERROR)) {
235 ZFCP_LOG_FLAGS(1, "QDIO_STATUS_LOOK_FOR_ERROR \n");
237 ZFCP_LOG_INFO("QDIO problem occurred (status=0x%x, "
238 "qdio_error=0x%x, siga_error=0x%x)\n",
239 status, qdio_error, siga_error);
241 if (status & QDIO_STATUS_ACTIVATE_CHECK_CONDITION) {
243 "QDIO_STATUS_ACTIVATE_CHECK_CONDITION\n");
245 if (status & QDIO_STATUS_MORE_THAN_ONE_QDIO_ERROR) {
247 "QDIO_STATUS_MORE_THAN_ONE_QDIO_ERROR\n");
249 if (status & QDIO_STATUS_MORE_THAN_ONE_SIGA_ERROR) {
251 "QDIO_STATUS_MORE_THAN_ONE_SIGA_ERROR\n");
254 if (siga_error & QDIO_SIGA_ERROR_ACCESS_EXCEPTION) {
255 ZFCP_LOG_FLAGS(2, "QDIO_SIGA_ERROR_ACCESS_EXCEPTION\n");
258 if (siga_error & QDIO_SIGA_ERROR_B_BIT_SET) {
259 ZFCP_LOG_FLAGS(2, "QDIO_SIGA_ERROR_B_BIT_SET\n");
262 switch (qdio_error) {
264 ZFCP_LOG_FLAGS(3, "QDIO_OK");
266 case SLSB_P_INPUT_ERROR:
267 ZFCP_LOG_FLAGS(1, "SLSB_P_INPUT_ERROR\n");
269 case SLSB_P_OUTPUT_ERROR:
270 ZFCP_LOG_FLAGS(1, "SLSB_P_OUTPUT_ERROR\n");
273 ZFCP_LOG_NORMAL("bug: unknown QDIO error 0x%x\n",
277 /* Restarting IO on the failed adapter from scratch */
278 debug_text_event(adapter->erp_dbf, 1, "qdio_err");
280 * Since we have been using this adapter, it is save to assume
281 * that it is not failed but recoverable. The card seems to
282 * report link-up events by self-initiated queue shutdown.
283 * That is why we need to clear the the link-down flag
284 * which is set again in case we have missed by a mile.
286 zfcp_erp_adapter_reopen(
288 ZFCP_STATUS_ADAPTER_LINK_UNPLUGGED |
289 ZFCP_STATUS_COMMON_ERP_FAILED);
295 * function: zfcp_qdio_request_handler
297 * purpose: is called by QDIO layer for completed SBALs in request queue
302 zfcp_qdio_request_handler(struct ccw_device *ccw_device,
304 unsigned int qdio_error,
305 unsigned int siga_error,
306 unsigned int queue_number,
308 int elements_processed,
309 unsigned long int_parm)
311 struct zfcp_adapter *adapter;
312 struct zfcp_qdio_queue *queue;
314 adapter = (struct zfcp_adapter *) int_parm;
315 queue = &adapter->request_queue;
317 ZFCP_LOG_DEBUG("adapter %s, first=%d, elements_processed=%d\n",
318 zfcp_get_busid_by_adapter(adapter),
319 first_element, elements_processed);
321 if (unlikely(zfcp_qdio_handler_error_check(adapter, status, qdio_error,
325 * we stored address of struct zfcp_adapter data structure
326 * associated with irq in int_parm
329 /* cleanup all SBALs being program-owned now */
330 zfcp_qdio_zero_sbals(queue->buffer, first_element, elements_processed);
332 /* increase free space in outbound queue */
333 atomic_add(elements_processed, &queue->free_count);
334 ZFCP_LOG_DEBUG("free_count=%d\n", atomic_read(&queue->free_count));
335 wake_up(&adapter->request_wq);
336 ZFCP_LOG_DEBUG("elements_processed=%d, free count=%d\n",
337 elements_processed, atomic_read(&queue->free_count));
343 * function: zfcp_qdio_response_handler
345 * purpose: is called by QDIO layer for completed SBALs in response queue
350 zfcp_qdio_response_handler(struct ccw_device *ccw_device,
352 unsigned int qdio_error,
353 unsigned int siga_error,
354 unsigned int queue_number,
356 int elements_processed,
357 unsigned long int_parm)
359 struct zfcp_adapter *adapter;
360 struct zfcp_qdio_queue *queue;
363 struct qdio_buffer *buffer;
367 volatile struct qdio_buffer_element *buffere = NULL;
370 adapter = (struct zfcp_adapter *) int_parm;
371 queue = &adapter->response_queue;
373 if (unlikely(zfcp_qdio_handler_error_check(adapter, status, qdio_error,
378 * we stored address of struct zfcp_adapter data structure
379 * associated with irq in int_parm
382 buffere = &(queue->buffer[first_element]->element[0]);
383 ZFCP_LOG_DEBUG("first BUFFERE flags=0x%x\n", buffere->flags);
385 * go through all SBALs from input queue currently
386 * returned by QDIO layer
389 for (i = 0; i < elements_processed; i++) {
391 buffer_index = first_element + i;
392 buffer_index %= QDIO_MAX_BUFFERS_PER_Q;
393 buffer = queue->buffer[buffer_index];
395 /* go through all SBALEs of SBAL */
396 for (buffere_index = 0;
397 buffere_index < QDIO_MAX_ELEMENTS_PER_BUFFER;
400 /* look for QDIO request identifiers in SB */
401 buffere = &buffer->element[buffere_index];
402 retval = zfcp_qdio_reqid_check(adapter,
403 (void *) buffere->addr);
406 ZFCP_LOG_NORMAL("bug: unexpected inbound "
407 "packet on adapter %s "
410 "elements_processed=%d)\n",
411 zfcp_get_busid_by_adapter(adapter),
412 (unsigned long) buffere->addr,
415 ZFCP_LOG_NORMAL("hex dump of inbound buffer "
418 "buffere_index=%d)\n", buffer,
419 buffer_index, buffere_index);
420 ZFCP_HEX_DUMP(ZFCP_LOG_LEVEL_NORMAL,
421 (char *) buffer, SBAL_SIZE);
424 * A single used SBALE per inbound SBALE has been
425 * implemented by QDIO so far. Hope they will
426 * do some optimisation. Will need to change to
429 if (likely(buffere->flags & SBAL_FLAGS_LAST_ENTRY))
433 if (unlikely(!(buffere->flags & SBAL_FLAGS_LAST_ENTRY))) {
434 ZFCP_LOG_NORMAL("bug: End of inbound data "
440 * put range of SBALs back to response queue
441 * (including SBALs which have already been free before)
443 count = atomic_read(&queue->free_count) + elements_processed;
444 start = queue->free_index;
446 ZFCP_LOG_TRACE("calling do_QDIO on adapter %s (flags=0x%x, "
447 "queue_no=%i, index_in_queue=%i, count=%i, "
449 zfcp_get_busid_by_adapter(adapter),
450 QDIO_FLAG_SYNC_INPUT | QDIO_FLAG_UNDER_INTERRUPT,
451 0, start, count, (unsigned long) &queue->buffer[start]);
453 retval = do_QDIO(ccw_device,
454 QDIO_FLAG_SYNC_INPUT | QDIO_FLAG_UNDER_INTERRUPT,
455 0, start, count, NULL);
457 if (unlikely(retval)) {
458 atomic_set(&queue->free_count, count);
459 ZFCP_LOG_DEBUG("clearing of inbound data regions failed, "
460 "queues may be down "
461 "(count=%d, start=%d, retval=%d)\n",
462 count, start, retval);
464 queue->free_index += count;
465 queue->free_index %= QDIO_MAX_BUFFERS_PER_Q;
466 atomic_set(&queue->free_count, 0);
467 ZFCP_LOG_TRACE("%i buffers enqueued to response "
468 "queue at position %i\n", count, start);
475 * function: zfcp_qdio_reqid_check
477 * purpose: checks for valid reqids or unsolicited status
479 * returns: 0 - valid request id or unsolicited status
483 zfcp_qdio_reqid_check(struct zfcp_adapter *adapter, void *sbale_addr)
485 struct zfcp_fsf_req *fsf_req;
488 /* invalid (per convention used in this driver) */
489 if (unlikely(!sbale_addr)) {
490 ZFCP_LOG_NORMAL("bug: invalid reqid\n");
495 /* valid request id and thus (hopefully :) valid fsf_req address */
496 fsf_req = (struct zfcp_fsf_req *) sbale_addr;
498 if (unlikely(adapter != fsf_req->adapter)) {
499 ZFCP_LOG_NORMAL("bug: invalid reqid (fsf_req=%p, "
500 "fsf_req->adapter=%p, adapter=%p)\n",
501 fsf_req, fsf_req->adapter, adapter);
506 ZFCP_LOG_TRACE("fsf_req at %p, QTCB at %p\n", fsf_req, fsf_req->qtcb);
507 if (likely(fsf_req->qtcb)) {
508 ZFCP_LOG_TRACE("hex dump of QTCB:\n");
509 ZFCP_HEX_DUMP(ZFCP_LOG_LEVEL_TRACE, (char *) fsf_req->qtcb,
510 sizeof(struct fsf_qtcb));
513 /* finish the FSF request */
514 zfcp_fsf_req_complete(fsf_req);
520 * zfcp_qdio_sbale_get - return pointer to SBALE of qdio_queue
521 * @queue: queue from which SBALE should be returned
522 * @sbal: specifies number of SBAL in queue
523 * @sbale: specifes number of SBALE in SBAL
525 static inline volatile struct qdio_buffer_element *
526 zfcp_qdio_sbale_get(struct zfcp_qdio_queue *queue, int sbal, int sbale)
528 return &queue->buffer[sbal]->element[sbale];
532 * zfcp_qdio_sbale_req - return pointer to SBALE of request_queue for
533 * a struct zfcp_fsf_req
535 inline volatile struct qdio_buffer_element *
536 zfcp_qdio_sbale_req(struct zfcp_fsf_req *fsf_req, int sbal, int sbale)
538 return zfcp_qdio_sbale_get(&fsf_req->adapter->request_queue,
543 * zfcp_qdio_sbale_resp - return pointer to SBALE of response_queue for
544 * a struct zfcp_fsf_req
546 static inline volatile struct qdio_buffer_element *
547 zfcp_qdio_sbale_resp(struct zfcp_fsf_req *fsf_req, int sbal, int sbale)
549 return zfcp_qdio_sbale_get(&fsf_req->adapter->response_queue,
554 * zfcp_qdio_sbale_curr - return current SBALE on request_queue for
555 * a struct zfcp_fsf_req
557 inline volatile struct qdio_buffer_element *
558 zfcp_qdio_sbale_curr(struct zfcp_fsf_req *fsf_req)
560 return zfcp_qdio_sbale_req(fsf_req, fsf_req->sbal_curr,
561 fsf_req->sbale_curr);
565 * zfcp_qdio_sbal_limit - determine maximum number of SBALs that can be used
566 * on the request_queue for a struct zfcp_fsf_req
567 * @fsf_req: the number of the last SBAL that can be used is stored herein
568 * @max_sbals: used to pass an upper limit for the number of SBALs
570 * Note: We can assume at least one free SBAL in the request_queue when called.
573 zfcp_qdio_sbal_limit(struct zfcp_fsf_req *fsf_req, int max_sbals)
575 int count = atomic_read(&fsf_req->adapter->request_queue.free_count);
576 count = min(count, max_sbals);
577 fsf_req->sbal_last = fsf_req->sbal_first;
578 fsf_req->sbal_last += (count - 1);
579 fsf_req->sbal_last %= QDIO_MAX_BUFFERS_PER_Q;
583 * zfcp_qdio_sbal_chain - chain SBALs if more than one SBAL is needed for a
585 * @fsf_req: zfcp_fsf_req to be processed
586 * @sbtype: SBAL flags which have to be set in first SBALE of new SBAL
588 * This function changes sbal_curr, sbale_curr, sbal_number of fsf_req.
590 static inline volatile struct qdio_buffer_element *
591 zfcp_qdio_sbal_chain(struct zfcp_fsf_req *fsf_req, unsigned long sbtype)
593 volatile struct qdio_buffer_element *sbale;
595 /* set last entry flag in current SBALE of current SBAL */
596 sbale = zfcp_qdio_sbale_curr(fsf_req);
597 sbale->flags |= SBAL_FLAGS_LAST_ENTRY;
599 /* don't exceed last allowed SBAL */
600 if (fsf_req->sbal_curr == fsf_req->sbal_last)
603 /* set chaining flag in first SBALE of current SBAL */
604 sbale = zfcp_qdio_sbale_req(fsf_req, fsf_req->sbal_curr, 0);
605 sbale->flags |= SBAL_FLAGS0_MORE_SBALS;
607 /* calculate index of next SBAL */
608 fsf_req->sbal_curr++;
609 fsf_req->sbal_curr %= QDIO_MAX_BUFFERS_PER_Q;
611 /* keep this requests number of SBALs up-to-date */
612 fsf_req->sbal_number++;
614 /* start at first SBALE of new SBAL */
615 fsf_req->sbale_curr = 0;
617 /* set storage-block type for new SBAL */
618 sbale = zfcp_qdio_sbale_curr(fsf_req);
619 sbale->flags |= sbtype;
625 * zfcp_qdio_sbale_next - switch to next SBALE, chain SBALs if needed
627 static inline volatile struct qdio_buffer_element *
628 zfcp_qdio_sbale_next(struct zfcp_fsf_req *fsf_req, unsigned long sbtype)
630 if (fsf_req->sbale_curr == ZFCP_LAST_SBALE_PER_SBAL)
631 return zfcp_qdio_sbal_chain(fsf_req, sbtype);
633 fsf_req->sbale_curr++;
635 return zfcp_qdio_sbale_curr(fsf_req);
639 * zfcp_qdio_sbals_zero - initialize SBALs between first and last in queue
643 zfcp_qdio_sbals_zero(struct zfcp_qdio_queue *queue, int first, int last)
645 struct qdio_buffer **buf = queue->buffer;
650 curr %= QDIO_MAX_BUFFERS_PER_Q;
652 memset(buf[curr], 0, sizeof(struct qdio_buffer));
662 * zfcp_qdio_sbals_wipe - reset all changes in SBALs for an fsf_req
665 zfcp_qdio_sbals_wipe(struct zfcp_fsf_req *fsf_req)
667 return zfcp_qdio_sbals_zero(&fsf_req->adapter->request_queue,
668 fsf_req->sbal_first, fsf_req->sbal_curr);
673 * zfcp_qdio_sbale_fill - set address and lenght in current SBALE
677 zfcp_qdio_sbale_fill(struct zfcp_fsf_req *fsf_req, unsigned long sbtype,
678 void *addr, int length)
680 volatile struct qdio_buffer_element *sbale;
682 sbale = zfcp_qdio_sbale_curr(fsf_req);
684 sbale->length = length;
688 * zfcp_qdio_sbals_from_segment - map memory segment to SBALE(s)
689 * @fsf_req: request to be processed
690 * @sbtype: SBALE flags
691 * @start_addr: address of memory segment
692 * @total_length: length of memory segment
694 * Alignment and length of the segment determine how many SBALEs are needed
695 * for the memory segment.
698 zfcp_qdio_sbals_from_segment(struct zfcp_fsf_req *fsf_req, unsigned long sbtype,
699 void *start_addr, unsigned long total_length)
701 unsigned long remaining, length;
704 /* split segment up heeding page boundaries */
705 for (addr = start_addr, remaining = total_length; remaining > 0;
706 addr += length, remaining -= length) {
707 /* get next free SBALE for new piece */
708 if (NULL == zfcp_qdio_sbale_next(fsf_req, sbtype)) {
709 /* no SBALE left, clean up and leave */
710 zfcp_qdio_sbals_wipe(fsf_req);
713 /* calculate length of new piece */
714 length = min(remaining,
715 (PAGE_SIZE - ((unsigned long) addr &
717 /* fill current SBALE with calculated piece */
718 zfcp_qdio_sbale_fill(fsf_req, sbtype, addr, length);
725 * zfcp_qdio_sbals_from_sg - fill SBALs from scatter-gather list
726 * @fsf_req: request to be processed
727 * @sbtype: SBALE flags
728 * @sg: scatter-gather list
729 * @sg_count: number of elements in scatter-gather list
730 * @max_sbals: upper bound for number of SBALs to be used
733 zfcp_qdio_sbals_from_sg(struct zfcp_fsf_req *fsf_req, unsigned long sbtype,
734 struct scatterlist *sg, int sg_count, int max_sbals)
737 struct scatterlist *sg_segment;
739 volatile struct qdio_buffer_element *sbale;
742 /* figure out last allowed SBAL */
743 zfcp_qdio_sbal_limit(fsf_req, max_sbals);
745 /* set storage-block type for current SBAL */
746 sbale = zfcp_qdio_sbale_req(fsf_req, fsf_req->sbal_curr, 0);
747 sbale->flags |= sbtype;
749 /* process all segements of scatter-gather list */
750 for (sg_index = 0, sg_segment = sg, bytes = 0;
752 sg_index++, sg_segment++) {
753 retval = zfcp_qdio_sbals_from_segment(
756 zfcp_sg_to_address(sg_segment),
764 /* assume that no other SBALEs are to follow in the same SBAL */
765 sbale = zfcp_qdio_sbale_curr(fsf_req);
766 sbale->flags |= SBAL_FLAGS_LAST_ENTRY;
773 * zfcp_qdio_sbals_from_buffer - fill SBALs from buffer
774 * @fsf_req: request to be processed
775 * @sbtype: SBALE flags
776 * @buffer: data buffer
777 * @length: length of buffer
778 * @max_sbals: upper bound for number of SBALs to be used
781 zfcp_qdio_sbals_from_buffer(struct zfcp_fsf_req *fsf_req, unsigned long sbtype,
782 void *buffer, unsigned long length, int max_sbals)
784 struct scatterlist sg_segment;
786 zfcp_address_to_sg(buffer, &sg_segment);
787 sg_segment.length = length;
789 return zfcp_qdio_sbals_from_sg(fsf_req, sbtype, &sg_segment, 1,
795 * zfcp_qdio_sbals_from_scsicmnd - fill SBALs from scsi command
796 * @fsf_req: request to be processed
797 * @sbtype: SBALE flags
798 * @scsi_cmnd: either scatter-gather list or buffer contained herein is used
802 zfcp_qdio_sbals_from_scsicmnd(struct zfcp_fsf_req *fsf_req,
803 unsigned long sbtype, struct scsi_cmnd *scsi_cmnd)
805 if (scsi_cmnd->use_sg) {
806 return zfcp_qdio_sbals_from_sg(fsf_req, sbtype,
807 (struct scatterlist *)
808 scsi_cmnd->request_buffer,
810 ZFCP_MAX_SBALS_PER_REQ);
812 return zfcp_qdio_sbals_from_buffer(fsf_req, sbtype,
813 scsi_cmnd->request_buffer,
814 scsi_cmnd->request_bufflen,
815 ZFCP_MAX_SBALS_PER_REQ);
820 * zfcp_qdio_determine_pci - set PCI flag in first SBALE on qdio queue if needed
823 zfcp_qdio_determine_pci(struct zfcp_qdio_queue *req_queue,
824 struct zfcp_fsf_req *fsf_req)
826 int new_distance_from_int;
828 volatile struct qdio_buffer_element *sbale;
830 new_distance_from_int = req_queue->distance_from_int +
831 fsf_req->sbal_number;
833 if (unlikely(new_distance_from_int >= ZFCP_QDIO_PCI_INTERVAL)) {
834 new_distance_from_int %= ZFCP_QDIO_PCI_INTERVAL;
835 pci_pos = fsf_req->sbal_first;
836 pci_pos += fsf_req->sbal_number;
837 pci_pos -= new_distance_from_int;
839 pci_pos %= QDIO_MAX_BUFFERS_PER_Q;
840 sbale = zfcp_qdio_sbale_req(fsf_req, pci_pos, 0);
841 sbale->flags |= SBAL_FLAGS0_PCI;
843 return new_distance_from_int;
847 * function: zfcp_zero_sbals
849 * purpose: zeros specified range of SBALs
854 zfcp_qdio_zero_sbals(struct qdio_buffer *buf[], int first, int clean_count)
859 for (cur_pos = first; cur_pos < (first + clean_count); cur_pos++) {
860 index = cur_pos % QDIO_MAX_BUFFERS_PER_Q;
861 memset(buf[index], 0, sizeof (struct qdio_buffer));
862 ZFCP_LOG_TRACE("zeroing BUFFER %d at address %p\n",