blob: 993db7de4e4b1d6bf043fc3751d5f11f4fdc5a18 [file] [log] [blame]
Narsimhulu Musinic8806b62015-05-29 01:04:01 -07001/*
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 pci_unmap_single(snic->pdev, buf->dma_addr, buf->len, PCI_DMA_TODEVICE);
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
140int
141snic_queue_wq_desc(struct snic *snic, void *os_buf, u16 len)
142{
143 dma_addr_t pa = 0;
144 unsigned long flags;
145 struct snic_fw_stats *fwstats = &snic->s_stats.fw;
146 long act_reqs;
147 int q_num = 0;
148
149 snic_print_desc(__func__, os_buf, len);
150
151 /* Map request buffer */
152 pa = pci_map_single(snic->pdev, os_buf, len, PCI_DMA_TODEVICE);
153 if (pci_dma_mapping_error(snic->pdev, pa)) {
154 SNIC_HOST_ERR(snic->shost, "qdesc: PCI DMA Mapping Fail.\n");
155
156 return -ENOMEM;
157 }
158
159 q_num = snic_select_wq(snic);
160
161 spin_lock_irqsave(&snic->wq_lock[q_num], flags);
162 if (!svnic_wq_desc_avail(snic->wq)) {
163 pci_unmap_single(snic->pdev, pa, len, PCI_DMA_TODEVICE);
164 spin_unlock_irqrestore(&snic->wq_lock[q_num], flags);
165 atomic64_inc(&snic->s_stats.misc.wq_alloc_fail);
166 SNIC_DBG("host = %d, WQ is Full\n", snic->shost->host_no);
167
168 return -ENOMEM;
169 }
170
171 snic_queue_wq_eth_desc(&snic->wq[q_num], os_buf, pa, len, 0, 0, 1);
172 spin_unlock_irqrestore(&snic->wq_lock[q_num], flags);
173
174 /* Update stats */
175 act_reqs = atomic64_inc_return(&fwstats->actv_reqs);
176 if (act_reqs > atomic64_read(&fwstats->max_actv_reqs))
177 atomic64_set(&fwstats->max_actv_reqs, act_reqs);
178
179 return 0;
180} /* end of snic_queue_wq_desc() */
181
182/*
183 * snic_handle_untagged_req: Adds snic specific requests to spl_cmd_list.
184 * Purpose : Used during driver unload to clean up the requests.
185 */
186void
187snic_handle_untagged_req(struct snic *snic, struct snic_req_info *rqi)
188{
189 unsigned long flags;
190
191 INIT_LIST_HEAD(&rqi->list);
192
193 spin_lock_irqsave(&snic->spl_cmd_lock, flags);
194 list_add_tail(&rqi->list, &snic->spl_cmd_list);
195 spin_unlock_irqrestore(&snic->spl_cmd_lock, flags);
196}
197
198/*
199 * snic_req_init:
200 * Allocates snic_req_info + snic_host_req + sgl data, and initializes.
201 */
202struct snic_req_info *
203snic_req_init(struct snic *snic, int sg_cnt)
204{
205 u8 typ;
206 struct snic_req_info *rqi = NULL;
207
208 typ = (sg_cnt <= SNIC_REQ_CACHE_DFLT_SGL) ?
209 SNIC_REQ_CACHE_DFLT_SGL : SNIC_REQ_CACHE_MAX_SGL;
210
211 rqi = mempool_alloc(snic->req_pool[typ], GFP_ATOMIC);
212 if (!rqi) {
213 atomic64_inc(&snic->s_stats.io.alloc_fail);
214 SNIC_HOST_ERR(snic->shost,
215 "Failed to allocate memory from snic req pool id = %d\n",
216 typ);
217 return rqi;
218 }
219
220 memset(rqi, 0, sizeof(*rqi));
221 rqi->rq_pool_type = typ;
222 rqi->start_time = jiffies;
223 rqi->req = (struct snic_host_req *) (rqi + 1);
224 rqi->req_len = sizeof(struct snic_host_req);
225 rqi->snic = snic;
226
227 rqi->req = (struct snic_host_req *)(rqi + 1);
228
229 if (sg_cnt == 0)
230 goto end;
231
232 rqi->req_len += (sg_cnt * sizeof(struct snic_sg_desc));
233
234 if (sg_cnt > atomic64_read(&snic->s_stats.io.max_sgl))
235 atomic64_set(&snic->s_stats.io.max_sgl, sg_cnt);
236
237 SNIC_BUG_ON(sg_cnt > SNIC_MAX_SG_DESC_CNT);
238 atomic64_inc(&snic->s_stats.io.sgl_cnt[sg_cnt - 1]);
239
240end:
241 memset(rqi->req, 0, rqi->req_len);
242
243 /* pre initialization of init_ctx to support req_to_rqi */
244 rqi->req->hdr.init_ctx = (ulong) rqi;
245
246 SNIC_SCSI_DBG(snic->shost, "Req_alloc:rqi = %p allocatd.\n", rqi);
247
248 return rqi;
249} /* end of snic_req_init */
250
251/*
252 * snic_abort_req_init : Inits abort request.
253 */
254struct snic_host_req *
255snic_abort_req_init(struct snic *snic, struct snic_req_info *rqi)
256{
257 struct snic_host_req *req = NULL;
258
259 SNIC_BUG_ON(!rqi);
260
261 /* If abort to be issued second time, then reuse */
262 if (rqi->abort_req)
263 return rqi->abort_req;
264
265
266 req = mempool_alloc(snic->req_pool[SNIC_REQ_TM_CACHE], GFP_ATOMIC);
267 if (!req) {
268 SNIC_HOST_ERR(snic->shost, "abts:Failed to alloc tm req.\n");
269 WARN_ON_ONCE(1);
270
271 return NULL;
272 }
273
274 rqi->abort_req = req;
275 memset(req, 0, sizeof(struct snic_host_req));
276 /* pre initialization of init_ctx to support req_to_rqi */
277 req->hdr.init_ctx = (ulong) rqi;
278
279 return req;
280} /* end of snic_abort_req_init */
281
282/*
283 * snic_dr_req_init : Inits device reset req
284 */
285struct snic_host_req *
286snic_dr_req_init(struct snic *snic, struct snic_req_info *rqi)
287{
288 struct snic_host_req *req = NULL;
289
290 SNIC_BUG_ON(!rqi);
291
292 req = mempool_alloc(snic->req_pool[SNIC_REQ_TM_CACHE], GFP_ATOMIC);
293 if (!req) {
294 SNIC_HOST_ERR(snic->shost, "dr:Failed to alloc tm req.\n");
295 WARN_ON_ONCE(1);
296
297 return NULL;
298 }
299
300 SNIC_BUG_ON(rqi->dr_req != NULL);
301 rqi->dr_req = req;
302 memset(req, 0, sizeof(struct snic_host_req));
303 /* pre initialization of init_ctx to support req_to_rqi */
304 req->hdr.init_ctx = (ulong) rqi;
305
306 return req;
307} /* end of snic_dr_req_init */
308
309/* frees snic_req_info and snic_host_req */
310void
311snic_req_free(struct snic *snic, struct snic_req_info *rqi)
312{
313 SNIC_BUG_ON(rqi->req == rqi->abort_req);
314 SNIC_BUG_ON(rqi->req == rqi->dr_req);
315 SNIC_BUG_ON(rqi->sge_va != 0);
316
317 SNIC_SCSI_DBG(snic->shost,
318 "Req_free:rqi %p:ioreq %p:abt %p:dr %p\n",
319 rqi, rqi->req, rqi->abort_req, rqi->dr_req);
320
321 if (rqi->abort_req)
322 mempool_free(rqi->abort_req, snic->req_pool[SNIC_REQ_TM_CACHE]);
323
324 if (rqi->dr_req)
325 mempool_free(rqi->dr_req, snic->req_pool[SNIC_REQ_TM_CACHE]);
326
327 mempool_free(rqi, snic->req_pool[rqi->rq_pool_type]);
328}
329
330void
331snic_pci_unmap_rsp_buf(struct snic *snic, struct snic_req_info *rqi)
332{
333 struct snic_sg_desc *sgd;
334
335 sgd = req_to_sgl(rqi_to_req(rqi));
336 SNIC_BUG_ON(sgd[0].addr == 0);
337 pci_unmap_single(snic->pdev,
338 le64_to_cpu(sgd[0].addr),
339 le32_to_cpu(sgd[0].len),
340 PCI_DMA_FROMDEVICE);
341}
342
343/*
344 * snic_free_all_untagged_reqs: Walks through untagged reqs and frees them.
345 */
346void
347snic_free_all_untagged_reqs(struct snic *snic)
348{
349 struct snic_req_info *rqi;
350 struct list_head *cur, *nxt;
351 unsigned long flags;
352
353 spin_lock_irqsave(&snic->spl_cmd_lock, flags);
354 list_for_each_safe(cur, nxt, &snic->spl_cmd_list) {
355 rqi = list_entry(cur, struct snic_req_info, list);
356 list_del_init(&rqi->list);
357 if (rqi->sge_va) {
358 snic_pci_unmap_rsp_buf(snic, rqi);
359 kfree((void *)rqi->sge_va);
360 rqi->sge_va = 0;
361 }
362
363 snic_req_free(snic, rqi);
364 }
365 spin_unlock_irqrestore(&snic->spl_cmd_lock, flags);
366}
367
368/*
369 * snic_release_untagged_req : Unlinks the untagged req and frees it.
370 */
371void
372snic_release_untagged_req(struct snic *snic, struct snic_req_info *rqi)
373{
374 unsigned long flags;
375
376 spin_lock_irqsave(&snic->snic_lock, flags);
377 if (snic->in_remove) {
378 spin_unlock_irqrestore(&snic->snic_lock, flags);
379 goto end;
380 }
381 spin_unlock_irqrestore(&snic->snic_lock, flags);
382
383 spin_lock_irqsave(&snic->spl_cmd_lock, flags);
384 if (list_empty(&rqi->list)) {
385 spin_unlock_irqrestore(&snic->spl_cmd_lock, flags);
386 goto end;
387 }
388 list_del_init(&rqi->list);
389 spin_unlock_irqrestore(&snic->spl_cmd_lock, flags);
390 snic_req_free(snic, rqi);
391
392end:
393 return;
394}
395
396/* dump buf in hex fmt */
397void
398snic_hex_dump(char *pfx, char *data, int len)
399{
400 SNIC_INFO("%s Dumping Data of Len = %d\n", pfx, len);
401 print_hex_dump_bytes(pfx, DUMP_PREFIX_NONE, data, len);
402}
403
404#define LINE_BUFSZ 128 /* for snic_print_desc fn */
405static void
406snic_dump_desc(const char *fn, char *os_buf, int len)
407{
408 struct snic_host_req *req = (struct snic_host_req *) os_buf;
409 struct snic_fw_req *fwreq = (struct snic_fw_req *) os_buf;
410 struct snic_req_info *rqi = NULL;
411 char line[LINE_BUFSZ] = { '\0' };
412 char *cmd_str = NULL;
413
414 if (req->hdr.type >= SNIC_RSP_REPORT_TGTS_CMPL)
415 rqi = (struct snic_req_info *) fwreq->hdr.init_ctx;
416 else
417 rqi = (struct snic_req_info *) req->hdr.init_ctx;
418
419 SNIC_BUG_ON(rqi == NULL || rqi->req == NULL);
420 switch (req->hdr.type) {
421 case SNIC_REQ_REPORT_TGTS:
422 cmd_str = "report-tgt : ";
423 snprintf(line, LINE_BUFSZ, "SNIC_REQ_REPORT_TGTS :");
424 break;
425
426 case SNIC_REQ_ICMND:
427 cmd_str = "icmnd : ";
428 snprintf(line, LINE_BUFSZ, "SNIC_REQ_ICMND : 0x%x :",
429 req->u.icmnd.cdb[0]);
430 break;
431
432 case SNIC_REQ_ITMF:
433 cmd_str = "itmf : ";
434 snprintf(line, LINE_BUFSZ, "SNIC_REQ_ITMF :");
435 break;
436
437 case SNIC_REQ_HBA_RESET:
438 cmd_str = "hba reset :";
439 snprintf(line, LINE_BUFSZ, "SNIC_REQ_HBA_RESET :");
440 break;
441
442 case SNIC_REQ_EXCH_VER:
443 cmd_str = "exch ver : ";
444 snprintf(line, LINE_BUFSZ, "SNIC_REQ_EXCH_VER :");
445 break;
446
447 case SNIC_REQ_TGT_INFO:
448 cmd_str = "tgt info : ";
449 break;
450
451 case SNIC_RSP_REPORT_TGTS_CMPL:
452 cmd_str = "report tgt cmpl : ";
453 snprintf(line, LINE_BUFSZ, "SNIC_RSP_REPORT_TGTS_CMPL :");
454 break;
455
456 case SNIC_RSP_ICMND_CMPL:
457 cmd_str = "icmnd_cmpl : ";
458 snprintf(line, LINE_BUFSZ, "SNIC_RSP_ICMND_CMPL : 0x%x :",
459 rqi->req->u.icmnd.cdb[0]);
460 break;
461
462 case SNIC_RSP_ITMF_CMPL:
463 cmd_str = "itmf_cmpl : ";
464 snprintf(line, LINE_BUFSZ, "SNIC_RSP_ITMF_CMPL :");
465 break;
466
467 case SNIC_RSP_HBA_RESET_CMPL:
468 cmd_str = "hba_reset_cmpl : ";
469 snprintf(line, LINE_BUFSZ, "SNIC_RSP_HBA_RESET_CMPL :");
470 break;
471
472 case SNIC_RSP_EXCH_VER_CMPL:
473 cmd_str = "exch_ver_cmpl : ";
474 snprintf(line, LINE_BUFSZ, "SNIC_RSP_EXCH_VER_CMPL :");
475 break;
476
477 case SNIC_MSG_ACK:
478 cmd_str = "msg ack : ";
479 snprintf(line, LINE_BUFSZ, "SNIC_MSG_ACK :");
480 break;
481
482 case SNIC_MSG_ASYNC_EVNOTIFY:
483 cmd_str = "async notify : ";
484 snprintf(line, LINE_BUFSZ, "SNIC_MSG_ASYNC_EVNOTIFY :");
485 break;
486
487 default:
488 cmd_str = "unknown : ";
489 SNIC_BUG_ON(1);
490 break;
491 }
492
493 SNIC_INFO("%s:%s >>cmndid=%x:sg_cnt = %x:status = %x:ctx = %lx.\n",
494 fn, line, req->hdr.cmnd_id, req->hdr.sg_cnt, req->hdr.status,
495 req->hdr.init_ctx);
496
497 /* Enable it, to dump byte stream */
498 if (snic_log_level & 0x20)
499 snic_hex_dump(cmd_str, os_buf, len);
500} /* end of __snic_print_desc */
501
502void
503snic_print_desc(const char *fn, char *os_buf, int len)
504{
505 if (snic_log_level & SNIC_DESC_LOGGING)
506 snic_dump_desc(fn, os_buf, len);
507}
508
509void
510snic_calc_io_process_time(struct snic *snic, struct snic_req_info *rqi)
511{
512 u64 duration;
513
514 duration = jiffies - rqi->start_time;
515
516 if (duration > atomic64_read(&snic->s_stats.io.max_time))
517 atomic64_set(&snic->s_stats.io.max_time, duration);
518}