1 /* 2 * Copyright (C) 2016 Cavium, Inc. 3 * 4 * This program is free software; you can redistribute it and/or modify 5 * it under the terms of version 2 of the GNU General Public License 6 * as published by the Free Software Foundation. 7 */ 8 9 #include <linux/interrupt.h> 10 #include <linux/module.h> 11 12 #include "cptvf.h" 13 14 #define DRV_NAME "thunder-cptvf" 15 #define DRV_VERSION "1.0" 16 17 struct cptvf_wqe { 18 struct tasklet_struct twork; 19 void *cptvf; 20 u32 qno; 21 }; 22 23 struct cptvf_wqe_info { 24 struct cptvf_wqe vq_wqe[CPT_NUM_QS_PER_VF]; 25 }; 26 27 static void vq_work_handler(unsigned long data) 28 { 29 struct cptvf_wqe_info *cwqe_info = (struct cptvf_wqe_info *)data; 30 struct cptvf_wqe *cwqe = &cwqe_info->vq_wqe[0]; 31 32 vq_post_process(cwqe->cptvf, cwqe->qno); 33 } 34 35 static int init_worker_threads(struct cpt_vf *cptvf) 36 { 37 struct pci_dev *pdev = cptvf->pdev; 38 struct cptvf_wqe_info *cwqe_info; 39 int i; 40 41 cwqe_info = kzalloc(sizeof(*cwqe_info), GFP_KERNEL); 42 if (!cwqe_info) 43 return -ENOMEM; 44 45 if (cptvf->nr_queues) { 46 dev_info(&pdev->dev, "Creating VQ worker threads (%d)\n", 47 cptvf->nr_queues); 48 } 49 50 for (i = 0; i < cptvf->nr_queues; i++) { 51 tasklet_init(&cwqe_info->vq_wqe[i].twork, vq_work_handler, 52 (u64)cwqe_info); 53 cwqe_info->vq_wqe[i].qno = i; 54 cwqe_info->vq_wqe[i].cptvf = cptvf; 55 } 56 57 cptvf->wqe_info = cwqe_info; 58 59 return 0; 60 } 61 62 static void cleanup_worker_threads(struct cpt_vf *cptvf) 63 { 64 struct cptvf_wqe_info *cwqe_info; 65 struct pci_dev *pdev = cptvf->pdev; 66 int i; 67 68 cwqe_info = (struct cptvf_wqe_info *)cptvf->wqe_info; 69 if (!cwqe_info) 70 return; 71 72 if (cptvf->nr_queues) { 73 dev_info(&pdev->dev, "Cleaning VQ worker threads (%u)\n", 74 cptvf->nr_queues); 75 } 76 77 for (i = 0; i < cptvf->nr_queues; i++) 78 tasklet_kill(&cwqe_info->vq_wqe[i].twork); 79 80 kzfree(cwqe_info); 81 cptvf->wqe_info = NULL; 82 } 83 84 static void free_pending_queues(struct pending_qinfo *pqinfo) 85 { 86 int i; 87 struct pending_queue *queue; 88 89 for_each_pending_queue(pqinfo, queue, i) { 90 if (!queue->head) 91 continue; 92 93 /* free single queue */ 94 kzfree((queue->head)); 95 96 queue->front = 0; 97 queue->rear = 0; 98 99 return; 100 } 101 102 pqinfo->qlen = 0; 103 pqinfo->nr_queues = 0; 104 } 105 106 static int alloc_pending_queues(struct pending_qinfo *pqinfo, u32 qlen, 107 u32 nr_queues) 108 { 109 u32 i; 110 size_t size; 111 int ret; 112 struct pending_queue *queue = NULL; 113 114 pqinfo->nr_queues = nr_queues; 115 pqinfo->qlen = qlen; 116 117 size = (qlen * sizeof(struct pending_entry)); 118 119 for_each_pending_queue(pqinfo, queue, i) { 120 queue->head = kzalloc((size), GFP_KERNEL); 121 if (!queue->head) { 122 ret = -ENOMEM; 123 goto pending_qfail; 124 } 125 126 queue->front = 0; 127 queue->rear = 0; 128 atomic64_set((&queue->pending_count), (0)); 129 130 /* init queue spin lock */ 131 spin_lock_init(&queue->lock); 132 } 133 134 return 0; 135 136 pending_qfail: 137 free_pending_queues(pqinfo); 138 139 return ret; 140 } 141 142 static int init_pending_queues(struct cpt_vf *cptvf, u32 qlen, u32 nr_queues) 143 { 144 struct pci_dev *pdev = cptvf->pdev; 145 int ret; 146 147 if (!nr_queues) 148 return 0; 149 150 ret = alloc_pending_queues(&cptvf->pqinfo, qlen, nr_queues); 151 if (ret) { 152 dev_err(&pdev->dev, "failed to setup pending queues (%u)\n", 153 nr_queues); 154 return ret; 155 } 156 157 return 0; 158 } 159 160 static void cleanup_pending_queues(struct cpt_vf *cptvf) 161 { 162 struct pci_dev *pdev = cptvf->pdev; 163 164 if (!cptvf->nr_queues) 165 return; 166 167 dev_info(&pdev->dev, "Cleaning VQ pending queue (%u)\n", 168 cptvf->nr_queues); 169 free_pending_queues(&cptvf->pqinfo); 170 } 171 172 static void free_command_queues(struct cpt_vf *cptvf, 173 struct command_qinfo *cqinfo) 174 { 175 int i; 176 struct command_queue *queue = NULL; 177 struct command_chunk *chunk = NULL; 178 struct pci_dev *pdev = cptvf->pdev; 179 struct hlist_node *node; 180 181 /* clean up for each queue */ 182 for (i = 0; i < cptvf->nr_queues; i++) { 183 queue = &cqinfo->queue[i]; 184 if (hlist_empty(&cqinfo->queue[i].chead)) 185 continue; 186 187 hlist_for_each_entry_safe(chunk, node, &cqinfo->queue[i].chead, 188 nextchunk) { 189 dma_free_coherent(&pdev->dev, chunk->size, 190 chunk->head, 191 chunk->dma_addr); 192 chunk->head = NULL; 193 chunk->dma_addr = 0; 194 hlist_del(&chunk->nextchunk); 195 kzfree(chunk); 196 } 197 198 queue->nchunks = 0; 199 queue->idx = 0; 200 } 201 202 /* common cleanup */ 203 cqinfo->cmd_size = 0; 204 } 205 206 static int alloc_command_queues(struct cpt_vf *cptvf, 207 struct command_qinfo *cqinfo, size_t cmd_size, 208 u32 qlen) 209 { 210 int i; 211 size_t q_size; 212 struct command_queue *queue = NULL; 213 struct pci_dev *pdev = cptvf->pdev; 214 215 /* common init */ 216 cqinfo->cmd_size = cmd_size; 217 /* Qsize in dwords, needed for SADDR config, 1-next chunk pointer */ 218 cptvf->qsize = min(qlen, cqinfo->qchunksize) * 219 CPT_NEXT_CHUNK_PTR_SIZE + 1; 220 /* Qsize in bytes to create space for alignment */ 221 q_size = qlen * cqinfo->cmd_size; 222 223 /* per queue initialization */ 224 for (i = 0; i < cptvf->nr_queues; i++) { 225 size_t c_size = 0; 226 size_t rem_q_size = q_size; 227 struct command_chunk *curr = NULL, *first = NULL, *last = NULL; 228 u32 qcsize_bytes = cqinfo->qchunksize * cqinfo->cmd_size; 229 230 queue = &cqinfo->queue[i]; 231 INIT_HLIST_HEAD(&cqinfo->queue[i].chead); 232 do { 233 curr = kzalloc(sizeof(*curr), GFP_KERNEL); 234 if (!curr) 235 goto cmd_qfail; 236 237 c_size = (rem_q_size > qcsize_bytes) ? qcsize_bytes : 238 rem_q_size; 239 curr->head = (u8 *)dma_zalloc_coherent(&pdev->dev, 240 c_size + CPT_NEXT_CHUNK_PTR_SIZE, 241 &curr->dma_addr, GFP_KERNEL); 242 if (!curr->head) { 243 dev_err(&pdev->dev, "Command Q (%d) chunk (%d) allocation failed\n", 244 i, queue->nchunks); 245 kfree(curr); 246 goto cmd_qfail; 247 } 248 249 curr->size = c_size; 250 if (queue->nchunks == 0) { 251 hlist_add_head(&curr->nextchunk, 252 &cqinfo->queue[i].chead); 253 first = curr; 254 } else { 255 hlist_add_behind(&curr->nextchunk, 256 &last->nextchunk); 257 } 258 259 queue->nchunks++; 260 rem_q_size -= c_size; 261 if (last) 262 *((u64 *)(&last->head[last->size])) = (u64)curr->dma_addr; 263 264 last = curr; 265 } while (rem_q_size); 266 267 /* Make the queue circular */ 268 /* Tie back last chunk entry to head */ 269 curr = first; 270 *((u64 *)(&last->head[last->size])) = (u64)curr->dma_addr; 271 queue->qhead = curr; 272 spin_lock_init(&queue->lock); 273 } 274 return 0; 275 276 cmd_qfail: 277 free_command_queues(cptvf, cqinfo); 278 return -ENOMEM; 279 } 280 281 static int init_command_queues(struct cpt_vf *cptvf, u32 qlen) 282 { 283 struct pci_dev *pdev = cptvf->pdev; 284 int ret; 285 286 /* setup AE command queues */ 287 ret = alloc_command_queues(cptvf, &cptvf->cqinfo, CPT_INST_SIZE, 288 qlen); 289 if (ret) { 290 dev_err(&pdev->dev, "failed to allocate AE command queues (%u)\n", 291 cptvf->nr_queues); 292 return ret; 293 } 294 295 return ret; 296 } 297 298 static void cleanup_command_queues(struct cpt_vf *cptvf) 299 { 300 struct pci_dev *pdev = cptvf->pdev; 301 302 if (!cptvf->nr_queues) 303 return; 304 305 dev_info(&pdev->dev, "Cleaning VQ command queue (%u)\n", 306 cptvf->nr_queues); 307 free_command_queues(cptvf, &cptvf->cqinfo); 308 } 309 310 static void cptvf_sw_cleanup(struct cpt_vf *cptvf) 311 { 312 cleanup_worker_threads(cptvf); 313 cleanup_pending_queues(cptvf); 314 cleanup_command_queues(cptvf); 315 } 316 317 static int cptvf_sw_init(struct cpt_vf *cptvf, u32 qlen, u32 nr_queues) 318 { 319 struct pci_dev *pdev = cptvf->pdev; 320 int ret = 0; 321 u32 max_dev_queues = 0; 322 323 max_dev_queues = CPT_NUM_QS_PER_VF; 324 /* possible cpus */ 325 nr_queues = min_t(u32, nr_queues, max_dev_queues); 326 cptvf->nr_queues = nr_queues; 327 328 ret = init_command_queues(cptvf, qlen); 329 if (ret) { 330 dev_err(&pdev->dev, "Failed to setup command queues (%u)\n", 331 nr_queues); 332 return ret; 333 } 334 335 ret = init_pending_queues(cptvf, qlen, nr_queues); 336 if (ret) { 337 dev_err(&pdev->dev, "Failed to setup pending queues (%u)\n", 338 nr_queues); 339 goto setup_pqfail; 340 } 341 342 /* Create worker threads for BH processing */ 343 ret = init_worker_threads(cptvf); 344 if (ret) { 345 dev_err(&pdev->dev, "Failed to setup worker threads\n"); 346 goto init_work_fail; 347 } 348 349 return 0; 350 351 init_work_fail: 352 cleanup_worker_threads(cptvf); 353 cleanup_pending_queues(cptvf); 354 355 setup_pqfail: 356 cleanup_command_queues(cptvf); 357 358 return ret; 359 } 360 361 static void cptvf_free_irq_affinity(struct cpt_vf *cptvf, int vec) 362 { 363 irq_set_affinity_hint(pci_irq_vector(cptvf->pdev, vec), NULL); 364 free_cpumask_var(cptvf->affinity_mask[vec]); 365 } 366 367 static void cptvf_write_vq_ctl(struct cpt_vf *cptvf, bool val) 368 { 369 union cptx_vqx_ctl vqx_ctl; 370 371 vqx_ctl.u = cpt_read_csr64(cptvf->reg_base, CPTX_VQX_CTL(0, 0)); 372 vqx_ctl.s.ena = val; 373 cpt_write_csr64(cptvf->reg_base, CPTX_VQX_CTL(0, 0), vqx_ctl.u); 374 } 375 376 void cptvf_write_vq_doorbell(struct cpt_vf *cptvf, u32 val) 377 { 378 union cptx_vqx_doorbell vqx_dbell; 379 380 vqx_dbell.u = cpt_read_csr64(cptvf->reg_base, 381 CPTX_VQX_DOORBELL(0, 0)); 382 vqx_dbell.s.dbell_cnt = val * 8; /* Num of Instructions * 8 words */ 383 cpt_write_csr64(cptvf->reg_base, CPTX_VQX_DOORBELL(0, 0), 384 vqx_dbell.u); 385 } 386 387 static void cptvf_write_vq_inprog(struct cpt_vf *cptvf, u8 val) 388 { 389 union cptx_vqx_inprog vqx_inprg; 390 391 vqx_inprg.u = cpt_read_csr64(cptvf->reg_base, CPTX_VQX_INPROG(0, 0)); 392 vqx_inprg.s.inflight = val; 393 cpt_write_csr64(cptvf->reg_base, CPTX_VQX_INPROG(0, 0), vqx_inprg.u); 394 } 395 396 static void cptvf_write_vq_done_numwait(struct cpt_vf *cptvf, u32 val) 397 { 398 union cptx_vqx_done_wait vqx_dwait; 399 400 vqx_dwait.u = cpt_read_csr64(cptvf->reg_base, 401 CPTX_VQX_DONE_WAIT(0, 0)); 402 vqx_dwait.s.num_wait = val; 403 cpt_write_csr64(cptvf->reg_base, CPTX_VQX_DONE_WAIT(0, 0), 404 vqx_dwait.u); 405 } 406 407 static void cptvf_write_vq_done_timewait(struct cpt_vf *cptvf, u16 time) 408 { 409 union cptx_vqx_done_wait vqx_dwait; 410 411 vqx_dwait.u = cpt_read_csr64(cptvf->reg_base, 412 CPTX_VQX_DONE_WAIT(0, 0)); 413 vqx_dwait.s.time_wait = time; 414 cpt_write_csr64(cptvf->reg_base, CPTX_VQX_DONE_WAIT(0, 0), 415 vqx_dwait.u); 416 } 417 418 static void cptvf_enable_swerr_interrupts(struct cpt_vf *cptvf) 419 { 420 union cptx_vqx_misc_ena_w1s vqx_misc_ena; 421 422 vqx_misc_ena.u = cpt_read_csr64(cptvf->reg_base, 423 CPTX_VQX_MISC_ENA_W1S(0, 0)); 424 /* Set mbox(0) interupts for the requested vf */ 425 vqx_misc_ena.s.swerr = 1; 426 cpt_write_csr64(cptvf->reg_base, CPTX_VQX_MISC_ENA_W1S(0, 0), 427 vqx_misc_ena.u); 428 } 429 430 static void cptvf_enable_mbox_interrupts(struct cpt_vf *cptvf) 431 { 432 union cptx_vqx_misc_ena_w1s vqx_misc_ena; 433 434 vqx_misc_ena.u = cpt_read_csr64(cptvf->reg_base, 435 CPTX_VQX_MISC_ENA_W1S(0, 0)); 436 /* Set mbox(0) interupts for the requested vf */ 437 vqx_misc_ena.s.mbox = 1; 438 cpt_write_csr64(cptvf->reg_base, CPTX_VQX_MISC_ENA_W1S(0, 0), 439 vqx_misc_ena.u); 440 } 441 442 static void cptvf_enable_done_interrupts(struct cpt_vf *cptvf) 443 { 444 union cptx_vqx_done_ena_w1s vqx_done_ena; 445 446 vqx_done_ena.u = cpt_read_csr64(cptvf->reg_base, 447 CPTX_VQX_DONE_ENA_W1S(0, 0)); 448 /* Set DONE interrupt for the requested vf */ 449 vqx_done_ena.s.done = 1; 450 cpt_write_csr64(cptvf->reg_base, CPTX_VQX_DONE_ENA_W1S(0, 0), 451 vqx_done_ena.u); 452 } 453 454 static void cptvf_clear_dovf_intr(struct cpt_vf *cptvf) 455 { 456 union cptx_vqx_misc_int vqx_misc_int; 457 458 vqx_misc_int.u = cpt_read_csr64(cptvf->reg_base, 459 CPTX_VQX_MISC_INT(0, 0)); 460 /* W1C for the VF */ 461 vqx_misc_int.s.dovf = 1; 462 cpt_write_csr64(cptvf->reg_base, CPTX_VQX_MISC_INT(0, 0), 463 vqx_misc_int.u); 464 } 465 466 static void cptvf_clear_irde_intr(struct cpt_vf *cptvf) 467 { 468 union cptx_vqx_misc_int vqx_misc_int; 469 470 vqx_misc_int.u = cpt_read_csr64(cptvf->reg_base, 471 CPTX_VQX_MISC_INT(0, 0)); 472 /* W1C for the VF */ 473 vqx_misc_int.s.irde = 1; 474 cpt_write_csr64(cptvf->reg_base, CPTX_VQX_MISC_INT(0, 0), 475 vqx_misc_int.u); 476 } 477 478 static void cptvf_clear_nwrp_intr(struct cpt_vf *cptvf) 479 { 480 union cptx_vqx_misc_int vqx_misc_int; 481 482 vqx_misc_int.u = cpt_read_csr64(cptvf->reg_base, 483 CPTX_VQX_MISC_INT(0, 0)); 484 /* W1C for the VF */ 485 vqx_misc_int.s.nwrp = 1; 486 cpt_write_csr64(cptvf->reg_base, 487 CPTX_VQX_MISC_INT(0, 0), vqx_misc_int.u); 488 } 489 490 static void cptvf_clear_mbox_intr(struct cpt_vf *cptvf) 491 { 492 union cptx_vqx_misc_int vqx_misc_int; 493 494 vqx_misc_int.u = cpt_read_csr64(cptvf->reg_base, 495 CPTX_VQX_MISC_INT(0, 0)); 496 /* W1C for the VF */ 497 vqx_misc_int.s.mbox = 1; 498 cpt_write_csr64(cptvf->reg_base, CPTX_VQX_MISC_INT(0, 0), 499 vqx_misc_int.u); 500 } 501 502 static void cptvf_clear_swerr_intr(struct cpt_vf *cptvf) 503 { 504 union cptx_vqx_misc_int vqx_misc_int; 505 506 vqx_misc_int.u = cpt_read_csr64(cptvf->reg_base, 507 CPTX_VQX_MISC_INT(0, 0)); 508 /* W1C for the VF */ 509 vqx_misc_int.s.swerr = 1; 510 cpt_write_csr64(cptvf->reg_base, CPTX_VQX_MISC_INT(0, 0), 511 vqx_misc_int.u); 512 } 513 514 static u64 cptvf_read_vf_misc_intr_status(struct cpt_vf *cptvf) 515 { 516 return cpt_read_csr64(cptvf->reg_base, CPTX_VQX_MISC_INT(0, 0)); 517 } 518 519 static irqreturn_t cptvf_misc_intr_handler(int irq, void *cptvf_irq) 520 { 521 struct cpt_vf *cptvf = (struct cpt_vf *)cptvf_irq; 522 struct pci_dev *pdev = cptvf->pdev; 523 u64 intr; 524 525 intr = cptvf_read_vf_misc_intr_status(cptvf); 526 /*Check for MISC interrupt types*/ 527 if (likely(intr & CPT_VF_INTR_MBOX_MASK)) { 528 dev_err(&pdev->dev, "Mailbox interrupt 0x%llx on CPT VF %d\n", 529 intr, cptvf->vfid); 530 cptvf_handle_mbox_intr(cptvf); 531 cptvf_clear_mbox_intr(cptvf); 532 } else if (unlikely(intr & CPT_VF_INTR_DOVF_MASK)) { 533 cptvf_clear_dovf_intr(cptvf); 534 /*Clear doorbell count*/ 535 cptvf_write_vq_doorbell(cptvf, 0); 536 dev_err(&pdev->dev, "Doorbell overflow error interrupt 0x%llx on CPT VF %d\n", 537 intr, cptvf->vfid); 538 } else if (unlikely(intr & CPT_VF_INTR_IRDE_MASK)) { 539 cptvf_clear_irde_intr(cptvf); 540 dev_err(&pdev->dev, "Instruction NCB read error interrupt 0x%llx on CPT VF %d\n", 541 intr, cptvf->vfid); 542 } else if (unlikely(intr & CPT_VF_INTR_NWRP_MASK)) { 543 cptvf_clear_nwrp_intr(cptvf); 544 dev_err(&pdev->dev, "NCB response write error interrupt 0x%llx on CPT VF %d\n", 545 intr, cptvf->vfid); 546 } else if (unlikely(intr & CPT_VF_INTR_SERR_MASK)) { 547 cptvf_clear_swerr_intr(cptvf); 548 dev_err(&pdev->dev, "Software error interrupt 0x%llx on CPT VF %d\n", 549 intr, cptvf->vfid); 550 } else { 551 dev_err(&pdev->dev, "Unhandled interrupt in CPT VF %d\n", 552 cptvf->vfid); 553 } 554 555 return IRQ_HANDLED; 556 } 557 558 static inline struct cptvf_wqe *get_cptvf_vq_wqe(struct cpt_vf *cptvf, 559 int qno) 560 { 561 struct cptvf_wqe_info *nwqe_info; 562 563 if (unlikely(qno >= cptvf->nr_queues)) 564 return NULL; 565 nwqe_info = (struct cptvf_wqe_info *)cptvf->wqe_info; 566 567 return &nwqe_info->vq_wqe[qno]; 568 } 569 570 static inline u32 cptvf_read_vq_done_count(struct cpt_vf *cptvf) 571 { 572 union cptx_vqx_done vqx_done; 573 574 vqx_done.u = cpt_read_csr64(cptvf->reg_base, CPTX_VQX_DONE(0, 0)); 575 return vqx_done.s.done; 576 } 577 578 static inline void cptvf_write_vq_done_ack(struct cpt_vf *cptvf, 579 u32 ackcnt) 580 { 581 union cptx_vqx_done_ack vqx_dack_cnt; 582 583 vqx_dack_cnt.u = cpt_read_csr64(cptvf->reg_base, 584 CPTX_VQX_DONE_ACK(0, 0)); 585 vqx_dack_cnt.s.done_ack = ackcnt; 586 cpt_write_csr64(cptvf->reg_base, CPTX_VQX_DONE_ACK(0, 0), 587 vqx_dack_cnt.u); 588 } 589 590 static irqreturn_t cptvf_done_intr_handler(int irq, void *cptvf_irq) 591 { 592 struct cpt_vf *cptvf = (struct cpt_vf *)cptvf_irq; 593 struct pci_dev *pdev = cptvf->pdev; 594 /* Read the number of completions */ 595 u32 intr = cptvf_read_vq_done_count(cptvf); 596 597 if (intr) { 598 struct cptvf_wqe *wqe; 599 600 /* Acknowledge the number of 601 * scheduled completions for processing 602 */ 603 cptvf_write_vq_done_ack(cptvf, intr); 604 wqe = get_cptvf_vq_wqe(cptvf, 0); 605 if (unlikely(!wqe)) { 606 dev_err(&pdev->dev, "No work to schedule for VF (%d)", 607 cptvf->vfid); 608 return IRQ_NONE; 609 } 610 tasklet_hi_schedule(&wqe->twork); 611 } 612 613 return IRQ_HANDLED; 614 } 615 616 static void cptvf_set_irq_affinity(struct cpt_vf *cptvf, int vec) 617 { 618 struct pci_dev *pdev = cptvf->pdev; 619 int cpu; 620 621 if (!zalloc_cpumask_var(&cptvf->affinity_mask[vec], 622 GFP_KERNEL)) { 623 dev_err(&pdev->dev, "Allocation failed for affinity_mask for VF %d", 624 cptvf->vfid); 625 return; 626 } 627 628 cpu = cptvf->vfid % num_online_cpus(); 629 cpumask_set_cpu(cpumask_local_spread(cpu, cptvf->node), 630 cptvf->affinity_mask[vec]); 631 irq_set_affinity_hint(pci_irq_vector(pdev, vec), 632 cptvf->affinity_mask[vec]); 633 } 634 635 static void cptvf_write_vq_saddr(struct cpt_vf *cptvf, u64 val) 636 { 637 union cptx_vqx_saddr vqx_saddr; 638 639 vqx_saddr.u = val; 640 cpt_write_csr64(cptvf->reg_base, CPTX_VQX_SADDR(0, 0), vqx_saddr.u); 641 } 642 643 void cptvf_device_init(struct cpt_vf *cptvf) 644 { 645 u64 base_addr = 0; 646 647 /* Disable the VQ */ 648 cptvf_write_vq_ctl(cptvf, 0); 649 /* Reset the doorbell */ 650 cptvf_write_vq_doorbell(cptvf, 0); 651 /* Clear inflight */ 652 cptvf_write_vq_inprog(cptvf, 0); 653 /* Write VQ SADDR */ 654 /* TODO: for now only one queue, so hard coded */ 655 base_addr = (u64)(cptvf->cqinfo.queue[0].qhead->dma_addr); 656 cptvf_write_vq_saddr(cptvf, base_addr); 657 /* Configure timerhold / coalescence */ 658 cptvf_write_vq_done_timewait(cptvf, CPT_TIMER_THOLD); 659 cptvf_write_vq_done_numwait(cptvf, 1); 660 /* Enable the VQ */ 661 cptvf_write_vq_ctl(cptvf, 1); 662 /* Flag the VF ready */ 663 cptvf->flags |= CPT_FLAG_DEVICE_READY; 664 } 665 666 static int cptvf_probe(struct pci_dev *pdev, const struct pci_device_id *ent) 667 { 668 struct device *dev = &pdev->dev; 669 struct cpt_vf *cptvf; 670 int err; 671 672 cptvf = devm_kzalloc(dev, sizeof(*cptvf), GFP_KERNEL); 673 if (!cptvf) 674 return -ENOMEM; 675 676 pci_set_drvdata(pdev, cptvf); 677 cptvf->pdev = pdev; 678 err = pci_enable_device(pdev); 679 if (err) { 680 dev_err(dev, "Failed to enable PCI device\n"); 681 pci_set_drvdata(pdev, NULL); 682 return err; 683 } 684 685 err = pci_request_regions(pdev, DRV_NAME); 686 if (err) { 687 dev_err(dev, "PCI request regions failed 0x%x\n", err); 688 goto cptvf_err_disable_device; 689 } 690 /* Mark as VF driver */ 691 cptvf->flags |= CPT_FLAG_VF_DRIVER; 692 err = pci_set_dma_mask(pdev, DMA_BIT_MASK(48)); 693 if (err) { 694 dev_err(dev, "Unable to get usable DMA configuration\n"); 695 goto cptvf_err_release_regions; 696 } 697 698 err = pci_set_consistent_dma_mask(pdev, DMA_BIT_MASK(48)); 699 if (err) { 700 dev_err(dev, "Unable to get 48-bit DMA for consistent allocations\n"); 701 goto cptvf_err_release_regions; 702 } 703 704 /* MAP PF's configuration registers */ 705 cptvf->reg_base = pcim_iomap(pdev, 0, 0); 706 if (!cptvf->reg_base) { 707 dev_err(dev, "Cannot map config register space, aborting\n"); 708 err = -ENOMEM; 709 goto cptvf_err_release_regions; 710 } 711 712 cptvf->node = dev_to_node(&pdev->dev); 713 err = pci_alloc_irq_vectors(pdev, CPT_VF_MSIX_VECTORS, 714 CPT_VF_MSIX_VECTORS, PCI_IRQ_MSIX); 715 if (err < 0) { 716 dev_err(dev, "Request for #%d msix vectors failed\n", 717 CPT_VF_MSIX_VECTORS); 718 goto cptvf_err_release_regions; 719 } 720 721 err = request_irq(pci_irq_vector(pdev, CPT_VF_INT_VEC_E_MISC), 722 cptvf_misc_intr_handler, 0, "CPT VF misc intr", 723 cptvf); 724 if (err) { 725 dev_err(dev, "Request misc irq failed"); 726 goto cptvf_free_vectors; 727 } 728 729 /* Enable mailbox interrupt */ 730 cptvf_enable_mbox_interrupts(cptvf); 731 cptvf_enable_swerr_interrupts(cptvf); 732 733 /* Check ready with PF */ 734 /* Gets chip ID / device Id from PF if ready */ 735 err = cptvf_check_pf_ready(cptvf); 736 if (err) { 737 dev_err(dev, "PF not responding to READY msg"); 738 goto cptvf_free_misc_irq; 739 } 740 741 /* CPT VF software resources initialization */ 742 cptvf->cqinfo.qchunksize = CPT_CMD_QCHUNK_SIZE; 743 err = cptvf_sw_init(cptvf, CPT_CMD_QLEN, CPT_NUM_QS_PER_VF); 744 if (err) { 745 dev_err(dev, "cptvf_sw_init() failed"); 746 goto cptvf_free_misc_irq; 747 } 748 /* Convey VQ LEN to PF */ 749 err = cptvf_send_vq_size_msg(cptvf); 750 if (err) { 751 dev_err(dev, "PF not responding to QLEN msg"); 752 goto cptvf_free_misc_irq; 753 } 754 755 /* CPT VF device initialization */ 756 cptvf_device_init(cptvf); 757 /* Send msg to PF to assign currnet Q to required group */ 758 cptvf->vfgrp = 1; 759 err = cptvf_send_vf_to_grp_msg(cptvf); 760 if (err) { 761 dev_err(dev, "PF not responding to VF_GRP msg"); 762 goto cptvf_free_misc_irq; 763 } 764 765 cptvf->priority = 1; 766 err = cptvf_send_vf_priority_msg(cptvf); 767 if (err) { 768 dev_err(dev, "PF not responding to VF_PRIO msg"); 769 goto cptvf_free_misc_irq; 770 } 771 772 err = request_irq(pci_irq_vector(pdev, CPT_VF_INT_VEC_E_DONE), 773 cptvf_done_intr_handler, 0, "CPT VF done intr", 774 cptvf); 775 if (err) { 776 dev_err(dev, "Request done irq failed\n"); 777 goto cptvf_free_misc_irq; 778 } 779 780 /* Enable mailbox interrupt */ 781 cptvf_enable_done_interrupts(cptvf); 782 783 /* Set irq affinity masks */ 784 cptvf_set_irq_affinity(cptvf, CPT_VF_INT_VEC_E_MISC); 785 cptvf_set_irq_affinity(cptvf, CPT_VF_INT_VEC_E_DONE); 786 787 err = cptvf_send_vf_up(cptvf); 788 if (err) { 789 dev_err(dev, "PF not responding to UP msg"); 790 goto cptvf_free_irq_affinity; 791 } 792 err = cvm_crypto_init(cptvf); 793 if (err) { 794 dev_err(dev, "Algorithm register failed\n"); 795 goto cptvf_free_irq_affinity; 796 } 797 return 0; 798 799 cptvf_free_irq_affinity: 800 cptvf_free_irq_affinity(cptvf, CPT_VF_INT_VEC_E_DONE); 801 cptvf_free_irq_affinity(cptvf, CPT_VF_INT_VEC_E_MISC); 802 cptvf_free_misc_irq: 803 free_irq(pci_irq_vector(pdev, CPT_VF_INT_VEC_E_MISC), cptvf); 804 cptvf_free_vectors: 805 pci_free_irq_vectors(cptvf->pdev); 806 cptvf_err_release_regions: 807 pci_release_regions(pdev); 808 cptvf_err_disable_device: 809 pci_disable_device(pdev); 810 pci_set_drvdata(pdev, NULL); 811 812 return err; 813 } 814 815 static void cptvf_remove(struct pci_dev *pdev) 816 { 817 struct cpt_vf *cptvf = pci_get_drvdata(pdev); 818 819 if (!cptvf) { 820 dev_err(&pdev->dev, "Invalid CPT-VF device\n"); 821 return; 822 } 823 824 /* Convey DOWN to PF */ 825 if (cptvf_send_vf_down(cptvf)) { 826 dev_err(&pdev->dev, "PF not responding to DOWN msg"); 827 } else { 828 cptvf_free_irq_affinity(cptvf, CPT_VF_INT_VEC_E_DONE); 829 cptvf_free_irq_affinity(cptvf, CPT_VF_INT_VEC_E_MISC); 830 free_irq(pci_irq_vector(pdev, CPT_VF_INT_VEC_E_DONE), cptvf); 831 free_irq(pci_irq_vector(pdev, CPT_VF_INT_VEC_E_MISC), cptvf); 832 pci_free_irq_vectors(cptvf->pdev); 833 cptvf_sw_cleanup(cptvf); 834 pci_set_drvdata(pdev, NULL); 835 pci_release_regions(pdev); 836 pci_disable_device(pdev); 837 cvm_crypto_exit(); 838 } 839 } 840 841 static void cptvf_shutdown(struct pci_dev *pdev) 842 { 843 cptvf_remove(pdev); 844 } 845 846 /* Supported devices */ 847 static const struct pci_device_id cptvf_id_table[] = { 848 {PCI_VDEVICE(CAVIUM, CPT_81XX_PCI_VF_DEVICE_ID), 0}, 849 { 0, } /* end of table */ 850 }; 851 852 static struct pci_driver cptvf_pci_driver = { 853 .name = DRV_NAME, 854 .id_table = cptvf_id_table, 855 .probe = cptvf_probe, 856 .remove = cptvf_remove, 857 .shutdown = cptvf_shutdown, 858 }; 859 860 module_pci_driver(cptvf_pci_driver); 861 862 MODULE_AUTHOR("George Cherian <george.cherian@cavium.com>"); 863 MODULE_DESCRIPTION("Cavium Thunder CPT Virtual Function Driver"); 864 MODULE_LICENSE("GPL v2"); 865 MODULE_VERSION(DRV_VERSION); 866 MODULE_DEVICE_TABLE(pci, cptvf_id_table); 867