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