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