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); 51 pci_unmap_single(snic->pdev, buf->dma_addr, buf->len, PCI_DMA_TODEVICE); 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 140 int 141 snic_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 */ 186 void 187 snic_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 */ 202 struct snic_req_info * 203 snic_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 240 end: 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 */ 254 struct snic_host_req * 255 snic_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 */ 285 struct snic_host_req * 286 snic_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 */ 310 void 311 snic_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 330 void 331 snic_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 */ 346 void 347 snic_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 */ 371 void 372 snic_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 392 end: 393 return; 394 } 395 396 /* dump buf in hex fmt */ 397 void 398 snic_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 */ 405 static void 406 snic_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 502 void 503 snic_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 509 void 510 snic_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 } 519