Merge tag 'block-6.2-2023-01-13' of git://git.kernel.dk/linux
[sfrench/cifs-2.6.git] / 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                 spin_lock_irqsave(snic->shost->host_lock, flags);
308                 list_del(&tgt->list);
309                 spin_unlock_irqrestore(snic->shost->host_lock, flags);
310                 kfree(tgt);
311                 tgt = NULL;
312
313                 return tgt;
314         }
315
316         SNIC_HOST_INFO(snic->shost, "Scanning %s.\n", dev_name(&tgt->dev));
317
318         scsi_queue_work(snic->shost, &tgt->scan_work);
319
320         return tgt;
321 } /* end of snic_tgt_create */
322
323 /* Handler for discovery */
324 void
325 snic_handle_tgt_disc(struct work_struct *work)
326 {
327         struct snic *snic = container_of(work, struct snic, tgt_work);
328         struct snic_tgt_id *tgtid = NULL;
329         struct snic_tgt *tgt = NULL;
330         unsigned long flags;
331         int i;
332
333         spin_lock_irqsave(&snic->snic_lock, flags);
334         if (snic->in_remove) {
335                 spin_unlock_irqrestore(&snic->snic_lock, flags);
336                 kfree(snic->disc.rtgt_info);
337
338                 return;
339         }
340         spin_unlock_irqrestore(&snic->snic_lock, flags);
341
342         mutex_lock(&snic->disc.mutex);
343         /* Discover triggered during disc in progress */
344         if (snic->disc.req_cnt) {
345                 snic->disc.state = SNIC_DISC_DONE;
346                 snic->disc.req_cnt = 0;
347                 mutex_unlock(&snic->disc.mutex);
348                 kfree(snic->disc.rtgt_info);
349                 snic->disc.rtgt_info = NULL;
350
351                 SNIC_HOST_INFO(snic->shost, "tgt_disc: Discovery restart.\n");
352                 /* Start Discovery Again */
353                 snic_disc_start(snic);
354
355                 return;
356         }
357
358         tgtid = (struct snic_tgt_id *)snic->disc.rtgt_info;
359
360         SNIC_BUG_ON(snic->disc.rtgt_cnt == 0 || tgtid == NULL);
361
362         for (i = 0; i < snic->disc.rtgt_cnt; i++) {
363                 tgt = snic_tgt_create(snic, &tgtid[i]);
364                 if (!tgt) {
365                         int buf_sz = snic->disc.rtgt_cnt * sizeof(*tgtid);
366
367                         SNIC_HOST_ERR(snic->shost, "Failed to create tgt.\n");
368                         snic_hex_dump("rpt_tgt_rsp", (char *)tgtid, buf_sz);
369                         break;
370                 }
371         }
372
373         snic->disc.rtgt_info = NULL;
374         snic->disc.state = SNIC_DISC_DONE;
375         mutex_unlock(&snic->disc.mutex);
376
377         SNIC_HOST_INFO(snic->shost, "Discovery Completed.\n");
378
379         kfree(tgtid);
380 } /* end of snic_handle_tgt_disc */
381
382
383 int
384 snic_report_tgt_cmpl_handler(struct snic *snic, struct snic_fw_req *fwreq)
385 {
386
387         u8 typ, cmpl_stat;
388         u32 cmnd_id, hid, tgt_cnt = 0;
389         ulong ctx;
390         struct snic_req_info *rqi = NULL;
391         struct snic_tgt_id *tgtid;
392         int i, ret = 0;
393
394         snic_io_hdr_dec(&fwreq->hdr, &typ, &cmpl_stat, &cmnd_id, &hid, &ctx);
395         rqi = (struct snic_req_info *) ctx;
396         tgtid = (struct snic_tgt_id *) rqi->sge_va;
397
398         tgt_cnt = le32_to_cpu(fwreq->u.rpt_tgts_cmpl.tgt_cnt);
399         if (tgt_cnt == 0) {
400                 SNIC_HOST_ERR(snic->shost, "No Targets Found on this host.\n");
401                 ret = 1;
402
403                 goto end;
404         }
405
406         /* printing list of targets here */
407         SNIC_HOST_INFO(snic->shost, "Target Count = %d\n", tgt_cnt);
408
409         SNIC_BUG_ON(tgt_cnt > snic->fwinfo.max_tgts);
410
411         for (i = 0; i < tgt_cnt; i++)
412                 SNIC_HOST_INFO(snic->shost,
413                                "Tgt id = 0x%x\n",
414                                le32_to_cpu(tgtid[i].tgt_id));
415
416         /*
417          * Queue work for further processing,
418          * Response Buffer Memory is freed after creating targets
419          */
420         snic->disc.rtgt_cnt = tgt_cnt;
421         snic->disc.rtgt_info = (u8 *) tgtid;
422         queue_work(snic_glob->event_q, &snic->tgt_work);
423         ret = 0;
424
425 end:
426         /* Unmap Response Buffer */
427         snic_pci_unmap_rsp_buf(snic, rqi);
428         if (ret)
429                 kfree(tgtid);
430
431         rqi->sge_va = 0;
432         snic_release_untagged_req(snic, rqi);
433
434         return ret;
435 } /* end of snic_report_tgt_cmpl_handler */
436
437 /* Discovery init fn */
438 void
439 snic_disc_init(struct snic_disc *disc)
440 {
441         INIT_LIST_HEAD(&disc->tgt_list);
442         mutex_init(&disc->mutex);
443         disc->disc_id = 0;
444         disc->nxt_tgt_id = 0;
445         disc->state = SNIC_DISC_INIT;
446         disc->req_cnt = 0;
447         disc->rtgt_cnt = 0;
448         disc->rtgt_info = NULL;
449         disc->cb = NULL;
450 } /* end of snic_disc_init */
451
452 /* Discovery, uninit fn */
453 void
454 snic_disc_term(struct snic *snic)
455 {
456         struct snic_disc *disc = &snic->disc;
457
458         mutex_lock(&disc->mutex);
459         if (disc->req_cnt) {
460                 disc->req_cnt = 0;
461                 SNIC_SCSI_DBG(snic->shost, "Terminating Discovery.\n");
462         }
463         mutex_unlock(&disc->mutex);
464 }
465
466 /*
467  * snic_disc_start: Discovery Start ...
468  */
469 int
470 snic_disc_start(struct snic *snic)
471 {
472         struct snic_disc *disc = &snic->disc;
473         unsigned long flags;
474         int ret = 0;
475
476         SNIC_SCSI_DBG(snic->shost, "Discovery Start.\n");
477
478         spin_lock_irqsave(&snic->snic_lock, flags);
479         if (snic->in_remove) {
480                 spin_unlock_irqrestore(&snic->snic_lock, flags);
481                 SNIC_ERR("snic driver removal in progress ...\n");
482                 ret = 0;
483
484                 return ret;
485         }
486         spin_unlock_irqrestore(&snic->snic_lock, flags);
487
488         mutex_lock(&disc->mutex);
489         if (disc->state == SNIC_DISC_PENDING) {
490                 disc->req_cnt++;
491                 mutex_unlock(&disc->mutex);
492
493                 return ret;
494         }
495         disc->state = SNIC_DISC_PENDING;
496         mutex_unlock(&disc->mutex);
497
498         ret = snic_queue_report_tgt_req(snic);
499         if (ret)
500                 SNIC_HOST_INFO(snic->shost, "Discovery Failed, err=%d.\n", ret);
501
502         return ret;
503 } /* end of snic_disc_start */
504
505 /*
506  * snic_disc_work :
507  */
508 void
509 snic_handle_disc(struct work_struct *work)
510 {
511         struct snic *snic = container_of(work, struct snic, disc_work);
512         int ret = 0;
513
514         SNIC_HOST_INFO(snic->shost, "disc_work: Discovery\n");
515
516         ret = snic_disc_start(snic);
517         if (ret)
518                 goto disc_err;
519
520 disc_err:
521         SNIC_HOST_ERR(snic->shost,
522                       "disc_work: Discovery Failed w/ err = %d\n",
523                       ret);
524 } /* end of snic_disc_work */
525
526 /*
527  * snic_tgt_del_all : cleanup all snic targets
528  * Called on unbinding the interface
529  */
530 void
531 snic_tgt_del_all(struct snic *snic)
532 {
533         struct snic_tgt *tgt = NULL;
534         struct list_head *cur, *nxt;
535         unsigned long flags;
536
537         scsi_flush_work(snic->shost);
538
539         mutex_lock(&snic->disc.mutex);
540         spin_lock_irqsave(snic->shost->host_lock, flags);
541
542         list_for_each_safe(cur, nxt, &snic->disc.tgt_list) {
543                 tgt = list_entry(cur, struct snic_tgt, list);
544                 tgt->state = SNIC_TGT_STAT_DEL;
545                 list_del_init(&tgt->list);
546                 SNIC_HOST_INFO(snic->shost, "Tgt %d q'ing for del\n", tgt->id);
547                 queue_work(snic_glob->event_q, &tgt->del_work);
548                 tgt = NULL;
549         }
550         spin_unlock_irqrestore(snic->shost->host_lock, flags);
551         mutex_unlock(&snic->disc.mutex);
552
553         flush_workqueue(snic_glob->event_q);
554 } /* end of snic_tgt_del_all */