drivers/s390/scsi/zfcp_qdio.c

   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         if (scsi_sg_count(scsi_cmnd))
 644                 return zfcp_qdio_sbals_from_sg(fsf_req, sbtype,
 645                                                scsi_sglist(scsi_cmnd),
 646                                                scsi_sg_count(scsi_cmnd),
 647                                                ZFCP_MAX_SBALS_PER_REQ);
 648         else
 649                 return 0;
 650 }
 651
 652 /**
 653  * zfcp_qdio_determine_pci - set PCI flag in first SBALE on qdio queue if needed
 654  */
 655 int
 656 zfcp_qdio_determine_pci(struct zfcp_qdio_queue *req_queue,
 657                         struct zfcp_fsf_req *fsf_req)
 658 {
 659         int new_distance_from_int;
 660         int pci_pos;
 661         volatile struct qdio_buffer_element *sbale;
 662
 663         new_distance_from_int = req_queue->distance_from_int +
 664                 fsf_req->sbal_number;
 665
 666         if (unlikely(new_distance_from_int >= ZFCP_QDIO_PCI_INTERVAL)) {
 667                 new_distance_from_int %= ZFCP_QDIO_PCI_INTERVAL;
 668                 pci_pos  = fsf_req->sbal_first;
 669                 pci_pos += fsf_req->sbal_number;
 670                 pci_pos -= new_distance_from_int;
 671                 pci_pos -= 1;
 672                 pci_pos %= QDIO_MAX_BUFFERS_PER_Q;
 673                 sbale = zfcp_qdio_sbale_req(fsf_req, pci_pos, 0);
 674                 sbale->flags |= SBAL_FLAGS0_PCI;
 675         }
 676         return new_distance_from_int;
 677 }
 678
 679 /*
 680  * function:    zfcp_zero_sbals
 681  *
 682  * purpose:     zeros specified range of SBALs
 683  *
 684  * returns:
 685  */
 686 void
 687 zfcp_qdio_zero_sbals(struct qdio_buffer *buf[], int first, int clean_count)
 688 {
 689         int cur_pos;
 690         int index;
 691
 692         for (cur_pos = first; cur_pos < (first + clean_count); cur_pos++) {
 693                 index = cur_pos % QDIO_MAX_BUFFERS_PER_Q;
 694                 memset(buf[index], 0, sizeof (struct qdio_buffer));
 695                 ZFCP_LOG_TRACE("zeroing BUFFER %d at address %p\n",
 696                                index, buf[index]);
 697         }
 698 }
 699
 700 #undef ZFCP_LOG_AREA