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