drivers/scsi/snic/snic_disc.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 // Copyright 2014 Cisco Systems, Inc.  All rights reserved.
   3
   4 #include <linux/errno.h>
   5 #include <linux/mempool.h>
   6
   7 #include <scsi/scsi_tcq.h>
   8
   9 #include "snic_disc.h"
  10 #include "snic.h"
  11 #include "snic_io.h"
  12
  13
  14 /* snic target types */
  15 static const char * const snic_tgt_type_str[] = {
  16         [SNIC_TGT_DAS] = "DAS",
  17         [SNIC_TGT_SAN] = "SAN",
  18 };
  19
  20 static inline const char *
  21 snic_tgt_type_to_str(int typ)
  22 {
  23         return ((typ > SNIC_TGT_NONE && typ <= SNIC_TGT_SAN) ?
  24                  snic_tgt_type_str[typ] : "Unknown");
  25 }
  26
  27 static const char * const snic_tgt_state_str[] = {
  28         [SNIC_TGT_STAT_INIT]    = "INIT",
  29         [SNIC_TGT_STAT_ONLINE]  = "ONLINE",
  30         [SNIC_TGT_STAT_OFFLINE] = "OFFLINE",
  31         [SNIC_TGT_STAT_DEL]     = "DELETION IN PROGRESS",
  32 };
  33
  34 const char *
  35 snic_tgt_state_to_str(int state)
  36 {
  37         return ((state >= SNIC_TGT_STAT_INIT && state <= SNIC_TGT_STAT_DEL) ?
  38                 snic_tgt_state_str[state] : "UNKNOWN");
  39 }
  40
  41 /*
  42  * Initiate report_tgt req desc
  43  */
  44 static void
  45 snic_report_tgt_init(struct snic_host_req *req, u32 hid, u8 *buf, u32 len,
  46                      dma_addr_t rsp_buf_pa, ulong ctx)
  47 {
  48         struct snic_sg_desc *sgd = NULL;
  49
  50
  51         snic_io_hdr_enc(&req->hdr, SNIC_REQ_REPORT_TGTS, 0, SCSI_NO_TAG, hid,
  52                         1, ctx);
  53
  54         req->u.rpt_tgts.sg_cnt = cpu_to_le16(1);
  55         sgd = req_to_sgl(req);
  56         sgd[0].addr = cpu_to_le64(rsp_buf_pa);
  57         sgd[0].len = cpu_to_le32(len);
  58         sgd[0]._resvd = 0;
  59         req->u.rpt_tgts.sg_addr = cpu_to_le64((ulong)sgd);
  60 }
  61
  62 /*
  63  * snic_queue_report_tgt_req: Queues report target request.
  64  */
  65 static int
  66 snic_queue_report_tgt_req(struct snic *snic)
  67 {
  68         struct snic_req_info *rqi = NULL;
  69         u32 ntgts, buf_len = 0;
  70         u8 *buf = NULL;
  71         dma_addr_t pa = 0;
  72         int ret = 0;
  73
  74         rqi = snic_req_init(snic, 1);
  75         if (!rqi) {
  76                 ret = -ENOMEM;
  77                 goto error;
  78         }
  79
  80         if (snic->fwinfo.max_tgts)
  81                 ntgts = min_t(u32, snic->fwinfo.max_tgts, snic->shost->max_id);
  82         else
  83                 ntgts = snic->shost->max_id;
  84
  85         /* Allocate Response Buffer */
  86         SNIC_BUG_ON(ntgts == 0);
  87         buf_len = ntgts * sizeof(struct snic_tgt_id) + SNIC_SG_DESC_ALIGN;
  88
  89         buf = kzalloc(buf_len, GFP_KERNEL);
  90         if (!buf) {
  91                 snic_req_free(snic, rqi);
  92                 SNIC_HOST_ERR(snic->shost, "Resp Buf Alloc Failed.\n");
  93
  94                 ret = -ENOMEM;
  95                 goto error;
  96         }
  97
  98         SNIC_BUG_ON((((unsigned long)buf) % SNIC_SG_DESC_ALIGN) != 0);
  99
 100         pa = dma_map_single(&snic->pdev->dev, buf, buf_len, DMA_FROM_DEVICE);
 101         if (dma_mapping_error(&snic->pdev->dev, pa)) {
 102                 SNIC_HOST_ERR(snic->shost,
 103                               "Rpt-tgt rspbuf %p: PCI DMA Mapping Failed\n",
 104                               buf);
 105                 kfree(buf);
 106                 snic_req_free(snic, rqi);
 107                 ret = -EINVAL;
 108
 109                 goto error;
 110         }
 111
 112
 113         SNIC_BUG_ON(pa == 0);
 114         rqi->sge_va = (ulong) buf;
 115
 116         snic_report_tgt_init(rqi->req,
 117                              snic->config.hid,
 118                              buf,
 119                              buf_len,
 120                              pa,
 121                              (ulong)rqi);
 122
 123         snic_handle_untagged_req(snic, rqi);
 124
 125         ret = snic_queue_wq_desc(snic, rqi->req, rqi->req_len);
 126         if (ret) {
 127                 dma_unmap_single(&snic->pdev->dev, pa, buf_len,
 128                                  DMA_FROM_DEVICE);
 129                 kfree(buf);
 130                 rqi->sge_va = 0;
 131                 snic_release_untagged_req(snic, rqi);
 132                 SNIC_HOST_ERR(snic->shost, "Queuing Report Tgts Failed.\n");
 133
 134                 goto error;
 135         }
 136
 137         SNIC_DISC_DBG(snic->shost, "Report Targets Issued.\n");
 138
 139         return ret;
 140
 141 error:
 142         SNIC_HOST_ERR(snic->shost,
 143                       "Queuing Report Targets Failed, err = %d\n",
 144                       ret);
 145         return ret;
 146 } /* end of snic_queue_report_tgt_req */
 147
 148 /* call into SML */
 149 static void
 150 snic_scsi_scan_tgt(struct work_struct *work)
 151 {
 152         struct snic_tgt *tgt = container_of(work, struct snic_tgt, scan_work);
 153         struct Scsi_Host *shost = dev_to_shost(&tgt->dev);
 154         unsigned long flags;
 155
 156         SNIC_HOST_INFO(shost, "Scanning Target id 0x%x\n", tgt->id);
 157         scsi_scan_target(&tgt->dev,
 158                          tgt->channel,
 159                          tgt->scsi_tgt_id,
 160                          SCAN_WILD_CARD,
 161                          SCSI_SCAN_RESCAN);
 162
 163         spin_lock_irqsave(shost->host_lock, flags);
 164         tgt->flags &= ~SNIC_TGT_SCAN_PENDING;
 165         spin_unlock_irqrestore(shost->host_lock, flags);
 166 } /* end of snic_scsi_scan_tgt */
 167
 168 /*
 169  * snic_tgt_lookup :
 170  */
 171 static struct snic_tgt *
 172 snic_tgt_lookup(struct snic *snic, struct snic_tgt_id *tgtid)
 173 {
 174         struct list_head *cur, *nxt;
 175         struct snic_tgt *tgt = NULL;
 176
 177         list_for_each_safe(cur, nxt, &snic->disc.tgt_list) {
 178                 tgt = list_entry(cur, struct snic_tgt, list);
 179                 if (tgt->id == le32_to_cpu(tgtid->tgt_id))
 180                         return tgt;
 181                 tgt = NULL;
 182         }
 183
 184         return tgt;
 185 } /* end of snic_tgt_lookup */
 186
 187 /*
 188  * snic_tgt_dev_release : Called on dropping last ref for snic_tgt object
 189  */
 190 void
 191 snic_tgt_dev_release(struct device *dev)
 192 {
 193         struct snic_tgt *tgt = dev_to_tgt(dev);
 194
 195         SNIC_HOST_INFO(snic_tgt_to_shost(tgt),
 196                        "Target Device ID %d (%s) Permanently Deleted.\n",
 197                        tgt->id,
 198                        dev_name(dev));
 199
 200         SNIC_BUG_ON(!list_empty(&tgt->list));
 201         kfree(tgt);
 202 }
 203
 204 /*
 205  * snic_tgt_del : work function to delete snic_tgt
 206  */
 207 static void
 208 snic_tgt_del(struct work_struct *work)
 209 {
 210         struct snic_tgt *tgt = container_of(work, struct snic_tgt, del_work);
 211         struct Scsi_Host *shost = snic_tgt_to_shost(tgt);
 212
 213         if (tgt->flags & SNIC_TGT_SCAN_PENDING)
 214                 scsi_flush_work(shost);
 215
 216         /* Block IOs on child devices, stops new IOs */
 217         scsi_target_block(&tgt->dev);
 218
 219         /* Cleanup IOs */
 220         snic_tgt_scsi_abort_io(tgt);
 221
 222         /* Unblock IOs now, to flush if there are any. */
 223         scsi_target_unblock(&tgt->dev, SDEV_TRANSPORT_OFFLINE);
 224
 225         /* Delete SCSI Target and sdevs */
 226         scsi_remove_target(&tgt->dev);  /* ?? */
 227         device_del(&tgt->dev);
 228         put_device(&tgt->dev);
 229 } /* end of snic_tgt_del */
 230
 231 /* snic_tgt_create: checks for existence of snic_tgt, if it doesn't
 232  * it creates one.
 233  */
 234 static struct snic_tgt *
 235 snic_tgt_create(struct snic *snic, struct snic_tgt_id *tgtid)
 236 {
 237         struct snic_tgt *tgt = NULL;
 238         unsigned long flags;
 239         int ret;
 240
 241         tgt = snic_tgt_lookup(snic, tgtid);
 242         if (tgt) {
 243                 /* update the information if required */
 244                 return tgt;
 245         }
 246
 247         tgt = kzalloc(sizeof(*tgt), GFP_KERNEL);
 248         if (!tgt) {
 249                 SNIC_HOST_ERR(snic->shost, "Failure to allocate snic_tgt.\n");
 250                 ret = -ENOMEM;
 251
 252                 return tgt;
 253         }
 254
 255         INIT_LIST_HEAD(&tgt->list);
 256         tgt->id = le32_to_cpu(tgtid->tgt_id);
 257         tgt->channel = 0;
 258
 259         SNIC_BUG_ON(le16_to_cpu(tgtid->tgt_type) > SNIC_TGT_SAN);
 260         tgt->tdata.typ = le16_to_cpu(tgtid->tgt_type);
 261
 262         /*
 263          * Plugging into SML Device Tree
 264          */
 265         tgt->tdata.disc_id = 0;
 266         tgt->state = SNIC_TGT_STAT_INIT;
 267         device_initialize(&tgt->dev);
 268         tgt->dev.parent = get_device(&snic->shost->shost_gendev);
 269         tgt->dev.release = snic_tgt_dev_release;
 270         INIT_WORK(&tgt->scan_work, snic_scsi_scan_tgt);
 271         INIT_WORK(&tgt->del_work, snic_tgt_del);
 272         switch (tgt->tdata.typ) {
 273         case SNIC_TGT_DAS:
 274                 dev_set_name(&tgt->dev, "snic_das_tgt:%d:%d-%d",
 275                              snic->shost->host_no, tgt->channel, tgt->id);
 276                 break;
 277
 278         case SNIC_TGT_SAN:
 279                 dev_set_name(&tgt->dev, "snic_san_tgt:%d:%d-%d",
 280                              snic->shost->host_no, tgt->channel, tgt->id);
 281                 break;
 282
 283         default:
 284                 SNIC_HOST_INFO(snic->shost, "Target type Unknown Detected.\n");
 285                 dev_set_name(&tgt->dev, "snic_das_tgt:%d:%d-%d",
 286                              snic->shost->host_no, tgt->channel, tgt->id);
 287                 break;
 288         }
 289
 290         spin_lock_irqsave(snic->shost->host_lock, flags);
 291         list_add_tail(&tgt->list, &snic->disc.tgt_list);
 292         tgt->scsi_tgt_id = snic->disc.nxt_tgt_id++;
 293         tgt->state = SNIC_TGT_STAT_ONLINE;
 294         spin_unlock_irqrestore(snic->shost->host_lock, flags);
 295
 296         SNIC_HOST_INFO(snic->shost,
 297                        "Tgt %d, type = %s detected. Adding..\n",
 298                        tgt->id, snic_tgt_type_to_str(tgt->tdata.typ));
 299
 300         ret = device_add(&tgt->dev);
 301         if (ret) {
 302                 SNIC_HOST_ERR(snic->shost,
 303                               "Snic Tgt: device_add, with err = %d\n",
 304                               ret);
 305
 306                 put_device(&snic->shost->shost_gendev);
 307                 kfree(tgt);
 308                 tgt = NULL;
 309
 310                 return tgt;
 311         }
 312
 313         SNIC_HOST_INFO(snic->shost, "Scanning %s.\n", dev_name(&tgt->dev));
 314
 315         scsi_queue_work(snic->shost, &tgt->scan_work);
 316
 317         return tgt;
 318 } /* end of snic_tgt_create */
 319
 320 /* Handler for discovery */
 321 void
 322 snic_handle_tgt_disc(struct work_struct *work)
 323 {
 324         struct snic *snic = container_of(work, struct snic, tgt_work);
 325         struct snic_tgt_id *tgtid = NULL;
 326         struct snic_tgt *tgt = NULL;
 327         unsigned long flags;
 328         int i;
 329
 330         spin_lock_irqsave(&snic->snic_lock, flags);
 331         if (snic->in_remove) {
 332                 spin_unlock_irqrestore(&snic->snic_lock, flags);
 333                 kfree(snic->disc.rtgt_info);
 334
 335                 return;
 336         }
 337         spin_unlock_irqrestore(&snic->snic_lock, flags);
 338
 339         mutex_lock(&snic->disc.mutex);
 340         /* Discover triggered during disc in progress */
 341         if (snic->disc.req_cnt) {
 342                 snic->disc.state = SNIC_DISC_DONE;
 343                 snic->disc.req_cnt = 0;
 344                 mutex_unlock(&snic->disc.mutex);
 345                 kfree(snic->disc.rtgt_info);
 346                 snic->disc.rtgt_info = NULL;
 347
 348                 SNIC_HOST_INFO(snic->shost, "tgt_disc: Discovery restart.\n");
 349                 /* Start Discovery Again */
 350                 snic_disc_start(snic);
 351
 352                 return;
 353         }
 354
 355         tgtid = (struct snic_tgt_id *)snic->disc.rtgt_info;
 356
 357         SNIC_BUG_ON(snic->disc.rtgt_cnt == 0 || tgtid == NULL);
 358
 359         for (i = 0; i < snic->disc.rtgt_cnt; i++) {
 360                 tgt = snic_tgt_create(snic, &tgtid[i]);
 361                 if (!tgt) {
 362                         int buf_sz = snic->disc.rtgt_cnt * sizeof(*tgtid);
 363
 364                         SNIC_HOST_ERR(snic->shost, "Failed to create tgt.\n");
 365                         snic_hex_dump("rpt_tgt_rsp", (char *)tgtid, buf_sz);
 366                         break;
 367                 }
 368         }
 369
 370         snic->disc.rtgt_info = NULL;
 371         snic->disc.state = SNIC_DISC_DONE;
 372         mutex_unlock(&snic->disc.mutex);
 373
 374         SNIC_HOST_INFO(snic->shost, "Discovery Completed.\n");
 375
 376         kfree(tgtid);
 377 } /* end of snic_handle_tgt_disc */
 378
 379
 380 int
 381 snic_report_tgt_cmpl_handler(struct snic *snic, struct snic_fw_req *fwreq)
 382 {
 383
 384         u8 typ, cmpl_stat;
 385         u32 cmnd_id, hid, tgt_cnt = 0;
 386         ulong ctx;
 387         struct snic_req_info *rqi = NULL;
 388         struct snic_tgt_id *tgtid;
 389         int i, ret = 0;
 390
 391         snic_io_hdr_dec(&fwreq->hdr, &typ, &cmpl_stat, &cmnd_id, &hid, &ctx);
 392         rqi = (struct snic_req_info *) ctx;
 393         tgtid = (struct snic_tgt_id *) rqi->sge_va;
 394
 395         tgt_cnt = le32_to_cpu(fwreq->u.rpt_tgts_cmpl.tgt_cnt);
 396         if (tgt_cnt == 0) {
 397                 SNIC_HOST_ERR(snic->shost, "No Targets Found on this host.\n");
 398                 ret = 1;
 399
 400                 goto end;
 401         }
 402
 403         /* printing list of targets here */
 404         SNIC_HOST_INFO(snic->shost, "Target Count = %d\n", tgt_cnt);
 405
 406         SNIC_BUG_ON(tgt_cnt > snic->fwinfo.max_tgts);
 407
 408         for (i = 0; i < tgt_cnt; i++)
 409                 SNIC_HOST_INFO(snic->shost,
 410                                "Tgt id = 0x%x\n",
 411                                le32_to_cpu(tgtid[i].tgt_id));
 412
 413         /*
 414          * Queue work for further processing,
 415          * Response Buffer Memory is freed after creating targets
 416          */
 417         snic->disc.rtgt_cnt = tgt_cnt;
 418         snic->disc.rtgt_info = (u8 *) tgtid;
 419         queue_work(snic_glob->event_q, &snic->tgt_work);
 420         ret = 0;
 421
 422 end:
 423         /* Unmap Response Buffer */
 424         snic_pci_unmap_rsp_buf(snic, rqi);
 425         if (ret)
 426                 kfree(tgtid);
 427
 428         rqi->sge_va = 0;
 429         snic_release_untagged_req(snic, rqi);
 430
 431         return ret;
 432 } /* end of snic_report_tgt_cmpl_handler */
 433
 434 /* Discovery init fn */
 435 void
 436 snic_disc_init(struct snic_disc *disc)
 437 {
 438         INIT_LIST_HEAD(&disc->tgt_list);
 439         mutex_init(&disc->mutex);
 440         disc->disc_id = 0;
 441         disc->nxt_tgt_id = 0;
 442         disc->state = SNIC_DISC_INIT;
 443         disc->req_cnt = 0;
 444         disc->rtgt_cnt = 0;
 445         disc->rtgt_info = NULL;
 446         disc->cb = NULL;
 447 } /* end of snic_disc_init */
 448
 449 /* Discovery, uninit fn */
 450 void
 451 snic_disc_term(struct snic *snic)
 452 {
 453         struct snic_disc *disc = &snic->disc;
 454
 455         mutex_lock(&disc->mutex);
 456         if (disc->req_cnt) {
 457                 disc->req_cnt = 0;
 458                 SNIC_SCSI_DBG(snic->shost, "Terminating Discovery.\n");
 459         }
 460         mutex_unlock(&disc->mutex);
 461 }
 462
 463 /*
 464  * snic_disc_start: Discovery Start ...
 465  */
 466 int
 467 snic_disc_start(struct snic *snic)
 468 {
 469         struct snic_disc *disc = &snic->disc;
 470         unsigned long flags;
 471         int ret = 0;
 472
 473         SNIC_SCSI_DBG(snic->shost, "Discovery Start.\n");
 474
 475         spin_lock_irqsave(&snic->snic_lock, flags);
 476         if (snic->in_remove) {
 477                 spin_unlock_irqrestore(&snic->snic_lock, flags);
 478                 SNIC_ERR("snic driver removal in progress ...\n");
 479                 ret = 0;
 480
 481                 return ret;
 482         }
 483         spin_unlock_irqrestore(&snic->snic_lock, flags);
 484
 485         mutex_lock(&disc->mutex);
 486         if (disc->state == SNIC_DISC_PENDING) {
 487                 disc->req_cnt++;
 488                 mutex_unlock(&disc->mutex);
 489
 490                 return ret;
 491         }
 492         disc->state = SNIC_DISC_PENDING;
 493         mutex_unlock(&disc->mutex);
 494
 495         ret = snic_queue_report_tgt_req(snic);
 496         if (ret)
 497                 SNIC_HOST_INFO(snic->shost, "Discovery Failed, err=%d.\n", ret);
 498
 499         return ret;
 500 } /* end of snic_disc_start */
 501
 502 /*
 503  * snic_disc_work :
 504  */
 505 void
 506 snic_handle_disc(struct work_struct *work)
 507 {
 508         struct snic *snic = container_of(work, struct snic, disc_work);
 509         int ret = 0;
 510
 511         SNIC_HOST_INFO(snic->shost, "disc_work: Discovery\n");
 512
 513         ret = snic_disc_start(snic);
 514         if (ret)
 515                 goto disc_err;
 516
 517 disc_err:
 518         SNIC_HOST_ERR(snic->shost,
 519                       "disc_work: Discovery Failed w/ err = %d\n",
 520                       ret);
 521 } /* end of snic_disc_work */
 522
 523 /*
 524  * snic_tgt_del_all : cleanup all snic targets
 525  * Called on unbinding the interface
 526  */
 527 void
 528 snic_tgt_del_all(struct snic *snic)
 529 {
 530         struct snic_tgt *tgt = NULL;
 531         struct list_head *cur, *nxt;
 532         unsigned long flags;
 533
 534         scsi_flush_work(snic->shost);
 535
 536         mutex_lock(&snic->disc.mutex);
 537         spin_lock_irqsave(snic->shost->host_lock, flags);
 538
 539         list_for_each_safe(cur, nxt, &snic->disc.tgt_list) {
 540                 tgt = list_entry(cur, struct snic_tgt, list);
 541                 tgt->state = SNIC_TGT_STAT_DEL;
 542                 list_del_init(&tgt->list);
 543                 SNIC_HOST_INFO(snic->shost, "Tgt %d q'ing for del\n", tgt->id);
 544                 queue_work(snic_glob->event_q, &tgt->del_work);
 545                 tgt = NULL;
 546         }
 547         spin_unlock_irqrestore(snic->shost->host_lock, flags);
 548         mutex_unlock(&snic->disc.mutex);
 549
 550         flush_workqueue(snic_glob->event_q);
 551 } /* end of snic_tgt_del_all */