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( 178 adapter, 179 ZFCP_STATUS_ADAPTER_LINK_UNPLUGGED | 180 ZFCP_STATUS_COMMON_ERP_FAILED); 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 debug_long_event(adapter->erp_dbf, 4, req_id); 244 245 spin_lock_irqsave(&adapter->req_list_lock, flags); 246 fsf_req = zfcp_reqlist_find(adapter, req_id); 247 248 if (!fsf_req) 249 /* 250 * Unknown request means that we have potentially memory 251 * corruption and must stop the machine immediatly. 252 */ 253 panic("error: unknown request id (%ld) on adapter %s.\n", 254 req_id, zfcp_get_busid_by_adapter(adapter)); 255 256 zfcp_reqlist_remove(adapter, fsf_req); 257 atomic_dec(&adapter->reqs_active); 258 spin_unlock_irqrestore(&adapter->req_list_lock, flags); 259 260 /* finish the FSF request */ 261 zfcp_fsf_req_complete(fsf_req); 262 } 263 264 /* 265 * function: zfcp_qdio_response_handler 266 * 267 * purpose: is called by QDIO layer for completed SBALs in response queue 268 * 269 * returns: (void) 270 */ 271 static void 272 zfcp_qdio_response_handler(struct ccw_device *ccw_device, 273 unsigned int status, 274 unsigned int qdio_error, 275 unsigned int siga_error, 276 unsigned int queue_number, 277 int first_element, 278 int elements_processed, 279 unsigned long int_parm) 280 { 281 struct zfcp_adapter *adapter; 282 struct zfcp_qdio_queue *queue; 283 int buffer_index; 284 int i; 285 struct qdio_buffer *buffer; 286 int retval = 0; 287 u8 count; 288 u8 start; 289 volatile struct qdio_buffer_element *buffere = NULL; 290 int buffere_index; 291 292 adapter = (struct zfcp_adapter *) int_parm; 293 queue = &adapter->response_queue; 294 295 if (unlikely(zfcp_qdio_handler_error_check(adapter, status, qdio_error, 296 siga_error, first_element, 297 elements_processed))) 298 goto out; 299 300 /* 301 * we stored address of struct zfcp_adapter data structure 302 * associated with irq in int_parm 303 */ 304 305 buffere = &(queue->buffer[first_element]->element[0]); 306 ZFCP_LOG_DEBUG("first BUFFERE flags=0x%x\n", buffere->flags); 307 /* 308 * go through all SBALs from input queue currently 309 * returned by QDIO layer 310 */ 311 312 for (i = 0; i < elements_processed; i++) { 313 314 buffer_index = first_element + i; 315 buffer_index %= QDIO_MAX_BUFFERS_PER_Q; 316 buffer = queue->buffer[buffer_index]; 317 318 /* go through all SBALEs of SBAL */ 319 for (buffere_index = 0; 320 buffere_index < QDIO_MAX_ELEMENTS_PER_BUFFER; 321 buffere_index++) { 322 323 /* look for QDIO request identifiers in SB */ 324 buffere = &buffer->element[buffere_index]; 325 zfcp_qdio_reqid_check(adapter, 326 (unsigned long) buffere->addr); 327 328 /* 329 * A single used SBALE per inbound SBALE has been 330 * implemented by QDIO so far. Hope they will 331 * do some optimisation. Will need to change to 332 * unlikely() then. 333 */ 334 if (likely(buffere->flags & SBAL_FLAGS_LAST_ENTRY)) 335 break; 336 }; 337 338 if (unlikely(!(buffere->flags & SBAL_FLAGS_LAST_ENTRY))) { 339 ZFCP_LOG_NORMAL("bug: End of inbound data " 340 "not marked!\n"); 341 } 342 } 343 344 /* 345 * put range of SBALs back to response queue 346 * (including SBALs which have already been free before) 347 */ 348 count = atomic_read(&queue->free_count) + elements_processed; 349 start = queue->free_index; 350 351 ZFCP_LOG_TRACE("calling do_QDIO on adapter %s (flags=0x%x, " 352 "queue_no=%i, index_in_queue=%i, count=%i, " 353 "buffers=0x%lx\n", 354 zfcp_get_busid_by_adapter(adapter), 355 QDIO_FLAG_SYNC_INPUT | QDIO_FLAG_UNDER_INTERRUPT, 356 0, start, count, (unsigned long) &queue->buffer[start]); 357 358 retval = do_QDIO(ccw_device, 359 QDIO_FLAG_SYNC_INPUT | QDIO_FLAG_UNDER_INTERRUPT, 360 0, start, count, NULL); 361 362 if (unlikely(retval)) { 363 atomic_set(&queue->free_count, count); 364 ZFCP_LOG_DEBUG("clearing of inbound data regions failed, " 365 "queues may be down " 366 "(count=%d, start=%d, retval=%d)\n", 367 count, start, retval); 368 } else { 369 queue->free_index += count; 370 queue->free_index %= QDIO_MAX_BUFFERS_PER_Q; 371 atomic_set(&queue->free_count, 0); 372 ZFCP_LOG_TRACE("%i buffers enqueued to response " 373 "queue at position %i\n", count, start); 374 } 375 out: 376 return; 377 } 378 379 /** 380 * zfcp_qdio_sbale_get - return pointer to SBALE of qdio_queue 381 * @queue: queue from which SBALE should be returned 382 * @sbal: specifies number of SBAL in queue 383 * @sbale: specifes number of SBALE in SBAL 384 */ 385 static inline volatile struct qdio_buffer_element * 386 zfcp_qdio_sbale_get(struct zfcp_qdio_queue *queue, int sbal, int sbale) 387 { 388 return &queue->buffer[sbal]->element[sbale]; 389 } 390 391 /** 392 * zfcp_qdio_sbale_req - return pointer to SBALE of request_queue for 393 * a struct zfcp_fsf_req 394 */ 395 volatile struct qdio_buffer_element * 396 zfcp_qdio_sbale_req(struct zfcp_fsf_req *fsf_req, int sbal, int sbale) 397 { 398 return zfcp_qdio_sbale_get(&fsf_req->adapter->request_queue, 399 sbal, sbale); 400 } 401 402 /** 403 * zfcp_qdio_sbale_resp - return pointer to SBALE of response_queue for 404 * a struct zfcp_fsf_req 405 */ 406 static inline volatile struct qdio_buffer_element * 407 zfcp_qdio_sbale_resp(struct zfcp_fsf_req *fsf_req, int sbal, int sbale) 408 { 409 return zfcp_qdio_sbale_get(&fsf_req->adapter->response_queue, 410 sbal, sbale); 411 } 412 413 /** 414 * zfcp_qdio_sbale_curr - return current SBALE on request_queue for 415 * a struct zfcp_fsf_req 416 */ 417 volatile struct qdio_buffer_element * 418 zfcp_qdio_sbale_curr(struct zfcp_fsf_req *fsf_req) 419 { 420 return zfcp_qdio_sbale_req(fsf_req, fsf_req->sbal_curr, 421 fsf_req->sbale_curr); 422 } 423 424 /** 425 * zfcp_qdio_sbal_limit - determine maximum number of SBALs that can be used 426 * on the request_queue for a struct zfcp_fsf_req 427 * @fsf_req: the number of the last SBAL that can be used is stored herein 428 * @max_sbals: used to pass an upper limit for the number of SBALs 429 * 430 * Note: We can assume at least one free SBAL in the request_queue when called. 431 */ 432 static void 433 zfcp_qdio_sbal_limit(struct zfcp_fsf_req *fsf_req, int max_sbals) 434 { 435 int count = atomic_read(&fsf_req->adapter->request_queue.free_count); 436 count = min(count, max_sbals); 437 fsf_req->sbal_last = fsf_req->sbal_first; 438 fsf_req->sbal_last += (count - 1); 439 fsf_req->sbal_last %= QDIO_MAX_BUFFERS_PER_Q; 440 } 441 442 /** 443 * zfcp_qdio_sbal_chain - chain SBALs if more than one SBAL is needed for a 444 * request 445 * @fsf_req: zfcp_fsf_req to be processed 446 * @sbtype: SBAL flags which have to be set in first SBALE of new SBAL 447 * 448 * This function changes sbal_curr, sbale_curr, sbal_number of fsf_req. 449 */ 450 static volatile struct qdio_buffer_element * 451 zfcp_qdio_sbal_chain(struct zfcp_fsf_req *fsf_req, unsigned long sbtype) 452 { 453 volatile struct qdio_buffer_element *sbale; 454 455 /* set last entry flag in current SBALE of current SBAL */ 456 sbale = zfcp_qdio_sbale_curr(fsf_req); 457 sbale->flags |= SBAL_FLAGS_LAST_ENTRY; 458 459 /* don't exceed last allowed SBAL */ 460 if (fsf_req->sbal_curr == fsf_req->sbal_last) 461 return NULL; 462 463 /* set chaining flag in first SBALE of current SBAL */ 464 sbale = zfcp_qdio_sbale_req(fsf_req, fsf_req->sbal_curr, 0); 465 sbale->flags |= SBAL_FLAGS0_MORE_SBALS; 466 467 /* calculate index of next SBAL */ 468 fsf_req->sbal_curr++; 469 fsf_req->sbal_curr %= QDIO_MAX_BUFFERS_PER_Q; 470 471 /* keep this requests number of SBALs up-to-date */ 472 fsf_req->sbal_number++; 473 474 /* start at first SBALE of new SBAL */ 475 fsf_req->sbale_curr = 0; 476 477 /* set storage-block type for new SBAL */ 478 sbale = zfcp_qdio_sbale_curr(fsf_req); 479 sbale->flags |= sbtype; 480 481 return sbale; 482 } 483 484 /** 485 * zfcp_qdio_sbale_next - switch to next SBALE, chain SBALs if needed 486 */ 487 static volatile struct qdio_buffer_element * 488 zfcp_qdio_sbale_next(struct zfcp_fsf_req *fsf_req, unsigned long sbtype) 489 { 490 if (fsf_req->sbale_curr == ZFCP_LAST_SBALE_PER_SBAL) 491 return zfcp_qdio_sbal_chain(fsf_req, sbtype); 492 493 fsf_req->sbale_curr++; 494 495 return zfcp_qdio_sbale_curr(fsf_req); 496 } 497 498 /** 499 * zfcp_qdio_sbals_zero - initialize SBALs between first and last in queue 500 * with zero from 501 */ 502 static int 503 zfcp_qdio_sbals_zero(struct zfcp_qdio_queue *queue, int first, int last) 504 { 505 struct qdio_buffer **buf = queue->buffer; 506 int curr = first; 507 int count = 0; 508 509 for(;;) { 510 curr %= QDIO_MAX_BUFFERS_PER_Q; 511 count++; 512 memset(buf[curr], 0, sizeof(struct qdio_buffer)); 513 if (curr == last) 514 break; 515 curr++; 516 } 517 return count; 518 } 519 520 521 /** 522 * zfcp_qdio_sbals_wipe - reset all changes in SBALs for an fsf_req 523 */ 524 static inline int 525 zfcp_qdio_sbals_wipe(struct zfcp_fsf_req *fsf_req) 526 { 527 return zfcp_qdio_sbals_zero(&fsf_req->adapter->request_queue, 528 fsf_req->sbal_first, fsf_req->sbal_curr); 529 } 530 531 532 /** 533 * zfcp_qdio_sbale_fill - set address and lenght in current SBALE 534 * on request_queue 535 */ 536 static void 537 zfcp_qdio_sbale_fill(struct zfcp_fsf_req *fsf_req, unsigned long sbtype, 538 void *addr, int length) 539 { 540 volatile struct qdio_buffer_element *sbale; 541 542 sbale = zfcp_qdio_sbale_curr(fsf_req); 543 sbale->addr = addr; 544 sbale->length = length; 545 } 546 547 /** 548 * zfcp_qdio_sbals_from_segment - map memory segment to SBALE(s) 549 * @fsf_req: request to be processed 550 * @sbtype: SBALE flags 551 * @start_addr: address of memory segment 552 * @total_length: length of memory segment 553 * 554 * Alignment and length of the segment determine how many SBALEs are needed 555 * for the memory segment. 556 */ 557 static int 558 zfcp_qdio_sbals_from_segment(struct zfcp_fsf_req *fsf_req, unsigned long sbtype, 559 void *start_addr, unsigned long total_length) 560 { 561 unsigned long remaining, length; 562 void *addr; 563 564 /* split segment up heeding page boundaries */ 565 for (addr = start_addr, remaining = total_length; remaining > 0; 566 addr += length, remaining -= length) { 567 /* get next free SBALE for new piece */ 568 if (NULL == zfcp_qdio_sbale_next(fsf_req, sbtype)) { 569 /* no SBALE left, clean up and leave */ 570 zfcp_qdio_sbals_wipe(fsf_req); 571 return -EINVAL; 572 } 573 /* calculate length of new piece */ 574 length = min(remaining, 575 (PAGE_SIZE - ((unsigned long) addr & 576 (PAGE_SIZE - 1)))); 577 /* fill current SBALE with calculated piece */ 578 zfcp_qdio_sbale_fill(fsf_req, sbtype, addr, length); 579 } 580 return total_length; 581 } 582 583 584 /** 585 * zfcp_qdio_sbals_from_sg - fill SBALs from scatter-gather list 586 * @fsf_req: request to be processed 587 * @sbtype: SBALE flags 588 * @sg: scatter-gather list 589 * @sg_count: number of elements in scatter-gather list 590 * @max_sbals: upper bound for number of SBALs to be used 591 */ 592 int 593 zfcp_qdio_sbals_from_sg(struct zfcp_fsf_req *fsf_req, unsigned long sbtype, 594 struct scatterlist *sg, int sg_count, int max_sbals) 595 { 596 int sg_index; 597 struct scatterlist *sg_segment; 598 int retval; 599 volatile struct qdio_buffer_element *sbale; 600 int bytes = 0; 601 602 /* figure out last allowed SBAL */ 603 zfcp_qdio_sbal_limit(fsf_req, max_sbals); 604 605 /* set storage-block type for current SBAL */ 606 sbale = zfcp_qdio_sbale_req(fsf_req, fsf_req->sbal_curr, 0); 607 sbale->flags |= sbtype; 608 609 /* process all segements of scatter-gather list */ 610 for (sg_index = 0, sg_segment = sg, bytes = 0; 611 sg_index < sg_count; 612 sg_index++, sg_segment++) { 613 retval = zfcp_qdio_sbals_from_segment( 614 fsf_req, 615 sbtype, 616 zfcp_sg_to_address(sg_segment), 617 sg_segment->length); 618 if (retval < 0) { 619 bytes = retval; 620 goto out; 621 } else 622 bytes += retval; 623 } 624 /* assume that no other SBALEs are to follow in the same SBAL */ 625 sbale = zfcp_qdio_sbale_curr(fsf_req); 626 sbale->flags |= SBAL_FLAGS_LAST_ENTRY; 627 out: 628 return bytes; 629 } 630 631 632 /** 633 * zfcp_qdio_sbals_from_scsicmnd - fill SBALs from scsi command 634 * @fsf_req: request to be processed 635 * @sbtype: SBALE flags 636 * @scsi_cmnd: either scatter-gather list or buffer contained herein is used 637 * to fill SBALs 638 */ 639 int 640 zfcp_qdio_sbals_from_scsicmnd(struct zfcp_fsf_req *fsf_req, 641 unsigned long sbtype, struct scsi_cmnd *scsi_cmnd) 642 { 643 return zfcp_qdio_sbals_from_sg(fsf_req, sbtype, scsi_sglist(scsi_cmnd), 644 scsi_sg_count(scsi_cmnd), 645 ZFCP_MAX_SBALS_PER_REQ); 646 } 647 648 /** 649 * zfcp_qdio_determine_pci - set PCI flag in first SBALE on qdio queue if needed 650 */ 651 int 652 zfcp_qdio_determine_pci(struct zfcp_qdio_queue *req_queue, 653 struct zfcp_fsf_req *fsf_req) 654 { 655 int new_distance_from_int; 656 int pci_pos; 657 volatile struct qdio_buffer_element *sbale; 658 659 new_distance_from_int = req_queue->distance_from_int + 660 fsf_req->sbal_number; 661 662 if (unlikely(new_distance_from_int >= ZFCP_QDIO_PCI_INTERVAL)) { 663 new_distance_from_int %= ZFCP_QDIO_PCI_INTERVAL; 664 pci_pos = fsf_req->sbal_first; 665 pci_pos += fsf_req->sbal_number; 666 pci_pos -= new_distance_from_int; 667 pci_pos -= 1; 668 pci_pos %= QDIO_MAX_BUFFERS_PER_Q; 669 sbale = zfcp_qdio_sbale_req(fsf_req, pci_pos, 0); 670 sbale->flags |= SBAL_FLAGS0_PCI; 671 } 672 return new_distance_from_int; 673 } 674 675 /* 676 * function: zfcp_zero_sbals 677 * 678 * purpose: zeros specified range of SBALs 679 * 680 * returns: 681 */ 682 void 683 zfcp_qdio_zero_sbals(struct qdio_buffer *buf[], int first, int clean_count) 684 { 685 int cur_pos; 686 int index; 687 688 for (cur_pos = first; cur_pos < (first + clean_count); cur_pos++) { 689 index = cur_pos % QDIO_MAX_BUFFERS_PER_Q; 690 memset(buf[index], 0, sizeof (struct qdio_buffer)); 691 ZFCP_LOG_TRACE("zeroing BUFFER %d at address %p\n", 692 index, buf[index]); 693 } 694 } 695 696 #undef ZFCP_LOG_AREA 697