drivers/s390/scsi/zfcp_qdio.c

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