2 * This file is part of the zfcp device driver for
3 * FCP adapters for IBM System z9 and zSeries.
5 * (C) Copyright IBM Corp. 2002, 2006
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)
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.
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.
24 static void zfcp_qdio_sbal_limit(struct zfcp_fsf_req *, int);
25 static inline volatile struct qdio_buffer_element *zfcp_qdio_sbale_get
26 (struct zfcp_qdio_queue *, int, int);
27 static inline volatile struct qdio_buffer_element *zfcp_qdio_sbale_resp
28 (struct zfcp_fsf_req *, int, int);
29 static volatile struct qdio_buffer_element *zfcp_qdio_sbal_chain
30 (struct zfcp_fsf_req *, unsigned long);
31 static volatile struct qdio_buffer_element *zfcp_qdio_sbale_next
32 (struct zfcp_fsf_req *, unsigned long);
33 static int zfcp_qdio_sbals_zero(struct zfcp_qdio_queue *, int, int);
34 static inline int zfcp_qdio_sbals_wipe(struct zfcp_fsf_req *);
35 static void zfcp_qdio_sbale_fill
36 (struct zfcp_fsf_req *, unsigned long, void *, int);
37 static int zfcp_qdio_sbals_from_segment
38 (struct zfcp_fsf_req *, unsigned long, void *, unsigned long);
40 static qdio_handler_t zfcp_qdio_request_handler;
41 static qdio_handler_t zfcp_qdio_response_handler;
42 static int zfcp_qdio_handler_error_check(struct zfcp_adapter *,
43 unsigned int, unsigned int, unsigned int, int, int);
45 #define ZFCP_LOG_AREA ZFCP_LOG_AREA_QDIO
48 * Frees BUFFER memory for each of the pointers of the struct qdio_buffer array
49 * in the adapter struct sbuf is the pointer array.
51 * locks: must only be called with zfcp_data.config_sema taken
54 zfcp_qdio_buffers_dequeue(struct qdio_buffer **sbuf)
58 for (pos = 0; pos < QDIO_MAX_BUFFERS_PER_Q; pos += QBUFF_PER_PAGE)
59 free_page((unsigned long) sbuf[pos]);
63 * Allocates BUFFER memory to each of the pointers of the qdio_buffer_t
64 * array in the adapter struct.
65 * Cur_buf is the pointer array
67 * returns: zero on success else -ENOMEM
68 * locks: must only be called with zfcp_data.config_sema taken
71 zfcp_qdio_buffers_enqueue(struct qdio_buffer **sbuf)
75 for (pos = 0; pos < QDIO_MAX_BUFFERS_PER_Q; pos += QBUFF_PER_PAGE) {
76 sbuf[pos] = (struct qdio_buffer *) get_zeroed_page(GFP_KERNEL);
78 zfcp_qdio_buffers_dequeue(sbuf);
82 for (pos = 0; pos < QDIO_MAX_BUFFERS_PER_Q; pos++)
83 if (pos % QBUFF_PER_PAGE)
84 sbuf[pos] = sbuf[pos - 1] + 1;
88 /* locks: must only be called with zfcp_data.config_sema taken */
90 zfcp_qdio_allocate_queues(struct zfcp_adapter *adapter)
94 ret = zfcp_qdio_buffers_enqueue(adapter->request_queue.buffer);
97 return zfcp_qdio_buffers_enqueue(adapter->response_queue.buffer);
100 /* locks: must only be called with zfcp_data.config_sema taken */
102 zfcp_qdio_free_queues(struct zfcp_adapter *adapter)
104 ZFCP_LOG_TRACE("freeing request_queue buffers\n");
105 zfcp_qdio_buffers_dequeue(adapter->request_queue.buffer);
107 ZFCP_LOG_TRACE("freeing response_queue buffers\n");
108 zfcp_qdio_buffers_dequeue(adapter->response_queue.buffer);
112 zfcp_qdio_allocate(struct zfcp_adapter *adapter)
114 struct qdio_initialize *init_data;
116 init_data = &adapter->qdio_init_data;
118 init_data->cdev = adapter->ccw_device;
119 init_data->q_format = QDIO_SCSI_QFMT;
120 memcpy(init_data->adapter_name, zfcp_get_busid_by_adapter(adapter), 8);
121 ASCEBC(init_data->adapter_name, 8);
122 init_data->qib_param_field_format = 0;
123 init_data->qib_param_field = NULL;
124 init_data->input_slib_elements = NULL;
125 init_data->output_slib_elements = NULL;
126 init_data->min_input_threshold = ZFCP_MIN_INPUT_THRESHOLD;
127 init_data->max_input_threshold = ZFCP_MAX_INPUT_THRESHOLD;
128 init_data->min_output_threshold = ZFCP_MIN_OUTPUT_THRESHOLD;
129 init_data->max_output_threshold = ZFCP_MAX_OUTPUT_THRESHOLD;
130 init_data->no_input_qs = 1;
131 init_data->no_output_qs = 1;
132 init_data->input_handler = zfcp_qdio_response_handler;
133 init_data->output_handler = zfcp_qdio_request_handler;
134 init_data->int_parm = (unsigned long) adapter;
135 init_data->flags = QDIO_INBOUND_0COPY_SBALS |
136 QDIO_OUTBOUND_0COPY_SBALS | QDIO_USE_OUTBOUND_PCIS;
137 init_data->input_sbal_addr_array =
138 (void **) (adapter->response_queue.buffer);
139 init_data->output_sbal_addr_array =
140 (void **) (adapter->request_queue.buffer);
142 return qdio_allocate(init_data);
146 * function: zfcp_qdio_handler_error_check
148 * purpose: called by the response handler to determine error condition
150 * returns: error flag
154 zfcp_qdio_handler_error_check(struct zfcp_adapter *adapter, unsigned int status,
155 unsigned int qdio_error, unsigned int siga_error,
156 int first_element, int elements_processed)
160 if (unlikely(status & QDIO_STATUS_LOOK_FOR_ERROR)) {
163 ZFCP_LOG_INFO("QDIO problem occurred (status=0x%x, "
164 "qdio_error=0x%x, siga_error=0x%x)\n",
165 status, qdio_error, siga_error);
167 zfcp_hba_dbf_event_qdio(adapter, status, qdio_error, siga_error,
168 first_element, elements_processed);
170 * Restarting IO on the failed adapter from scratch.
171 * Since we have been using this adapter, it is save to assume
172 * that it is not failed but recoverable. The card seems to
173 * report link-up events by self-initiated queue shutdown.
174 * That is why we need to clear the link-down flag
175 * which is set again in case we have missed by a mile.
177 zfcp_erp_adapter_reopen(adapter,
178 ZFCP_STATUS_ADAPTER_LINK_UNPLUGGED |
179 ZFCP_STATUS_COMMON_ERP_FAILED, 140, 0);
185 * function: zfcp_qdio_request_handler
187 * purpose: is called by QDIO layer for completed SBALs in request queue
192 zfcp_qdio_request_handler(struct ccw_device *ccw_device,
194 unsigned int qdio_error,
195 unsigned int siga_error,
196 unsigned int queue_number,
198 int elements_processed,
199 unsigned long int_parm)
201 struct zfcp_adapter *adapter;
202 struct zfcp_qdio_queue *queue;
204 adapter = (struct zfcp_adapter *) int_parm;
205 queue = &adapter->request_queue;
207 ZFCP_LOG_DEBUG("adapter %s, first=%d, elements_processed=%d\n",
208 zfcp_get_busid_by_adapter(adapter),
209 first_element, elements_processed);
211 if (unlikely(zfcp_qdio_handler_error_check(adapter, status, qdio_error,
212 siga_error, first_element,
213 elements_processed)))
216 * we stored address of struct zfcp_adapter data structure
217 * associated with irq in int_parm
220 /* cleanup all SBALs being program-owned now */
221 zfcp_qdio_zero_sbals(queue->buffer, first_element, elements_processed);
223 /* increase free space in outbound queue */
224 atomic_add(elements_processed, &queue->free_count);
225 ZFCP_LOG_DEBUG("free_count=%d\n", atomic_read(&queue->free_count));
226 wake_up(&adapter->request_wq);
227 ZFCP_LOG_DEBUG("elements_processed=%d, free count=%d\n",
228 elements_processed, atomic_read(&queue->free_count));
234 * zfcp_qdio_reqid_check - checks for valid reqids.
236 static void zfcp_qdio_reqid_check(struct zfcp_adapter *adapter,
237 unsigned long req_id)
239 struct zfcp_fsf_req *fsf_req;
242 spin_lock_irqsave(&adapter->req_list_lock, flags);
243 fsf_req = zfcp_reqlist_find(adapter, req_id);
247 * Unknown request means that we have potentially memory
248 * corruption and must stop the machine immediatly.
250 panic("error: unknown request id (%ld) on adapter %s.\n",
251 req_id, zfcp_get_busid_by_adapter(adapter));
253 zfcp_reqlist_remove(adapter, fsf_req);
254 atomic_dec(&adapter->reqs_active);
255 spin_unlock_irqrestore(&adapter->req_list_lock, flags);
257 /* finish the FSF request */
258 zfcp_fsf_req_complete(fsf_req);
262 * function: zfcp_qdio_response_handler
264 * purpose: is called by QDIO layer for completed SBALs in response queue
269 zfcp_qdio_response_handler(struct ccw_device *ccw_device,
271 unsigned int qdio_error,
272 unsigned int siga_error,
273 unsigned int queue_number,
275 int elements_processed,
276 unsigned long int_parm)
278 struct zfcp_adapter *adapter;
279 struct zfcp_qdio_queue *queue;
282 struct qdio_buffer *buffer;
286 volatile struct qdio_buffer_element *buffere = NULL;
289 adapter = (struct zfcp_adapter *) int_parm;
290 queue = &adapter->response_queue;
292 if (unlikely(zfcp_qdio_handler_error_check(adapter, status, qdio_error,
293 siga_error, first_element,
294 elements_processed)))
298 * we stored address of struct zfcp_adapter data structure
299 * associated with irq in int_parm
302 buffere = &(queue->buffer[first_element]->element[0]);
303 ZFCP_LOG_DEBUG("first BUFFERE flags=0x%x\n", buffere->flags);
305 * go through all SBALs from input queue currently
306 * returned by QDIO layer
309 for (i = 0; i < elements_processed; i++) {
311 buffer_index = first_element + i;
312 buffer_index %= QDIO_MAX_BUFFERS_PER_Q;
313 buffer = queue->buffer[buffer_index];
315 /* go through all SBALEs of SBAL */
316 for (buffere_index = 0;
317 buffere_index < QDIO_MAX_ELEMENTS_PER_BUFFER;
320 /* look for QDIO request identifiers in SB */
321 buffere = &buffer->element[buffere_index];
322 zfcp_qdio_reqid_check(adapter,
323 (unsigned long) buffere->addr);
326 * A single used SBALE per inbound SBALE has been
327 * implemented by QDIO so far. Hope they will
328 * do some optimisation. Will need to change to
331 if (likely(buffere->flags & SBAL_FLAGS_LAST_ENTRY))
335 if (unlikely(!(buffere->flags & SBAL_FLAGS_LAST_ENTRY))) {
336 ZFCP_LOG_NORMAL("bug: End of inbound data "
342 * put range of SBALs back to response queue
343 * (including SBALs which have already been free before)
345 count = atomic_read(&queue->free_count) + elements_processed;
346 start = queue->free_index;
348 ZFCP_LOG_TRACE("calling do_QDIO on adapter %s (flags=0x%x, "
349 "queue_no=%i, index_in_queue=%i, count=%i, "
351 zfcp_get_busid_by_adapter(adapter),
352 QDIO_FLAG_SYNC_INPUT | QDIO_FLAG_UNDER_INTERRUPT,
353 0, start, count, (unsigned long) &queue->buffer[start]);
355 retval = do_QDIO(ccw_device,
356 QDIO_FLAG_SYNC_INPUT | QDIO_FLAG_UNDER_INTERRUPT,
357 0, start, count, NULL);
359 if (unlikely(retval)) {
360 atomic_set(&queue->free_count, count);
361 ZFCP_LOG_DEBUG("clearing of inbound data regions failed, "
362 "queues may be down "
363 "(count=%d, start=%d, retval=%d)\n",
364 count, start, retval);
366 queue->free_index += count;
367 queue->free_index %= QDIO_MAX_BUFFERS_PER_Q;
368 atomic_set(&queue->free_count, 0);
369 ZFCP_LOG_TRACE("%i buffers enqueued to response "
370 "queue at position %i\n", count, start);
377 * zfcp_qdio_sbale_get - return pointer to SBALE of qdio_queue
378 * @queue: queue from which SBALE should be returned
379 * @sbal: specifies number of SBAL in queue
380 * @sbale: specifes number of SBALE in SBAL
382 static inline volatile struct qdio_buffer_element *
383 zfcp_qdio_sbale_get(struct zfcp_qdio_queue *queue, int sbal, int sbale)
385 return &queue->buffer[sbal]->element[sbale];
389 * zfcp_qdio_sbale_req - return pointer to SBALE of request_queue for
390 * a struct zfcp_fsf_req
392 volatile struct qdio_buffer_element *
393 zfcp_qdio_sbale_req(struct zfcp_fsf_req *fsf_req, int sbal, int sbale)
395 return zfcp_qdio_sbale_get(&fsf_req->adapter->request_queue,
400 * zfcp_qdio_sbale_resp - return pointer to SBALE of response_queue for
401 * a struct zfcp_fsf_req
403 static inline volatile struct qdio_buffer_element *
404 zfcp_qdio_sbale_resp(struct zfcp_fsf_req *fsf_req, int sbal, int sbale)
406 return zfcp_qdio_sbale_get(&fsf_req->adapter->response_queue,
411 * zfcp_qdio_sbale_curr - return current SBALE on request_queue for
412 * a struct zfcp_fsf_req
414 volatile struct qdio_buffer_element *
415 zfcp_qdio_sbale_curr(struct zfcp_fsf_req *fsf_req)
417 return zfcp_qdio_sbale_req(fsf_req, fsf_req->sbal_curr,
418 fsf_req->sbale_curr);
422 * zfcp_qdio_sbal_limit - determine maximum number of SBALs that can be used
423 * on the request_queue for a struct zfcp_fsf_req
424 * @fsf_req: the number of the last SBAL that can be used is stored herein
425 * @max_sbals: used to pass an upper limit for the number of SBALs
427 * Note: We can assume at least one free SBAL in the request_queue when called.
430 zfcp_qdio_sbal_limit(struct zfcp_fsf_req *fsf_req, int max_sbals)
432 int count = atomic_read(&fsf_req->adapter->request_queue.free_count);
433 count = min(count, max_sbals);
434 fsf_req->sbal_last = fsf_req->sbal_first;
435 fsf_req->sbal_last += (count - 1);
436 fsf_req->sbal_last %= QDIO_MAX_BUFFERS_PER_Q;
440 * zfcp_qdio_sbal_chain - chain SBALs if more than one SBAL is needed for a
442 * @fsf_req: zfcp_fsf_req to be processed
443 * @sbtype: SBAL flags which have to be set in first SBALE of new SBAL
445 * This function changes sbal_curr, sbale_curr, sbal_number of fsf_req.
447 static volatile struct qdio_buffer_element *
448 zfcp_qdio_sbal_chain(struct zfcp_fsf_req *fsf_req, unsigned long sbtype)
450 volatile struct qdio_buffer_element *sbale;
452 /* set last entry flag in current SBALE of current SBAL */
453 sbale = zfcp_qdio_sbale_curr(fsf_req);
454 sbale->flags |= SBAL_FLAGS_LAST_ENTRY;
456 /* don't exceed last allowed SBAL */
457 if (fsf_req->sbal_curr == fsf_req->sbal_last)
460 /* set chaining flag in first SBALE of current SBAL */
461 sbale = zfcp_qdio_sbale_req(fsf_req, fsf_req->sbal_curr, 0);
462 sbale->flags |= SBAL_FLAGS0_MORE_SBALS;
464 /* calculate index of next SBAL */
465 fsf_req->sbal_curr++;
466 fsf_req->sbal_curr %= QDIO_MAX_BUFFERS_PER_Q;
468 /* keep this requests number of SBALs up-to-date */
469 fsf_req->sbal_number++;
471 /* start at first SBALE of new SBAL */
472 fsf_req->sbale_curr = 0;
474 /* set storage-block type for new SBAL */
475 sbale = zfcp_qdio_sbale_curr(fsf_req);
476 sbale->flags |= sbtype;
482 * zfcp_qdio_sbale_next - switch to next SBALE, chain SBALs if needed
484 static volatile struct qdio_buffer_element *
485 zfcp_qdio_sbale_next(struct zfcp_fsf_req *fsf_req, unsigned long sbtype)
487 if (fsf_req->sbale_curr == ZFCP_LAST_SBALE_PER_SBAL)
488 return zfcp_qdio_sbal_chain(fsf_req, sbtype);
490 fsf_req->sbale_curr++;
492 return zfcp_qdio_sbale_curr(fsf_req);
496 * zfcp_qdio_sbals_zero - initialize SBALs between first and last in queue
500 zfcp_qdio_sbals_zero(struct zfcp_qdio_queue *queue, int first, int last)
502 struct qdio_buffer **buf = queue->buffer;
507 curr %= QDIO_MAX_BUFFERS_PER_Q;
509 memset(buf[curr], 0, sizeof(struct qdio_buffer));
519 * zfcp_qdio_sbals_wipe - reset all changes in SBALs for an fsf_req
522 zfcp_qdio_sbals_wipe(struct zfcp_fsf_req *fsf_req)
524 return zfcp_qdio_sbals_zero(&fsf_req->adapter->request_queue,
525 fsf_req->sbal_first, fsf_req->sbal_curr);
530 * zfcp_qdio_sbale_fill - set address and length in current SBALE
534 zfcp_qdio_sbale_fill(struct zfcp_fsf_req *fsf_req, unsigned long sbtype,
535 void *addr, int length)
537 volatile struct qdio_buffer_element *sbale;
539 sbale = zfcp_qdio_sbale_curr(fsf_req);
541 sbale->length = length;
545 * zfcp_qdio_sbals_from_segment - map memory segment to SBALE(s)
546 * @fsf_req: request to be processed
547 * @sbtype: SBALE flags
548 * @start_addr: address of memory segment
549 * @total_length: length of memory segment
551 * Alignment and length of the segment determine how many SBALEs are needed
552 * for the memory segment.
555 zfcp_qdio_sbals_from_segment(struct zfcp_fsf_req *fsf_req, unsigned long sbtype,
556 void *start_addr, unsigned long total_length)
558 unsigned long remaining, length;
561 /* split segment up heeding page boundaries */
562 for (addr = start_addr, remaining = total_length; remaining > 0;
563 addr += length, remaining -= length) {
564 /* get next free SBALE for new piece */
565 if (NULL == zfcp_qdio_sbale_next(fsf_req, sbtype)) {
566 /* no SBALE left, clean up and leave */
567 zfcp_qdio_sbals_wipe(fsf_req);
570 /* calculate length of new piece */
571 length = min(remaining,
572 (PAGE_SIZE - ((unsigned long) addr &
574 /* fill current SBALE with calculated piece */
575 zfcp_qdio_sbale_fill(fsf_req, sbtype, addr, length);
582 * zfcp_qdio_sbals_from_sg - fill SBALs from scatter-gather list
583 * @fsf_req: request to be processed
584 * @sbtype: SBALE flags
585 * @sg: scatter-gather list
586 * @sg_count: number of elements in scatter-gather list
587 * @max_sbals: upper bound for number of SBALs to be used
590 zfcp_qdio_sbals_from_sg(struct zfcp_fsf_req *fsf_req, unsigned long sbtype,
591 struct scatterlist *sgl, int sg_count, int max_sbals)
594 struct scatterlist *sg_segment;
596 volatile struct qdio_buffer_element *sbale;
599 /* figure out last allowed SBAL */
600 zfcp_qdio_sbal_limit(fsf_req, max_sbals);
602 /* set storage-block type for current SBAL */
603 sbale = zfcp_qdio_sbale_req(fsf_req, fsf_req->sbal_curr, 0);
604 sbale->flags |= sbtype;
606 /* process all segements of scatter-gather list */
607 for_each_sg(sgl, sg_segment, sg_count, sg_index) {
608 retval = zfcp_qdio_sbals_from_segment(
611 zfcp_sg_to_address(sg_segment),
619 /* assume that no other SBALEs are to follow in the same SBAL */
620 sbale = zfcp_qdio_sbale_curr(fsf_req);
621 sbale->flags |= SBAL_FLAGS_LAST_ENTRY;
628 * zfcp_qdio_sbals_from_scsicmnd - fill SBALs from scsi command
629 * @fsf_req: request to be processed
630 * @sbtype: SBALE flags
631 * @scsi_cmnd: either scatter-gather list or buffer contained herein is used
635 zfcp_qdio_sbals_from_scsicmnd(struct zfcp_fsf_req *fsf_req,
636 unsigned long sbtype, struct scsi_cmnd *scsi_cmnd)
638 return zfcp_qdio_sbals_from_sg(fsf_req, sbtype, scsi_sglist(scsi_cmnd),
639 scsi_sg_count(scsi_cmnd),
640 ZFCP_MAX_SBALS_PER_REQ);
644 * zfcp_qdio_determine_pci - set PCI flag in first SBALE on qdio queue if needed
647 zfcp_qdio_determine_pci(struct zfcp_qdio_queue *req_queue,
648 struct zfcp_fsf_req *fsf_req)
650 int new_distance_from_int;
652 volatile struct qdio_buffer_element *sbale;
654 new_distance_from_int = req_queue->distance_from_int +
655 fsf_req->sbal_number;
657 if (unlikely(new_distance_from_int >= ZFCP_QDIO_PCI_INTERVAL)) {
658 new_distance_from_int %= ZFCP_QDIO_PCI_INTERVAL;
659 pci_pos = fsf_req->sbal_first;
660 pci_pos += fsf_req->sbal_number;
661 pci_pos -= new_distance_from_int;
663 pci_pos %= QDIO_MAX_BUFFERS_PER_Q;
664 sbale = zfcp_qdio_sbale_req(fsf_req, pci_pos, 0);
665 sbale->flags |= SBAL_FLAGS0_PCI;
667 return new_distance_from_int;
671 * function: zfcp_zero_sbals
673 * purpose: zeros specified range of SBALs
678 zfcp_qdio_zero_sbals(struct qdio_buffer *buf[], int first, int clean_count)
683 for (cur_pos = first; cur_pos < (first + clean_count); cur_pos++) {
684 index = cur_pos % QDIO_MAX_BUFFERS_PER_Q;
685 memset(buf[index], 0, sizeof (struct qdio_buffer));
686 ZFCP_LOG_TRACE("zeroing BUFFER %d at address %p\n",