1 // SPDX-License-Identifier: GPL-2.0+ 2 // Copyright (c) 2016-2017 Hisilicon Limited. 3 4 #include "hclge_main.h" 5 #include "hclge_tm.h" 6 #include "hnae3.h" 7 8 #define BW_PERCENT 100 9 10 static int hclge_ieee_ets_to_tm_info(struct hclge_dev *hdev, 11 struct ieee_ets *ets) 12 { 13 u8 i; 14 15 for (i = 0; i < HNAE3_MAX_TC; i++) { 16 switch (ets->tc_tsa[i]) { 17 case IEEE_8021QAZ_TSA_STRICT: 18 hdev->tm_info.tc_info[i].tc_sch_mode = 19 HCLGE_SCH_MODE_SP; 20 hdev->tm_info.pg_info[0].tc_dwrr[i] = 0; 21 break; 22 case IEEE_8021QAZ_TSA_ETS: 23 hdev->tm_info.tc_info[i].tc_sch_mode = 24 HCLGE_SCH_MODE_DWRR; 25 hdev->tm_info.pg_info[0].tc_dwrr[i] = 26 ets->tc_tx_bw[i]; 27 break; 28 default: 29 /* Hardware only supports SP (strict priority) 30 * or ETS (enhanced transmission selection) 31 * algorithms, if we receive some other value 32 * from dcbnl, then throw an error. 33 */ 34 return -EINVAL; 35 } 36 } 37 38 hclge_tm_prio_tc_info_update(hdev, ets->prio_tc); 39 40 return 0; 41 } 42 43 static void hclge_tm_info_to_ieee_ets(struct hclge_dev *hdev, 44 struct ieee_ets *ets) 45 { 46 u32 i; 47 48 memset(ets, 0, sizeof(*ets)); 49 ets->willing = 1; 50 ets->ets_cap = hdev->tc_max; 51 52 for (i = 0; i < HNAE3_MAX_TC; i++) { 53 ets->prio_tc[i] = hdev->tm_info.prio_tc[i]; 54 ets->tc_tx_bw[i] = hdev->tm_info.pg_info[0].tc_dwrr[i]; 55 56 if (hdev->tm_info.tc_info[i].tc_sch_mode == 57 HCLGE_SCH_MODE_SP) 58 ets->tc_tsa[i] = IEEE_8021QAZ_TSA_STRICT; 59 else 60 ets->tc_tsa[i] = IEEE_8021QAZ_TSA_ETS; 61 } 62 } 63 64 /* IEEE std */ 65 static int hclge_ieee_getets(struct hnae3_handle *h, struct ieee_ets *ets) 66 { 67 struct hclge_vport *vport = hclge_get_vport(h); 68 struct hclge_dev *hdev = vport->back; 69 70 hclge_tm_info_to_ieee_ets(hdev, ets); 71 72 return 0; 73 } 74 75 static int hclge_dcb_common_validate(struct hclge_dev *hdev, u8 num_tc, 76 u8 *prio_tc) 77 { 78 int i; 79 80 if (num_tc > hdev->tc_max) { 81 dev_err(&hdev->pdev->dev, 82 "tc num checking failed, %u > tc_max(%u)\n", 83 num_tc, hdev->tc_max); 84 return -EINVAL; 85 } 86 87 for (i = 0; i < HNAE3_MAX_USER_PRIO; i++) { 88 if (prio_tc[i] >= num_tc) { 89 dev_err(&hdev->pdev->dev, 90 "prio_tc[%u] checking failed, %u >= num_tc(%u)\n", 91 i, prio_tc[i], num_tc); 92 return -EINVAL; 93 } 94 } 95 96 if (num_tc > hdev->vport[0].alloc_tqps) { 97 dev_err(&hdev->pdev->dev, 98 "allocated tqp checking failed, %u > tqp(%u)\n", 99 num_tc, hdev->vport[0].alloc_tqps); 100 return -EINVAL; 101 } 102 103 return 0; 104 } 105 106 static int hclge_ets_validate(struct hclge_dev *hdev, struct ieee_ets *ets, 107 u8 *tc, bool *changed) 108 { 109 bool has_ets_tc = false; 110 u32 total_ets_bw = 0; 111 u8 max_tc = 0; 112 int ret; 113 u8 i; 114 115 for (i = 0; i < HNAE3_MAX_USER_PRIO; i++) { 116 if (ets->prio_tc[i] != hdev->tm_info.prio_tc[i]) 117 *changed = true; 118 119 if (ets->prio_tc[i] > max_tc) 120 max_tc = ets->prio_tc[i]; 121 } 122 123 ret = hclge_dcb_common_validate(hdev, max_tc + 1, ets->prio_tc); 124 if (ret) 125 return ret; 126 127 for (i = 0; i < HNAE3_MAX_TC; i++) { 128 switch (ets->tc_tsa[i]) { 129 case IEEE_8021QAZ_TSA_STRICT: 130 if (hdev->tm_info.tc_info[i].tc_sch_mode != 131 HCLGE_SCH_MODE_SP) 132 *changed = true; 133 break; 134 case IEEE_8021QAZ_TSA_ETS: 135 if (hdev->tm_info.tc_info[i].tc_sch_mode != 136 HCLGE_SCH_MODE_DWRR) 137 *changed = true; 138 139 total_ets_bw += ets->tc_tx_bw[i]; 140 has_ets_tc = true; 141 break; 142 default: 143 return -EINVAL; 144 } 145 } 146 147 if (has_ets_tc && total_ets_bw != BW_PERCENT) 148 return -EINVAL; 149 150 *tc = max_tc + 1; 151 if (*tc != hdev->tm_info.num_tc) 152 *changed = true; 153 154 return 0; 155 } 156 157 static int hclge_map_update(struct hclge_dev *hdev) 158 { 159 int ret; 160 161 ret = hclge_tm_schd_setup_hw(hdev); 162 if (ret) 163 return ret; 164 165 ret = hclge_pause_setup_hw(hdev, false); 166 if (ret) 167 return ret; 168 169 ret = hclge_buffer_alloc(hdev); 170 if (ret) 171 return ret; 172 173 hclge_rss_indir_init_cfg(hdev); 174 175 return hclge_rss_init_hw(hdev); 176 } 177 178 static int hclge_client_setup_tc(struct hclge_dev *hdev) 179 { 180 struct hclge_vport *vport = hdev->vport; 181 struct hnae3_client *client; 182 struct hnae3_handle *handle; 183 int ret; 184 u32 i; 185 186 for (i = 0; i < hdev->num_vmdq_vport + 1; i++) { 187 handle = &vport[i].nic; 188 client = handle->client; 189 190 if (!client || !client->ops || !client->ops->setup_tc) 191 continue; 192 193 ret = client->ops->setup_tc(handle, hdev->tm_info.num_tc); 194 if (ret) 195 return ret; 196 } 197 198 return 0; 199 } 200 201 static int hclge_ieee_setets(struct hnae3_handle *h, struct ieee_ets *ets) 202 { 203 struct hclge_vport *vport = hclge_get_vport(h); 204 struct net_device *netdev = h->kinfo.netdev; 205 struct hclge_dev *hdev = vport->back; 206 bool map_changed = false; 207 u8 num_tc = 0; 208 int ret; 209 210 if (!(hdev->dcbx_cap & DCB_CAP_DCBX_VER_IEEE) || 211 hdev->flag & HCLGE_FLAG_MQPRIO_ENABLE) 212 return -EINVAL; 213 214 ret = hclge_ets_validate(hdev, ets, &num_tc, &map_changed); 215 if (ret) 216 return ret; 217 218 if (map_changed) { 219 netif_dbg(h, drv, netdev, "set ets\n"); 220 221 ret = hclge_notify_client(hdev, HNAE3_DOWN_CLIENT); 222 if (ret) 223 return ret; 224 225 ret = hclge_notify_client(hdev, HNAE3_UNINIT_CLIENT); 226 if (ret) 227 return ret; 228 } 229 230 hclge_tm_schd_info_update(hdev, num_tc); 231 232 ret = hclge_ieee_ets_to_tm_info(hdev, ets); 233 if (ret) 234 goto err_out; 235 236 if (map_changed) { 237 ret = hclge_map_update(hdev); 238 if (ret) 239 goto err_out; 240 241 ret = hclge_client_setup_tc(hdev); 242 if (ret) 243 goto err_out; 244 245 ret = hclge_notify_client(hdev, HNAE3_INIT_CLIENT); 246 if (ret) 247 return ret; 248 249 ret = hclge_notify_client(hdev, HNAE3_UP_CLIENT); 250 if (ret) 251 return ret; 252 } 253 254 return hclge_tm_dwrr_cfg(hdev); 255 256 err_out: 257 if (!map_changed) 258 return ret; 259 260 if (hclge_notify_client(hdev, HNAE3_INIT_CLIENT)) 261 return ret; 262 263 hclge_notify_client(hdev, HNAE3_UP_CLIENT); 264 return ret; 265 } 266 267 static int hclge_ieee_getpfc(struct hnae3_handle *h, struct ieee_pfc *pfc) 268 { 269 u64 requests[HNAE3_MAX_TC], indications[HNAE3_MAX_TC]; 270 struct hclge_vport *vport = hclge_get_vport(h); 271 struct hclge_dev *hdev = vport->back; 272 u8 i, j, pfc_map, *prio_tc; 273 int ret; 274 275 memset(pfc, 0, sizeof(*pfc)); 276 pfc->pfc_cap = hdev->pfc_max; 277 prio_tc = hdev->tm_info.prio_tc; 278 pfc_map = hdev->tm_info.hw_pfc_map; 279 280 /* Pfc setting is based on TC */ 281 for (i = 0; i < hdev->tm_info.num_tc; i++) { 282 for (j = 0; j < HNAE3_MAX_USER_PRIO; j++) { 283 if ((prio_tc[j] == i) && (pfc_map & BIT(i))) 284 pfc->pfc_en |= BIT(j); 285 } 286 } 287 288 ret = hclge_pfc_tx_stats_get(hdev, requests); 289 if (ret) 290 return ret; 291 292 ret = hclge_pfc_rx_stats_get(hdev, indications); 293 if (ret) 294 return ret; 295 296 for (i = 0; i < HCLGE_MAX_TC_NUM; i++) { 297 pfc->requests[i] = requests[i]; 298 pfc->indications[i] = indications[i]; 299 } 300 return 0; 301 } 302 303 static int hclge_ieee_setpfc(struct hnae3_handle *h, struct ieee_pfc *pfc) 304 { 305 struct hclge_vport *vport = hclge_get_vport(h); 306 struct net_device *netdev = h->kinfo.netdev; 307 struct hclge_dev *hdev = vport->back; 308 u8 i, j, pfc_map, *prio_tc; 309 310 if (!(hdev->dcbx_cap & DCB_CAP_DCBX_VER_IEEE) || 311 hdev->flag & HCLGE_FLAG_MQPRIO_ENABLE) 312 return -EINVAL; 313 314 if (pfc->pfc_en == hdev->tm_info.pfc_en) 315 return 0; 316 317 prio_tc = hdev->tm_info.prio_tc; 318 pfc_map = 0; 319 320 for (i = 0; i < hdev->tm_info.num_tc; i++) { 321 for (j = 0; j < HNAE3_MAX_USER_PRIO; j++) { 322 if ((prio_tc[j] == i) && (pfc->pfc_en & BIT(j))) { 323 pfc_map |= BIT(i); 324 break; 325 } 326 } 327 } 328 329 hdev->tm_info.hw_pfc_map = pfc_map; 330 hdev->tm_info.pfc_en = pfc->pfc_en; 331 332 netif_dbg(h, drv, netdev, 333 "set pfc: pfc_en=%u, pfc_map=%u, num_tc=%u\n", 334 pfc->pfc_en, pfc_map, hdev->tm_info.num_tc); 335 336 hclge_tm_pfc_info_update(hdev); 337 338 return hclge_pause_setup_hw(hdev, false); 339 } 340 341 /* DCBX configuration */ 342 static u8 hclge_getdcbx(struct hnae3_handle *h) 343 { 344 struct hclge_vport *vport = hclge_get_vport(h); 345 struct hclge_dev *hdev = vport->back; 346 347 if (hdev->flag & HCLGE_FLAG_MQPRIO_ENABLE) 348 return 0; 349 350 return hdev->dcbx_cap; 351 } 352 353 static u8 hclge_setdcbx(struct hnae3_handle *h, u8 mode) 354 { 355 struct hclge_vport *vport = hclge_get_vport(h); 356 struct net_device *netdev = h->kinfo.netdev; 357 struct hclge_dev *hdev = vport->back; 358 359 netif_dbg(h, drv, netdev, "set dcbx: mode=%u\n", mode); 360 361 /* No support for LLD_MANAGED modes or CEE */ 362 if ((mode & DCB_CAP_DCBX_LLD_MANAGED) || 363 (mode & DCB_CAP_DCBX_VER_CEE) || 364 !(mode & DCB_CAP_DCBX_HOST)) 365 return 1; 366 367 hdev->dcbx_cap = mode; 368 369 return 0; 370 } 371 372 /* Set up TC for hardware offloaded mqprio in channel mode */ 373 static int hclge_setup_tc(struct hnae3_handle *h, u8 tc, u8 *prio_tc) 374 { 375 struct hclge_vport *vport = hclge_get_vport(h); 376 struct hclge_dev *hdev = vport->back; 377 int ret; 378 379 if (hdev->flag & HCLGE_FLAG_DCB_ENABLE) 380 return -EINVAL; 381 382 ret = hclge_dcb_common_validate(hdev, tc, prio_tc); 383 if (ret) 384 return -EINVAL; 385 386 ret = hclge_notify_client(hdev, HNAE3_DOWN_CLIENT); 387 if (ret) 388 return ret; 389 390 ret = hclge_notify_client(hdev, HNAE3_UNINIT_CLIENT); 391 if (ret) 392 return ret; 393 394 hclge_tm_schd_info_update(hdev, tc); 395 hclge_tm_prio_tc_info_update(hdev, prio_tc); 396 397 ret = hclge_tm_init_hw(hdev, false); 398 if (ret) 399 goto err_out; 400 401 ret = hclge_client_setup_tc(hdev); 402 if (ret) 403 goto err_out; 404 405 hdev->flag &= ~HCLGE_FLAG_DCB_ENABLE; 406 407 if (tc > 1) 408 hdev->flag |= HCLGE_FLAG_MQPRIO_ENABLE; 409 else 410 hdev->flag &= ~HCLGE_FLAG_MQPRIO_ENABLE; 411 412 ret = hclge_notify_client(hdev, HNAE3_INIT_CLIENT); 413 if (ret) 414 return ret; 415 416 return hclge_notify_client(hdev, HNAE3_UP_CLIENT); 417 418 err_out: 419 if (hclge_notify_client(hdev, HNAE3_INIT_CLIENT)) 420 return ret; 421 422 hclge_notify_client(hdev, HNAE3_UP_CLIENT); 423 return ret; 424 } 425 426 static const struct hnae3_dcb_ops hns3_dcb_ops = { 427 .ieee_getets = hclge_ieee_getets, 428 .ieee_setets = hclge_ieee_setets, 429 .ieee_getpfc = hclge_ieee_getpfc, 430 .ieee_setpfc = hclge_ieee_setpfc, 431 .getdcbx = hclge_getdcbx, 432 .setdcbx = hclge_setdcbx, 433 .setup_tc = hclge_setup_tc, 434 }; 435 436 void hclge_dcb_ops_set(struct hclge_dev *hdev) 437 { 438 struct hclge_vport *vport = hdev->vport; 439 struct hnae3_knic_private_info *kinfo; 440 441 /* Hdev does not support DCB or vport is 442 * not a pf, then dcb_ops is not set. 443 */ 444 if (!hnae3_dev_dcb_supported(hdev) || 445 vport->vport_id != 0) 446 return; 447 448 kinfo = &vport->nic.kinfo; 449 kinfo->dcb_ops = &hns3_dcb_ops; 450 hdev->dcbx_cap = DCB_CAP_DCBX_VER_IEEE | DCB_CAP_DCBX_HOST; 451 } 452