3bf007aa472575d856239be05b8838f02e246a8d
[muen/linux.git] / drivers / net / ethernet / marvell / octeontx2 / af / rvu.c
1 // SPDX-License-Identifier: GPL-2.0
2 /* Marvell OcteonTx2 RVU Admin Function driver
3  *
4  * Copyright (C) 2018 Marvell International Ltd.
5  *
6  * This program is free software; you can redistribute it and/or modify
7  * it under the terms of the GNU General Public License version 2 as
8  * published by the Free Software Foundation.
9  */
10
11 #include <linux/module.h>
12 #include <linux/interrupt.h>
13 #include <linux/delay.h>
14 #include <linux/irq.h>
15 #include <linux/pci.h>
16 #include <linux/sysfs.h>
17
18 #include "cgx.h"
19 #include "rvu.h"
20 #include "rvu_reg.h"
21
22 #define DRV_NAME        "octeontx2-af"
23 #define DRV_STRING      "Marvell OcteonTX2 RVU Admin Function Driver"
24 #define DRV_VERSION     "1.0"
25
26 static int rvu_get_hwvf(struct rvu *rvu, int pcifunc);
27
28 static void rvu_set_msix_offset(struct rvu *rvu, struct rvu_pfvf *pfvf,
29                                 struct rvu_block *block, int lf);
30 static void rvu_clear_msix_offset(struct rvu *rvu, struct rvu_pfvf *pfvf,
31                                   struct rvu_block *block, int lf);
32
33 /* Supported devices */
34 static const struct pci_device_id rvu_id_table[] = {
35         { PCI_DEVICE(PCI_VENDOR_ID_CAVIUM, PCI_DEVID_OCTEONTX2_RVU_AF) },
36         { 0, }  /* end of table */
37 };
38
39 MODULE_AUTHOR("Marvell International Ltd.");
40 MODULE_DESCRIPTION(DRV_STRING);
41 MODULE_LICENSE("GPL v2");
42 MODULE_VERSION(DRV_VERSION);
43 MODULE_DEVICE_TABLE(pci, rvu_id_table);
44
45 /* Poll a RVU block's register 'offset', for a 'zero'
46  * or 'nonzero' at bits specified by 'mask'
47  */
48 int rvu_poll_reg(struct rvu *rvu, u64 block, u64 offset, u64 mask, bool zero)
49 {
50         unsigned long timeout = jiffies + usecs_to_jiffies(100);
51         void __iomem *reg;
52         u64 reg_val;
53
54         reg = rvu->afreg_base + ((block << 28) | offset);
55         while (time_before(jiffies, timeout)) {
56                 reg_val = readq(reg);
57                 if (zero && !(reg_val & mask))
58                         return 0;
59                 if (!zero && (reg_val & mask))
60                         return 0;
61                 usleep_range(1, 5);
62                 timeout--;
63         }
64         return -EBUSY;
65 }
66
67 int rvu_alloc_rsrc(struct rsrc_bmap *rsrc)
68 {
69         int id;
70
71         if (!rsrc->bmap)
72                 return -EINVAL;
73
74         id = find_first_zero_bit(rsrc->bmap, rsrc->max);
75         if (id >= rsrc->max)
76                 return -ENOSPC;
77
78         __set_bit(id, rsrc->bmap);
79
80         return id;
81 }
82
83 int rvu_alloc_rsrc_contig(struct rsrc_bmap *rsrc, int nrsrc)
84 {
85         int start;
86
87         if (!rsrc->bmap)
88                 return -EINVAL;
89
90         start = bitmap_find_next_zero_area(rsrc->bmap, rsrc->max, 0, nrsrc, 0);
91         if (start >= rsrc->max)
92                 return -ENOSPC;
93
94         bitmap_set(rsrc->bmap, start, nrsrc);
95         return start;
96 }
97
98 static void rvu_free_rsrc_contig(struct rsrc_bmap *rsrc, int nrsrc, int start)
99 {
100         if (!rsrc->bmap)
101                 return;
102         if (start >= rsrc->max)
103                 return;
104
105         bitmap_clear(rsrc->bmap, start, nrsrc);
106 }
107
108 bool rvu_rsrc_check_contig(struct rsrc_bmap *rsrc, int nrsrc)
109 {
110         int start;
111
112         if (!rsrc->bmap)
113                 return false;
114
115         start = bitmap_find_next_zero_area(rsrc->bmap, rsrc->max, 0, nrsrc, 0);
116         if (start >= rsrc->max)
117                 return false;
118
119         return true;
120 }
121
122 void rvu_free_rsrc(struct rsrc_bmap *rsrc, int id)
123 {
124         if (!rsrc->bmap)
125                 return;
126
127         __clear_bit(id, rsrc->bmap);
128 }
129
130 int rvu_rsrc_free_count(struct rsrc_bmap *rsrc)
131 {
132         int used;
133
134         if (!rsrc->bmap)
135                 return 0;
136
137         used = bitmap_weight(rsrc->bmap, rsrc->max);
138         return (rsrc->max - used);
139 }
140
141 int rvu_alloc_bitmap(struct rsrc_bmap *rsrc)
142 {
143         rsrc->bmap = kcalloc(BITS_TO_LONGS(rsrc->max),
144                              sizeof(long), GFP_KERNEL);
145         if (!rsrc->bmap)
146                 return -ENOMEM;
147         return 0;
148 }
149
150 /* Get block LF's HW index from a PF_FUNC's block slot number */
151 int rvu_get_lf(struct rvu *rvu, struct rvu_block *block, u16 pcifunc, u16 slot)
152 {
153         u16 match = 0;
154         int lf;
155
156         spin_lock(&rvu->rsrc_lock);
157         for (lf = 0; lf < block->lf.max; lf++) {
158                 if (block->fn_map[lf] == pcifunc) {
159                         if (slot == match) {
160                                 spin_unlock(&rvu->rsrc_lock);
161                                 return lf;
162                         }
163                         match++;
164                 }
165         }
166         spin_unlock(&rvu->rsrc_lock);
167         return -ENODEV;
168 }
169
170 /* Convert BLOCK_TYPE_E to a BLOCK_ADDR_E.
171  * Some silicon variants of OcteonTX2 supports
172  * multiple blocks of same type.
173  *
174  * @pcifunc has to be zero when no LF is yet attached.
175  */
176 int rvu_get_blkaddr(struct rvu *rvu, int blktype, u16 pcifunc)
177 {
178         int devnum, blkaddr = -ENODEV;
179         u64 cfg, reg;
180         bool is_pf;
181
182         switch (blktype) {
183         case BLKTYPE_NPA:
184                 blkaddr = BLKADDR_NPA;
185                 goto exit;
186         case BLKTYPE_NIX:
187                 /* For now assume NIX0 */
188                 if (!pcifunc) {
189                         blkaddr = BLKADDR_NIX0;
190                         goto exit;
191                 }
192                 break;
193         case BLKTYPE_SSO:
194                 blkaddr = BLKADDR_SSO;
195                 goto exit;
196         case BLKTYPE_SSOW:
197                 blkaddr = BLKADDR_SSOW;
198                 goto exit;
199         case BLKTYPE_TIM:
200                 blkaddr = BLKADDR_TIM;
201                 goto exit;
202         case BLKTYPE_CPT:
203                 /* For now assume CPT0 */
204                 if (!pcifunc) {
205                         blkaddr = BLKADDR_CPT0;
206                         goto exit;
207                 }
208                 break;
209         }
210
211         /* Check if this is a RVU PF or VF */
212         if (pcifunc & RVU_PFVF_FUNC_MASK) {
213                 is_pf = false;
214                 devnum = rvu_get_hwvf(rvu, pcifunc);
215         } else {
216                 is_pf = true;
217                 devnum = rvu_get_pf(pcifunc);
218         }
219
220         /* Check if the 'pcifunc' has a NIX LF from 'BLKADDR_NIX0' */
221         if (blktype == BLKTYPE_NIX) {
222                 reg = is_pf ? RVU_PRIV_PFX_NIX0_CFG : RVU_PRIV_HWVFX_NIX0_CFG;
223                 cfg = rvu_read64(rvu, BLKADDR_RVUM, reg | (devnum << 16));
224                 if (cfg)
225                         blkaddr = BLKADDR_NIX0;
226         }
227
228         /* Check if the 'pcifunc' has a CPT LF from 'BLKADDR_CPT0' */
229         if (blktype == BLKTYPE_CPT) {
230                 reg = is_pf ? RVU_PRIV_PFX_CPT0_CFG : RVU_PRIV_HWVFX_CPT0_CFG;
231                 cfg = rvu_read64(rvu, BLKADDR_RVUM, reg | (devnum << 16));
232                 if (cfg)
233                         blkaddr = BLKADDR_CPT0;
234         }
235
236 exit:
237         if (is_block_implemented(rvu->hw, blkaddr))
238                 return blkaddr;
239         return -ENODEV;
240 }
241
242 static void rvu_update_rsrc_map(struct rvu *rvu, struct rvu_pfvf *pfvf,
243                                 struct rvu_block *block, u16 pcifunc,
244                                 u16 lf, bool attach)
245 {
246         int devnum, num_lfs = 0;
247         bool is_pf;
248         u64 reg;
249
250         if (lf >= block->lf.max) {
251                 dev_err(&rvu->pdev->dev,
252                         "%s: FATAL: LF %d is >= %s's max lfs i.e %d\n",
253                         __func__, lf, block->name, block->lf.max);
254                 return;
255         }
256
257         /* Check if this is for a RVU PF or VF */
258         if (pcifunc & RVU_PFVF_FUNC_MASK) {
259                 is_pf = false;
260                 devnum = rvu_get_hwvf(rvu, pcifunc);
261         } else {
262                 is_pf = true;
263                 devnum = rvu_get_pf(pcifunc);
264         }
265
266         block->fn_map[lf] = attach ? pcifunc : 0;
267
268         switch (block->type) {
269         case BLKTYPE_NPA:
270                 pfvf->npalf = attach ? true : false;
271                 num_lfs = pfvf->npalf;
272                 break;
273         case BLKTYPE_NIX:
274                 pfvf->nixlf = attach ? true : false;
275                 num_lfs = pfvf->nixlf;
276                 break;
277         case BLKTYPE_SSO:
278                 attach ? pfvf->sso++ : pfvf->sso--;
279                 num_lfs = pfvf->sso;
280                 break;
281         case BLKTYPE_SSOW:
282                 attach ? pfvf->ssow++ : pfvf->ssow--;
283                 num_lfs = pfvf->ssow;
284                 break;
285         case BLKTYPE_TIM:
286                 attach ? pfvf->timlfs++ : pfvf->timlfs--;
287                 num_lfs = pfvf->timlfs;
288                 break;
289         case BLKTYPE_CPT:
290                 attach ? pfvf->cptlfs++ : pfvf->cptlfs--;
291                 num_lfs = pfvf->cptlfs;
292                 break;
293         }
294
295         reg = is_pf ? block->pf_lfcnt_reg : block->vf_lfcnt_reg;
296         rvu_write64(rvu, BLKADDR_RVUM, reg | (devnum << 16), num_lfs);
297 }
298
299 inline int rvu_get_pf(u16 pcifunc)
300 {
301         return (pcifunc >> RVU_PFVF_PF_SHIFT) & RVU_PFVF_PF_MASK;
302 }
303
304 void rvu_get_pf_numvfs(struct rvu *rvu, int pf, int *numvfs, int *hwvf)
305 {
306         u64 cfg;
307
308         /* Get numVFs attached to this PF and first HWVF */
309         cfg = rvu_read64(rvu, BLKADDR_RVUM, RVU_PRIV_PFX_CFG(pf));
310         *numvfs = (cfg >> 12) & 0xFF;
311         *hwvf = cfg & 0xFFF;
312 }
313
314 static int rvu_get_hwvf(struct rvu *rvu, int pcifunc)
315 {
316         int pf, func;
317         u64 cfg;
318
319         pf = rvu_get_pf(pcifunc);
320         func = pcifunc & RVU_PFVF_FUNC_MASK;
321
322         /* Get first HWVF attached to this PF */
323         cfg = rvu_read64(rvu, BLKADDR_RVUM, RVU_PRIV_PFX_CFG(pf));
324
325         return ((cfg & 0xFFF) + func - 1);
326 }
327
328 struct rvu_pfvf *rvu_get_pfvf(struct rvu *rvu, int pcifunc)
329 {
330         /* Check if it is a PF or VF */
331         if (pcifunc & RVU_PFVF_FUNC_MASK)
332                 return &rvu->hwvf[rvu_get_hwvf(rvu, pcifunc)];
333         else
334                 return &rvu->pf[rvu_get_pf(pcifunc)];
335 }
336
337 bool is_block_implemented(struct rvu_hwinfo *hw, int blkaddr)
338 {
339         struct rvu_block *block;
340
341         if (blkaddr < BLKADDR_RVUM || blkaddr >= BLK_COUNT)
342                 return false;
343
344         block = &hw->block[blkaddr];
345         return block->implemented;
346 }
347
348 static void rvu_check_block_implemented(struct rvu *rvu)
349 {
350         struct rvu_hwinfo *hw = rvu->hw;
351         struct rvu_block *block;
352         int blkid;
353         u64 cfg;
354
355         /* For each block check if 'implemented' bit is set */
356         for (blkid = 0; blkid < BLK_COUNT; blkid++) {
357                 block = &hw->block[blkid];
358                 cfg = rvupf_read64(rvu, RVU_PF_BLOCK_ADDRX_DISC(blkid));
359                 if (cfg & BIT_ULL(11))
360                         block->implemented = true;
361         }
362 }
363
364 int rvu_lf_reset(struct rvu *rvu, struct rvu_block *block, int lf)
365 {
366         int err;
367
368         if (!block->implemented)
369                 return 0;
370
371         rvu_write64(rvu, block->addr, block->lfreset_reg, lf | BIT_ULL(12));
372         err = rvu_poll_reg(rvu, block->addr, block->lfreset_reg, BIT_ULL(12),
373                            true);
374         return err;
375 }
376
377 static void rvu_block_reset(struct rvu *rvu, int blkaddr, u64 rst_reg)
378 {
379         struct rvu_block *block = &rvu->hw->block[blkaddr];
380
381         if (!block->implemented)
382                 return;
383
384         rvu_write64(rvu, blkaddr, rst_reg, BIT_ULL(0));
385         rvu_poll_reg(rvu, blkaddr, rst_reg, BIT_ULL(63), true);
386 }
387
388 static void rvu_reset_all_blocks(struct rvu *rvu)
389 {
390         /* Do a HW reset of all RVU blocks */
391         rvu_block_reset(rvu, BLKADDR_NPA, NPA_AF_BLK_RST);
392         rvu_block_reset(rvu, BLKADDR_NIX0, NIX_AF_BLK_RST);
393         rvu_block_reset(rvu, BLKADDR_NPC, NPC_AF_BLK_RST);
394         rvu_block_reset(rvu, BLKADDR_SSO, SSO_AF_BLK_RST);
395         rvu_block_reset(rvu, BLKADDR_TIM, TIM_AF_BLK_RST);
396         rvu_block_reset(rvu, BLKADDR_CPT0, CPT_AF_BLK_RST);
397         rvu_block_reset(rvu, BLKADDR_NDC0, NDC_AF_BLK_RST);
398         rvu_block_reset(rvu, BLKADDR_NDC1, NDC_AF_BLK_RST);
399         rvu_block_reset(rvu, BLKADDR_NDC2, NDC_AF_BLK_RST);
400 }
401
402 static void rvu_scan_block(struct rvu *rvu, struct rvu_block *block)
403 {
404         struct rvu_pfvf *pfvf;
405         u64 cfg;
406         int lf;
407
408         for (lf = 0; lf < block->lf.max; lf++) {
409                 cfg = rvu_read64(rvu, block->addr,
410                                  block->lfcfg_reg | (lf << block->lfshift));
411                 if (!(cfg & BIT_ULL(63)))
412                         continue;
413
414                 /* Set this resource as being used */
415                 __set_bit(lf, block->lf.bmap);
416
417                 /* Get, to whom this LF is attached */
418                 pfvf = rvu_get_pfvf(rvu, (cfg >> 8) & 0xFFFF);
419                 rvu_update_rsrc_map(rvu, pfvf, block,
420                                     (cfg >> 8) & 0xFFFF, lf, true);
421
422                 /* Set start MSIX vector for this LF within this PF/VF */
423                 rvu_set_msix_offset(rvu, pfvf, block, lf);
424         }
425 }
426
427 static void rvu_check_min_msix_vec(struct rvu *rvu, int nvecs, int pf, int vf)
428 {
429         int min_vecs;
430
431         if (!vf)
432                 goto check_pf;
433
434         if (!nvecs) {
435                 dev_warn(rvu->dev,
436                          "PF%d:VF%d is configured with zero msix vectors, %d\n",
437                          pf, vf - 1, nvecs);
438         }
439         return;
440
441 check_pf:
442         if (pf == 0)
443                 min_vecs = RVU_AF_INT_VEC_CNT + RVU_PF_INT_VEC_CNT;
444         else
445                 min_vecs = RVU_PF_INT_VEC_CNT;
446
447         if (!(nvecs < min_vecs))
448                 return;
449         dev_warn(rvu->dev,
450                  "PF%d is configured with too few vectors, %d, min is %d\n",
451                  pf, nvecs, min_vecs);
452 }
453
454 static int rvu_setup_msix_resources(struct rvu *rvu)
455 {
456         struct rvu_hwinfo *hw = rvu->hw;
457         int pf, vf, numvfs, hwvf, err;
458         int nvecs, offset, max_msix;
459         struct rvu_pfvf *pfvf;
460         u64 cfg, phy_addr;
461         dma_addr_t iova;
462
463         for (pf = 0; pf < hw->total_pfs; pf++) {
464                 cfg = rvu_read64(rvu, BLKADDR_RVUM, RVU_PRIV_PFX_CFG(pf));
465                 /* If PF is not enabled, nothing to do */
466                 if (!((cfg >> 20) & 0x01))
467                         continue;
468
469                 rvu_get_pf_numvfs(rvu, pf, &numvfs, &hwvf);
470
471                 pfvf = &rvu->pf[pf];
472                 /* Get num of MSIX vectors attached to this PF */
473                 cfg = rvu_read64(rvu, BLKADDR_RVUM, RVU_PRIV_PFX_MSIX_CFG(pf));
474                 pfvf->msix.max = ((cfg >> 32) & 0xFFF) + 1;
475                 rvu_check_min_msix_vec(rvu, pfvf->msix.max, pf, 0);
476
477                 /* Alloc msix bitmap for this PF */
478                 err = rvu_alloc_bitmap(&pfvf->msix);
479                 if (err)
480                         return err;
481
482                 /* Allocate memory for MSIX vector to RVU block LF mapping */
483                 pfvf->msix_lfmap = devm_kcalloc(rvu->dev, pfvf->msix.max,
484                                                 sizeof(u16), GFP_KERNEL);
485                 if (!pfvf->msix_lfmap)
486                         return -ENOMEM;
487
488                 /* For PF0 (AF) firmware will set msix vector offsets for
489                  * AF, block AF and PF0_INT vectors, so jump to VFs.
490                  */
491                 if (!pf)
492                         goto setup_vfmsix;
493
494                 /* Set MSIX offset for PF's 'RVU_PF_INT_VEC' vectors.
495                  * These are allocated on driver init and never freed,
496                  * so no need to set 'msix_lfmap' for these.
497                  */
498                 cfg = rvu_read64(rvu, BLKADDR_RVUM, RVU_PRIV_PFX_INT_CFG(pf));
499                 nvecs = (cfg >> 12) & 0xFF;
500                 cfg &= ~0x7FFULL;
501                 offset = rvu_alloc_rsrc_contig(&pfvf->msix, nvecs);
502                 rvu_write64(rvu, BLKADDR_RVUM,
503                             RVU_PRIV_PFX_INT_CFG(pf), cfg | offset);
504 setup_vfmsix:
505                 /* Alloc msix bitmap for VFs */
506                 for (vf = 0; vf < numvfs; vf++) {
507                         pfvf =  &rvu->hwvf[hwvf + vf];
508                         /* Get num of MSIX vectors attached to this VF */
509                         cfg = rvu_read64(rvu, BLKADDR_RVUM,
510                                          RVU_PRIV_PFX_MSIX_CFG(pf));
511                         pfvf->msix.max = (cfg & 0xFFF) + 1;
512                         rvu_check_min_msix_vec(rvu, pfvf->msix.max, pf, vf + 1);
513
514                         /* Alloc msix bitmap for this VF */
515                         err = rvu_alloc_bitmap(&pfvf->msix);
516                         if (err)
517                                 return err;
518
519                         pfvf->msix_lfmap =
520                                 devm_kcalloc(rvu->dev, pfvf->msix.max,
521                                              sizeof(u16), GFP_KERNEL);
522                         if (!pfvf->msix_lfmap)
523                                 return -ENOMEM;
524
525                         /* Set MSIX offset for HWVF's 'RVU_VF_INT_VEC' vectors.
526                          * These are allocated on driver init and never freed,
527                          * so no need to set 'msix_lfmap' for these.
528                          */
529                         cfg = rvu_read64(rvu, BLKADDR_RVUM,
530                                          RVU_PRIV_HWVFX_INT_CFG(hwvf + vf));
531                         nvecs = (cfg >> 12) & 0xFF;
532                         cfg &= ~0x7FFULL;
533                         offset = rvu_alloc_rsrc_contig(&pfvf->msix, nvecs);
534                         rvu_write64(rvu, BLKADDR_RVUM,
535                                     RVU_PRIV_HWVFX_INT_CFG(hwvf + vf),
536                                     cfg | offset);
537                 }
538         }
539
540         /* HW interprets RVU_AF_MSIXTR_BASE address as an IOVA, hence
541          * create a IOMMU mapping for the physcial address configured by
542          * firmware and reconfig RVU_AF_MSIXTR_BASE with IOVA.
543          */
544         cfg = rvu_read64(rvu, BLKADDR_RVUM, RVU_PRIV_CONST);
545         max_msix = cfg & 0xFFFFF;
546         phy_addr = rvu_read64(rvu, BLKADDR_RVUM, RVU_AF_MSIXTR_BASE);
547         iova = dma_map_resource(rvu->dev, phy_addr,
548                                 max_msix * PCI_MSIX_ENTRY_SIZE,
549                                 DMA_BIDIRECTIONAL, 0);
550
551         if (dma_mapping_error(rvu->dev, iova))
552                 return -ENOMEM;
553
554         rvu_write64(rvu, BLKADDR_RVUM, RVU_AF_MSIXTR_BASE, (u64)iova);
555         rvu->msix_base_iova = iova;
556
557         return 0;
558 }
559
560 static void rvu_free_hw_resources(struct rvu *rvu)
561 {
562         struct rvu_hwinfo *hw = rvu->hw;
563         struct rvu_block *block;
564         struct rvu_pfvf  *pfvf;
565         int id, max_msix;
566         u64 cfg;
567
568         rvu_npa_freemem(rvu);
569         rvu_nix_freemem(rvu);
570
571         /* Free block LF bitmaps */
572         for (id = 0; id < BLK_COUNT; id++) {
573                 block = &hw->block[id];
574                 kfree(block->lf.bmap);
575         }
576
577         /* Free MSIX bitmaps */
578         for (id = 0; id < hw->total_pfs; id++) {
579                 pfvf = &rvu->pf[id];
580                 kfree(pfvf->msix.bmap);
581         }
582
583         for (id = 0; id < hw->total_vfs; id++) {
584                 pfvf = &rvu->hwvf[id];
585                 kfree(pfvf->msix.bmap);
586         }
587
588         /* Unmap MSIX vector base IOVA mapping */
589         if (!rvu->msix_base_iova)
590                 return;
591         cfg = rvu_read64(rvu, BLKADDR_RVUM, RVU_PRIV_CONST);
592         max_msix = cfg & 0xFFFFF;
593         dma_unmap_resource(rvu->dev, rvu->msix_base_iova,
594                            max_msix * PCI_MSIX_ENTRY_SIZE,
595                            DMA_BIDIRECTIONAL, 0);
596 }
597
598 static int rvu_setup_hw_resources(struct rvu *rvu)
599 {
600         struct rvu_hwinfo *hw = rvu->hw;
601         struct rvu_block *block;
602         int blkid, err;
603         u64 cfg;
604
605         /* Get HW supported max RVU PF & VF count */
606         cfg = rvu_read64(rvu, BLKADDR_RVUM, RVU_PRIV_CONST);
607         hw->total_pfs = (cfg >> 32) & 0xFF;
608         hw->total_vfs = (cfg >> 20) & 0xFFF;
609         hw->max_vfs_per_pf = (cfg >> 40) & 0xFF;
610
611         /* Init NPA LF's bitmap */
612         block = &hw->block[BLKADDR_NPA];
613         if (!block->implemented)
614                 goto nix;
615         cfg = rvu_read64(rvu, BLKADDR_NPA, NPA_AF_CONST);
616         block->lf.max = (cfg >> 16) & 0xFFF;
617         block->addr = BLKADDR_NPA;
618         block->type = BLKTYPE_NPA;
619         block->lfshift = 8;
620         block->lookup_reg = NPA_AF_RVU_LF_CFG_DEBUG;
621         block->pf_lfcnt_reg = RVU_PRIV_PFX_NPA_CFG;
622         block->vf_lfcnt_reg = RVU_PRIV_HWVFX_NPA_CFG;
623         block->lfcfg_reg = NPA_PRIV_LFX_CFG;
624         block->msixcfg_reg = NPA_PRIV_LFX_INT_CFG;
625         block->lfreset_reg = NPA_AF_LF_RST;
626         sprintf(block->name, "NPA");
627         err = rvu_alloc_bitmap(&block->lf);
628         if (err)
629                 return err;
630
631 nix:
632         /* Init NIX LF's bitmap */
633         block = &hw->block[BLKADDR_NIX0];
634         if (!block->implemented)
635                 goto sso;
636         cfg = rvu_read64(rvu, BLKADDR_NIX0, NIX_AF_CONST2);
637         block->lf.max = cfg & 0xFFF;
638         block->addr = BLKADDR_NIX0;
639         block->type = BLKTYPE_NIX;
640         block->lfshift = 8;
641         block->lookup_reg = NIX_AF_RVU_LF_CFG_DEBUG;
642         block->pf_lfcnt_reg = RVU_PRIV_PFX_NIX0_CFG;
643         block->vf_lfcnt_reg = RVU_PRIV_HWVFX_NIX0_CFG;
644         block->lfcfg_reg = NIX_PRIV_LFX_CFG;
645         block->msixcfg_reg = NIX_PRIV_LFX_INT_CFG;
646         block->lfreset_reg = NIX_AF_LF_RST;
647         sprintf(block->name, "NIX");
648         err = rvu_alloc_bitmap(&block->lf);
649         if (err)
650                 return err;
651
652 sso:
653         /* Init SSO group's bitmap */
654         block = &hw->block[BLKADDR_SSO];
655         if (!block->implemented)
656                 goto ssow;
657         cfg = rvu_read64(rvu, BLKADDR_SSO, SSO_AF_CONST);
658         block->lf.max = cfg & 0xFFFF;
659         block->addr = BLKADDR_SSO;
660         block->type = BLKTYPE_SSO;
661         block->multislot = true;
662         block->lfshift = 3;
663         block->lookup_reg = SSO_AF_RVU_LF_CFG_DEBUG;
664         block->pf_lfcnt_reg = RVU_PRIV_PFX_SSO_CFG;
665         block->vf_lfcnt_reg = RVU_PRIV_HWVFX_SSO_CFG;
666         block->lfcfg_reg = SSO_PRIV_LFX_HWGRP_CFG;
667         block->msixcfg_reg = SSO_PRIV_LFX_HWGRP_INT_CFG;
668         block->lfreset_reg = SSO_AF_LF_HWGRP_RST;
669         sprintf(block->name, "SSO GROUP");
670         err = rvu_alloc_bitmap(&block->lf);
671         if (err)
672                 return err;
673
674 ssow:
675         /* Init SSO workslot's bitmap */
676         block = &hw->block[BLKADDR_SSOW];
677         if (!block->implemented)
678                 goto tim;
679         block->lf.max = (cfg >> 56) & 0xFF;
680         block->addr = BLKADDR_SSOW;
681         block->type = BLKTYPE_SSOW;
682         block->multislot = true;
683         block->lfshift = 3;
684         block->lookup_reg = SSOW_AF_RVU_LF_HWS_CFG_DEBUG;
685         block->pf_lfcnt_reg = RVU_PRIV_PFX_SSOW_CFG;
686         block->vf_lfcnt_reg = RVU_PRIV_HWVFX_SSOW_CFG;
687         block->lfcfg_reg = SSOW_PRIV_LFX_HWS_CFG;
688         block->msixcfg_reg = SSOW_PRIV_LFX_HWS_INT_CFG;
689         block->lfreset_reg = SSOW_AF_LF_HWS_RST;
690         sprintf(block->name, "SSOWS");
691         err = rvu_alloc_bitmap(&block->lf);
692         if (err)
693                 return err;
694
695 tim:
696         /* Init TIM LF's bitmap */
697         block = &hw->block[BLKADDR_TIM];
698         if (!block->implemented)
699                 goto cpt;
700         cfg = rvu_read64(rvu, BLKADDR_TIM, TIM_AF_CONST);
701         block->lf.max = cfg & 0xFFFF;
702         block->addr = BLKADDR_TIM;
703         block->type = BLKTYPE_TIM;
704         block->multislot = true;
705         block->lfshift = 3;
706         block->lookup_reg = TIM_AF_RVU_LF_CFG_DEBUG;
707         block->pf_lfcnt_reg = RVU_PRIV_PFX_TIM_CFG;
708         block->vf_lfcnt_reg = RVU_PRIV_HWVFX_TIM_CFG;
709         block->lfcfg_reg = TIM_PRIV_LFX_CFG;
710         block->msixcfg_reg = TIM_PRIV_LFX_INT_CFG;
711         block->lfreset_reg = TIM_AF_LF_RST;
712         sprintf(block->name, "TIM");
713         err = rvu_alloc_bitmap(&block->lf);
714         if (err)
715                 return err;
716
717 cpt:
718         /* Init CPT LF's bitmap */
719         block = &hw->block[BLKADDR_CPT0];
720         if (!block->implemented)
721                 goto init;
722         cfg = rvu_read64(rvu, BLKADDR_CPT0, CPT_AF_CONSTANTS0);
723         block->lf.max = cfg & 0xFF;
724         block->addr = BLKADDR_CPT0;
725         block->type = BLKTYPE_CPT;
726         block->multislot = true;
727         block->lfshift = 3;
728         block->lookup_reg = CPT_AF_RVU_LF_CFG_DEBUG;
729         block->pf_lfcnt_reg = RVU_PRIV_PFX_CPT0_CFG;
730         block->vf_lfcnt_reg = RVU_PRIV_HWVFX_CPT0_CFG;
731         block->lfcfg_reg = CPT_PRIV_LFX_CFG;
732         block->msixcfg_reg = CPT_PRIV_LFX_INT_CFG;
733         block->lfreset_reg = CPT_AF_LF_RST;
734         sprintf(block->name, "CPT");
735         err = rvu_alloc_bitmap(&block->lf);
736         if (err)
737                 return err;
738
739 init:
740         /* Allocate memory for PFVF data */
741         rvu->pf = devm_kcalloc(rvu->dev, hw->total_pfs,
742                                sizeof(struct rvu_pfvf), GFP_KERNEL);
743         if (!rvu->pf)
744                 return -ENOMEM;
745
746         rvu->hwvf = devm_kcalloc(rvu->dev, hw->total_vfs,
747                                  sizeof(struct rvu_pfvf), GFP_KERNEL);
748         if (!rvu->hwvf)
749                 return -ENOMEM;
750
751         spin_lock_init(&rvu->rsrc_lock);
752
753         err = rvu_setup_msix_resources(rvu);
754         if (err)
755                 return err;
756
757         for (blkid = 0; blkid < BLK_COUNT; blkid++) {
758                 block = &hw->block[blkid];
759                 if (!block->lf.bmap)
760                         continue;
761
762                 /* Allocate memory for block LF/slot to pcifunc mapping info */
763                 block->fn_map = devm_kcalloc(rvu->dev, block->lf.max,
764                                              sizeof(u16), GFP_KERNEL);
765                 if (!block->fn_map)
766                         return -ENOMEM;
767
768                 /* Scan all blocks to check if low level firmware has
769                  * already provisioned any of the resources to a PF/VF.
770                  */
771                 rvu_scan_block(rvu, block);
772         }
773
774         err = rvu_npa_init(rvu);
775         if (err)
776                 return err;
777
778         err = rvu_nix_init(rvu);
779         if (err)
780                 return err;
781
782         return 0;
783 }
784
785 /* NPA and NIX admin queue APIs */
786 void rvu_aq_free(struct rvu *rvu, struct admin_queue *aq)
787 {
788         if (!aq)
789                 return;
790
791         qmem_free(rvu->dev, aq->inst);
792         qmem_free(rvu->dev, aq->res);
793         devm_kfree(rvu->dev, aq);
794 }
795
796 int rvu_aq_alloc(struct rvu *rvu, struct admin_queue **ad_queue,
797                  int qsize, int inst_size, int res_size)
798 {
799         struct admin_queue *aq;
800         int err;
801
802         *ad_queue = devm_kzalloc(rvu->dev, sizeof(*aq), GFP_KERNEL);
803         if (!*ad_queue)
804                 return -ENOMEM;
805         aq = *ad_queue;
806
807         /* Alloc memory for instructions i.e AQ */
808         err = qmem_alloc(rvu->dev, &aq->inst, qsize, inst_size);
809         if (err) {
810                 devm_kfree(rvu->dev, aq);
811                 return err;
812         }
813
814         /* Alloc memory for results */
815         err = qmem_alloc(rvu->dev, &aq->res, qsize, res_size);
816         if (err) {
817                 rvu_aq_free(rvu, aq);
818                 return err;
819         }
820
821         spin_lock_init(&aq->lock);
822         return 0;
823 }
824
825 static int rvu_mbox_handler_READY(struct rvu *rvu, struct msg_req *req,
826                                   struct ready_msg_rsp *rsp)
827 {
828         return 0;
829 }
830
831 /* Get current count of a RVU block's LF/slots
832  * provisioned to a given RVU func.
833  */
834 static u16 rvu_get_rsrc_mapcount(struct rvu_pfvf *pfvf, int blktype)
835 {
836         switch (blktype) {
837         case BLKTYPE_NPA:
838                 return pfvf->npalf ? 1 : 0;
839         case BLKTYPE_NIX:
840                 return pfvf->nixlf ? 1 : 0;
841         case BLKTYPE_SSO:
842                 return pfvf->sso;
843         case BLKTYPE_SSOW:
844                 return pfvf->ssow;
845         case BLKTYPE_TIM:
846                 return pfvf->timlfs;
847         case BLKTYPE_CPT:
848                 return pfvf->cptlfs;
849         }
850         return 0;
851 }
852
853 static int rvu_lookup_rsrc(struct rvu *rvu, struct rvu_block *block,
854                            int pcifunc, int slot)
855 {
856         u64 val;
857
858         val = ((u64)pcifunc << 24) | (slot << 16) | (1ULL << 13);
859         rvu_write64(rvu, block->addr, block->lookup_reg, val);
860         /* Wait for the lookup to finish */
861         /* TODO: put some timeout here */
862         while (rvu_read64(rvu, block->addr, block->lookup_reg) & (1ULL << 13))
863                 ;
864
865         val = rvu_read64(rvu, block->addr, block->lookup_reg);
866
867         /* Check LF valid bit */
868         if (!(val & (1ULL << 12)))
869                 return -1;
870
871         return (val & 0xFFF);
872 }
873
874 static void rvu_detach_block(struct rvu *rvu, int pcifunc, int blktype)
875 {
876         struct rvu_pfvf *pfvf = rvu_get_pfvf(rvu, pcifunc);
877         struct rvu_hwinfo *hw = rvu->hw;
878         struct rvu_block *block;
879         int slot, lf, num_lfs;
880         int blkaddr;
881
882         blkaddr = rvu_get_blkaddr(rvu, blktype, pcifunc);
883         if (blkaddr < 0)
884                 return;
885
886         block = &hw->block[blkaddr];
887
888         num_lfs = rvu_get_rsrc_mapcount(pfvf, block->type);
889         if (!num_lfs)
890                 return;
891
892         for (slot = 0; slot < num_lfs; slot++) {
893                 lf = rvu_lookup_rsrc(rvu, block, pcifunc, slot);
894                 if (lf < 0) /* This should never happen */
895                         continue;
896
897                 /* Disable the LF */
898                 rvu_write64(rvu, blkaddr, block->lfcfg_reg |
899                             (lf << block->lfshift), 0x00ULL);
900
901                 /* Update SW maintained mapping info as well */
902                 rvu_update_rsrc_map(rvu, pfvf, block,
903                                     pcifunc, lf, false);
904
905                 /* Free the resource */
906                 rvu_free_rsrc(&block->lf, lf);
907
908                 /* Clear MSIX vector offset for this LF */
909                 rvu_clear_msix_offset(rvu, pfvf, block, lf);
910         }
911 }
912
913 static int rvu_detach_rsrcs(struct rvu *rvu, struct rsrc_detach *detach,
914                             u16 pcifunc)
915 {
916         struct rvu_hwinfo *hw = rvu->hw;
917         bool detach_all = true;
918         struct rvu_block *block;
919         int blkid;
920
921         spin_lock(&rvu->rsrc_lock);
922
923         /* Check for partial resource detach */
924         if (detach && detach->partial)
925                 detach_all = false;
926
927         /* Check for RVU block's LFs attached to this func,
928          * if so, detach them.
929          */
930         for (blkid = 0; blkid < BLK_COUNT; blkid++) {
931                 block = &hw->block[blkid];
932                 if (!block->lf.bmap)
933                         continue;
934                 if (!detach_all && detach) {
935                         if (blkid == BLKADDR_NPA && !detach->npalf)
936                                 continue;
937                         else if ((blkid == BLKADDR_NIX0) && !detach->nixlf)
938                                 continue;
939                         else if ((blkid == BLKADDR_SSO) && !detach->sso)
940                                 continue;
941                         else if ((blkid == BLKADDR_SSOW) && !detach->ssow)
942                                 continue;
943                         else if ((blkid == BLKADDR_TIM) && !detach->timlfs)
944                                 continue;
945                         else if ((blkid == BLKADDR_CPT0) && !detach->cptlfs)
946                                 continue;
947                 }
948                 rvu_detach_block(rvu, pcifunc, block->type);
949         }
950
951         spin_unlock(&rvu->rsrc_lock);
952         return 0;
953 }
954
955 static int rvu_mbox_handler_DETACH_RESOURCES(struct rvu *rvu,
956                                              struct rsrc_detach *detach,
957                                              struct msg_rsp *rsp)
958 {
959         return rvu_detach_rsrcs(rvu, detach, detach->hdr.pcifunc);
960 }
961
962 static void rvu_attach_block(struct rvu *rvu, int pcifunc,
963                              int blktype, int num_lfs)
964 {
965         struct rvu_pfvf *pfvf = rvu_get_pfvf(rvu, pcifunc);
966         struct rvu_hwinfo *hw = rvu->hw;
967         struct rvu_block *block;
968         int slot, lf;
969         int blkaddr;
970         u64 cfg;
971
972         if (!num_lfs)
973                 return;
974
975         blkaddr = rvu_get_blkaddr(rvu, blktype, 0);
976         if (blkaddr < 0)
977                 return;
978
979         block = &hw->block[blkaddr];
980         if (!block->lf.bmap)
981                 return;
982
983         for (slot = 0; slot < num_lfs; slot++) {
984                 /* Allocate the resource */
985                 lf = rvu_alloc_rsrc(&block->lf);
986                 if (lf < 0)
987                         return;
988
989                 cfg = (1ULL << 63) | (pcifunc << 8) | slot;
990                 rvu_write64(rvu, blkaddr, block->lfcfg_reg |
991                             (lf << block->lfshift), cfg);
992                 rvu_update_rsrc_map(rvu, pfvf, block,
993                                     pcifunc, lf, true);
994
995                 /* Set start MSIX vector for this LF within this PF/VF */
996                 rvu_set_msix_offset(rvu, pfvf, block, lf);
997         }
998 }
999
1000 static int rvu_check_rsrc_availability(struct rvu *rvu,
1001                                        struct rsrc_attach *req, u16 pcifunc)
1002 {
1003         struct rvu_pfvf *pfvf = rvu_get_pfvf(rvu, pcifunc);
1004         struct rvu_hwinfo *hw = rvu->hw;
1005         struct rvu_block *block;
1006         int free_lfs, mappedlfs;
1007
1008         /* Only one NPA LF can be attached */
1009         if (req->npalf && !rvu_get_rsrc_mapcount(pfvf, BLKTYPE_NPA)) {
1010                 block = &hw->block[BLKADDR_NPA];
1011                 free_lfs = rvu_rsrc_free_count(&block->lf);
1012                 if (!free_lfs)
1013                         goto fail;
1014         } else if (req->npalf) {
1015                 dev_err(&rvu->pdev->dev,
1016                         "Func 0x%x: Invalid req, already has NPA\n",
1017                          pcifunc);
1018                 return -EINVAL;
1019         }
1020
1021         /* Only one NIX LF can be attached */
1022         if (req->nixlf && !rvu_get_rsrc_mapcount(pfvf, BLKTYPE_NIX)) {
1023                 block = &hw->block[BLKADDR_NIX0];
1024                 free_lfs = rvu_rsrc_free_count(&block->lf);
1025                 if (!free_lfs)
1026                         goto fail;
1027         } else if (req->nixlf) {
1028                 dev_err(&rvu->pdev->dev,
1029                         "Func 0x%x: Invalid req, already has NIX\n",
1030                         pcifunc);
1031                 return -EINVAL;
1032         }
1033
1034         if (req->sso) {
1035                 block = &hw->block[BLKADDR_SSO];
1036                 /* Is request within limits ? */
1037                 if (req->sso > block->lf.max) {
1038                         dev_err(&rvu->pdev->dev,
1039                                 "Func 0x%x: Invalid SSO req, %d > max %d\n",
1040                                  pcifunc, req->sso, block->lf.max);
1041                         return -EINVAL;
1042                 }
1043                 mappedlfs = rvu_get_rsrc_mapcount(pfvf, block->type);
1044                 free_lfs = rvu_rsrc_free_count(&block->lf);
1045                 /* Check if additional resources are available */
1046                 if (req->sso > mappedlfs &&
1047                     ((req->sso - mappedlfs) > free_lfs))
1048                         goto fail;
1049         }
1050
1051         if (req->ssow) {
1052                 block = &hw->block[BLKADDR_SSOW];
1053                 if (req->ssow > block->lf.max) {
1054                         dev_err(&rvu->pdev->dev,
1055                                 "Func 0x%x: Invalid SSOW req, %d > max %d\n",
1056                                  pcifunc, req->sso, block->lf.max);
1057                         return -EINVAL;
1058                 }
1059                 mappedlfs = rvu_get_rsrc_mapcount(pfvf, block->type);
1060                 free_lfs = rvu_rsrc_free_count(&block->lf);
1061                 if (req->ssow > mappedlfs &&
1062                     ((req->ssow - mappedlfs) > free_lfs))
1063                         goto fail;
1064         }
1065
1066         if (req->timlfs) {
1067                 block = &hw->block[BLKADDR_TIM];
1068                 if (req->timlfs > block->lf.max) {
1069                         dev_err(&rvu->pdev->dev,
1070                                 "Func 0x%x: Invalid TIMLF req, %d > max %d\n",
1071                                  pcifunc, req->timlfs, block->lf.max);
1072                         return -EINVAL;
1073                 }
1074                 mappedlfs = rvu_get_rsrc_mapcount(pfvf, block->type);
1075                 free_lfs = rvu_rsrc_free_count(&block->lf);
1076                 if (req->timlfs > mappedlfs &&
1077                     ((req->timlfs - mappedlfs) > free_lfs))
1078                         goto fail;
1079         }
1080
1081         if (req->cptlfs) {
1082                 block = &hw->block[BLKADDR_CPT0];
1083                 if (req->cptlfs > block->lf.max) {
1084                         dev_err(&rvu->pdev->dev,
1085                                 "Func 0x%x: Invalid CPTLF req, %d > max %d\n",
1086                                  pcifunc, req->cptlfs, block->lf.max);
1087                         return -EINVAL;
1088                 }
1089                 mappedlfs = rvu_get_rsrc_mapcount(pfvf, block->type);
1090                 free_lfs = rvu_rsrc_free_count(&block->lf);
1091                 if (req->cptlfs > mappedlfs &&
1092                     ((req->cptlfs - mappedlfs) > free_lfs))
1093                         goto fail;
1094         }
1095
1096         return 0;
1097
1098 fail:
1099         dev_info(rvu->dev, "Request for %s failed\n", block->name);
1100         return -ENOSPC;
1101 }
1102
1103 static int rvu_mbox_handler_ATTACH_RESOURCES(struct rvu *rvu,
1104                                              struct rsrc_attach *attach,
1105                                              struct msg_rsp *rsp)
1106 {
1107         u16 pcifunc = attach->hdr.pcifunc;
1108         int err;
1109
1110         /* If first request, detach all existing attached resources */
1111         if (!attach->modify)
1112                 rvu_detach_rsrcs(rvu, NULL, pcifunc);
1113
1114         spin_lock(&rvu->rsrc_lock);
1115
1116         /* Check if the request can be accommodated */
1117         err = rvu_check_rsrc_availability(rvu, attach, pcifunc);
1118         if (err)
1119                 goto exit;
1120
1121         /* Now attach the requested resources */
1122         if (attach->npalf)
1123                 rvu_attach_block(rvu, pcifunc, BLKTYPE_NPA, 1);
1124
1125         if (attach->nixlf)
1126                 rvu_attach_block(rvu, pcifunc, BLKTYPE_NIX, 1);
1127
1128         if (attach->sso) {
1129                 /* RVU func doesn't know which exact LF or slot is attached
1130                  * to it, it always sees as slot 0,1,2. So for a 'modify'
1131                  * request, simply detach all existing attached LFs/slots
1132                  * and attach a fresh.
1133                  */
1134                 if (attach->modify)
1135                         rvu_detach_block(rvu, pcifunc, BLKTYPE_SSO);
1136                 rvu_attach_block(rvu, pcifunc, BLKTYPE_SSO, attach->sso);
1137         }
1138
1139         if (attach->ssow) {
1140                 if (attach->modify)
1141                         rvu_detach_block(rvu, pcifunc, BLKTYPE_SSOW);
1142                 rvu_attach_block(rvu, pcifunc, BLKTYPE_SSOW, attach->ssow);
1143         }
1144
1145         if (attach->timlfs) {
1146                 if (attach->modify)
1147                         rvu_detach_block(rvu, pcifunc, BLKTYPE_TIM);
1148                 rvu_attach_block(rvu, pcifunc, BLKTYPE_TIM, attach->timlfs);
1149         }
1150
1151         if (attach->cptlfs) {
1152                 if (attach->modify)
1153                         rvu_detach_block(rvu, pcifunc, BLKTYPE_CPT);
1154                 rvu_attach_block(rvu, pcifunc, BLKTYPE_CPT, attach->cptlfs);
1155         }
1156
1157 exit:
1158         spin_unlock(&rvu->rsrc_lock);
1159         return err;
1160 }
1161
1162 static u16 rvu_get_msix_offset(struct rvu *rvu, struct rvu_pfvf *pfvf,
1163                                int blkaddr, int lf)
1164 {
1165         u16 vec;
1166
1167         if (lf < 0)
1168                 return MSIX_VECTOR_INVALID;
1169
1170         for (vec = 0; vec < pfvf->msix.max; vec++) {
1171                 if (pfvf->msix_lfmap[vec] == MSIX_BLKLF(blkaddr, lf))
1172                         return vec;
1173         }
1174         return MSIX_VECTOR_INVALID;
1175 }
1176
1177 static void rvu_set_msix_offset(struct rvu *rvu, struct rvu_pfvf *pfvf,
1178                                 struct rvu_block *block, int lf)
1179 {
1180         u16 nvecs, vec, offset;
1181         u64 cfg;
1182
1183         cfg = rvu_read64(rvu, block->addr, block->msixcfg_reg |
1184                          (lf << block->lfshift));
1185         nvecs = (cfg >> 12) & 0xFF;
1186
1187         /* Check and alloc MSIX vectors, must be contiguous */
1188         if (!rvu_rsrc_check_contig(&pfvf->msix, nvecs))
1189                 return;
1190
1191         offset = rvu_alloc_rsrc_contig(&pfvf->msix, nvecs);
1192
1193         /* Config MSIX offset in LF */
1194         rvu_write64(rvu, block->addr, block->msixcfg_reg |
1195                     (lf << block->lfshift), (cfg & ~0x7FFULL) | offset);
1196
1197         /* Update the bitmap as well */
1198         for (vec = 0; vec < nvecs; vec++)
1199                 pfvf->msix_lfmap[offset + vec] = MSIX_BLKLF(block->addr, lf);
1200 }
1201
1202 static void rvu_clear_msix_offset(struct rvu *rvu, struct rvu_pfvf *pfvf,
1203                                   struct rvu_block *block, int lf)
1204 {
1205         u16 nvecs, vec, offset;
1206         u64 cfg;
1207
1208         cfg = rvu_read64(rvu, block->addr, block->msixcfg_reg |
1209                          (lf << block->lfshift));
1210         nvecs = (cfg >> 12) & 0xFF;
1211
1212         /* Clear MSIX offset in LF */
1213         rvu_write64(rvu, block->addr, block->msixcfg_reg |
1214                     (lf << block->lfshift), cfg & ~0x7FFULL);
1215
1216         offset = rvu_get_msix_offset(rvu, pfvf, block->addr, lf);
1217
1218         /* Update the mapping */
1219         for (vec = 0; vec < nvecs; vec++)
1220                 pfvf->msix_lfmap[offset + vec] = 0;
1221
1222         /* Free the same in MSIX bitmap */
1223         rvu_free_rsrc_contig(&pfvf->msix, nvecs, offset);
1224 }
1225
1226 static int rvu_mbox_handler_MSIX_OFFSET(struct rvu *rvu, struct msg_req *req,
1227                                         struct msix_offset_rsp *rsp)
1228 {
1229         struct rvu_hwinfo *hw = rvu->hw;
1230         u16 pcifunc = req->hdr.pcifunc;
1231         struct rvu_pfvf *pfvf;
1232         int lf, slot;
1233
1234         pfvf = rvu_get_pfvf(rvu, pcifunc);
1235         if (!pfvf->msix.bmap)
1236                 return 0;
1237
1238         /* Set MSIX offsets for each block's LFs attached to this PF/VF */
1239         lf = rvu_get_lf(rvu, &hw->block[BLKADDR_NPA], pcifunc, 0);
1240         rsp->npa_msixoff = rvu_get_msix_offset(rvu, pfvf, BLKADDR_NPA, lf);
1241
1242         lf = rvu_get_lf(rvu, &hw->block[BLKADDR_NIX0], pcifunc, 0);
1243         rsp->nix_msixoff = rvu_get_msix_offset(rvu, pfvf, BLKADDR_NIX0, lf);
1244
1245         rsp->sso = pfvf->sso;
1246         for (slot = 0; slot < rsp->sso; slot++) {
1247                 lf = rvu_get_lf(rvu, &hw->block[BLKADDR_SSO], pcifunc, slot);
1248                 rsp->sso_msixoff[slot] =
1249                         rvu_get_msix_offset(rvu, pfvf, BLKADDR_SSO, lf);
1250         }
1251
1252         rsp->ssow = pfvf->ssow;
1253         for (slot = 0; slot < rsp->ssow; slot++) {
1254                 lf = rvu_get_lf(rvu, &hw->block[BLKADDR_SSOW], pcifunc, slot);
1255                 rsp->ssow_msixoff[slot] =
1256                         rvu_get_msix_offset(rvu, pfvf, BLKADDR_SSOW, lf);
1257         }
1258
1259         rsp->timlfs = pfvf->timlfs;
1260         for (slot = 0; slot < rsp->timlfs; slot++) {
1261                 lf = rvu_get_lf(rvu, &hw->block[BLKADDR_TIM], pcifunc, slot);
1262                 rsp->timlf_msixoff[slot] =
1263                         rvu_get_msix_offset(rvu, pfvf, BLKADDR_TIM, lf);
1264         }
1265
1266         rsp->cptlfs = pfvf->cptlfs;
1267         for (slot = 0; slot < rsp->cptlfs; slot++) {
1268                 lf = rvu_get_lf(rvu, &hw->block[BLKADDR_CPT0], pcifunc, slot);
1269                 rsp->cptlf_msixoff[slot] =
1270                         rvu_get_msix_offset(rvu, pfvf, BLKADDR_CPT0, lf);
1271         }
1272         return 0;
1273 }
1274
1275 static int rvu_process_mbox_msg(struct rvu *rvu, int devid,
1276                                 struct mbox_msghdr *req)
1277 {
1278         /* Check if valid, if not reply with a invalid msg */
1279         if (req->sig != OTX2_MBOX_REQ_SIG)
1280                 goto bad_message;
1281
1282         switch (req->id) {
1283 #define M(_name, _id, _req_type, _rsp_type)                             \
1284         case _id: {                                                     \
1285                 struct _rsp_type *rsp;                                  \
1286                 int err;                                                \
1287                                                                         \
1288                 rsp = (struct _rsp_type *)otx2_mbox_alloc_msg(          \
1289                         &rvu->mbox, devid,                              \
1290                         sizeof(struct _rsp_type));                      \
1291                 if (rsp) {                                              \
1292                         rsp->hdr.id = _id;                              \
1293                         rsp->hdr.sig = OTX2_MBOX_RSP_SIG;               \
1294                         rsp->hdr.pcifunc = req->pcifunc;                \
1295                         rsp->hdr.rc = 0;                                \
1296                 }                                                       \
1297                                                                         \
1298                 err = rvu_mbox_handler_ ## _name(rvu,                   \
1299                                                  (struct _req_type *)req, \
1300                                                  rsp);                  \
1301                 if (rsp && err)                                         \
1302                         rsp->hdr.rc = err;                              \
1303                                                                         \
1304                 return rsp ? err : -ENOMEM;                             \
1305         }
1306 MBOX_MESSAGES
1307 #undef M
1308                 break;
1309 bad_message:
1310         default:
1311                 otx2_reply_invalid_msg(&rvu->mbox, devid, req->pcifunc,
1312                                        req->id);
1313                 return -ENODEV;
1314         }
1315 }
1316
1317 static void rvu_mbox_handler(struct work_struct *work)
1318 {
1319         struct rvu_work *mwork = container_of(work, struct rvu_work, work);
1320         struct rvu *rvu = mwork->rvu;
1321         struct otx2_mbox_dev *mdev;
1322         struct mbox_hdr *req_hdr;
1323         struct mbox_msghdr *msg;
1324         struct otx2_mbox *mbox;
1325         int offset, id, err;
1326         u16 pf;
1327
1328         mbox = &rvu->mbox;
1329         pf = mwork - rvu->mbox_wrk;
1330         mdev = &mbox->dev[pf];
1331
1332         /* Process received mbox messages */
1333         req_hdr = mdev->mbase + mbox->rx_start;
1334         if (req_hdr->num_msgs == 0)
1335                 return;
1336
1337         offset = mbox->rx_start + ALIGN(sizeof(*req_hdr), MBOX_MSG_ALIGN);
1338
1339         for (id = 0; id < req_hdr->num_msgs; id++) {
1340                 msg = mdev->mbase + offset;
1341
1342                 /* Set which PF sent this message based on mbox IRQ */
1343                 msg->pcifunc &= ~(RVU_PFVF_PF_MASK << RVU_PFVF_PF_SHIFT);
1344                 msg->pcifunc |= (pf << RVU_PFVF_PF_SHIFT);
1345                 err = rvu_process_mbox_msg(rvu, pf, msg);
1346                 if (!err) {
1347                         offset = mbox->rx_start + msg->next_msgoff;
1348                         continue;
1349                 }
1350
1351                 if (msg->pcifunc & RVU_PFVF_FUNC_MASK)
1352                         dev_warn(rvu->dev, "Error %d when processing message %s (0x%x) from PF%d:VF%d\n",
1353                                  err, otx2_mbox_id2name(msg->id), msg->id, pf,
1354                                  (msg->pcifunc & RVU_PFVF_FUNC_MASK) - 1);
1355                 else
1356                         dev_warn(rvu->dev, "Error %d when processing message %s (0x%x) from PF%d\n",
1357                                  err, otx2_mbox_id2name(msg->id), msg->id, pf);
1358         }
1359
1360         /* Send mbox responses to PF */
1361         otx2_mbox_msg_send(mbox, pf);
1362 }
1363
1364 static void rvu_mbox_up_handler(struct work_struct *work)
1365 {
1366         struct rvu_work *mwork = container_of(work, struct rvu_work, work);
1367         struct rvu *rvu = mwork->rvu;
1368         struct otx2_mbox_dev *mdev;
1369         struct mbox_hdr *rsp_hdr;
1370         struct mbox_msghdr *msg;
1371         struct otx2_mbox *mbox;
1372         int offset, id;
1373         u16 pf;
1374
1375         mbox = &rvu->mbox_up;
1376         pf = mwork - rvu->mbox_wrk_up;
1377         mdev = &mbox->dev[pf];
1378
1379         rsp_hdr = mdev->mbase + mbox->rx_start;
1380         if (rsp_hdr->num_msgs == 0) {
1381                 dev_warn(rvu->dev, "mbox up handler: num_msgs = 0\n");
1382                 return;
1383         }
1384
1385         offset = mbox->rx_start + ALIGN(sizeof(*rsp_hdr), MBOX_MSG_ALIGN);
1386
1387         for (id = 0; id < rsp_hdr->num_msgs; id++) {
1388                 msg = mdev->mbase + offset;
1389
1390                 if (msg->id >= MBOX_MSG_MAX) {
1391                         dev_err(rvu->dev,
1392                                 "Mbox msg with unknown ID 0x%x\n", msg->id);
1393                         goto end;
1394                 }
1395
1396                 if (msg->sig != OTX2_MBOX_RSP_SIG) {
1397                         dev_err(rvu->dev,
1398                                 "Mbox msg with wrong signature %x, ID 0x%x\n",
1399                                 msg->sig, msg->id);
1400                         goto end;
1401                 }
1402
1403                 switch (msg->id) {
1404                 case MBOX_MSG_CGX_LINK_EVENT:
1405                         break;
1406                 default:
1407                         if (msg->rc)
1408                                 dev_err(rvu->dev,
1409                                         "Mbox msg response has err %d, ID 0x%x\n",
1410                                         msg->rc, msg->id);
1411                         break;
1412                 }
1413 end:
1414                 offset = mbox->rx_start + msg->next_msgoff;
1415                 mdev->msgs_acked++;
1416         }
1417
1418         otx2_mbox_reset(mbox, 0);
1419 }
1420
1421 static int rvu_mbox_init(struct rvu *rvu)
1422 {
1423         struct rvu_hwinfo *hw = rvu->hw;
1424         void __iomem *hwbase = NULL;
1425         struct rvu_work *mwork;
1426         u64 bar4_addr;
1427         int err, pf;
1428
1429         rvu->mbox_wq = alloc_workqueue("rvu_afpf_mailbox",
1430                                        WQ_UNBOUND | WQ_HIGHPRI | WQ_MEM_RECLAIM,
1431                                        hw->total_pfs);
1432         if (!rvu->mbox_wq)
1433                 return -ENOMEM;
1434
1435         rvu->mbox_wrk = devm_kcalloc(rvu->dev, hw->total_pfs,
1436                                      sizeof(struct rvu_work), GFP_KERNEL);
1437         if (!rvu->mbox_wrk) {
1438                 err = -ENOMEM;
1439                 goto exit;
1440         }
1441
1442         rvu->mbox_wrk_up = devm_kcalloc(rvu->dev, hw->total_pfs,
1443                                         sizeof(struct rvu_work), GFP_KERNEL);
1444         if (!rvu->mbox_wrk_up) {
1445                 err = -ENOMEM;
1446                 goto exit;
1447         }
1448
1449         /* Map mbox region shared with PFs */
1450         bar4_addr = rvu_read64(rvu, BLKADDR_RVUM, RVU_AF_PF_BAR4_ADDR);
1451         /* Mailbox is a reserved memory (in RAM) region shared between
1452          * RVU devices, shouldn't be mapped as device memory to allow
1453          * unaligned accesses.
1454          */
1455         hwbase = ioremap_wc(bar4_addr, MBOX_SIZE * hw->total_pfs);
1456         if (!hwbase) {
1457                 dev_err(rvu->dev, "Unable to map mailbox region\n");
1458                 err = -ENOMEM;
1459                 goto exit;
1460         }
1461
1462         err = otx2_mbox_init(&rvu->mbox, hwbase, rvu->pdev, rvu->afreg_base,
1463                              MBOX_DIR_AFPF, hw->total_pfs);
1464         if (err)
1465                 goto exit;
1466
1467         err = otx2_mbox_init(&rvu->mbox_up, hwbase, rvu->pdev, rvu->afreg_base,
1468                              MBOX_DIR_AFPF_UP, hw->total_pfs);
1469         if (err)
1470                 goto exit;
1471
1472         for (pf = 0; pf < hw->total_pfs; pf++) {
1473                 mwork = &rvu->mbox_wrk[pf];
1474                 mwork->rvu = rvu;
1475                 INIT_WORK(&mwork->work, rvu_mbox_handler);
1476         }
1477
1478         for (pf = 0; pf < hw->total_pfs; pf++) {
1479                 mwork = &rvu->mbox_wrk_up[pf];
1480                 mwork->rvu = rvu;
1481                 INIT_WORK(&mwork->work, rvu_mbox_up_handler);
1482         }
1483
1484         return 0;
1485 exit:
1486         if (hwbase)
1487                 iounmap((void __iomem *)hwbase);
1488         destroy_workqueue(rvu->mbox_wq);
1489         return err;
1490 }
1491
1492 static void rvu_mbox_destroy(struct rvu *rvu)
1493 {
1494         if (rvu->mbox_wq) {
1495                 flush_workqueue(rvu->mbox_wq);
1496                 destroy_workqueue(rvu->mbox_wq);
1497                 rvu->mbox_wq = NULL;
1498         }
1499
1500         if (rvu->mbox.hwbase)
1501                 iounmap((void __iomem *)rvu->mbox.hwbase);
1502
1503         otx2_mbox_destroy(&rvu->mbox);
1504         otx2_mbox_destroy(&rvu->mbox_up);
1505 }
1506
1507 static irqreturn_t rvu_mbox_intr_handler(int irq, void *rvu_irq)
1508 {
1509         struct rvu *rvu = (struct rvu *)rvu_irq;
1510         struct otx2_mbox_dev *mdev;
1511         struct otx2_mbox *mbox;
1512         struct mbox_hdr *hdr;
1513         u64 intr;
1514         u8  pf;
1515
1516         intr = rvu_read64(rvu, BLKADDR_RVUM, RVU_AF_PFAF_MBOX_INT);
1517         /* Clear interrupts */
1518         rvu_write64(rvu, BLKADDR_RVUM, RVU_AF_PFAF_MBOX_INT, intr);
1519
1520         /* Sync with mbox memory region */
1521         smp_wmb();
1522
1523         for (pf = 0; pf < rvu->hw->total_pfs; pf++) {
1524                 if (intr & (1ULL << pf)) {
1525                         mbox = &rvu->mbox;
1526                         mdev = &mbox->dev[pf];
1527                         hdr = mdev->mbase + mbox->rx_start;
1528                         if (hdr->num_msgs)
1529                                 queue_work(rvu->mbox_wq,
1530                                            &rvu->mbox_wrk[pf].work);
1531                         mbox = &rvu->mbox_up;
1532                         mdev = &mbox->dev[pf];
1533                         hdr = mdev->mbase + mbox->rx_start;
1534                         if (hdr->num_msgs)
1535                                 queue_work(rvu->mbox_wq,
1536                                            &rvu->mbox_wrk_up[pf].work);
1537                 }
1538         }
1539
1540         return IRQ_HANDLED;
1541 }
1542
1543 static void rvu_enable_mbox_intr(struct rvu *rvu)
1544 {
1545         struct rvu_hwinfo *hw = rvu->hw;
1546
1547         /* Clear spurious irqs, if any */
1548         rvu_write64(rvu, BLKADDR_RVUM,
1549                     RVU_AF_PFAF_MBOX_INT, INTR_MASK(hw->total_pfs));
1550
1551         /* Enable mailbox interrupt for all PFs except PF0 i.e AF itself */
1552         rvu_write64(rvu, BLKADDR_RVUM, RVU_AF_PFAF_MBOX_INT_ENA_W1S,
1553                     INTR_MASK(hw->total_pfs) & ~1ULL);
1554 }
1555
1556 static void rvu_unregister_interrupts(struct rvu *rvu)
1557 {
1558         int irq;
1559
1560         /* Disable the Mbox interrupt */
1561         rvu_write64(rvu, BLKADDR_RVUM, RVU_AF_PFAF_MBOX_INT_ENA_W1C,
1562                     INTR_MASK(rvu->hw->total_pfs) & ~1ULL);
1563
1564         for (irq = 0; irq < rvu->num_vec; irq++) {
1565                 if (rvu->irq_allocated[irq])
1566                         free_irq(pci_irq_vector(rvu->pdev, irq), rvu);
1567         }
1568
1569         pci_free_irq_vectors(rvu->pdev);
1570         rvu->num_vec = 0;
1571 }
1572
1573 static int rvu_register_interrupts(struct rvu *rvu)
1574 {
1575         int ret;
1576
1577         rvu->num_vec = pci_msix_vec_count(rvu->pdev);
1578
1579         rvu->irq_name = devm_kmalloc_array(rvu->dev, rvu->num_vec,
1580                                            NAME_SIZE, GFP_KERNEL);
1581         if (!rvu->irq_name)
1582                 return -ENOMEM;
1583
1584         rvu->irq_allocated = devm_kcalloc(rvu->dev, rvu->num_vec,
1585                                           sizeof(bool), GFP_KERNEL);
1586         if (!rvu->irq_allocated)
1587                 return -ENOMEM;
1588
1589         /* Enable MSI-X */
1590         ret = pci_alloc_irq_vectors(rvu->pdev, rvu->num_vec,
1591                                     rvu->num_vec, PCI_IRQ_MSIX);
1592         if (ret < 0) {
1593                 dev_err(rvu->dev,
1594                         "RVUAF: Request for %d msix vectors failed, ret %d\n",
1595                         rvu->num_vec, ret);
1596                 return ret;
1597         }
1598
1599         /* Register mailbox interrupt handler */
1600         sprintf(&rvu->irq_name[RVU_AF_INT_VEC_MBOX * NAME_SIZE], "RVUAF Mbox");
1601         ret = request_irq(pci_irq_vector(rvu->pdev, RVU_AF_INT_VEC_MBOX),
1602                           rvu_mbox_intr_handler, 0,
1603                           &rvu->irq_name[RVU_AF_INT_VEC_MBOX * NAME_SIZE], rvu);
1604         if (ret) {
1605                 dev_err(rvu->dev,
1606                         "RVUAF: IRQ registration failed for mbox irq\n");
1607                 goto fail;
1608         }
1609
1610         rvu->irq_allocated[RVU_AF_INT_VEC_MBOX] = true;
1611
1612         /* Enable mailbox interrupts from all PFs */
1613         rvu_enable_mbox_intr(rvu);
1614
1615         return 0;
1616
1617 fail:
1618         pci_free_irq_vectors(rvu->pdev);
1619         return ret;
1620 }
1621
1622 static int rvu_probe(struct pci_dev *pdev, const struct pci_device_id *id)
1623 {
1624         struct device *dev = &pdev->dev;
1625         struct rvu *rvu;
1626         int    err;
1627
1628         rvu = devm_kzalloc(dev, sizeof(*rvu), GFP_KERNEL);
1629         if (!rvu)
1630                 return -ENOMEM;
1631
1632         rvu->hw = devm_kzalloc(dev, sizeof(struct rvu_hwinfo), GFP_KERNEL);
1633         if (!rvu->hw) {
1634                 devm_kfree(dev, rvu);
1635                 return -ENOMEM;
1636         }
1637
1638         pci_set_drvdata(pdev, rvu);
1639         rvu->pdev = pdev;
1640         rvu->dev = &pdev->dev;
1641
1642         err = pci_enable_device(pdev);
1643         if (err) {
1644                 dev_err(dev, "Failed to enable PCI device\n");
1645                 goto err_freemem;
1646         }
1647
1648         err = pci_request_regions(pdev, DRV_NAME);
1649         if (err) {
1650                 dev_err(dev, "PCI request regions failed 0x%x\n", err);
1651                 goto err_disable_device;
1652         }
1653
1654         err = pci_set_dma_mask(pdev, DMA_BIT_MASK(48));
1655         if (err) {
1656                 dev_err(dev, "Unable to set DMA mask\n");
1657                 goto err_release_regions;
1658         }
1659
1660         err = pci_set_consistent_dma_mask(pdev, DMA_BIT_MASK(48));
1661         if (err) {
1662                 dev_err(dev, "Unable to set consistent DMA mask\n");
1663                 goto err_release_regions;
1664         }
1665
1666         /* Map Admin function CSRs */
1667         rvu->afreg_base = pcim_iomap(pdev, PCI_AF_REG_BAR_NUM, 0);
1668         rvu->pfreg_base = pcim_iomap(pdev, PCI_PF_REG_BAR_NUM, 0);
1669         if (!rvu->afreg_base || !rvu->pfreg_base) {
1670                 dev_err(dev, "Unable to map admin function CSRs, aborting\n");
1671                 err = -ENOMEM;
1672                 goto err_release_regions;
1673         }
1674
1675         /* Check which blocks the HW supports */
1676         rvu_check_block_implemented(rvu);
1677
1678         rvu_reset_all_blocks(rvu);
1679
1680         err = rvu_setup_hw_resources(rvu);
1681         if (err)
1682                 goto err_release_regions;
1683
1684         err = rvu_mbox_init(rvu);
1685         if (err)
1686                 goto err_hwsetup;
1687
1688         err = rvu_cgx_probe(rvu);
1689         if (err)
1690                 goto err_mbox;
1691
1692         err = rvu_register_interrupts(rvu);
1693         if (err)
1694                 goto err_cgx;
1695
1696         return 0;
1697 err_cgx:
1698         rvu_cgx_wq_destroy(rvu);
1699 err_mbox:
1700         rvu_mbox_destroy(rvu);
1701 err_hwsetup:
1702         rvu_reset_all_blocks(rvu);
1703         rvu_free_hw_resources(rvu);
1704 err_release_regions:
1705         pci_release_regions(pdev);
1706 err_disable_device:
1707         pci_disable_device(pdev);
1708 err_freemem:
1709         pci_set_drvdata(pdev, NULL);
1710         devm_kfree(&pdev->dev, rvu->hw);
1711         devm_kfree(dev, rvu);
1712         return err;
1713 }
1714
1715 static void rvu_remove(struct pci_dev *pdev)
1716 {
1717         struct rvu *rvu = pci_get_drvdata(pdev);
1718
1719         rvu_unregister_interrupts(rvu);
1720         rvu_cgx_wq_destroy(rvu);
1721         rvu_mbox_destroy(rvu);
1722         rvu_reset_all_blocks(rvu);
1723         rvu_free_hw_resources(rvu);
1724
1725         pci_release_regions(pdev);
1726         pci_disable_device(pdev);
1727         pci_set_drvdata(pdev, NULL);
1728
1729         devm_kfree(&pdev->dev, rvu->hw);
1730         devm_kfree(&pdev->dev, rvu);
1731 }
1732
1733 static struct pci_driver rvu_driver = {
1734         .name = DRV_NAME,
1735         .id_table = rvu_id_table,
1736         .probe = rvu_probe,
1737         .remove = rvu_remove,
1738 };
1739
1740 static int __init rvu_init_module(void)
1741 {
1742         int err;
1743
1744         pr_info("%s: %s\n", DRV_NAME, DRV_STRING);
1745
1746         err = pci_register_driver(&cgx_driver);
1747         if (err < 0)
1748                 return err;
1749
1750         err =  pci_register_driver(&rvu_driver);
1751         if (err < 0)
1752                 pci_unregister_driver(&cgx_driver);
1753
1754         return err;
1755 }
1756
1757 static void __exit rvu_cleanup_module(void)
1758 {
1759         pci_unregister_driver(&rvu_driver);
1760         pci_unregister_driver(&cgx_driver);
1761 }
1762
1763 module_init(rvu_init_module);
1764 module_exit(rvu_cleanup_module);