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