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