SAFE public projects git trees. - safe/jmp/linux-2.6/blob - drivers/s390/scsi/zfcp_qdio.c

   1 /*
   2  * zfcp device driver
   3  *
   4  * Setup and helper functions to access QDIO.
   5  *
   6  * Copyright IBM Corporation 2002, 2009
   7  */
   8
   9 #define KMSG_COMPONENT "zfcp"
  10 #define pr_fmt(fmt) KMSG_COMPONENT ": " fmt
  11
  12 #include "zfcp_ext.h"
  13
  14 #define QBUFF_PER_PAGE          (PAGE_SIZE / sizeof(struct qdio_buffer))
  15
  16 static int zfcp_qdio_buffers_enqueue(struct qdio_buffer **sbal)
  17 {
  18         int pos;
  19
  20         for (pos = 0; pos < QDIO_MAX_BUFFERS_PER_Q; pos += QBUFF_PER_PAGE) {
  21                 sbal[pos] = (struct qdio_buffer *) get_zeroed_page(GFP_KERNEL);
  22                 if (!sbal[pos])
  23                         return -ENOMEM;
  24         }
  25         for (pos = 0; pos < QDIO_MAX_BUFFERS_PER_Q; pos++)
  26                 if (pos % QBUFF_PER_PAGE)
  27                         sbal[pos] = sbal[pos - 1] + 1;
  28         return 0;
  29 }
  30
  31 static struct qdio_buffer_element *
  32 zfcp_qdio_sbale(struct zfcp_qdio_queue *q, int sbal_idx, int sbale_idx)
  33 {
  34         return &q->sbal[sbal_idx]->element[sbale_idx];
  35 }
  36
  37 /**
  38  * zfcp_qdio_free - free memory used by request- and resposne queue
  39  * @qdio: pointer to the zfcp_qdio structure
  40  */
  41 void zfcp_qdio_free(struct zfcp_qdio *qdio)
  42 {
  43         struct qdio_buffer **sbal_req, **sbal_resp;
  44         int p;
  45
  46         if (qdio->adapter->ccw_device)
  47                 qdio_free(qdio->adapter->ccw_device);
  48
  49         sbal_req = qdio->req_q.sbal;
  50         sbal_resp = qdio->resp_q.sbal;
  51
  52         for (p = 0; p < QDIO_MAX_BUFFERS_PER_Q; p += QBUFF_PER_PAGE) {
  53                 free_page((unsigned long) sbal_req[p]);
  54                 free_page((unsigned long) sbal_resp[p]);
  55         }
  56 }
  57
  58 static void zfcp_qdio_handler_error(struct zfcp_qdio *qdio, char *id)
  59 {
  60         struct zfcp_adapter *adapter = qdio->adapter;
  61
  62         dev_warn(&adapter->ccw_device->dev, "A QDIO problem occurred\n");
  63
  64         zfcp_erp_adapter_reopen(adapter,
  65                                 ZFCP_STATUS_ADAPTER_LINK_UNPLUGGED |
  66                                 ZFCP_STATUS_COMMON_ERP_FAILED, id, NULL);
  67 }
  68
  69 static void zfcp_qdio_zero_sbals(struct qdio_buffer *sbal[], int first, int cnt)
  70 {
  71         int i, sbal_idx;
  72
  73         for (i = first; i < first + cnt; i++) {
  74                 sbal_idx = i % QDIO_MAX_BUFFERS_PER_Q;
  75                 memset(sbal[sbal_idx], 0, sizeof(struct qdio_buffer));
  76         }
  77 }
  78
  79 /* this needs to be called prior to updating the queue fill level */
  80 static void zfcp_qdio_account(struct zfcp_qdio *qdio)
  81 {
  82         ktime_t now;
  83         s64 span;
  84         int free, used;
  85
  86         spin_lock(&qdio->stat_lock);
  87         now = ktime_get();
  88         span = ktime_us_delta(now, qdio->req_q_time);
  89         free = max(0, atomic_read(&qdio->req_q.count));
  90         used = QDIO_MAX_BUFFERS_PER_Q - free;
  91         qdio->req_q_util += used * span;
  92         qdio->req_q_time = now;
  93         spin_unlock(&qdio->stat_lock);
  94 }
  95
  96 static void zfcp_qdio_int_req(struct ccw_device *cdev, unsigned int qdio_err,
  97                               int queue_no, int first, int count,
  98                               unsigned long parm)
  99 {
 100         struct zfcp_qdio *qdio = (struct zfcp_qdio *) parm;
 101         struct zfcp_qdio_queue *queue = &qdio->req_q;
 102
 103         if (unlikely(qdio_err)) {
 104                 zfcp_hba_dbf_event_qdio(qdio, qdio_err, first, count);
 105                 zfcp_qdio_handler_error(qdio, "qdireq1");
 106                 return;
 107         }
 108
 109         /* cleanup all SBALs being program-owned now */
 110         zfcp_qdio_zero_sbals(queue->sbal, first, count);
 111
 112         zfcp_qdio_account(qdio);
 113         atomic_add(count, &queue->count);
 114         wake_up(&qdio->req_q_wq);
 115 }
 116
 117 static void zfcp_qdio_resp_put_back(struct zfcp_qdio *qdio, int processed)
 118 {
 119         struct zfcp_qdio_queue *queue = &qdio->resp_q;
 120         struct ccw_device *cdev = qdio->adapter->ccw_device;
 121         u8 count, start = queue->first;
 122         unsigned int retval;
 123
 124         count = atomic_read(&queue->count) + processed;
 125
 126         retval = do_QDIO(cdev, QDIO_FLAG_SYNC_INPUT, 0, start, count);
 127
 128         if (unlikely(retval)) {
 129                 atomic_set(&queue->count, count);
 130                 /* FIXME: Recover this with an adapter reopen? */
 131         } else {
 132                 queue->first += count;
 133                 queue->first %= QDIO_MAX_BUFFERS_PER_Q;
 134                 atomic_set(&queue->count, 0);
 135         }
 136 }
 137
 138 static void zfcp_qdio_int_resp(struct ccw_device *cdev, unsigned int qdio_err,
 139                                int queue_no, int first, int count,
 140                                unsigned long parm)
 141 {
 142         struct zfcp_qdio *qdio = (struct zfcp_qdio *) parm;
 143         int sbal_idx, sbal_no;
 144
 145         if (unlikely(qdio_err)) {
 146                 zfcp_hba_dbf_event_qdio(qdio, qdio_err, first, count);
 147                 zfcp_qdio_handler_error(qdio, "qdires1");
 148                 return;
 149         }
 150
 151         /*
 152          * go through all SBALs from input queue currently
 153          * returned by QDIO layer
 154          */
 155         for (sbal_no = 0; sbal_no < count; sbal_no++) {
 156                 sbal_idx = (first + sbal_no) % QDIO_MAX_BUFFERS_PER_Q;
 157                 /* go through all SBALEs of SBAL */
 158                 zfcp_fsf_reqid_check(qdio, sbal_idx);
 159         }
 160
 161         /*
 162          * put range of SBALs back to response queue
 163          * (including SBALs which have already been free before)
 164          */
 165         zfcp_qdio_resp_put_back(qdio, count);
 166 }
 167
 168 /**
 169  * zfcp_qdio_sbale_req - return ptr to SBALE of req_q for a struct zfcp_fsf_req
 170  * @qdio: pointer to struct zfcp_qdio
 171  * @q_rec: pointer to struct zfcp_queue_rec
 172  * Returns: pointer to qdio_buffer_element (SBALE) structure
 173  */
 174 struct qdio_buffer_element *zfcp_qdio_sbale_req(struct zfcp_qdio *qdio,
 175                                                 struct zfcp_queue_req *q_req)
 176 {
 177         return zfcp_qdio_sbale(&qdio->req_q, q_req->sbal_last, 0);
 178 }
 179
 180 /**
 181  * zfcp_qdio_sbale_curr - return curr SBALE on req_q for a struct zfcp_fsf_req
 182  * @fsf_req: pointer to struct fsf_req
 183  * Returns: pointer to qdio_buffer_element (SBALE) structure
 184  */
 185 struct qdio_buffer_element *zfcp_qdio_sbale_curr(struct zfcp_qdio *qdio,
 186                                                  struct zfcp_queue_req *q_req)
 187 {
 188         return zfcp_qdio_sbale(&qdio->req_q, q_req->sbal_last,
 189                                q_req->sbale_curr);
 190 }
 191
 192 static void zfcp_qdio_sbal_limit(struct zfcp_qdio *qdio,
 193                                  struct zfcp_queue_req *q_req, int max_sbals)
 194 {
 195         int count = atomic_read(&qdio->req_q.count);
 196         count = min(count, max_sbals);
 197         q_req->sbal_limit = (q_req->sbal_first + count - 1)
 198                                         % QDIO_MAX_BUFFERS_PER_Q;
 199 }
 200
 201 static struct qdio_buffer_element *
 202 zfcp_qdio_sbal_chain(struct zfcp_qdio *qdio, struct zfcp_queue_req *q_req,
 203                      unsigned long sbtype)
 204 {
 205         struct qdio_buffer_element *sbale;
 206
 207         /* set last entry flag in current SBALE of current SBAL */
 208         sbale = zfcp_qdio_sbale_curr(qdio, q_req);
 209         sbale->flags |= SBAL_FLAGS_LAST_ENTRY;
 210
 211         /* don't exceed last allowed SBAL */
 212         if (q_req->sbal_last == q_req->sbal_limit)
 213                 return NULL;
 214
 215         /* set chaining flag in first SBALE of current SBAL */
 216         sbale = zfcp_qdio_sbale_req(qdio, q_req);
 217         sbale->flags |= SBAL_FLAGS0_MORE_SBALS;
 218
 219         /* calculate index of next SBAL */
 220         q_req->sbal_last++;
 221         q_req->sbal_last %= QDIO_MAX_BUFFERS_PER_Q;
 222
 223         /* keep this requests number of SBALs up-to-date */
 224         q_req->sbal_number++;
 225
 226         /* start at first SBALE of new SBAL */
 227         q_req->sbale_curr = 0;
 228
 229         /* set storage-block type for new SBAL */
 230         sbale = zfcp_qdio_sbale_curr(qdio, q_req);
 231         sbale->flags |= sbtype;
 232
 233         return sbale;
 234 }
 235
 236 static struct qdio_buffer_element *
 237 zfcp_qdio_sbale_next(struct zfcp_qdio *qdio, struct zfcp_queue_req *q_req,
 238                      unsigned int sbtype)
 239 {
 240         if (q_req->sbale_curr == ZFCP_LAST_SBALE_PER_SBAL)
 241                 return zfcp_qdio_sbal_chain(qdio, q_req, sbtype);
 242         q_req->sbale_curr++;
 243         return zfcp_qdio_sbale_curr(qdio, q_req);
 244 }
 245
 246 static void zfcp_qdio_undo_sbals(struct zfcp_qdio *qdio,
 247                                  struct zfcp_queue_req *q_req)
 248 {
 249         struct qdio_buffer **sbal = qdio->req_q.sbal;
 250         int first = q_req->sbal_first;
 251         int last = q_req->sbal_last;
 252         int count = (last - first + QDIO_MAX_BUFFERS_PER_Q) %
 253                 QDIO_MAX_BUFFERS_PER_Q + 1;
 254         zfcp_qdio_zero_sbals(sbal, first, count);
 255 }
 256
 257 static int zfcp_qdio_fill_sbals(struct zfcp_qdio *qdio,
 258                                 struct zfcp_queue_req *q_req,
 259                                 unsigned int sbtype, void *start_addr,
 260                                 unsigned int total_length)
 261 {
 262         struct qdio_buffer_element *sbale;
 263         unsigned long remaining, length;
 264         void *addr;
 265
 266         /* split segment up */
 267         for (addr = start_addr, remaining = total_length; remaining > 0;
 268              addr += length, remaining -= length) {
 269                 sbale = zfcp_qdio_sbale_next(qdio, q_req, sbtype);
 270                 if (!sbale) {
 271                         atomic_inc(&qdio->req_q_full);
 272                         zfcp_qdio_undo_sbals(qdio, q_req);
 273                         return -EINVAL;
 274                 }
 275
 276                 /* new piece must not exceed next page boundary */
 277                 length = min(remaining,
 278                              (PAGE_SIZE - ((unsigned long)addr &
 279                                            (PAGE_SIZE - 1))));
 280                 sbale->addr = addr;
 281                 sbale->length = length;
 282         }
 283         return 0;
 284 }
 285
 286 /**
 287  * zfcp_qdio_sbals_from_sg - fill SBALs from scatter-gather list
 288  * @fsf_req: request to be processed
 289  * @sbtype: SBALE flags
 290  * @sg: scatter-gather list
 291  * @max_sbals: upper bound for number of SBALs to be used
 292  * Returns: number of bytes, or error (negativ)
 293  */
 294 int zfcp_qdio_sbals_from_sg(struct zfcp_qdio *qdio,
 295                             struct zfcp_queue_req *q_req,
 296                             unsigned long sbtype, struct scatterlist *sg,
 297                             int max_sbals)
 298 {
 299         struct qdio_buffer_element *sbale;
 300         int retval, bytes = 0;
 301
 302         /* figure out last allowed SBAL */
 303         zfcp_qdio_sbal_limit(qdio, q_req, max_sbals);
 304
 305         /* set storage-block type for this request */
 306         sbale = zfcp_qdio_sbale_req(qdio, q_req);
 307         sbale->flags |= sbtype;
 308
 309         for (; sg; sg = sg_next(sg)) {
 310                 retval = zfcp_qdio_fill_sbals(qdio, q_req, sbtype,
 311                                               sg_virt(sg), sg->length);
 312                 if (retval < 0)
 313                         return retval;
 314                 bytes += sg->length;
 315         }
 316
 317         /* assume that no other SBALEs are to follow in the same SBAL */
 318         sbale = zfcp_qdio_sbale_curr(qdio, q_req);
 319         sbale->flags |= SBAL_FLAGS_LAST_ENTRY;
 320
 321         return bytes;
 322 }
 323
 324 /**
 325  * zfcp_qdio_send - set PCI flag in first SBALE and send req to QDIO
 326  * @qdio: pointer to struct zfcp_qdio
 327  * @q_req: pointer to struct zfcp_queue_req
 328  * Returns: 0 on success, error otherwise
 329  */
 330 int zfcp_qdio_send(struct zfcp_qdio *qdio, struct zfcp_queue_req *q_req)
 331 {
 332         struct zfcp_qdio_queue *req_q = &qdio->req_q;
 333         int first = q_req->sbal_first;
 334         int count = q_req->sbal_number;
 335         int retval;
 336         unsigned int qdio_flags = QDIO_FLAG_SYNC_OUTPUT;
 337
 338         zfcp_qdio_account(qdio);
 339
 340         retval = do_QDIO(qdio->adapter->ccw_device, qdio_flags, 0, first,
 341                          count);
 342         if (unlikely(retval)) {
 343                 zfcp_qdio_zero_sbals(req_q->sbal, first, count);
 344                 return retval;
 345         }
 346
 347         /* account for transferred buffers */
 348         atomic_sub(count, &req_q->count);
 349         req_q->first += count;
 350         req_q->first %= QDIO_MAX_BUFFERS_PER_Q;
 351         return 0;
 352 }
 353
 354
 355 static void zfcp_qdio_setup_init_data(struct qdio_initialize *id,
 356                                       struct zfcp_qdio *qdio)
 357 {
 358
 359         id->cdev = qdio->adapter->ccw_device;
 360         id->q_format = QDIO_ZFCP_QFMT;
 361         memcpy(id->adapter_name, dev_name(&id->cdev->dev), 8);
 362         ASCEBC(id->adapter_name, 8);
 363         id->qib_param_field_format = 0;
 364         id->qib_param_field = NULL;
 365         id->input_slib_elements = NULL;
 366         id->output_slib_elements = NULL;
 367         id->no_input_qs = 1;
 368         id->no_output_qs = 1;
 369         id->input_handler = zfcp_qdio_int_resp;
 370         id->output_handler = zfcp_qdio_int_req;
 371         id->int_parm = (unsigned long) qdio;
 372         id->flags = QDIO_INBOUND_0COPY_SBALS |
 373                     QDIO_OUTBOUND_0COPY_SBALS | QDIO_USE_OUTBOUND_PCIS;
 374         id->input_sbal_addr_array = (void **) (qdio->resp_q.sbal);
 375         id->output_sbal_addr_array = (void **) (qdio->req_q.sbal);
 376
 377 }
 378 /**
 379  * zfcp_qdio_allocate - allocate queue memory and initialize QDIO data
 380  * @adapter: pointer to struct zfcp_adapter
 381  * Returns: -ENOMEM on memory allocation error or return value from
 382  *          qdio_allocate
 383  */
 384 int zfcp_qdio_allocate(struct zfcp_qdio *qdio, struct ccw_device *ccw_dev)
 385 {
 386         struct qdio_initialize init_data;
 387
 388         if (zfcp_qdio_buffers_enqueue(qdio->req_q.sbal) ||
 389             zfcp_qdio_buffers_enqueue(qdio->resp_q.sbal))
 390                 return -ENOMEM;
 391
 392         zfcp_qdio_setup_init_data(&init_data, qdio);
 393
 394         return qdio_allocate(&init_data);
 395 }
 396
 397 /**
 398  * zfcp_close_qdio - close qdio queues for an adapter
 399  * @qdio: pointer to structure zfcp_qdio
 400  */
 401 void zfcp_qdio_close(struct zfcp_qdio *qdio)
 402 {
 403         struct zfcp_qdio_queue *req_q;
 404         int first, count;
 405
 406         if (!(atomic_read(&qdio->adapter->status) & ZFCP_STATUS_ADAPTER_QDIOUP))
 407                 return;
 408
 409         /* clear QDIOUP flag, thus do_QDIO is not called during qdio_shutdown */
 410         req_q = &qdio->req_q;
 411         spin_lock_bh(&qdio->req_q_lock);
 412         atomic_clear_mask(ZFCP_STATUS_ADAPTER_QDIOUP, &qdio->adapter->status);
 413         spin_unlock_bh(&qdio->req_q_lock);
 414
 415         qdio_shutdown(qdio->adapter->ccw_device,
 416                       QDIO_FLAG_CLEANUP_USING_CLEAR);
 417
 418         /* cleanup used outbound sbals */
 419         count = atomic_read(&req_q->count);
 420         if (count < QDIO_MAX_BUFFERS_PER_Q) {
 421                 first = (req_q->first + count) % QDIO_MAX_BUFFERS_PER_Q;
 422                 count = QDIO_MAX_BUFFERS_PER_Q - count;
 423                 zfcp_qdio_zero_sbals(req_q->sbal, first, count);
 424         }
 425         req_q->first = 0;
 426         atomic_set(&req_q->count, 0);
 427         qdio->resp_q.first = 0;
 428         atomic_set(&qdio->resp_q.count, 0);
 429 }
 430
 431 /**
 432  * zfcp_qdio_open - prepare and initialize response queue
 433  * @qdio: pointer to struct zfcp_qdio
 434  * Returns: 0 on success, otherwise -EIO
 435  */
 436 int zfcp_qdio_open(struct zfcp_qdio *qdio)
 437 {
 438         struct qdio_buffer_element *sbale;
 439         struct qdio_initialize init_data;
 440         struct ccw_device *cdev = qdio->adapter->ccw_device;
 441         int cc;
 442
 443         if (atomic_read(&qdio->adapter->status) & ZFCP_STATUS_ADAPTER_QDIOUP)
 444                 return -EIO;
 445
 446         zfcp_qdio_setup_init_data(&init_data, qdio);
 447
 448         if (qdio_establish(&init_data))
 449                 goto failed_establish;
 450
 451         if (qdio_activate(cdev))
 452                 goto failed_qdio;
 453
 454         for (cc = 0; cc < QDIO_MAX_BUFFERS_PER_Q; cc++) {
 455                 sbale = &(qdio->resp_q.sbal[cc]->element[0]);
 456                 sbale->length = 0;
 457                 sbale->flags = SBAL_FLAGS_LAST_ENTRY;
 458                 sbale->addr = NULL;
 459         }
 460
 461         if (do_QDIO(cdev, QDIO_FLAG_SYNC_INPUT, 0, 0,
 462                      QDIO_MAX_BUFFERS_PER_Q))
 463                 goto failed_qdio;
 464
 465         /* set index of first avalable SBALS / number of available SBALS */
 466         qdio->req_q.first = 0;
 467         atomic_set(&qdio->req_q.count, QDIO_MAX_BUFFERS_PER_Q);
 468
 469         return 0;
 470
 471 failed_qdio:
 472         qdio_shutdown(cdev, QDIO_FLAG_CLEANUP_USING_CLEAR);
 473 failed_establish:
 474         dev_err(&cdev->dev,
 475                 "Setting up the QDIO connection to the FCP adapter failed\n");
 476         return -EIO;
 477 }