Narsimhulu Musini | c8806b6 | 2015-05-29 01:04:01 -0700 | [diff] [blame] | 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); |
Narsimhulu Musini | c974782 | 2016-03-17 00:51:14 -0700 | [diff] [blame] | 51 | |
Narsimhulu Musini | c8806b6 | 2015-05-29 01:04:01 -0700 | [diff] [blame] | 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 | |
Narsimhulu Musini | c974782 | 2016-03-17 00:51:14 -0700 | [diff] [blame] | 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 | |
Narsimhulu Musini | c8806b6 | 2015-05-29 01:04:01 -0700 | [diff] [blame] | 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; |
Narsimhulu Musini | c974782 | 2016-03-17 00:51:14 -0700 | [diff] [blame] | 167 | struct snic_host_req *req = (struct snic_host_req *) os_buf; |
Narsimhulu Musini | c8806b6 | 2015-05-29 01:04:01 -0700 | [diff] [blame] | 168 | long act_reqs; |
Narsimhulu Musini | c974782 | 2016-03-17 00:51:14 -0700 | [diff] [blame] | 169 | long desc_avail = 0; |
Narsimhulu Musini | c8806b6 | 2015-05-29 01:04:01 -0700 | [diff] [blame] | 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 | |
Narsimhulu Musini | c974782 | 2016-03-17 00:51:14 -0700 | [diff] [blame] | 182 | req->req_pa = (ulong)pa; |
| 183 | |
Narsimhulu Musini | c8806b6 | 2015-05-29 01:04:01 -0700 | [diff] [blame] | 184 | q_num = snic_select_wq(snic); |
| 185 | |
| 186 | spin_lock_irqsave(&snic->wq_lock[q_num], flags); |
Narsimhulu Musini | c974782 | 2016-03-17 00:51:14 -0700 | [diff] [blame] | 187 | desc_avail = snic_wqdesc_avail(snic, q_num, req->hdr.type); |
| 188 | if (desc_avail <= 0) { |
Narsimhulu Musini | c8806b6 | 2015-05-29 01:04:01 -0700 | [diff] [blame] | 189 | pci_unmap_single(snic->pdev, pa, len, PCI_DMA_TODEVICE); |
Narsimhulu Musini | c974782 | 2016-03-17 00:51:14 -0700 | [diff] [blame] | 190 | req->req_pa = 0; |
Narsimhulu Musini | c8806b6 | 2015-05-29 01:04:01 -0700 | [diff] [blame] | 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); |
Narsimhulu Musini | c974782 | 2016-03-17 00:51:14 -0700 | [diff] [blame] | 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); |
Narsimhulu Musini | c8806b6 | 2015-05-29 01:04:01 -0700 | [diff] [blame] | 204 | spin_unlock_irqrestore(&snic->wq_lock[q_num], flags); |
| 205 | |
Narsimhulu Musini | c8806b6 | 2015-05-29 01:04:01 -0700 | [diff] [blame] | 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 | |
Narsimhulu Musini | c974782 | 2016-03-17 00:51:14 -0700 | [diff] [blame] | 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); |
Narsimhulu Musini | c8806b6 | 2015-05-29 01:04:01 -0700 | [diff] [blame] | 357 | |
Narsimhulu Musini | c974782 | 2016-03-17 00:51:14 -0700 | [diff] [blame] | 358 | mempool_free(rqi->abort_req, snic->req_pool[SNIC_REQ_TM_CACHE]); |
| 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); |
| 367 | |
Narsimhulu Musini | c8806b6 | 2015-05-29 01:04:01 -0700 | [diff] [blame] | 368 | mempool_free(rqi->dr_req, snic->req_pool[SNIC_REQ_TM_CACHE]); |
Narsimhulu Musini | c974782 | 2016-03-17 00:51:14 -0700 | [diff] [blame] | 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); |
Narsimhulu Musini | c8806b6 | 2015-05-29 01:04:01 -0700 | [diff] [blame] | 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 | } |