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