1 /* 2 * This file is part of the zfcp device driver for 3 * FCP adapters for IBM System z9 and zSeries. 4 * 5 * (C) Copyright IBM Corp. 2002, 2006 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 22 #include "zfcp_ext.h" 23 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); 39 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); 44 45 #define ZFCP_LOG_AREA ZFCP_LOG_AREA_QDIO 46 47 /* 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. 50 * 51 * locks: must only be called with zfcp_data.config_sema taken 52 */ 53 static void 54 zfcp_qdio_buffers_dequeue(struct qdio_buffer **sbuf) 55 { 56 int pos; 57 58 for (pos = 0; pos < QDIO_MAX_BUFFERS_PER_Q; pos += QBUFF_PER_PAGE) 59 free_page((unsigned long) sbuf[pos]); 60 } 61 62 /* 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 66 * 67 * returns: zero on success else -ENOMEM 68 * locks: must only be called with zfcp_data.config_sema taken 69 */ 70 static int 71 zfcp_qdio_buffers_enqueue(struct qdio_buffer **sbuf) 72 { 73 int pos; 74 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); 77 if (!sbuf[pos]) { 78 zfcp_qdio_buffers_dequeue(sbuf); 79 return -ENOMEM; 80 } 81 } 82 for (pos = 0; pos < QDIO_MAX_BUFFERS_PER_Q; pos++) 83 if (pos % QBUFF_PER_PAGE) 84 sbuf[pos] = sbuf[pos - 1] + 1; 85 return 0; 86 } 87 88 /* locks: must only be called with zfcp_data.config_sema taken */ 89 int 90 zfcp_qdio_allocate_queues(struct zfcp_adapter *adapter) 91 { 92 int ret; 93 94 ret = zfcp_qdio_buffers_enqueue(adapter->request_queue.buffer); 95 if (ret) 96 return ret; 97 return zfcp_qdio_buffers_enqueue(adapter->response_queue.buffer); 98 } 99 100 /* locks: must only be called with zfcp_data.config_sema taken */ 101 void 102 zfcp_qdio_free_queues(struct zfcp_adapter *adapter) 103 { 104 ZFCP_LOG_TRACE("freeing request_queue buffers\n"); 105 zfcp_qdio_buffers_dequeue(adapter->request_queue.buffer); 106 107 ZFCP_LOG_TRACE("freeing response_queue buffers\n"); 108 zfcp_qdio_buffers_dequeue(adapter->response_queue.buffer); 109 } 110 111 int 112 zfcp_qdio_allocate(struct zfcp_adapter *adapter) 113 { 114 struct qdio_initialize *init_data; 115 116 init_data = &adapter->qdio_init_data; 117 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); 141 142 return qdio_allocate(init_data); 143 } 144 145 /* 146 * function: zfcp_qdio_handler_error_check 147 * 148 * purpose: called by the response handler to determine error condition 149 * 150 * returns: error flag 151 * 152 */ 153 static int 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) 157 { 158 int retval = 0; 159 160 if (unlikely(status & QDIO_STATUS_LOOK_FOR_ERROR)) { 161 retval = -EIO; 162 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); 166 167 zfcp_hba_dbf_event_qdio(adapter, status, qdio_error, siga_error, 168 first_element, elements_processed); 169 /* 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. 176 */ 177 zfcp_erp_adapter_reopen(adapter, 178 ZFCP_STATUS_ADAPTER_LINK_UNPLUGGED | 179 ZFCP_STATUS_COMMON_ERP_FAILED, 140, 180 NULL); 181 } 182 return retval; 183 } 184 185 /* 186 * function: zfcp_qdio_request_handler 187 * 188 * purpose: is called by QDIO layer for completed SBALs in request queue 189 * 190 * returns: (void) 191 */ 192 static void 193 zfcp_qdio_request_handler(struct ccw_device *ccw_device, 194 unsigned int status, 195 unsigned int qdio_error, 196 unsigned int siga_error, 197 unsigned int queue_number, 198 int first_element, 199 int elements_processed, 200 unsigned long int_parm) 201 { 202 struct zfcp_adapter *adapter; 203 struct zfcp_qdio_queue *queue; 204 205 adapter = (struct zfcp_adapter *) int_parm; 206 queue = &adapter->request_queue; 207 208 ZFCP_LOG_DEBUG("adapter %s, first=%d, elements_processed=%d\n", 209 zfcp_get_busid_by_adapter(adapter), 210 first_element, elements_processed); 211 212 if (unlikely(zfcp_qdio_handler_error_check(adapter, status, qdio_error, 213 siga_error, first_element, 214 elements_processed))) 215 goto out; 216 /* 217 * we stored address of struct zfcp_adapter data structure 218 * associated with irq in int_parm 219 */ 220 221 /* cleanup all SBALs being program-owned now */ 222 zfcp_qdio_zero_sbals(queue->buffer, first_element, elements_processed); 223 224 /* increase free space in outbound queue */ 225 atomic_add(elements_processed, &queue->free_count); 226 ZFCP_LOG_DEBUG("free_count=%d\n", atomic_read(&queue->free_count)); 227 wake_up(&adapter->request_wq); 228 ZFCP_LOG_DEBUG("elements_processed=%d, free count=%d\n", 229 elements_processed, atomic_read(&queue->free_count)); 230 out: 231 return; 232 } 233 234 /** 235 * zfcp_qdio_reqid_check - checks for valid reqids. 236 */ 237 static void zfcp_qdio_reqid_check(struct zfcp_adapter *adapter, 238 unsigned long req_id) 239 { 240 struct zfcp_fsf_req *fsf_req; 241 unsigned long flags; 242 243 spin_lock_irqsave(&adapter->req_list_lock, flags); 244 fsf_req = zfcp_reqlist_find(adapter, req_id); 245 246 if (!fsf_req) 247 /* 248 * Unknown request means that we have potentially memory 249 * corruption and must stop the machine immediatly. 250 */ 251 panic("error: unknown request id (%ld) on adapter %s.\n", 252 req_id, zfcp_get_busid_by_adapter(adapter)); 253 254 zfcp_reqlist_remove(adapter, fsf_req); 255 atomic_dec(&adapter->reqs_active); 256 spin_unlock_irqrestore(&adapter->req_list_lock, flags); 257 258 /* finish the FSF request */ 259 zfcp_fsf_req_complete(fsf_req); 260 } 261 262 /* 263 * function: zfcp_qdio_response_handler 264 * 265 * purpose: is called by QDIO layer for completed SBALs in response queue 266 * 267 * returns: (void) 268 */ 269 static void 270 zfcp_qdio_response_handler(struct ccw_device *ccw_device, 271 unsigned int status, 272 unsigned int qdio_error, 273 unsigned int siga_error, 274 unsigned int queue_number, 275 int first_element, 276 int elements_processed, 277 unsigned long int_parm) 278 { 279 struct zfcp_adapter *adapter; 280 struct zfcp_qdio_queue *queue; 281 int buffer_index; 282 int i; 283 struct qdio_buffer *buffer; 284 int retval = 0; 285 u8 count; 286 u8 start; 287 volatile struct qdio_buffer_element *buffere = NULL; 288 int buffere_index; 289 290 adapter = (struct zfcp_adapter *) int_parm; 291 queue = &adapter->response_queue; 292 293 if (unlikely(zfcp_qdio_handler_error_check(adapter, status, qdio_error, 294 siga_error, first_element, 295 elements_processed))) 296 goto out; 297 298 /* 299 * we stored address of struct zfcp_adapter data structure 300 * associated with irq in int_parm 301 */ 302 303 buffere = &(queue->buffer[first_element]->element[0]); 304 ZFCP_LOG_DEBUG("first BUFFERE flags=0x%x\n", buffere->flags); 305 /* 306 * go through all SBALs from input queue currently 307 * returned by QDIO layer 308 */ 309 310 for (i = 0; i < elements_processed; i++) { 311 312 buffer_index = first_element + i; 313 buffer_index %= QDIO_MAX_BUFFERS_PER_Q; 314 buffer = queue->buffer[buffer_index]; 315 316 /* go through all SBALEs of SBAL */ 317 for (buffere_index = 0; 318 buffere_index < QDIO_MAX_ELEMENTS_PER_BUFFER; 319 buffere_index++) { 320 321 /* look for QDIO request identifiers in SB */ 322 buffere = &buffer->element[buffere_index]; 323 zfcp_qdio_reqid_check(adapter, 324 (unsigned long) buffere->addr); 325 326 /* 327 * A single used SBALE per inbound SBALE has been 328 * implemented by QDIO so far. Hope they will 329 * do some optimisation. Will need to change to 330 * unlikely() then. 331 */ 332 if (likely(buffere->flags & SBAL_FLAGS_LAST_ENTRY)) 333 break; 334 }; 335 336 if (unlikely(!(buffere->flags & SBAL_FLAGS_LAST_ENTRY))) { 337 ZFCP_LOG_NORMAL("bug: End of inbound data " 338 "not marked!\n"); 339 } 340 } 341 342 /* 343 * put range of SBALs back to response queue 344 * (including SBALs which have already been free before) 345 */ 346 count = atomic_read(&queue->free_count) + elements_processed; 347 start = queue->free_index; 348 349 ZFCP_LOG_TRACE("calling do_QDIO on adapter %s (flags=0x%x, " 350 "queue_no=%i, index_in_queue=%i, count=%i, " 351 "buffers=0x%lx\n", 352 zfcp_get_busid_by_adapter(adapter), 353 QDIO_FLAG_SYNC_INPUT | QDIO_FLAG_UNDER_INTERRUPT, 354 0, start, count, (unsigned long) &queue->buffer[start]); 355 356 retval = do_QDIO(ccw_device, 357 QDIO_FLAG_SYNC_INPUT | QDIO_FLAG_UNDER_INTERRUPT, 358 0, start, count, NULL); 359 360 if (unlikely(retval)) { 361 atomic_set(&queue->free_count, count); 362 ZFCP_LOG_DEBUG("clearing of inbound data regions failed, " 363 "queues may be down " 364 "(count=%d, start=%d, retval=%d)\n", 365 count, start, retval); 366 } else { 367 queue->free_index += count; 368 queue->free_index %= QDIO_MAX_BUFFERS_PER_Q; 369 atomic_set(&queue->free_count, 0); 370 ZFCP_LOG_TRACE("%i buffers enqueued to response " 371 "queue at position %i\n", count, start); 372 } 373 out: 374 return; 375 } 376 377 /** 378 * zfcp_qdio_sbale_get - return pointer to SBALE of qdio_queue 379 * @queue: queue from which SBALE should be returned 380 * @sbal: specifies number of SBAL in queue 381 * @sbale: specifes number of SBALE in SBAL 382 */ 383 static inline volatile struct qdio_buffer_element * 384 zfcp_qdio_sbale_get(struct zfcp_qdio_queue *queue, int sbal, int sbale) 385 { 386 return &queue->buffer[sbal]->element[sbale]; 387 } 388 389 /** 390 * zfcp_qdio_sbale_req - return pointer to SBALE of request_queue for 391 * a struct zfcp_fsf_req 392 */ 393 volatile struct qdio_buffer_element * 394 zfcp_qdio_sbale_req(struct zfcp_fsf_req *fsf_req, int sbal, int sbale) 395 { 396 return zfcp_qdio_sbale_get(&fsf_req->adapter->request_queue, 397 sbal, sbale); 398 } 399 400 /** 401 * zfcp_qdio_sbale_resp - return pointer to SBALE of response_queue for 402 * a struct zfcp_fsf_req 403 */ 404 static inline volatile struct qdio_buffer_element * 405 zfcp_qdio_sbale_resp(struct zfcp_fsf_req *fsf_req, int sbal, int sbale) 406 { 407 return zfcp_qdio_sbale_get(&fsf_req->adapter->response_queue, 408 sbal, sbale); 409 } 410 411 /** 412 * zfcp_qdio_sbale_curr - return current SBALE on request_queue for 413 * a struct zfcp_fsf_req 414 */ 415 volatile struct qdio_buffer_element * 416 zfcp_qdio_sbale_curr(struct zfcp_fsf_req *fsf_req) 417 { 418 return zfcp_qdio_sbale_req(fsf_req, fsf_req->sbal_curr, 419 fsf_req->sbale_curr); 420 } 421 422 /** 423 * zfcp_qdio_sbal_limit - determine maximum number of SBALs that can be used 424 * on the request_queue for a struct zfcp_fsf_req 425 * @fsf_req: the number of the last SBAL that can be used is stored herein 426 * @max_sbals: used to pass an upper limit for the number of SBALs 427 * 428 * Note: We can assume at least one free SBAL in the request_queue when called. 429 */ 430 static void 431 zfcp_qdio_sbal_limit(struct zfcp_fsf_req *fsf_req, int max_sbals) 432 { 433 int count = atomic_read(&fsf_req->adapter->request_queue.free_count); 434 count = min(count, max_sbals); 435 fsf_req->sbal_last = fsf_req->sbal_first; 436 fsf_req->sbal_last += (count - 1); 437 fsf_req->sbal_last %= QDIO_MAX_BUFFERS_PER_Q; 438 } 439 440 /** 441 * zfcp_qdio_sbal_chain - chain SBALs if more than one SBAL is needed for a 442 * request 443 * @fsf_req: zfcp_fsf_req to be processed 444 * @sbtype: SBAL flags which have to be set in first SBALE of new SBAL 445 * 446 * This function changes sbal_curr, sbale_curr, sbal_number of fsf_req. 447 */ 448 static volatile struct qdio_buffer_element * 449 zfcp_qdio_sbal_chain(struct zfcp_fsf_req *fsf_req, unsigned long sbtype) 450 { 451 volatile struct qdio_buffer_element *sbale; 452 453 /* set last entry flag in current SBALE of current SBAL */ 454 sbale = zfcp_qdio_sbale_curr(fsf_req); 455 sbale->flags |= SBAL_FLAGS_LAST_ENTRY; 456 457 /* don't exceed last allowed SBAL */ 458 if (fsf_req->sbal_curr == fsf_req->sbal_last) 459 return NULL; 460 461 /* set chaining flag in first SBALE of current SBAL */ 462 sbale = zfcp_qdio_sbale_req(fsf_req, fsf_req->sbal_curr, 0); 463 sbale->flags |= SBAL_FLAGS0_MORE_SBALS; 464 465 /* calculate index of next SBAL */ 466 fsf_req->sbal_curr++; 467 fsf_req->sbal_curr %= QDIO_MAX_BUFFERS_PER_Q; 468 469 /* keep this requests number of SBALs up-to-date */ 470 fsf_req->sbal_number++; 471 472 /* start at first SBALE of new SBAL */ 473 fsf_req->sbale_curr = 0; 474 475 /* set storage-block type for new SBAL */ 476 sbale = zfcp_qdio_sbale_curr(fsf_req); 477 sbale->flags |= sbtype; 478 479 return sbale; 480 } 481 482 /** 483 * zfcp_qdio_sbale_next - switch to next SBALE, chain SBALs if needed 484 */ 485 static volatile struct qdio_buffer_element * 486 zfcp_qdio_sbale_next(struct zfcp_fsf_req *fsf_req, unsigned long sbtype) 487 { 488 if (fsf_req->sbale_curr == ZFCP_LAST_SBALE_PER_SBAL) 489 return zfcp_qdio_sbal_chain(fsf_req, sbtype); 490 491 fsf_req->sbale_curr++; 492 493 return zfcp_qdio_sbale_curr(fsf_req); 494 } 495 496 /** 497 * zfcp_qdio_sbals_zero - initialize SBALs between first and last in queue 498 * with zero from 499 */ 500 static int 501 zfcp_qdio_sbals_zero(struct zfcp_qdio_queue *queue, int first, int last) 502 { 503 struct qdio_buffer **buf = queue->buffer; 504 int curr = first; 505 int count = 0; 506 507 for(;;) { 508 curr %= QDIO_MAX_BUFFERS_PER_Q; 509 count++; 510 memset(buf[curr], 0, sizeof(struct qdio_buffer)); 511 if (curr == last) 512 break; 513 curr++; 514 } 515 return count; 516 } 517 518 519 /** 520 * zfcp_qdio_sbals_wipe - reset all changes in SBALs for an fsf_req 521 */ 522 static inline int 523 zfcp_qdio_sbals_wipe(struct zfcp_fsf_req *fsf_req) 524 { 525 return zfcp_qdio_sbals_zero(&fsf_req->adapter->request_queue, 526 fsf_req->sbal_first, fsf_req->sbal_curr); 527 } 528 529 530 /** 531 * zfcp_qdio_sbale_fill - set address and length in current SBALE 532 * on request_queue 533 */ 534 static void 535 zfcp_qdio_sbale_fill(struct zfcp_fsf_req *fsf_req, unsigned long sbtype, 536 void *addr, int length) 537 { 538 volatile struct qdio_buffer_element *sbale; 539 540 sbale = zfcp_qdio_sbale_curr(fsf_req); 541 sbale->addr = addr; 542 sbale->length = length; 543 } 544 545 /** 546 * zfcp_qdio_sbals_from_segment - map memory segment to SBALE(s) 547 * @fsf_req: request to be processed 548 * @sbtype: SBALE flags 549 * @start_addr: address of memory segment 550 * @total_length: length of memory segment 551 * 552 * Alignment and length of the segment determine how many SBALEs are needed 553 * for the memory segment. 554 */ 555 static int 556 zfcp_qdio_sbals_from_segment(struct zfcp_fsf_req *fsf_req, unsigned long sbtype, 557 void *start_addr, unsigned long total_length) 558 { 559 unsigned long remaining, length; 560 void *addr; 561 562 /* split segment up heeding page boundaries */ 563 for (addr = start_addr, remaining = total_length; remaining > 0; 564 addr += length, remaining -= length) { 565 /* get next free SBALE for new piece */ 566 if (NULL == zfcp_qdio_sbale_next(fsf_req, sbtype)) { 567 /* no SBALE left, clean up and leave */ 568 zfcp_qdio_sbals_wipe(fsf_req); 569 return -EINVAL; 570 } 571 /* calculate length of new piece */ 572 length = min(remaining, 573 (PAGE_SIZE - ((unsigned long) addr & 574 (PAGE_SIZE - 1)))); 575 /* fill current SBALE with calculated piece */ 576 zfcp_qdio_sbale_fill(fsf_req, sbtype, addr, length); 577 } 578 return total_length; 579 } 580 581 582 /** 583 * zfcp_qdio_sbals_from_sg - fill SBALs from scatter-gather list 584 * @fsf_req: request to be processed 585 * @sbtype: SBALE flags 586 * @sg: scatter-gather list 587 * @sg_count: number of elements in scatter-gather list 588 * @max_sbals: upper bound for number of SBALs to be used 589 */ 590 int 591 zfcp_qdio_sbals_from_sg(struct zfcp_fsf_req *fsf_req, unsigned long sbtype, 592 struct scatterlist *sgl, int sg_count, int max_sbals) 593 { 594 int sg_index; 595 struct scatterlist *sg_segment; 596 int retval; 597 volatile struct qdio_buffer_element *sbale; 598 int bytes = 0; 599 600 /* figure out last allowed SBAL */ 601 zfcp_qdio_sbal_limit(fsf_req, max_sbals); 602 603 /* set storage-block type for current SBAL */ 604 sbale = zfcp_qdio_sbale_req(fsf_req, fsf_req->sbal_curr, 0); 605 sbale->flags |= sbtype; 606 607 /* process all segements of scatter-gather list */ 608 for_each_sg(sgl, sg_segment, sg_count, sg_index) { 609 retval = zfcp_qdio_sbals_from_segment( 610 fsf_req, 611 sbtype, 612 zfcp_sg_to_address(sg_segment), 613 sg_segment->length); 614 if (retval < 0) { 615 bytes = retval; 616 goto out; 617 } else 618 bytes += retval; 619 } 620 /* assume that no other SBALEs are to follow in the same SBAL */ 621 sbale = zfcp_qdio_sbale_curr(fsf_req); 622 sbale->flags |= SBAL_FLAGS_LAST_ENTRY; 623 out: 624 return bytes; 625 } 626 627 628 /** 629 * zfcp_qdio_sbals_from_scsicmnd - fill SBALs from scsi command 630 * @fsf_req: request to be processed 631 * @sbtype: SBALE flags 632 * @scsi_cmnd: either scatter-gather list or buffer contained herein is used 633 * to fill SBALs 634 */ 635 int 636 zfcp_qdio_sbals_from_scsicmnd(struct zfcp_fsf_req *fsf_req, 637 unsigned long sbtype, struct scsi_cmnd *scsi_cmnd) 638 { 639 return zfcp_qdio_sbals_from_sg(fsf_req, sbtype, scsi_sglist(scsi_cmnd), 640 scsi_sg_count(scsi_cmnd), 641 ZFCP_MAX_SBALS_PER_REQ); 642 } 643 644 /** 645 * zfcp_qdio_determine_pci - set PCI flag in first SBALE on qdio queue if needed 646 */ 647 int 648 zfcp_qdio_determine_pci(struct zfcp_qdio_queue *req_queue, 649 struct zfcp_fsf_req *fsf_req) 650 { 651 int new_distance_from_int; 652 int pci_pos; 653 volatile struct qdio_buffer_element *sbale; 654 655 new_distance_from_int = req_queue->distance_from_int + 656 fsf_req->sbal_number; 657 658 if (unlikely(new_distance_from_int >= ZFCP_QDIO_PCI_INTERVAL)) { 659 new_distance_from_int %= ZFCP_QDIO_PCI_INTERVAL; 660 pci_pos = fsf_req->sbal_first; 661 pci_pos += fsf_req->sbal_number; 662 pci_pos -= new_distance_from_int; 663 pci_pos -= 1; 664 pci_pos %= QDIO_MAX_BUFFERS_PER_Q; 665 sbale = zfcp_qdio_sbale_req(fsf_req, pci_pos, 0); 666 sbale->flags |= SBAL_FLAGS0_PCI; 667 } 668 return new_distance_from_int; 669 } 670 671 /* 672 * function: zfcp_zero_sbals 673 * 674 * purpose: zeros specified range of SBALs 675 * 676 * returns: 677 */ 678 void 679 zfcp_qdio_zero_sbals(struct qdio_buffer *buf[], int first, int clean_count) 680 { 681 int cur_pos; 682 int index; 683 684 for (cur_pos = first; cur_pos < (first + clean_count); cur_pos++) { 685 index = cur_pos % QDIO_MAX_BUFFERS_PER_Q; 686 memset(buf[index], 0, sizeof (struct qdio_buffer)); 687 ZFCP_LOG_TRACE("zeroing BUFFER %d at address %p\n", 688 index, buf[index]); 689 } 690 } 691 692 #undef ZFCP_LOG_AREA 693