1 // SPDX-License-Identifier: GPL-2.0 2 // Copyright (c) 2024 Pengutronix, Oleksij Rempel <kernel@pengutronix.de> 3 4 #include <linux/array_size.h> 5 #include <linux/printk.h> 6 #include <linux/types.h> 7 #include <net/dscp.h> 8 #include <net/ieee8021q.h> 9 10 /* The following arrays map Traffic Types (TT) to traffic classes (TC) for 11 * different number of queues as shown in the example provided by 12 * IEEE 802.1Q-2022 in Annex I "I.3 Traffic type to traffic class mapping" and 13 * Table I-1 "Traffic type to traffic class mapping". 14 */ 15 static const u8 ieee8021q_8queue_tt_tc_map[] = { 16 [IEEE8021Q_TT_BK] = 0, 17 [IEEE8021Q_TT_BE] = 1, 18 [IEEE8021Q_TT_EE] = 2, 19 [IEEE8021Q_TT_CA] = 3, 20 [IEEE8021Q_TT_VI] = 4, 21 [IEEE8021Q_TT_VO] = 5, 22 [IEEE8021Q_TT_IC] = 6, 23 [IEEE8021Q_TT_NC] = 7, 24 }; 25 26 static const u8 ieee8021q_7queue_tt_tc_map[] = { 27 [IEEE8021Q_TT_BK] = 0, 28 [IEEE8021Q_TT_BE] = 1, 29 [IEEE8021Q_TT_EE] = 2, 30 [IEEE8021Q_TT_CA] = 3, 31 [IEEE8021Q_TT_VI] = 4, [IEEE8021Q_TT_VO] = 4, 32 [IEEE8021Q_TT_IC] = 5, 33 [IEEE8021Q_TT_NC] = 6, 34 }; 35 36 static const u8 ieee8021q_6queue_tt_tc_map[] = { 37 [IEEE8021Q_TT_BK] = 0, 38 [IEEE8021Q_TT_BE] = 1, 39 [IEEE8021Q_TT_EE] = 2, [IEEE8021Q_TT_CA] = 2, 40 [IEEE8021Q_TT_VI] = 3, [IEEE8021Q_TT_VO] = 3, 41 [IEEE8021Q_TT_IC] = 4, 42 [IEEE8021Q_TT_NC] = 5, 43 }; 44 45 static const u8 ieee8021q_5queue_tt_tc_map[] = { 46 [IEEE8021Q_TT_BK] = 0, [IEEE8021Q_TT_BE] = 0, 47 [IEEE8021Q_TT_EE] = 1, [IEEE8021Q_TT_CA] = 1, 48 [IEEE8021Q_TT_VI] = 2, [IEEE8021Q_TT_VO] = 2, 49 [IEEE8021Q_TT_IC] = 3, 50 [IEEE8021Q_TT_NC] = 4, 51 }; 52 53 static const u8 ieee8021q_4queue_tt_tc_map[] = { 54 [IEEE8021Q_TT_BK] = 0, [IEEE8021Q_TT_BE] = 0, 55 [IEEE8021Q_TT_EE] = 1, [IEEE8021Q_TT_CA] = 1, 56 [IEEE8021Q_TT_VI] = 2, [IEEE8021Q_TT_VO] = 2, 57 [IEEE8021Q_TT_IC] = 3, [IEEE8021Q_TT_NC] = 3, 58 }; 59 60 static const u8 ieee8021q_3queue_tt_tc_map[] = { 61 [IEEE8021Q_TT_BK] = 0, [IEEE8021Q_TT_BE] = 0, 62 [IEEE8021Q_TT_EE] = 0, [IEEE8021Q_TT_CA] = 0, 63 [IEEE8021Q_TT_VI] = 1, [IEEE8021Q_TT_VO] = 1, 64 [IEEE8021Q_TT_IC] = 2, [IEEE8021Q_TT_NC] = 2, 65 }; 66 67 static const u8 ieee8021q_2queue_tt_tc_map[] = { 68 [IEEE8021Q_TT_BK] = 0, [IEEE8021Q_TT_BE] = 0, 69 [IEEE8021Q_TT_EE] = 0, [IEEE8021Q_TT_CA] = 0, 70 [IEEE8021Q_TT_VI] = 1, [IEEE8021Q_TT_VO] = 1, 71 [IEEE8021Q_TT_IC] = 1, [IEEE8021Q_TT_NC] = 1, 72 }; 73 74 static const u8 ieee8021q_1queue_tt_tc_map[] = { 75 [IEEE8021Q_TT_BK] = 0, [IEEE8021Q_TT_BE] = 0, 76 [IEEE8021Q_TT_EE] = 0, [IEEE8021Q_TT_CA] = 0, 77 [IEEE8021Q_TT_VI] = 0, [IEEE8021Q_TT_VO] = 0, 78 [IEEE8021Q_TT_IC] = 0, [IEEE8021Q_TT_NC] = 0, 79 }; 80 81 /** 82 * ieee8021q_tt_to_tc - Map IEEE 802.1Q Traffic Type to Traffic Class 83 * @tt: IEEE 802.1Q Traffic Type 84 * @num_queues: Number of queues 85 * 86 * This function maps an IEEE 802.1Q Traffic Type to a Traffic Class (TC) based 87 * on the number of queues configured on the NIC. The mapping is based on the 88 * example provided by IEEE 802.1Q-2022 in Annex I "I.3 Traffic type to traffic 89 * class mapping" and Table I-1 "Traffic type to traffic class mapping". 90 * 91 * Return: Traffic Class corresponding to the given Traffic Type or negative 92 * value in case of error. 93 */ 94 int ieee8021q_tt_to_tc(enum ieee8021q_traffic_type tt, unsigned int num_queues) 95 { 96 if (tt < 0 || tt >= IEEE8021Q_TT_MAX) { 97 pr_err("Requested Traffic Type (%d) is out of range (%d)\n", tt, 98 IEEE8021Q_TT_MAX); 99 return -EINVAL; 100 } 101 102 switch (num_queues) { 103 case 8: 104 compiletime_assert(ARRAY_SIZE(ieee8021q_8queue_tt_tc_map) != 105 IEEE8021Q_TT_MAX - 1, 106 "ieee8021q_8queue_tt_tc_map != max - 1"); 107 return ieee8021q_8queue_tt_tc_map[tt]; 108 case 7: 109 compiletime_assert(ARRAY_SIZE(ieee8021q_7queue_tt_tc_map) != 110 IEEE8021Q_TT_MAX - 1, 111 "ieee8021q_7queue_tt_tc_map != max - 1"); 112 113 return ieee8021q_7queue_tt_tc_map[tt]; 114 case 6: 115 compiletime_assert(ARRAY_SIZE(ieee8021q_6queue_tt_tc_map) != 116 IEEE8021Q_TT_MAX - 1, 117 "ieee8021q_6queue_tt_tc_map != max - 1"); 118 119 return ieee8021q_6queue_tt_tc_map[tt]; 120 case 5: 121 compiletime_assert(ARRAY_SIZE(ieee8021q_5queue_tt_tc_map) != 122 IEEE8021Q_TT_MAX - 1, 123 "ieee8021q_5queue_tt_tc_map != max - 1"); 124 125 return ieee8021q_5queue_tt_tc_map[tt]; 126 case 4: 127 compiletime_assert(ARRAY_SIZE(ieee8021q_4queue_tt_tc_map) != 128 IEEE8021Q_TT_MAX - 1, 129 "ieee8021q_4queue_tt_tc_map != max - 1"); 130 131 return ieee8021q_4queue_tt_tc_map[tt]; 132 case 3: 133 compiletime_assert(ARRAY_SIZE(ieee8021q_3queue_tt_tc_map) != 134 IEEE8021Q_TT_MAX - 1, 135 "ieee8021q_3queue_tt_tc_map != max - 1"); 136 137 return ieee8021q_3queue_tt_tc_map[tt]; 138 case 2: 139 compiletime_assert(ARRAY_SIZE(ieee8021q_2queue_tt_tc_map) != 140 IEEE8021Q_TT_MAX - 1, 141 "ieee8021q_2queue_tt_tc_map != max - 1"); 142 143 return ieee8021q_2queue_tt_tc_map[tt]; 144 case 1: 145 compiletime_assert(ARRAY_SIZE(ieee8021q_1queue_tt_tc_map) != 146 IEEE8021Q_TT_MAX - 1, 147 "ieee8021q_1queue_tt_tc_map != max - 1"); 148 149 return ieee8021q_1queue_tt_tc_map[tt]; 150 } 151 152 pr_err("Invalid number of queues %d\n", num_queues); 153 154 return -EINVAL; 155 } 156 EXPORT_SYMBOL_GPL(ieee8021q_tt_to_tc); 157 158 /** 159 * ietf_dscp_to_ieee8021q_tt - Map IETF DSCP to IEEE 802.1Q Traffic Type 160 * @dscp: IETF DSCP value 161 * 162 * This function maps an IETF DSCP value to an IEEE 802.1Q Traffic Type (TT). 163 * Since there is no corresponding mapping between DSCP and IEEE 802.1Q Traffic 164 * Type, this function is inspired by the RFC8325 documentation which describe 165 * the mapping between DSCP and 802.11 User Priority (UP) values. 166 * 167 * Return: IEEE 802.1Q Traffic Type corresponding to the given DSCP value 168 */ 169 int ietf_dscp_to_ieee8021q_tt(u8 dscp) 170 { 171 switch (dscp) { 172 case DSCP_CS0: 173 /* Comment from RFC8325: 174 * [RFC4594], Section 4.8, recommends High-Throughput Data be marked 175 * AF1x (that is, AF11, AF12, and AF13, according to the rules defined 176 * in [RFC2475]). 177 * 178 * By default (as described in Section 2.3), High-Throughput Data will 179 * map to UP 1 and, thus, to the Background Access Category (AC_BK), 180 * which is contrary to the intent expressed in [RFC4594]. 181 182 * Unfortunately, there really is no corresponding fit for the High- 183 * Throughput Data service class within the constrained 4 Access 184 * Category [IEEE.802.11-2016] model. If the High-Throughput Data 185 * service class is assigned to the Best Effort Access Category (AC_BE), 186 * then it would contend with Low-Latency Data (while [RFC4594] 187 * recommends a distinction in servicing between these service classes) 188 * as well as with the default service class; alternatively, if it is 189 * assigned to the Background Access Category (AC_BK), then it would 190 * receive a less-then-best-effort service and contend with Low-Priority 191 * Data (as discussed in Section 4.2.10). 192 * 193 * As such, since there is no directly corresponding fit for the High- 194 * Throughout Data service class within the [IEEE.802.11-2016] model, it 195 * is generally RECOMMENDED to map High-Throughput Data to UP 0, thereby 196 * admitting it to the Best Effort Access Category (AC_BE). 197 * 198 * Note: The above text is from RFC8325 which is describing the mapping 199 * between DSCP and 802.11 User Priority (UP) values. The mapping 200 * between UP and IEEE 802.1Q Traffic Type is not defined in the RFC but 201 * the 802.11 AC_BK and AC_BE are closely related to the IEEE 802.1Q 202 * Traffic Types BE and BK. 203 */ 204 case DSCP_AF11: 205 case DSCP_AF12: 206 case DSCP_AF13: 207 return IEEE8021Q_TT_BE; 208 /* Comment from RFC8325: 209 * RFC3662 and RFC4594 both recommend Low-Priority Data be marked 210 * with DSCP CS1. The Low-Priority Data service class loosely 211 * corresponds to the [IEEE.802.11-2016] Background Access Category 212 */ 213 case DSCP_CS1: 214 return IEEE8021Q_TT_BK; 215 case DSCP_CS2: 216 case DSCP_AF21: 217 case DSCP_AF22: 218 case DSCP_AF23: 219 return IEEE8021Q_TT_EE; 220 case DSCP_CS3: 221 case DSCP_AF31: 222 case DSCP_AF32: 223 case DSCP_AF33: 224 return IEEE8021Q_TT_CA; 225 case DSCP_CS4: 226 case DSCP_AF41: 227 case DSCP_AF42: 228 case DSCP_AF43: 229 return IEEE8021Q_TT_VI; 230 case DSCP_CS5: 231 case DSCP_EF: 232 case DSCP_VOICE_ADMIT: 233 return IEEE8021Q_TT_VO; 234 case DSCP_CS6: 235 return IEEE8021Q_TT_IC; 236 case DSCP_CS7: 237 return IEEE8021Q_TT_NC; 238 } 239 240 return SIMPLE_IETF_DSCP_TO_IEEE8021Q_TT(dscp); 241 } 242 EXPORT_SYMBOL_GPL(ietf_dscp_to_ieee8021q_tt); 243