update kernel to 5.10.198

hc

2024-01-03 2f7c68cb55ecb7331f2381deb497c27155f32faf

 kernel/drivers/net/ethernet/marvell/octeontx2/af/rvu.c
..
..
@@ -316,30 +316,35 @@
316
316
 
317
317
 	block->fn_map[lf] = attach ? pcifunc : 0;
318
318
 
319
-	switch (block->type) {
320
-	case BLKTYPE_NPA:
319
+	switch (block->addr) {
320
+	case BLKADDR_NPA:
321
321
 		pfvf->npalf = attach ? true : false;
322
322
 		num_lfs = pfvf->npalf;
323
323
 		break;
324
-	case BLKTYPE_NIX:
324
+	case BLKADDR_NIX0:
325
+	case BLKADDR_NIX1:
325
326
 		pfvf->nixlf = attach ? true : false;
326
327
 		num_lfs = pfvf->nixlf;
327
328
 		break;
328
-	case BLKTYPE_SSO:
329
+	case BLKADDR_SSO:
329
330
 		attach ? pfvf->sso++ : pfvf->sso--;
330
331
 		num_lfs = pfvf->sso;
331
332
 		break;
332
-	case BLKTYPE_SSOW:
333
+	case BLKADDR_SSOW:
333
334
 		attach ? pfvf->ssow++ : pfvf->ssow--;
334
335
 		num_lfs = pfvf->ssow;
335
336
 		break;
336
-	case BLKTYPE_TIM:
337
+	case BLKADDR_TIM:
337
338
 		attach ? pfvf->timlfs++ : pfvf->timlfs--;
338
339
 		num_lfs = pfvf->timlfs;
339
340
 		break;
340
-	case BLKTYPE_CPT:
341
+	case BLKADDR_CPT0:
341
342
 		attach ? pfvf->cptlfs++ : pfvf->cptlfs--;
342
343
 		num_lfs = pfvf->cptlfs;
344
+		break;
345
+	case BLKADDR_CPT1:
346
+		attach ? pfvf->cpt1_lfs++ : pfvf->cpt1_lfs--;
347
+		num_lfs = pfvf->cpt1_lfs;
343
348
 		break;
344
349
 	}
345
350
 
..
..
@@ -1035,7 +1040,30 @@
1035
1040
 /* Get current count of a RVU block's LF/slots
1036
1041
  * provisioned to a given RVU func.
1037
1042
  */
1038
-static u16 rvu_get_rsrc_mapcount(struct rvu_pfvf *pfvf, int blktype)
1043
+u16 rvu_get_rsrc_mapcount(struct rvu_pfvf *pfvf, int blkaddr)
1044
+{
1045
+	switch (blkaddr) {
1046
+	case BLKADDR_NPA:
1047
+		return pfvf->npalf ? 1 : 0;
1048
+	case BLKADDR_NIX0:
1049
+	case BLKADDR_NIX1:
1050
+		return pfvf->nixlf ? 1 : 0;
1051
+	case BLKADDR_SSO:
1052
+		return pfvf->sso;
1053
+	case BLKADDR_SSOW:
1054
+		return pfvf->ssow;
1055
+	case BLKADDR_TIM:
1056
+		return pfvf->timlfs;
1057
+	case BLKADDR_CPT0:
1058
+		return pfvf->cptlfs;
1059
+	case BLKADDR_CPT1:
1060
+		return pfvf->cpt1_lfs;
1061
+	}
1062
+	return 0;
1063
+}
1064
+
1065
+/* Return true if LFs of block type are attached to pcifunc */
1066
+static bool is_blktype_attached(struct rvu_pfvf *pfvf, int blktype)
1039
1067
 {
1040
1068
 	switch (blktype) {
1041
1069
 	case BLKTYPE_NPA:
..
..
@@ -1043,15 +1071,16 @@
1043
1071
 	case BLKTYPE_NIX:
1044
1072
 		return pfvf->nixlf ? 1 : 0;
1045
1073
 	case BLKTYPE_SSO:
1046
-		return pfvf->sso;
1074
+		return !!pfvf->sso;
1047
1075
 	case BLKTYPE_SSOW:
1048
-		return pfvf->ssow;
1076
+		return !!pfvf->ssow;
1049
1077
 	case BLKTYPE_TIM:
1050
-		return pfvf->timlfs;
1078
+		return !!pfvf->timlfs;
1051
1079
 	case BLKTYPE_CPT:
1052
-		return pfvf->cptlfs;
1080
+		return pfvf->cptlfs || pfvf->cpt1_lfs;
1053
1081
 	}
1054
-	return 0;
1082
+
1083
+	return false;
1055
1084
 }
1056
1085
 
1057
1086
 bool is_pffunc_map_valid(struct rvu *rvu, u16 pcifunc, int blktype)
..
..
@@ -1064,7 +1093,7 @@
1064
1093
 	pfvf = rvu_get_pfvf(rvu, pcifunc);
1065
1094
 
1066
1095
 	/* Check if this PFFUNC has a LF of type blktype attached */
1067
-	if (!rvu_get_rsrc_mapcount(pfvf, blktype))
1096
+	if (!is_blktype_attached(pfvf, blktype))
1068
1097
 		return false;
1069
1098
 
1070
1099
 	return true;
..
..
@@ -1105,7 +1134,7 @@
1105
1134
 
1106
1135
 	block = &hw->block[blkaddr];
1107
1136
 
1108
-	num_lfs = rvu_get_rsrc_mapcount(pfvf, block->type);
1137
+	num_lfs = rvu_get_rsrc_mapcount(pfvf, block->addr);
1109
1138
 	if (!num_lfs)
1110
1139
 		return;
1111
1140
 
..
..
@@ -1179,6 +1208,58 @@
1179
1208
 	return rvu_detach_rsrcs(rvu, detach, detach->hdr.pcifunc);
1180
1209
 }
1181
1210
 
1211
+static int rvu_get_nix_blkaddr(struct rvu *rvu, u16 pcifunc)
1212
+{
1213
+	struct rvu_pfvf *pfvf = rvu_get_pfvf(rvu, pcifunc);
1214
+	int blkaddr = BLKADDR_NIX0, vf;
1215
+	struct rvu_pfvf *pf;
1216
+
1217
+	/* All CGX mapped PFs are set with assigned NIX block during init */
1218
+	if (is_pf_cgxmapped(rvu, rvu_get_pf(pcifunc))) {
1219
+		pf = rvu_get_pfvf(rvu, pcifunc & ~RVU_PFVF_FUNC_MASK);
1220
+		blkaddr = pf->nix_blkaddr;
1221
+	} else if (is_afvf(pcifunc)) {
1222
+		vf = pcifunc - 1;
1223
+		/* Assign NIX based on VF number. All even numbered VFs get
1224
+		 * NIX0 and odd numbered gets NIX1
1225
+		 */
1226
+		blkaddr = (vf & 1) ? BLKADDR_NIX1 : BLKADDR_NIX0;
1227
+		/* NIX1 is not present on all silicons */
1228
+		if (!is_block_implemented(rvu->hw, BLKADDR_NIX1))
1229
+			blkaddr = BLKADDR_NIX0;
1230
+	}
1231
+
1232
+	switch (blkaddr) {
1233
+	case BLKADDR_NIX1:
1234
+		pfvf->nix_blkaddr = BLKADDR_NIX1;
1235
+		break;
1236
+	case BLKADDR_NIX0:
1237
+	default:
1238
+		pfvf->nix_blkaddr = BLKADDR_NIX0;
1239
+		break;
1240
+	}
1241
+
1242
+	return pfvf->nix_blkaddr;
1243
+}
1244
+
1245
+static int rvu_get_attach_blkaddr(struct rvu *rvu, int blktype, u16 pcifunc)
1246
+{
1247
+	int blkaddr;
1248
+
1249
+	switch (blktype) {
1250
+	case BLKTYPE_NIX:
1251
+		blkaddr = rvu_get_nix_blkaddr(rvu, pcifunc);
1252
+		break;
1253
+	default:
1254
+		return rvu_get_blkaddr(rvu, blktype, 0);
1255
+	};
1256
+
1257
+	if (is_block_implemented(rvu->hw, blkaddr))
1258
+		return blkaddr;
1259
+
1260
+	return -ENODEV;
1261
+}
1262
+
1182
1263
 static void rvu_attach_block(struct rvu *rvu, int pcifunc,
1183
1264
 			     int blktype, int num_lfs)
1184
1265
 {
..
..
@@ -1192,7 +1273,7 @@
1192
1273
 	if (!num_lfs)
1193
1274
 		return;
1194
1275
 
1195
-	blkaddr = rvu_get_blkaddr(rvu, blktype, 0);
1276
+	blkaddr = rvu_get_attach_blkaddr(rvu, blktype, pcifunc);
1196
1277
 	if (blkaddr < 0)
1197
1278
 		return;
1198
1279
 
..
..
@@ -1221,12 +1302,12 @@
1221
1302
 				       struct rsrc_attach *req, u16 pcifunc)
1222
1303
 {
1223
1304
 	struct rvu_pfvf *pfvf = rvu_get_pfvf(rvu, pcifunc);
1305
+	int free_lfs, mappedlfs, blkaddr;
1224
1306
 	struct rvu_hwinfo *hw = rvu->hw;
1225
1307
 	struct rvu_block *block;
1226
-	int free_lfs, mappedlfs;
1227
1308
 
1228
1309
 	/* Only one NPA LF can be attached */
1229
-	if (req->npalf && !rvu_get_rsrc_mapcount(pfvf, BLKTYPE_NPA)) {
1310
+	if (req->npalf && !is_blktype_attached(pfvf, BLKTYPE_NPA)) {
1230
1311
 		block = &hw->block[BLKADDR_NPA];
1231
1312
 		free_lfs = rvu_rsrc_free_count(&block->lf);
1232
1313
 		if (!free_lfs)
..
..
@@ -1239,8 +1320,11 @@
1239
1320
 	}
1240
1321
 
1241
1322
 	/* Only one NIX LF can be attached */
1242
-	if (req->nixlf && !rvu_get_rsrc_mapcount(pfvf, BLKTYPE_NIX)) {
1243
-		block = &hw->block[BLKADDR_NIX0];
1323
+	if (req->nixlf && !is_blktype_attached(pfvf, BLKTYPE_NIX)) {
1324
+		blkaddr = rvu_get_attach_blkaddr(rvu, BLKTYPE_NIX, pcifunc);
1325
+		if (blkaddr < 0)
1326
+			return blkaddr;
1327
+		block = &hw->block[blkaddr];
1244
1328
 		free_lfs = rvu_rsrc_free_count(&block->lf);
1245
1329
 		if (!free_lfs)
1246
1330
 			goto fail;
..
..
@@ -1260,7 +1344,7 @@
1260
1344
 				 pcifunc, req->sso, block->lf.max);
1261
1345
 			return -EINVAL;
1262
1346
 		}
1263
-		mappedlfs = rvu_get_rsrc_mapcount(pfvf, block->type);
1347
+		mappedlfs = rvu_get_rsrc_mapcount(pfvf, block->addr);
1264
1348
 		free_lfs = rvu_rsrc_free_count(&block->lf);
1265
1349
 		/* Check if additional resources are available */
1266
1350
 		if (req->sso > mappedlfs &&
..
..
@@ -1276,7 +1360,7 @@
1276
1360
 				 pcifunc, req->sso, block->lf.max);
1277
1361
 			return -EINVAL;
1278
1362
 		}
1279
-		mappedlfs = rvu_get_rsrc_mapcount(pfvf, block->type);
1363
+		mappedlfs = rvu_get_rsrc_mapcount(pfvf, block->addr);
1280
1364
 		free_lfs = rvu_rsrc_free_count(&block->lf);
1281
1365
 		if (req->ssow > mappedlfs &&
1282
1366
 		    ((req->ssow - mappedlfs) > free_lfs))
..
..
@@ -1291,7 +1375,7 @@
1291
1375
 				 pcifunc, req->timlfs, block->lf.max);
1292
1376
 			return -EINVAL;
1293
1377
 		}
1294
-		mappedlfs = rvu_get_rsrc_mapcount(pfvf, block->type);
1378
+		mappedlfs = rvu_get_rsrc_mapcount(pfvf, block->addr);
1295
1379
 		free_lfs = rvu_rsrc_free_count(&block->lf);
1296
1380
 		if (req->timlfs > mappedlfs &&
1297
1381
 		    ((req->timlfs - mappedlfs) > free_lfs))
..
..
@@ -1306,7 +1390,7 @@
1306
1390
 				 pcifunc, req->cptlfs, block->lf.max);
1307
1391
 			return -EINVAL;
1308
1392
 		}
1309
-		mappedlfs = rvu_get_rsrc_mapcount(pfvf, block->type);
1393
+		mappedlfs = rvu_get_rsrc_mapcount(pfvf, block->addr);
1310
1394
 		free_lfs = rvu_rsrc_free_count(&block->lf);
1311
1395
 		if (req->cptlfs > mappedlfs &&
1312
1396
 		    ((req->cptlfs - mappedlfs) > free_lfs))
..
..
@@ -1942,7 +2026,7 @@
1942
2026
 
1943
2027
 	block = &rvu->hw->block[blkaddr];
1944
2028
 	num_lfs = rvu_get_rsrc_mapcount(rvu_get_pfvf(rvu, pcifunc),
1945
-					block->type);
2029
+					block->addr);
1946
2030
 	if (!num_lfs)
1947
2031
 		return;
1948
2032
 	for (slot = 0; slot < num_lfs; slot++) {