LXR linux/drivers/scsi/snic/snic

   1/*
   2 * Copyright 2014 Cisco Systems, Inc.  All rights reserved.
   3 *
   4 * This program is free software; you may redistribute it and/or modify
   5 * it under the terms of the GNU General Public License as published by
   6 * the Free Software Foundation; version 2 of the License.
   7 *
   8 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
   9 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  10 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  11 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
  12 * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
  13 * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
  14 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  15 * SOFTWARE.
  16 */
  17
  18#include <linux/errno.h>
  19#include <linux/pci.h>
  20#include <linux/slab.h>
  21
  22#include <linux/interrupt.h>
  23#include <linux/workqueue.h>
  24#include <linux/spinlock.h>
  25#include <linux/mempool.h>
  26#include <scsi/scsi_tcq.h>
  27
  28#include "snic_io.h"
  29#include "snic.h"
  30#include "cq_enet_desc.h"
  31#include "snic_fwint.h"
  32
  33static void
  34snic_wq_cmpl_frame_send(struct vnic_wq *wq,
  35                            struct cq_desc *cq_desc,
  36                            struct vnic_wq_buf *buf,
  37                            void *opaque)
  38{
  39        struct snic *snic = svnic_dev_priv(wq->vdev);
  40
  41        SNIC_BUG_ON(buf->os_buf == NULL);
  42
  43        if (snic_log_level & SNIC_DESC_LOGGING)
  44                SNIC_HOST_INFO(snic->shost,
  45                               "Ack received for snic_host_req %p.\n",
  46                               buf->os_buf);
  47
  48        SNIC_TRC(snic->shost->host_no, 0, 0,
  49                 ((ulong)(buf->os_buf) - sizeof(struct snic_req_info)), 0, 0,
  50                 0);
  51
  52        buf->os_buf = NULL;
  53}
  54
  55static int
  56snic_wq_cmpl_handler_cont(struct vnic_dev *vdev,
  57                          struct cq_desc *cq_desc,
  58                          u8 type,
  59                          u16 q_num,
  60                          u16 cmpl_idx,
  61                          void *opaque)
  62{
  63        struct snic *snic = svnic_dev_priv(vdev);
  64        unsigned long flags;
  65
  66        SNIC_BUG_ON(q_num != 0);
  67
  68        spin_lock_irqsave(&snic->wq_lock[q_num], flags);
  69        svnic_wq_service(&snic->wq[q_num],
  70                         cq_desc,
  71                         cmpl_idx,
  72                         snic_wq_cmpl_frame_send,
  73                         NULL);
  74        spin_unlock_irqrestore(&snic->wq_lock[q_num], flags);
  75
  76        return 0;
  77} /* end of snic_cmpl_handler_cont */
  78
  79int
  80snic_wq_cmpl_handler(struct snic *snic, int work_to_do)
  81{
  82        unsigned int work_done = 0;
  83        unsigned int i;
  84
  85        snic->s_stats.misc.last_ack_time = jiffies;
  86        for (i = 0; i < snic->wq_count; i++) {
  87                work_done += svnic_cq_service(&snic->cq[i],
  88                                              work_to_do,
  89                                              snic_wq_cmpl_handler_cont,
  90                                              NULL);
  91        }
  92
  93        return work_done;
  94} /* end of snic_wq_cmpl_handler */
  95
  96void
  97snic_free_wq_buf(struct vnic_wq *wq, struct vnic_wq_buf *buf)
  98{
  99
 100        struct snic_host_req *req = buf->os_buf;
 101        struct snic *snic = svnic_dev_priv(wq->vdev);
 102        struct snic_req_info *rqi = NULL;
 103        unsigned long flags;
 104
 105        pci_unmap_single(snic->pdev, buf->dma_addr, buf->len, PCI_DMA_TODEVICE);
 106
 107        rqi = req_to_rqi(req);
 108        spin_lock_irqsave(&snic->spl_cmd_lock, flags);
 109        if (list_empty(&rqi->list)) {
 110                spin_unlock_irqrestore(&snic->spl_cmd_lock, flags);
 111                goto end;
 112        }
 113
 114        SNIC_BUG_ON(rqi->list.next == NULL); /* if not added to spl_cmd_list */
 115        list_del_init(&rqi->list);
 116        spin_unlock_irqrestore(&snic->spl_cmd_lock, flags);
 117
 118        if (rqi->sge_va) {
 119                snic_pci_unmap_rsp_buf(snic, rqi);
 120                kfree((void *)rqi->sge_va);
 121                rqi->sge_va = 0;
 122        }
 123        snic_req_free(snic, rqi);
 124        SNIC_HOST_INFO(snic->shost, "snic_free_wq_buf .. freed.\n");
 125
 126end:
 127        return;
 128}
 129
 130/* Criteria to select work queue in multi queue mode */
 131static int
 132snic_select_wq(struct snic *snic)
 133{
 134        /* No multi queue support for now */
 135        BUILD_BUG_ON(SNIC_WQ_MAX > 1);
 136
 137        return 0;
 138}
 139
 140static int
 141snic_wqdesc_avail(struct snic *snic, int q_num, int req_type)
 142{
 143        int nr_wqdesc = snic->config.wq_enet_desc_count;
 144
 145        if (q_num > 0) {
 146                /*
 147                 * Multi Queue case, additional care is required.
 148                 * Per WQ active requests need to be maintained.
 149                 */
 150                SNIC_HOST_INFO(snic->shost, "desc_avail: Multi Queue case.\n");
 151                SNIC_BUG_ON(q_num > 0);
 152
 153                return -1;
 154        }
 155
 156        nr_wqdesc -= atomic64_read(&snic->s_stats.fw.actv_reqs);
 157
 158        return ((req_type == SNIC_REQ_HBA_RESET) ? nr_wqdesc : nr_wqdesc - 1);
 159}
 160
 161int
 162snic_queue_wq_desc(struct snic *snic, void *os_buf, u16 len)
 163{
 164        dma_addr_t pa = 0;
 165        unsigned long flags;
 166        struct snic_fw_stats *fwstats = &snic->s_stats.fw;
 167        struct snic_host_req *req = (struct snic_host_req *) os_buf;
 168        long act_reqs;
 169        long desc_avail = 0;
 170        int q_num = 0;
 171
 172        snic_print_desc(__func__, os_buf, len);
 173
 174        /* Map request buffer */
 175        pa = pci_map_single(snic->pdev, os_buf, len, PCI_DMA_TODEVICE);
 176        if (pci_dma_mapping_error(snic->pdev, pa)) {
 177                SNIC_HOST_ERR(snic->shost, "qdesc: PCI DMA Mapping Fail.\n");
 178
 179                return -ENOMEM;
 180        }
 181
 182        req->req_pa = (ulong)pa;
 183
 184        q_num = snic_select_wq(snic);
 185
 186        spin_lock_irqsave(&snic->wq_lock[q_num], flags);
 187        desc_avail = snic_wqdesc_avail(snic, q_num, req->hdr.type);
 188        if (desc_avail <= 0) {
 189                pci_unmap_single(snic->pdev, pa, len, PCI_DMA_TODEVICE);
 190                req->req_pa = 0;
 191                spin_unlock_irqrestore(&snic->wq_lock[q_num], flags);
 192                atomic64_inc(&snic->s_stats.misc.wq_alloc_fail);
 193                SNIC_DBG("host = %d, WQ is Full\n", snic->shost->host_no);
 194
 195                return -ENOMEM;
 196        }
 197
 198        snic_queue_wq_eth_desc(&snic->wq[q_num], os_buf, pa, len, 0, 0, 1);
 199        /*
 200         * Update stats
 201         * note: when multi queue enabled, fw actv_reqs should be per queue.
 202         */
 203        act_reqs = atomic64_inc_return(&fwstats->actv_reqs);
 204        spin_unlock_irqrestore(&snic->wq_lock[q_num], flags);
 205
 206        if (act_reqs > atomic64_read(&fwstats->max_actv_reqs))
 207                atomic64_set(&fwstats->max_actv_reqs, act_reqs);
 208
 209        return 0;
 210} /* end of snic_queue_wq_desc() */
 211
 212/*
 213 * snic_handle_untagged_req: Adds snic specific requests to spl_cmd_list.
 214 * Purpose : Used during driver unload to clean up the requests.
 215 */
 216void
 217snic_handle_untagged_req(struct snic *snic, struct snic_req_info *rqi)
 218{
 219        unsigned long flags;
 220
 221        INIT_LIST_HEAD(&rqi->list);
 222
 223        spin_lock_irqsave(&snic->spl_cmd_lock, flags);
 224        list_add_tail(&rqi->list, &snic->spl_cmd_list);
 225        spin_unlock_irqrestore(&snic->spl_cmd_lock, flags);
 226}
 227
 228/*
 229 * snic_req_init:
 230 * Allocates snic_req_info + snic_host_req + sgl data, and initializes.
 231 */
 232struct snic_req_info *
 233snic_req_init(struct snic *snic, int sg_cnt)
 234{
 235        u8 typ;
 236        struct snic_req_info *rqi = NULL;
 237
 238        typ = (sg_cnt <= SNIC_REQ_CACHE_DFLT_SGL) ?
 239                SNIC_REQ_CACHE_DFLT_SGL : SNIC_REQ_CACHE_MAX_SGL;
 240
 241        rqi = mempool_alloc(snic->req_pool[typ], GFP_ATOMIC);
 242        if (!rqi) {
 243                atomic64_inc(&snic->s_stats.io.alloc_fail);
 244                SNIC_HOST_ERR(snic->shost,
 245                              "Failed to allocate memory from snic req pool id = %d\n",
 246                              typ);
 247                return rqi;
 248        }
 249
 250        memset(rqi, 0, sizeof(*rqi));
 251        rqi->rq_pool_type = typ;
 252        rqi->start_time = jiffies;
 253        rqi->req = (struct snic_host_req *) (rqi + 1);
 254        rqi->req_len = sizeof(struct snic_host_req);
 255        rqi->snic = snic;
 256
 257        rqi->req = (struct snic_host_req *)(rqi + 1);
 258
 259        if (sg_cnt == 0)
 260                goto end;
 261
 262        rqi->req_len += (sg_cnt * sizeof(struct snic_sg_desc));
 263
 264        if (sg_cnt > atomic64_read(&snic->s_stats.io.max_sgl))
 265                atomic64_set(&snic->s_stats.io.max_sgl, sg_cnt);
 266
 267        SNIC_BUG_ON(sg_cnt > SNIC_MAX_SG_DESC_CNT);
 268        atomic64_inc(&snic->s_stats.io.sgl_cnt[sg_cnt - 1]);
 269
 270end:
 271        memset(rqi->req, 0, rqi->req_len);
 272
 273        /* pre initialization of init_ctx to support req_to_rqi */
 274        rqi->req->hdr.init_ctx = (ulong) rqi;
 275
 276        SNIC_SCSI_DBG(snic->shost, "Req_alloc:rqi = %p allocatd.\n", rqi);
 277
 278        return rqi;
 279} /* end of snic_req_init */
 280
 281/*
 282 * snic_abort_req_init : Inits abort request.
 283 */
 284struct snic_host_req *
 285snic_abort_req_init(struct snic *snic, struct snic_req_info *rqi)
 286{
 287        struct snic_host_req *req = NULL;
 288
 289        SNIC_BUG_ON(!rqi);
 290
 291        /* If abort to be issued second time, then reuse */
 292        if (rqi->abort_req)
 293                return rqi->abort_req;
 294
 295
 296        req = mempool_alloc(snic->req_pool[SNIC_REQ_TM_CACHE], GFP_ATOMIC);
 297        if (!req) {
 298                SNIC_HOST_ERR(snic->shost, "abts:Failed to alloc tm req.\n");
 299                WARN_ON_ONCE(1);
 300
 301                return NULL;
 302        }
 303
 304        rqi->abort_req = req;
 305        memset(req, 0, sizeof(struct snic_host_req));
 306        /* pre initialization of init_ctx to support req_to_rqi */
 307        req->hdr.init_ctx = (ulong) rqi;
 308
 309        return req;
 310} /* end of snic_abort_req_init */
 311
 312/*
 313 * snic_dr_req_init : Inits device reset req
 314 */
 315struct snic_host_req *
 316snic_dr_req_init(struct snic *snic, struct snic_req_info *rqi)
 317{
 318        struct snic_host_req *req = NULL;
 319
 320        SNIC_BUG_ON(!rqi);
 321
 322        req = mempool_alloc(snic->req_pool[SNIC_REQ_TM_CACHE], GFP_ATOMIC);
 323        if (!req) {
 324                SNIC_HOST_ERR(snic->shost, "dr:Failed to alloc tm req.\n");
 325                WARN_ON_ONCE(1);
 326
 327                return NULL;
 328        }
 329
 330        SNIC_BUG_ON(rqi->dr_req != NULL);
 331        rqi->dr_req = req;
 332        memset(req, 0, sizeof(struct snic_host_req));
 333        /* pre initialization of init_ctx to support req_to_rqi */
 334        req->hdr.init_ctx = (ulong) rqi;
 335
 336        return req;
 337} /* end of snic_dr_req_init */
 338
 339/* frees snic_req_info and snic_host_req */
 340void
 341snic_req_free(struct snic *snic, struct snic_req_info *rqi)
 342{
 343        SNIC_BUG_ON(rqi->req == rqi->abort_req);
 344        SNIC_BUG_ON(rqi->req == rqi->dr_req);
 345        SNIC_BUG_ON(rqi->sge_va != 0);
 346
 347        SNIC_SCSI_DBG(snic->shost,
 348                      "Req_free:rqi %p:ioreq %p:abt %p:dr %p\n",
 349                      rqi, rqi->req, rqi->abort_req, rqi->dr_req);
 350
 351        if (rqi->abort_req) {
 352                if (rqi->abort_req->req_pa)
 353                        pci_unmap_single(snic->pdev,
 354                                         rqi->abort_req->req_pa,
 355                                         sizeof(struct snic_host_req),
 356                                         PCI_DMA_TODEVICE);
 357
 358                mempool_free(rqi->abort_req, snic->req_pool[SNIC_REQ_TM_CACHE]);
 359        }
 360
 361        if (rqi->dr_req) {
 362                if (rqi->dr_req->req_pa)
 363                        pci_unmap_single(snic->pdev,
 364                                         rqi->dr_req->req_pa,
 365                                         sizeof(struct snic_host_req),
 366                                         PCI_DMA_TODEVICE);
 367
 368                mempool_free(rqi->dr_req, snic->req_pool[SNIC_REQ_TM_CACHE]);
 369        }
 370
 371        if (rqi->req->req_pa)
 372                pci_unmap_single(snic->pdev,
 373                                 rqi->req->req_pa,
 374                                 rqi->req_len,
 375                                 PCI_DMA_TODEVICE);
 376
 377        mempool_free(rqi, snic->req_pool[rqi->rq_pool_type]);
 378}
 379
 380void
 381snic_pci_unmap_rsp_buf(struct snic *snic, struct snic_req_info *rqi)
 382{
 383        struct snic_sg_desc *sgd;
 384
 385        sgd = req_to_sgl(rqi_to_req(rqi));
 386        SNIC_BUG_ON(sgd[0].addr == 0);
 387        pci_unmap_single(snic->pdev,
 388                         le64_to_cpu(sgd[0].addr),
 389                         le32_to_cpu(sgd[0].len),
 390                         PCI_DMA_FROMDEVICE);
 391}
 392
 393/*
 394 * snic_free_all_untagged_reqs: Walks through untagged reqs and frees them.
 395 */
 396void
 397snic_free_all_untagged_reqs(struct snic *snic)
 398{
 399        struct snic_req_info *rqi;
 400        struct list_head *cur, *nxt;
 401        unsigned long flags;
 402
 403        spin_lock_irqsave(&snic->spl_cmd_lock, flags);
 404        list_for_each_safe(cur, nxt, &snic->spl_cmd_list) {
 405                rqi = list_entry(cur, struct snic_req_info, list);
 406                list_del_init(&rqi->list);
 407                if (rqi->sge_va) {
 408                        snic_pci_unmap_rsp_buf(snic, rqi);
 409                        kfree((void *)rqi->sge_va);
 410                        rqi->sge_va = 0;
 411                }
 412
 413                snic_req_free(snic, rqi);
 414        }
 415        spin_unlock_irqrestore(&snic->spl_cmd_lock, flags);
 416}
 417
 418/*
 419 * snic_release_untagged_req : Unlinks the untagged req and frees it.
 420 */
 421void
 422snic_release_untagged_req(struct snic *snic, struct snic_req_info *rqi)
 423{
 424        unsigned long flags;
 425
 426        spin_lock_irqsave(&snic->snic_lock, flags);
 427        if (snic->in_remove) {
 428                spin_unlock_irqrestore(&snic->snic_lock, flags);
 429                goto end;
 430        }
 431        spin_unlock_irqrestore(&snic->snic_lock, flags);
 432
 433        spin_lock_irqsave(&snic->spl_cmd_lock, flags);
 434        if (list_empty(&rqi->list)) {
 435                spin_unlock_irqrestore(&snic->spl_cmd_lock, flags);
 436                goto end;
 437        }
 438        list_del_init(&rqi->list);
 439        spin_unlock_irqrestore(&snic->spl_cmd_lock, flags);
 440        snic_req_free(snic, rqi);
 441
 442end:
 443        return;
 444}
 445
 446/* dump buf in hex fmt */
 447void
 448snic_hex_dump(char *pfx, char *data, int len)
 449{
 450        SNIC_INFO("%s Dumping Data of Len = %d\n", pfx, len);
 451        print_hex_dump_bytes(pfx, DUMP_PREFIX_NONE, data, len);
 452}
 453
 454#define LINE_BUFSZ      128     /* for snic_print_desc fn */
 455static void
 456snic_dump_desc(const char *fn, char *os_buf, int len)
 457{
 458        struct snic_host_req *req = (struct snic_host_req *) os_buf;
 459        struct snic_fw_req *fwreq = (struct snic_fw_req *) os_buf;
 460        struct snic_req_info *rqi = NULL;
 461        char line[LINE_BUFSZ] = { '\0' };
 462        char *cmd_str = NULL;
 463
 464        if (req->hdr.type >= SNIC_RSP_REPORT_TGTS_CMPL)
 465                rqi = (struct snic_req_info *) fwreq->hdr.init_ctx;
 466        else
 467                rqi = (struct snic_req_info *) req->hdr.init_ctx;
 468
 469        SNIC_BUG_ON(rqi == NULL || rqi->req == NULL);
 470        switch (req->hdr.type) {
 471        case SNIC_REQ_REPORT_TGTS:
 472                cmd_str = "report-tgt : ";
 473                snprintf(line, LINE_BUFSZ, "SNIC_REQ_REPORT_TGTS :");
 474                break;
 475
 476        case SNIC_REQ_ICMND:
 477                cmd_str = "icmnd : ";
 478                snprintf(line, LINE_BUFSZ, "SNIC_REQ_ICMND : 0x%x :",
 479                         req->u.icmnd.cdb[0]);
 480                break;
 481
 482        case SNIC_REQ_ITMF:
 483                cmd_str = "itmf : ";
 484                snprintf(line, LINE_BUFSZ, "SNIC_REQ_ITMF :");
 485                break;
 486
 487        case SNIC_REQ_HBA_RESET:
 488                cmd_str = "hba reset :";
 489                snprintf(line, LINE_BUFSZ, "SNIC_REQ_HBA_RESET :");
 490                break;
 491
 492        case SNIC_REQ_EXCH_VER:
 493                cmd_str = "exch ver : ";
 494                snprintf(line, LINE_BUFSZ, "SNIC_REQ_EXCH_VER :");
 495                break;
 496
 497        case SNIC_REQ_TGT_INFO:
 498                cmd_str = "tgt info : ";
 499                break;
 500
 501        case SNIC_RSP_REPORT_TGTS_CMPL:
 502                cmd_str = "report tgt cmpl : ";
 503                snprintf(line, LINE_BUFSZ, "SNIC_RSP_REPORT_TGTS_CMPL :");
 504                break;
 505
 506        case SNIC_RSP_ICMND_CMPL:
 507                cmd_str = "icmnd_cmpl : ";
 508                snprintf(line, LINE_BUFSZ, "SNIC_RSP_ICMND_CMPL : 0x%x :",
 509                         rqi->req->u.icmnd.cdb[0]);
 510                break;
 511
 512        case SNIC_RSP_ITMF_CMPL:
 513                cmd_str = "itmf_cmpl : ";
 514                snprintf(line, LINE_BUFSZ, "SNIC_RSP_ITMF_CMPL :");
 515                break;
 516
 517        case SNIC_RSP_HBA_RESET_CMPL:
 518                cmd_str = "hba_reset_cmpl : ";
 519                snprintf(line, LINE_BUFSZ, "SNIC_RSP_HBA_RESET_CMPL :");
 520                break;
 521
 522        case SNIC_RSP_EXCH_VER_CMPL:
 523                cmd_str = "exch_ver_cmpl : ";
 524                snprintf(line, LINE_BUFSZ, "SNIC_RSP_EXCH_VER_CMPL :");
 525                break;
 526
 527        case SNIC_MSG_ACK:
 528                cmd_str = "msg ack : ";
 529                snprintf(line, LINE_BUFSZ, "SNIC_MSG_ACK :");
 530                break;
 531
 532        case SNIC_MSG_ASYNC_EVNOTIFY:
 533                cmd_str = "async notify : ";
 534                snprintf(line, LINE_BUFSZ, "SNIC_MSG_ASYNC_EVNOTIFY :");
 535                break;
 536
 537        default:
 538                cmd_str = "unknown : ";
 539                SNIC_BUG_ON(1);
 540                break;
 541        }
 542
 543        SNIC_INFO("%s:%s >>cmndid=%x:sg_cnt = %x:status = %x:ctx = %lx.\n",
 544                  fn, line, req->hdr.cmnd_id, req->hdr.sg_cnt, req->hdr.status,
 545                  req->hdr.init_ctx);
 546
 547        /* Enable it, to dump byte stream */
 548        if (snic_log_level & 0x20)
 549                snic_hex_dump(cmd_str, os_buf, len);
 550} /* end of __snic_print_desc */
 551
 552void
 553snic_print_desc(const char *fn, char *os_buf, int len)
 554{
 555        if (snic_log_level & SNIC_DESC_LOGGING)
 556                snic_dump_desc(fn, os_buf, len);
 557}
 558
 559void
 560snic_calc_io_process_time(struct snic *snic, struct snic_req_info *rqi)
 561{
 562        u64 duration;
 563
 564        duration = jiffies - rqi->start_time;
 565
 566        if (duration > atomic64_read(&snic->s_stats.io.max_time))
 567                atomic64_set(&snic->s_stats.io.max_time, duration);
 568}
 569