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 *
snic_tgt_type_to_str(int typ)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 *
snic_tgt_state_to_str(int state)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
snic_report_tgt_init(struct snic_host_req * req,u32 hid,u8 * buf,u32 len,dma_addr_t rsp_buf_pa,ulong ctx)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
snic_queue_report_tgt_req(struct snic * snic)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
snic_scsi_scan_tgt(struct work_struct * work)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 *
snic_tgt_lookup(struct snic * snic,struct snic_tgt_id * tgtid)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
snic_tgt_dev_release(struct device * dev)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
snic_tgt_del(struct work_struct * work)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_block_targets(shost, &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 *
snic_tgt_create(struct snic * snic,struct snic_tgt_id * tgtid)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 put_device(&tgt->dev);
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
snic_handle_tgt_disc(struct work_struct * work)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
snic_report_tgt_cmpl_handler(struct snic * snic,struct snic_fw_req * fwreq)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
snic_disc_init(struct snic_disc * disc)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
snic_disc_term(struct snic * snic)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
snic_disc_start(struct snic * snic)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
snic_handle_disc(struct work_struct * work)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
snic_tgt_del_all(struct snic * snic)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 */
555