1 // SPDX-License-Identifier: GPL-2.0 2 /* Copyright (c) 2018-2019, Vladimir Oltean <olteanv@gmail.com> 3 */ 4 #include "sja1105.h" 5 6 /* In the dynamic configuration interface, the switch exposes a register-like 7 * view of some of the static configuration tables. 8 * Many times the field organization of the dynamic tables is abbreviated (not 9 * all fields are dynamically reconfigurable) and different from the static 10 * ones, but the key reason for having it is that we can spare a switch reset 11 * for settings that can be changed dynamically. 12 * 13 * This file creates a per-switch-family abstraction called 14 * struct sja1105_dynamic_table_ops and two operations that work with it: 15 * - sja1105_dynamic_config_write 16 * - sja1105_dynamic_config_read 17 * 18 * Compared to the struct sja1105_table_ops from sja1105_static_config.c, 19 * the dynamic accessors work with a compound buffer: 20 * 21 * packed_buf 22 * 23 * | 24 * V 25 * +-----------------------------------------+------------------+ 26 * | ENTRY BUFFER | COMMAND BUFFER | 27 * +-----------------------------------------+------------------+ 28 * 29 * <----------------------- packed_size ------------------------> 30 * 31 * The ENTRY BUFFER may or may not have the same layout, or size, as its static 32 * configuration table entry counterpart. When it does, the same packing 33 * function is reused (bar exceptional cases - see 34 * sja1105pqrs_dyn_l2_lookup_entry_packing). 35 * 36 * The reason for the COMMAND BUFFER being at the end is to be able to send 37 * a dynamic write command through a single SPI burst. By the time the switch 38 * reacts to the command, the ENTRY BUFFER is already populated with the data 39 * sent by the core. 40 * 41 * The COMMAND BUFFER is always SJA1105_SIZE_DYN_CMD bytes (one 32-bit word) in 42 * size. 43 * 44 * Sometimes the ENTRY BUFFER does not really exist (when the number of fields 45 * that can be reconfigured is small), then the switch repurposes some of the 46 * unused 32 bits of the COMMAND BUFFER to hold ENTRY data. 47 * 48 * The key members of struct sja1105_dynamic_table_ops are: 49 * - .entry_packing: A function that deals with packing an ENTRY structure 50 * into an SPI buffer, or retrieving an ENTRY structure 51 * from one. 52 * The @packed_buf pointer it's given does always point to 53 * the ENTRY portion of the buffer. 54 * - .cmd_packing: A function that deals with packing/unpacking the COMMAND 55 * structure to/from the SPI buffer. 56 * It is given the same @packed_buf pointer as .entry_packing, 57 * so most of the time, the @packed_buf points *behind* the 58 * COMMAND offset inside the buffer. 59 * To access the COMMAND portion of the buffer, the function 60 * knows its correct offset. 61 * Giving both functions the same pointer is handy because in 62 * extreme cases (see sja1105pqrs_dyn_l2_lookup_entry_packing) 63 * the .entry_packing is able to jump to the COMMAND portion, 64 * or vice-versa (sja1105pqrs_l2_lookup_cmd_packing). 65 * - .access: A bitmap of: 66 * OP_READ: Set if the hardware manual marks the ENTRY portion of the 67 * dynamic configuration table buffer as R (readable) after 68 * an SPI read command (the switch will populate the buffer). 69 * OP_WRITE: Set if the manual marks the ENTRY portion of the dynamic 70 * table buffer as W (writable) after an SPI write command 71 * (the switch will read the fields provided in the buffer). 72 * OP_DEL: Set if the manual says the VALIDENT bit is supported in the 73 * COMMAND portion of this dynamic config buffer (i.e. the 74 * specified entry can be invalidated through a SPI write 75 * command). 76 * OP_SEARCH: Set if the manual says that the index of an entry can 77 * be retrieved in the COMMAND portion of the buffer based 78 * on its ENTRY portion, as a result of a SPI write command. 79 * Only the TCAM-based FDB table on SJA1105 P/Q/R/S supports 80 * this. 81 * OP_VALID_ANYWAY: Reading some tables through the dynamic config 82 * interface is possible even if the VALIDENT bit is not 83 * set in the writeback. So don't error out in that case. 84 * - .max_entry_count: The number of entries, counting from zero, that can be 85 * reconfigured through the dynamic interface. If a static 86 * table can be reconfigured at all dynamically, this 87 * number always matches the maximum number of supported 88 * static entries. 89 * - .packed_size: The length in bytes of the compound ENTRY + COMMAND BUFFER. 90 * Note that sometimes the compound buffer may contain holes in 91 * it (see sja1105_vlan_lookup_cmd_packing). The @packed_buf is 92 * contiguous however, so @packed_size includes any unused 93 * bytes. 94 * - .addr: The base SPI address at which the buffer must be written to the 95 * switch's memory. When looking at the hardware manual, this must 96 * always match the lowest documented address for the ENTRY, and not 97 * that of the COMMAND, since the other 32-bit words will follow along 98 * at the correct addresses. 99 */ 100 101 #define SJA1105_SIZE_DYN_CMD 4 102 103 #define SJA1105ET_SIZE_VL_LOOKUP_DYN_CMD \ 104 SJA1105_SIZE_DYN_CMD 105 106 #define SJA1105PQRS_SIZE_VL_LOOKUP_DYN_CMD \ 107 (SJA1105_SIZE_DYN_CMD + SJA1105_SIZE_VL_LOOKUP_ENTRY) 108 109 #define SJA1110_SIZE_VL_POLICING_DYN_CMD \ 110 (SJA1105_SIZE_DYN_CMD + SJA1105_SIZE_VL_POLICING_ENTRY) 111 112 #define SJA1105ET_SIZE_MAC_CONFIG_DYN_ENTRY \ 113 SJA1105_SIZE_DYN_CMD 114 115 #define SJA1105ET_SIZE_L2_LOOKUP_DYN_CMD \ 116 (SJA1105_SIZE_DYN_CMD + SJA1105ET_SIZE_L2_LOOKUP_ENTRY) 117 118 #define SJA1105PQRS_SIZE_L2_LOOKUP_DYN_CMD \ 119 (SJA1105_SIZE_DYN_CMD + SJA1105PQRS_SIZE_L2_LOOKUP_ENTRY) 120 121 #define SJA1110_SIZE_L2_LOOKUP_DYN_CMD \ 122 (SJA1105_SIZE_DYN_CMD + SJA1110_SIZE_L2_LOOKUP_ENTRY) 123 124 #define SJA1105_SIZE_VLAN_LOOKUP_DYN_CMD \ 125 (SJA1105_SIZE_DYN_CMD + 4 + SJA1105_SIZE_VLAN_LOOKUP_ENTRY) 126 127 #define SJA1110_SIZE_VLAN_LOOKUP_DYN_CMD \ 128 (SJA1105_SIZE_DYN_CMD + SJA1110_SIZE_VLAN_LOOKUP_ENTRY) 129 130 #define SJA1105_SIZE_L2_FORWARDING_DYN_CMD \ 131 (SJA1105_SIZE_DYN_CMD + SJA1105_SIZE_L2_FORWARDING_ENTRY) 132 133 #define SJA1105ET_SIZE_MAC_CONFIG_DYN_CMD \ 134 (SJA1105_SIZE_DYN_CMD + SJA1105ET_SIZE_MAC_CONFIG_DYN_ENTRY) 135 136 #define SJA1105PQRS_SIZE_MAC_CONFIG_DYN_CMD \ 137 (SJA1105_SIZE_DYN_CMD + SJA1105PQRS_SIZE_MAC_CONFIG_ENTRY) 138 139 #define SJA1105ET_SIZE_L2_LOOKUP_PARAMS_DYN_CMD \ 140 SJA1105_SIZE_DYN_CMD 141 142 #define SJA1105PQRS_SIZE_L2_LOOKUP_PARAMS_DYN_CMD \ 143 (SJA1105_SIZE_DYN_CMD + SJA1105PQRS_SIZE_L2_LOOKUP_PARAMS_ENTRY) 144 145 #define SJA1110_SIZE_L2_LOOKUP_PARAMS_DYN_CMD \ 146 (SJA1105_SIZE_DYN_CMD + SJA1110_SIZE_L2_LOOKUP_PARAMS_ENTRY) 147 148 #define SJA1105ET_SIZE_GENERAL_PARAMS_DYN_CMD \ 149 SJA1105_SIZE_DYN_CMD 150 151 #define SJA1105PQRS_SIZE_GENERAL_PARAMS_DYN_CMD \ 152 (SJA1105_SIZE_DYN_CMD + SJA1105PQRS_SIZE_GENERAL_PARAMS_ENTRY) 153 154 #define SJA1110_SIZE_GENERAL_PARAMS_DYN_CMD \ 155 (SJA1105_SIZE_DYN_CMD + SJA1110_SIZE_GENERAL_PARAMS_ENTRY) 156 157 #define SJA1105PQRS_SIZE_AVB_PARAMS_DYN_CMD \ 158 (SJA1105_SIZE_DYN_CMD + SJA1105PQRS_SIZE_AVB_PARAMS_ENTRY) 159 160 #define SJA1105_SIZE_RETAGGING_DYN_CMD \ 161 (SJA1105_SIZE_DYN_CMD + SJA1105_SIZE_RETAGGING_ENTRY) 162 163 #define SJA1105ET_SIZE_CBS_DYN_CMD \ 164 (SJA1105_SIZE_DYN_CMD + SJA1105ET_SIZE_CBS_ENTRY) 165 166 #define SJA1105PQRS_SIZE_CBS_DYN_CMD \ 167 (SJA1105_SIZE_DYN_CMD + SJA1105PQRS_SIZE_CBS_ENTRY) 168 169 #define SJA1110_SIZE_XMII_PARAMS_DYN_CMD \ 170 SJA1110_SIZE_XMII_PARAMS_ENTRY 171 172 #define SJA1110_SIZE_L2_POLICING_DYN_CMD \ 173 (SJA1105_SIZE_DYN_CMD + SJA1105_SIZE_L2_POLICING_ENTRY) 174 175 #define SJA1110_SIZE_L2_FORWARDING_PARAMS_DYN_CMD \ 176 SJA1105_SIZE_L2_FORWARDING_PARAMS_ENTRY 177 178 #define SJA1105_MAX_DYN_CMD_SIZE \ 179 SJA1110_SIZE_GENERAL_PARAMS_DYN_CMD 180 181 struct sja1105_dyn_cmd { 182 bool search; 183 u64 valid; 184 u64 rdwrset; 185 u64 errors; 186 u64 valident; 187 u64 index; 188 }; 189 190 enum sja1105_hostcmd { 191 SJA1105_HOSTCMD_SEARCH = 1, 192 SJA1105_HOSTCMD_READ = 2, 193 SJA1105_HOSTCMD_WRITE = 3, 194 SJA1105_HOSTCMD_INVALIDATE = 4, 195 }; 196 197 /* Command and entry overlap */ 198 static void 199 sja1105et_vl_lookup_cmd_packing(void *buf, struct sja1105_dyn_cmd *cmd, 200 enum packing_op op) 201 { 202 const int size = SJA1105_SIZE_DYN_CMD; 203 204 sja1105_packing(buf, &cmd->valid, 31, 31, size, op); 205 sja1105_packing(buf, &cmd->errors, 30, 30, size, op); 206 sja1105_packing(buf, &cmd->rdwrset, 29, 29, size, op); 207 sja1105_packing(buf, &cmd->index, 9, 0, size, op); 208 } 209 210 /* Command and entry are separate */ 211 static void 212 sja1105pqrs_vl_lookup_cmd_packing(void *buf, struct sja1105_dyn_cmd *cmd, 213 enum packing_op op) 214 { 215 u8 *p = buf + SJA1105_SIZE_VL_LOOKUP_ENTRY; 216 const int size = SJA1105_SIZE_DYN_CMD; 217 218 sja1105_packing(p, &cmd->valid, 31, 31, size, op); 219 sja1105_packing(p, &cmd->errors, 30, 30, size, op); 220 sja1105_packing(p, &cmd->rdwrset, 29, 29, size, op); 221 sja1105_packing(p, &cmd->index, 9, 0, size, op); 222 } 223 224 static void 225 sja1110_vl_lookup_cmd_packing(void *buf, struct sja1105_dyn_cmd *cmd, 226 enum packing_op op) 227 { 228 u8 *p = buf + SJA1105PQRS_SIZE_L2_LOOKUP_ENTRY; 229 const int size = SJA1105_SIZE_DYN_CMD; 230 231 sja1105_packing(p, &cmd->valid, 31, 31, size, op); 232 sja1105_packing(p, &cmd->rdwrset, 30, 30, size, op); 233 sja1105_packing(p, &cmd->errors, 29, 29, size, op); 234 sja1105_packing(p, &cmd->index, 11, 0, size, op); 235 } 236 237 static size_t sja1105et_vl_lookup_entry_packing(void *buf, void *entry_ptr, 238 enum packing_op op) 239 { 240 struct sja1105_vl_lookup_entry *entry = entry_ptr; 241 const int size = SJA1105ET_SIZE_VL_LOOKUP_DYN_CMD; 242 243 sja1105_packing(buf, &entry->egrmirr, 21, 17, size, op); 244 sja1105_packing(buf, &entry->ingrmirr, 16, 16, size, op); 245 return size; 246 } 247 248 static void 249 sja1110_vl_policing_cmd_packing(void *buf, struct sja1105_dyn_cmd *cmd, 250 enum packing_op op) 251 { 252 u8 *p = buf + SJA1105_SIZE_VL_LOOKUP_ENTRY; 253 const int size = SJA1105_SIZE_DYN_CMD; 254 255 sja1105_packing(p, &cmd->valid, 31, 31, size, op); 256 sja1105_packing(p, &cmd->rdwrset, 30, 30, size, op); 257 sja1105_packing(p, &cmd->index, 11, 0, size, op); 258 } 259 260 static void 261 sja1105pqrs_common_l2_lookup_cmd_packing(void *buf, struct sja1105_dyn_cmd *cmd, 262 enum packing_op op, int entry_size) 263 { 264 const int size = SJA1105_SIZE_DYN_CMD; 265 u8 *p = buf + entry_size; 266 u64 hostcmd; 267 268 sja1105_packing(p, &cmd->valid, 31, 31, size, op); 269 sja1105_packing(p, &cmd->rdwrset, 30, 30, size, op); 270 sja1105_packing(p, &cmd->errors, 29, 29, size, op); 271 sja1105_packing(p, &cmd->valident, 27, 27, size, op); 272 273 /* VALIDENT is supposed to indicate "keep or not", but in SJA1105 E/T, 274 * using it to delete a management route was unsupported. UM10944 275 * said about it: 276 * 277 * In case of a write access with the MGMTROUTE flag set, 278 * the flag will be ignored. It will always be found cleared 279 * for read accesses with the MGMTROUTE flag set. 280 * 281 * SJA1105 P/Q/R/S keeps the same behavior w.r.t. VALIDENT, but there 282 * is now another flag called HOSTCMD which does more stuff (quoting 283 * from UM11040): 284 * 285 * A write request is accepted only when HOSTCMD is set to write host 286 * or invalid. A read request is accepted only when HOSTCMD is set to 287 * search host or read host. 288 * 289 * So it is possible to translate a RDWRSET/VALIDENT combination into 290 * HOSTCMD so that we keep the dynamic command API in place, and 291 * at the same time achieve compatibility with the management route 292 * command structure. 293 */ 294 if (cmd->rdwrset == SPI_READ) { 295 if (cmd->search) 296 hostcmd = SJA1105_HOSTCMD_SEARCH; 297 else 298 hostcmd = SJA1105_HOSTCMD_READ; 299 } else { 300 /* SPI_WRITE */ 301 if (cmd->valident) 302 hostcmd = SJA1105_HOSTCMD_WRITE; 303 else 304 hostcmd = SJA1105_HOSTCMD_INVALIDATE; 305 } 306 sja1105_packing(p, &hostcmd, 25, 23, size, op); 307 } 308 309 static void 310 sja1105pqrs_l2_lookup_cmd_packing(void *buf, struct sja1105_dyn_cmd *cmd, 311 enum packing_op op) 312 { 313 int entry_size = SJA1105PQRS_SIZE_L2_LOOKUP_ENTRY; 314 315 sja1105pqrs_common_l2_lookup_cmd_packing(buf, cmd, op, entry_size); 316 317 /* Hack - The hardware takes the 'index' field within 318 * struct sja1105_l2_lookup_entry as the index on which this command 319 * will operate. However it will ignore everything else, so 'index' 320 * is logically part of command but physically part of entry. 321 * Populate the 'index' entry field from within the command callback, 322 * such that our API doesn't need to ask for a full-blown entry 323 * structure when e.g. a delete is requested. 324 */ 325 sja1105_packing(buf, &cmd->index, 15, 6, entry_size, op); 326 } 327 328 static void 329 sja1110_l2_lookup_cmd_packing(void *buf, struct sja1105_dyn_cmd *cmd, 330 enum packing_op op) 331 { 332 int entry_size = SJA1110_SIZE_L2_LOOKUP_ENTRY; 333 334 sja1105pqrs_common_l2_lookup_cmd_packing(buf, cmd, op, entry_size); 335 336 sja1105_packing(buf, &cmd->index, 10, 1, entry_size, op); 337 } 338 339 /* The switch is so retarded that it makes our command/entry abstraction 340 * crumble apart. 341 * 342 * On P/Q/R/S, the switch tries to say whether a FDB entry 343 * is statically programmed or dynamically learned via a flag called LOCKEDS. 344 * The hardware manual says about this fiels: 345 * 346 * On write will specify the format of ENTRY. 347 * On read the flag will be found cleared at times the VALID flag is found 348 * set. The flag will also be found cleared in response to a read having the 349 * MGMTROUTE flag set. In response to a read with the MGMTROUTE flag 350 * cleared, the flag be set if the most recent access operated on an entry 351 * that was either loaded by configuration or through dynamic reconfiguration 352 * (as opposed to automatically learned entries). 353 * 354 * The trouble with this flag is that it's part of the *command* to access the 355 * dynamic interface, and not part of the *entry* retrieved from it. 356 * Otherwise said, for a sja1105_dynamic_config_read, LOCKEDS is supposed to be 357 * an output from the switch into the command buffer, and for a 358 * sja1105_dynamic_config_write, the switch treats LOCKEDS as an input 359 * (hence we can write either static, or automatically learned entries, from 360 * the core). 361 * But the manual contradicts itself in the last phrase where it says that on 362 * read, LOCKEDS will be set to 1 for all FDB entries written through the 363 * dynamic interface (therefore, the value of LOCKEDS from the 364 * sja1105_dynamic_config_write is not really used for anything, it'll store a 365 * 1 anyway). 366 * This means you can't really write a FDB entry with LOCKEDS=0 (automatically 367 * learned) into the switch, which kind of makes sense. 368 * As for reading through the dynamic interface, it doesn't make too much sense 369 * to put LOCKEDS into the command, since the switch will inevitably have to 370 * ignore it (otherwise a command would be like "read the FDB entry 123, but 371 * only if it's dynamically learned" <- well how am I supposed to know?) and 372 * just use it as an output buffer for its findings. But guess what... that's 373 * what the entry buffer is for! 374 * Unfortunately, what really breaks this abstraction is the fact that it 375 * wasn't designed having the fact in mind that the switch can output 376 * entry-related data as writeback through the command buffer. 377 * However, whether a FDB entry is statically or dynamically learned *is* part 378 * of the entry and not the command data, no matter what the switch thinks. 379 * In order to do that, we'll need to wrap around the 380 * sja1105pqrs_l2_lookup_entry_packing from sja1105_static_config.c, and take 381 * a peek outside of the caller-supplied @buf (the entry buffer), to reach the 382 * command buffer. 383 */ 384 static size_t 385 sja1105pqrs_dyn_l2_lookup_entry_packing(void *buf, void *entry_ptr, 386 enum packing_op op) 387 { 388 struct sja1105_l2_lookup_entry *entry = entry_ptr; 389 u8 *cmd = buf + SJA1105PQRS_SIZE_L2_LOOKUP_ENTRY; 390 const int size = SJA1105_SIZE_DYN_CMD; 391 392 sja1105_packing(cmd, &entry->lockeds, 28, 28, size, op); 393 394 return sja1105pqrs_l2_lookup_entry_packing(buf, entry_ptr, op); 395 } 396 397 static size_t sja1110_dyn_l2_lookup_entry_packing(void *buf, void *entry_ptr, 398 enum packing_op op) 399 { 400 struct sja1105_l2_lookup_entry *entry = entry_ptr; 401 u8 *cmd = buf + SJA1110_SIZE_L2_LOOKUP_ENTRY; 402 const int size = SJA1105_SIZE_DYN_CMD; 403 404 sja1105_packing(cmd, &entry->lockeds, 28, 28, size, op); 405 406 return sja1110_l2_lookup_entry_packing(buf, entry_ptr, op); 407 } 408 409 static void 410 sja1105et_l2_lookup_cmd_packing(void *buf, struct sja1105_dyn_cmd *cmd, 411 enum packing_op op) 412 { 413 u8 *p = buf + SJA1105ET_SIZE_L2_LOOKUP_ENTRY; 414 const int size = SJA1105_SIZE_DYN_CMD; 415 416 sja1105_packing(p, &cmd->valid, 31, 31, size, op); 417 sja1105_packing(p, &cmd->rdwrset, 30, 30, size, op); 418 sja1105_packing(p, &cmd->errors, 29, 29, size, op); 419 sja1105_packing(p, &cmd->valident, 27, 27, size, op); 420 /* Hack - see comments above. */ 421 sja1105_packing(buf, &cmd->index, 29, 20, 422 SJA1105ET_SIZE_L2_LOOKUP_ENTRY, op); 423 } 424 425 static size_t sja1105et_dyn_l2_lookup_entry_packing(void *buf, void *entry_ptr, 426 enum packing_op op) 427 { 428 struct sja1105_l2_lookup_entry *entry = entry_ptr; 429 u8 *cmd = buf + SJA1105ET_SIZE_L2_LOOKUP_ENTRY; 430 const int size = SJA1105_SIZE_DYN_CMD; 431 432 sja1105_packing(cmd, &entry->lockeds, 28, 28, size, op); 433 434 return sja1105et_l2_lookup_entry_packing(buf, entry_ptr, op); 435 } 436 437 static void 438 sja1105et_mgmt_route_cmd_packing(void *buf, struct sja1105_dyn_cmd *cmd, 439 enum packing_op op) 440 { 441 u8 *p = buf + SJA1105ET_SIZE_L2_LOOKUP_ENTRY; 442 u64 mgmtroute = 1; 443 444 sja1105et_l2_lookup_cmd_packing(buf, cmd, op); 445 if (op == PACK) 446 sja1105_pack(p, &mgmtroute, 26, 26, SJA1105_SIZE_DYN_CMD); 447 } 448 449 static size_t sja1105et_mgmt_route_entry_packing(void *buf, void *entry_ptr, 450 enum packing_op op) 451 { 452 struct sja1105_mgmt_entry *entry = entry_ptr; 453 const size_t size = SJA1105ET_SIZE_L2_LOOKUP_ENTRY; 454 455 /* UM10944: To specify if a PTP egress timestamp shall be captured on 456 * each port upon transmission of the frame, the LSB of VLANID in the 457 * ENTRY field provided by the host must be set. 458 * Bit 1 of VLANID then specifies the register where the timestamp for 459 * this port is stored in. 460 */ 461 sja1105_packing(buf, &entry->tsreg, 85, 85, size, op); 462 sja1105_packing(buf, &entry->takets, 84, 84, size, op); 463 sja1105_packing(buf, &entry->macaddr, 83, 36, size, op); 464 sja1105_packing(buf, &entry->destports, 35, 31, size, op); 465 sja1105_packing(buf, &entry->enfport, 30, 30, size, op); 466 return size; 467 } 468 469 static void 470 sja1105pqrs_mgmt_route_cmd_packing(void *buf, struct sja1105_dyn_cmd *cmd, 471 enum packing_op op) 472 { 473 u8 *p = buf + SJA1105PQRS_SIZE_L2_LOOKUP_ENTRY; 474 u64 mgmtroute = 1; 475 476 sja1105pqrs_l2_lookup_cmd_packing(buf, cmd, op); 477 if (op == PACK) 478 sja1105_pack(p, &mgmtroute, 26, 26, SJA1105_SIZE_DYN_CMD); 479 } 480 481 static size_t sja1105pqrs_mgmt_route_entry_packing(void *buf, void *entry_ptr, 482 enum packing_op op) 483 { 484 const size_t size = SJA1105PQRS_SIZE_L2_LOOKUP_ENTRY; 485 struct sja1105_mgmt_entry *entry = entry_ptr; 486 487 /* In P/Q/R/S, enfport got renamed to mgmtvalid, but its purpose 488 * is the same (driver uses it to confirm that frame was sent). 489 * So just keep the name from E/T. 490 */ 491 sja1105_packing(buf, &entry->tsreg, 71, 71, size, op); 492 sja1105_packing(buf, &entry->takets, 70, 70, size, op); 493 sja1105_packing(buf, &entry->macaddr, 69, 22, size, op); 494 sja1105_packing(buf, &entry->destports, 21, 17, size, op); 495 sja1105_packing(buf, &entry->enfport, 16, 16, size, op); 496 return size; 497 } 498 499 /* In E/T, entry is at addresses 0x27-0x28. There is a 4 byte gap at 0x29, 500 * and command is at 0x2a. Similarly in P/Q/R/S there is a 1 register gap 501 * between entry (0x2d, 0x2e) and command (0x30). 502 */ 503 static void 504 sja1105_vlan_lookup_cmd_packing(void *buf, struct sja1105_dyn_cmd *cmd, 505 enum packing_op op) 506 { 507 u8 *p = buf + SJA1105_SIZE_VLAN_LOOKUP_ENTRY + 4; 508 const int size = SJA1105_SIZE_DYN_CMD; 509 510 sja1105_packing(p, &cmd->valid, 31, 31, size, op); 511 sja1105_packing(p, &cmd->rdwrset, 30, 30, size, op); 512 sja1105_packing(p, &cmd->valident, 27, 27, size, op); 513 /* Hack - see comments above, applied for 'vlanid' field of 514 * struct sja1105_vlan_lookup_entry. 515 */ 516 sja1105_packing(buf, &cmd->index, 38, 27, 517 SJA1105_SIZE_VLAN_LOOKUP_ENTRY, op); 518 } 519 520 /* In SJA1110 there is no gap between the command and the data, yay... */ 521 static void 522 sja1110_vlan_lookup_cmd_packing(void *buf, struct sja1105_dyn_cmd *cmd, 523 enum packing_op op) 524 { 525 u8 *p = buf + SJA1110_SIZE_VLAN_LOOKUP_ENTRY; 526 const int size = SJA1105_SIZE_DYN_CMD; 527 u64 type_entry = 0; 528 529 sja1105_packing(p, &cmd->valid, 31, 31, size, op); 530 sja1105_packing(p, &cmd->rdwrset, 30, 30, size, op); 531 sja1105_packing(p, &cmd->errors, 29, 29, size, op); 532 /* Hack: treat 'vlanid' field of struct sja1105_vlan_lookup_entry as 533 * cmd->index. 534 */ 535 sja1105_packing(buf, &cmd->index, 38, 27, 536 SJA1110_SIZE_VLAN_LOOKUP_ENTRY, op); 537 538 /* But the VALIDENT bit has disappeared, now we are supposed to 539 * invalidate an entry through the TYPE_ENTRY field of the entry.. 540 * This is a hack to transform the non-zero quality of the TYPE_ENTRY 541 * field into a VALIDENT bit. 542 */ 543 if (op == PACK && !cmd->valident) { 544 sja1105_packing(buf, &type_entry, 40, 39, 545 SJA1110_SIZE_VLAN_LOOKUP_ENTRY, PACK); 546 } else if (op == UNPACK) { 547 sja1105_packing(buf, &type_entry, 40, 39, 548 SJA1110_SIZE_VLAN_LOOKUP_ENTRY, UNPACK); 549 cmd->valident = !!type_entry; 550 } 551 } 552 553 static void 554 sja1105_l2_forwarding_cmd_packing(void *buf, struct sja1105_dyn_cmd *cmd, 555 enum packing_op op) 556 { 557 u8 *p = buf + SJA1105_SIZE_L2_FORWARDING_ENTRY; 558 const int size = SJA1105_SIZE_DYN_CMD; 559 560 sja1105_packing(p, &cmd->valid, 31, 31, size, op); 561 sja1105_packing(p, &cmd->errors, 30, 30, size, op); 562 sja1105_packing(p, &cmd->rdwrset, 29, 29, size, op); 563 sja1105_packing(p, &cmd->index, 4, 0, size, op); 564 } 565 566 static void 567 sja1110_l2_forwarding_cmd_packing(void *buf, struct sja1105_dyn_cmd *cmd, 568 enum packing_op op) 569 { 570 u8 *p = buf + SJA1105_SIZE_L2_FORWARDING_ENTRY; 571 const int size = SJA1105_SIZE_DYN_CMD; 572 573 sja1105_packing(p, &cmd->valid, 31, 31, size, op); 574 sja1105_packing(p, &cmd->rdwrset, 30, 30, size, op); 575 sja1105_packing(p, &cmd->errors, 29, 29, size, op); 576 sja1105_packing(p, &cmd->index, 4, 0, size, op); 577 } 578 579 static void 580 sja1105et_mac_config_cmd_packing(void *buf, struct sja1105_dyn_cmd *cmd, 581 enum packing_op op) 582 { 583 const int size = SJA1105_SIZE_DYN_CMD; 584 /* Yup, user manual definitions are reversed */ 585 u8 *reg1 = buf + 4; 586 587 sja1105_packing(reg1, &cmd->valid, 31, 31, size, op); 588 sja1105_packing(reg1, &cmd->index, 26, 24, size, op); 589 } 590 591 static size_t sja1105et_mac_config_entry_packing(void *buf, void *entry_ptr, 592 enum packing_op op) 593 { 594 const int size = SJA1105ET_SIZE_MAC_CONFIG_DYN_ENTRY; 595 struct sja1105_mac_config_entry *entry = entry_ptr; 596 /* Yup, user manual definitions are reversed */ 597 u8 *reg1 = buf + 4; 598 u8 *reg2 = buf; 599 600 sja1105_packing(reg1, &entry->speed, 30, 29, size, op); 601 sja1105_packing(reg1, &entry->drpdtag, 23, 23, size, op); 602 sja1105_packing(reg1, &entry->drpuntag, 22, 22, size, op); 603 sja1105_packing(reg1, &entry->retag, 21, 21, size, op); 604 sja1105_packing(reg1, &entry->dyn_learn, 20, 20, size, op); 605 sja1105_packing(reg1, &entry->egress, 19, 19, size, op); 606 sja1105_packing(reg1, &entry->ingress, 18, 18, size, op); 607 sja1105_packing(reg1, &entry->ing_mirr, 17, 17, size, op); 608 sja1105_packing(reg1, &entry->egr_mirr, 16, 16, size, op); 609 sja1105_packing(reg1, &entry->vlanprio, 14, 12, size, op); 610 sja1105_packing(reg1, &entry->vlanid, 11, 0, size, op); 611 sja1105_packing(reg2, &entry->tp_delin, 31, 16, size, op); 612 sja1105_packing(reg2, &entry->tp_delout, 15, 0, size, op); 613 /* MAC configuration table entries which can't be reconfigured: 614 * top, base, enabled, ifg, maxage, drpnona664 615 */ 616 /* Bogus return value, not used anywhere */ 617 return 0; 618 } 619 620 static void 621 sja1105pqrs_mac_config_cmd_packing(void *buf, struct sja1105_dyn_cmd *cmd, 622 enum packing_op op) 623 { 624 const int size = SJA1105ET_SIZE_MAC_CONFIG_DYN_ENTRY; 625 u8 *p = buf + SJA1105PQRS_SIZE_MAC_CONFIG_ENTRY; 626 627 sja1105_packing(p, &cmd->valid, 31, 31, size, op); 628 sja1105_packing(p, &cmd->errors, 30, 30, size, op); 629 sja1105_packing(p, &cmd->rdwrset, 29, 29, size, op); 630 sja1105_packing(p, &cmd->index, 2, 0, size, op); 631 } 632 633 static void 634 sja1110_mac_config_cmd_packing(void *buf, struct sja1105_dyn_cmd *cmd, 635 enum packing_op op) 636 { 637 u8 *p = buf + SJA1105PQRS_SIZE_MAC_CONFIG_ENTRY; 638 const int size = SJA1105_SIZE_DYN_CMD; 639 640 sja1105_packing(p, &cmd->valid, 31, 31, size, op); 641 sja1105_packing(p, &cmd->rdwrset, 30, 30, size, op); 642 sja1105_packing(p, &cmd->errors, 29, 29, size, op); 643 sja1105_packing(p, &cmd->index, 3, 0, size, op); 644 } 645 646 static void 647 sja1105et_l2_lookup_params_cmd_packing(void *buf, struct sja1105_dyn_cmd *cmd, 648 enum packing_op op) 649 { 650 sja1105_packing(buf, &cmd->valid, 31, 31, 651 SJA1105ET_SIZE_L2_LOOKUP_PARAMS_DYN_CMD, op); 652 } 653 654 static size_t 655 sja1105et_l2_lookup_params_entry_packing(void *buf, void *entry_ptr, 656 enum packing_op op) 657 { 658 struct sja1105_l2_lookup_params_entry *entry = entry_ptr; 659 660 sja1105_packing(buf, &entry->poly, 7, 0, 661 SJA1105ET_SIZE_L2_LOOKUP_PARAMS_DYN_CMD, op); 662 /* Bogus return value, not used anywhere */ 663 return 0; 664 } 665 666 static void 667 sja1105pqrs_l2_lookup_params_cmd_packing(void *buf, 668 struct sja1105_dyn_cmd *cmd, 669 enum packing_op op) 670 { 671 u8 *p = buf + SJA1105PQRS_SIZE_L2_LOOKUP_PARAMS_ENTRY; 672 const int size = SJA1105_SIZE_DYN_CMD; 673 674 sja1105_packing(p, &cmd->valid, 31, 31, size, op); 675 sja1105_packing(p, &cmd->rdwrset, 30, 30, size, op); 676 } 677 678 static void 679 sja1110_l2_lookup_params_cmd_packing(void *buf, struct sja1105_dyn_cmd *cmd, 680 enum packing_op op) 681 { 682 u8 *p = buf + SJA1110_SIZE_L2_LOOKUP_PARAMS_ENTRY; 683 const int size = SJA1105_SIZE_DYN_CMD; 684 685 sja1105_packing(p, &cmd->valid, 31, 31, size, op); 686 sja1105_packing(p, &cmd->rdwrset, 30, 30, size, op); 687 sja1105_packing(p, &cmd->errors, 29, 29, size, op); 688 } 689 690 static void 691 sja1105et_general_params_cmd_packing(void *buf, struct sja1105_dyn_cmd *cmd, 692 enum packing_op op) 693 { 694 const int size = SJA1105ET_SIZE_GENERAL_PARAMS_DYN_CMD; 695 696 sja1105_packing(buf, &cmd->valid, 31, 31, size, op); 697 sja1105_packing(buf, &cmd->errors, 30, 30, size, op); 698 } 699 700 static size_t 701 sja1105et_general_params_entry_packing(void *buf, void *entry_ptr, 702 enum packing_op op) 703 { 704 struct sja1105_general_params_entry *entry = entry_ptr; 705 const int size = SJA1105ET_SIZE_GENERAL_PARAMS_DYN_CMD; 706 707 sja1105_packing(buf, &entry->mirr_port, 2, 0, size, op); 708 /* Bogus return value, not used anywhere */ 709 return 0; 710 } 711 712 static void 713 sja1105pqrs_general_params_cmd_packing(void *buf, struct sja1105_dyn_cmd *cmd, 714 enum packing_op op) 715 { 716 u8 *p = buf + SJA1105PQRS_SIZE_GENERAL_PARAMS_ENTRY; 717 const int size = SJA1105_SIZE_DYN_CMD; 718 719 sja1105_packing(p, &cmd->valid, 31, 31, size, op); 720 sja1105_packing(p, &cmd->errors, 30, 30, size, op); 721 sja1105_packing(p, &cmd->rdwrset, 28, 28, size, op); 722 } 723 724 static void 725 sja1110_general_params_cmd_packing(void *buf, struct sja1105_dyn_cmd *cmd, 726 enum packing_op op) 727 { 728 u8 *p = buf + SJA1110_SIZE_GENERAL_PARAMS_ENTRY; 729 const int size = SJA1105_SIZE_DYN_CMD; 730 731 sja1105_packing(p, &cmd->valid, 31, 31, size, op); 732 sja1105_packing(p, &cmd->rdwrset, 30, 30, size, op); 733 sja1105_packing(p, &cmd->errors, 29, 29, size, op); 734 } 735 736 static void 737 sja1105pqrs_avb_params_cmd_packing(void *buf, struct sja1105_dyn_cmd *cmd, 738 enum packing_op op) 739 { 740 u8 *p = buf + SJA1105PQRS_SIZE_AVB_PARAMS_ENTRY; 741 const int size = SJA1105_SIZE_DYN_CMD; 742 743 sja1105_packing(p, &cmd->valid, 31, 31, size, op); 744 sja1105_packing(p, &cmd->errors, 30, 30, size, op); 745 sja1105_packing(p, &cmd->rdwrset, 29, 29, size, op); 746 } 747 748 static void 749 sja1105_retagging_cmd_packing(void *buf, struct sja1105_dyn_cmd *cmd, 750 enum packing_op op) 751 { 752 u8 *p = buf + SJA1105_SIZE_RETAGGING_ENTRY; 753 const int size = SJA1105_SIZE_DYN_CMD; 754 755 sja1105_packing(p, &cmd->valid, 31, 31, size, op); 756 sja1105_packing(p, &cmd->errors, 30, 30, size, op); 757 sja1105_packing(p, &cmd->valident, 29, 29, size, op); 758 sja1105_packing(p, &cmd->rdwrset, 28, 28, size, op); 759 sja1105_packing(p, &cmd->index, 5, 0, size, op); 760 } 761 762 static void 763 sja1110_retagging_cmd_packing(void *buf, struct sja1105_dyn_cmd *cmd, 764 enum packing_op op) 765 { 766 u8 *p = buf + SJA1105_SIZE_RETAGGING_ENTRY; 767 const int size = SJA1105_SIZE_DYN_CMD; 768 769 sja1105_packing(p, &cmd->valid, 31, 31, size, op); 770 sja1105_packing(p, &cmd->rdwrset, 30, 30, size, op); 771 sja1105_packing(p, &cmd->errors, 29, 29, size, op); 772 sja1105_packing(p, &cmd->valident, 28, 28, size, op); 773 sja1105_packing(p, &cmd->index, 4, 0, size, op); 774 } 775 776 static void sja1105et_cbs_cmd_packing(void *buf, struct sja1105_dyn_cmd *cmd, 777 enum packing_op op) 778 { 779 u8 *p = buf + SJA1105ET_SIZE_CBS_ENTRY; 780 const int size = SJA1105_SIZE_DYN_CMD; 781 782 sja1105_packing(p, &cmd->valid, 31, 31, size, op); 783 sja1105_packing(p, &cmd->index, 19, 16, size, op); 784 } 785 786 static size_t sja1105et_cbs_entry_packing(void *buf, void *entry_ptr, 787 enum packing_op op) 788 { 789 const size_t size = SJA1105ET_SIZE_CBS_ENTRY; 790 struct sja1105_cbs_entry *entry = entry_ptr; 791 u8 *cmd = buf + size; 792 u32 *p = buf; 793 794 sja1105_packing(cmd, &entry->port, 5, 3, SJA1105_SIZE_DYN_CMD, op); 795 sja1105_packing(cmd, &entry->prio, 2, 0, SJA1105_SIZE_DYN_CMD, op); 796 sja1105_packing(p + 3, &entry->credit_lo, 31, 0, size, op); 797 sja1105_packing(p + 2, &entry->credit_hi, 31, 0, size, op); 798 sja1105_packing(p + 1, &entry->send_slope, 31, 0, size, op); 799 sja1105_packing(p + 0, &entry->idle_slope, 31, 0, size, op); 800 return size; 801 } 802 803 static void sja1105pqrs_cbs_cmd_packing(void *buf, struct sja1105_dyn_cmd *cmd, 804 enum packing_op op) 805 { 806 u8 *p = buf + SJA1105PQRS_SIZE_CBS_ENTRY; 807 const int size = SJA1105_SIZE_DYN_CMD; 808 809 sja1105_packing(p, &cmd->valid, 31, 31, size, op); 810 sja1105_packing(p, &cmd->rdwrset, 30, 30, size, op); 811 sja1105_packing(p, &cmd->errors, 29, 29, size, op); 812 sja1105_packing(p, &cmd->index, 3, 0, size, op); 813 } 814 815 static void sja1110_cbs_cmd_packing(void *buf, struct sja1105_dyn_cmd *cmd, 816 enum packing_op op) 817 { 818 u8 *p = buf + SJA1105PQRS_SIZE_CBS_ENTRY; 819 const int size = SJA1105_SIZE_DYN_CMD; 820 821 sja1105_packing(p, &cmd->valid, 31, 31, size, op); 822 sja1105_packing(p, &cmd->rdwrset, 30, 30, size, op); 823 sja1105_packing(p, &cmd->errors, 29, 29, size, op); 824 sja1105_packing(p, &cmd->index, 7, 0, size, op); 825 } 826 827 static size_t sja1105pqrs_cbs_entry_packing(void *buf, void *entry_ptr, 828 enum packing_op op) 829 { 830 const size_t size = SJA1105PQRS_SIZE_CBS_ENTRY; 831 struct sja1105_cbs_entry *entry = entry_ptr; 832 833 sja1105_packing(buf, &entry->port, 159, 157, size, op); 834 sja1105_packing(buf, &entry->prio, 156, 154, size, op); 835 sja1105_packing(buf, &entry->credit_lo, 153, 122, size, op); 836 sja1105_packing(buf, &entry->credit_hi, 121, 90, size, op); 837 sja1105_packing(buf, &entry->send_slope, 89, 58, size, op); 838 sja1105_packing(buf, &entry->idle_slope, 57, 26, size, op); 839 return size; 840 } 841 842 static size_t sja1110_cbs_entry_packing(void *buf, void *entry_ptr, 843 enum packing_op op) 844 { 845 const size_t size = SJA1105PQRS_SIZE_CBS_ENTRY; 846 struct sja1105_cbs_entry *entry = entry_ptr; 847 u64 entry_type = SJA1110_CBS_SHAPER; 848 849 sja1105_packing(buf, &entry_type, 159, 159, size, op); 850 sja1105_packing(buf, &entry->credit_lo, 151, 120, size, op); 851 sja1105_packing(buf, &entry->credit_hi, 119, 88, size, op); 852 sja1105_packing(buf, &entry->send_slope, 87, 56, size, op); 853 sja1105_packing(buf, &entry->idle_slope, 55, 24, size, op); 854 return size; 855 } 856 857 static void sja1110_dummy_cmd_packing(void *buf, struct sja1105_dyn_cmd *cmd, 858 enum packing_op op) 859 { 860 } 861 862 static void 863 sja1110_l2_policing_cmd_packing(void *buf, struct sja1105_dyn_cmd *cmd, 864 enum packing_op op) 865 { 866 u8 *p = buf + SJA1105_SIZE_L2_POLICING_ENTRY; 867 const int size = SJA1105_SIZE_DYN_CMD; 868 869 sja1105_packing(p, &cmd->valid, 31, 31, size, op); 870 sja1105_packing(p, &cmd->rdwrset, 30, 30, size, op); 871 sja1105_packing(p, &cmd->errors, 29, 29, size, op); 872 sja1105_packing(p, &cmd->index, 6, 0, size, op); 873 } 874 875 #define OP_READ BIT(0) 876 #define OP_WRITE BIT(1) 877 #define OP_DEL BIT(2) 878 #define OP_SEARCH BIT(3) 879 #define OP_VALID_ANYWAY BIT(4) 880 881 /* SJA1105E/T: First generation */ 882 const struct sja1105_dynamic_table_ops sja1105et_dyn_ops[BLK_IDX_MAX_DYN] = { 883 [BLK_IDX_VL_LOOKUP] = { 884 .entry_packing = sja1105et_vl_lookup_entry_packing, 885 .cmd_packing = sja1105et_vl_lookup_cmd_packing, 886 .access = OP_WRITE, 887 .max_entry_count = SJA1105_MAX_VL_LOOKUP_COUNT, 888 .packed_size = SJA1105ET_SIZE_VL_LOOKUP_DYN_CMD, 889 .addr = 0x35, 890 }, 891 [BLK_IDX_L2_LOOKUP] = { 892 .entry_packing = sja1105et_dyn_l2_lookup_entry_packing, 893 .cmd_packing = sja1105et_l2_lookup_cmd_packing, 894 .access = (OP_READ | OP_WRITE | OP_DEL), 895 .max_entry_count = SJA1105_MAX_L2_LOOKUP_COUNT, 896 .packed_size = SJA1105ET_SIZE_L2_LOOKUP_DYN_CMD, 897 .addr = 0x20, 898 }, 899 [BLK_IDX_MGMT_ROUTE] = { 900 .entry_packing = sja1105et_mgmt_route_entry_packing, 901 .cmd_packing = sja1105et_mgmt_route_cmd_packing, 902 .access = (OP_READ | OP_WRITE | OP_VALID_ANYWAY), 903 .max_entry_count = SJA1105_NUM_PORTS, 904 .packed_size = SJA1105ET_SIZE_L2_LOOKUP_DYN_CMD, 905 .addr = 0x20, 906 }, 907 [BLK_IDX_VLAN_LOOKUP] = { 908 .entry_packing = sja1105_vlan_lookup_entry_packing, 909 .cmd_packing = sja1105_vlan_lookup_cmd_packing, 910 .access = (OP_WRITE | OP_DEL), 911 .max_entry_count = SJA1105_MAX_VLAN_LOOKUP_COUNT, 912 .packed_size = SJA1105_SIZE_VLAN_LOOKUP_DYN_CMD, 913 .addr = 0x27, 914 }, 915 [BLK_IDX_L2_FORWARDING] = { 916 .entry_packing = sja1105_l2_forwarding_entry_packing, 917 .cmd_packing = sja1105_l2_forwarding_cmd_packing, 918 .max_entry_count = SJA1105_MAX_L2_FORWARDING_COUNT, 919 .access = OP_WRITE, 920 .packed_size = SJA1105_SIZE_L2_FORWARDING_DYN_CMD, 921 .addr = 0x24, 922 }, 923 [BLK_IDX_MAC_CONFIG] = { 924 .entry_packing = sja1105et_mac_config_entry_packing, 925 .cmd_packing = sja1105et_mac_config_cmd_packing, 926 .max_entry_count = SJA1105_MAX_MAC_CONFIG_COUNT, 927 .access = OP_WRITE, 928 .packed_size = SJA1105ET_SIZE_MAC_CONFIG_DYN_CMD, 929 .addr = 0x36, 930 }, 931 [BLK_IDX_L2_LOOKUP_PARAMS] = { 932 .entry_packing = sja1105et_l2_lookup_params_entry_packing, 933 .cmd_packing = sja1105et_l2_lookup_params_cmd_packing, 934 .max_entry_count = SJA1105_MAX_L2_LOOKUP_PARAMS_COUNT, 935 .access = OP_WRITE, 936 .packed_size = SJA1105ET_SIZE_L2_LOOKUP_PARAMS_DYN_CMD, 937 .addr = 0x38, 938 }, 939 [BLK_IDX_GENERAL_PARAMS] = { 940 .entry_packing = sja1105et_general_params_entry_packing, 941 .cmd_packing = sja1105et_general_params_cmd_packing, 942 .max_entry_count = SJA1105_MAX_GENERAL_PARAMS_COUNT, 943 .access = OP_WRITE, 944 .packed_size = SJA1105ET_SIZE_GENERAL_PARAMS_DYN_CMD, 945 .addr = 0x34, 946 }, 947 [BLK_IDX_RETAGGING] = { 948 .entry_packing = sja1105_retagging_entry_packing, 949 .cmd_packing = sja1105_retagging_cmd_packing, 950 .max_entry_count = SJA1105_MAX_RETAGGING_COUNT, 951 .access = (OP_WRITE | OP_DEL), 952 .packed_size = SJA1105_SIZE_RETAGGING_DYN_CMD, 953 .addr = 0x31, 954 }, 955 [BLK_IDX_CBS] = { 956 .entry_packing = sja1105et_cbs_entry_packing, 957 .cmd_packing = sja1105et_cbs_cmd_packing, 958 .max_entry_count = SJA1105ET_MAX_CBS_COUNT, 959 .access = OP_WRITE, 960 .packed_size = SJA1105ET_SIZE_CBS_DYN_CMD, 961 .addr = 0x2c, 962 }, 963 }; 964 965 /* SJA1105P/Q/R/S: Second generation */ 966 const struct sja1105_dynamic_table_ops sja1105pqrs_dyn_ops[BLK_IDX_MAX_DYN] = { 967 [BLK_IDX_VL_LOOKUP] = { 968 .entry_packing = sja1105_vl_lookup_entry_packing, 969 .cmd_packing = sja1105pqrs_vl_lookup_cmd_packing, 970 .access = (OP_READ | OP_WRITE), 971 .max_entry_count = SJA1105_MAX_VL_LOOKUP_COUNT, 972 .packed_size = SJA1105PQRS_SIZE_VL_LOOKUP_DYN_CMD, 973 .addr = 0x47, 974 }, 975 [BLK_IDX_L2_LOOKUP] = { 976 .entry_packing = sja1105pqrs_dyn_l2_lookup_entry_packing, 977 .cmd_packing = sja1105pqrs_l2_lookup_cmd_packing, 978 .access = (OP_READ | OP_WRITE | OP_DEL | OP_SEARCH), 979 .max_entry_count = SJA1105_MAX_L2_LOOKUP_COUNT, 980 .packed_size = SJA1105PQRS_SIZE_L2_LOOKUP_DYN_CMD, 981 .addr = 0x24, 982 }, 983 [BLK_IDX_MGMT_ROUTE] = { 984 .entry_packing = sja1105pqrs_mgmt_route_entry_packing, 985 .cmd_packing = sja1105pqrs_mgmt_route_cmd_packing, 986 .access = (OP_READ | OP_WRITE | OP_DEL | OP_SEARCH | OP_VALID_ANYWAY), 987 .max_entry_count = SJA1105_NUM_PORTS, 988 .packed_size = SJA1105PQRS_SIZE_L2_LOOKUP_DYN_CMD, 989 .addr = 0x24, 990 }, 991 [BLK_IDX_VLAN_LOOKUP] = { 992 .entry_packing = sja1105_vlan_lookup_entry_packing, 993 .cmd_packing = sja1105_vlan_lookup_cmd_packing, 994 .access = (OP_READ | OP_WRITE | OP_DEL), 995 .max_entry_count = SJA1105_MAX_VLAN_LOOKUP_COUNT, 996 .packed_size = SJA1105_SIZE_VLAN_LOOKUP_DYN_CMD, 997 .addr = 0x2D, 998 }, 999 [BLK_IDX_L2_FORWARDING] = { 1000 .entry_packing = sja1105_l2_forwarding_entry_packing, 1001 .cmd_packing = sja1105_l2_forwarding_cmd_packing, 1002 .max_entry_count = SJA1105_MAX_L2_FORWARDING_COUNT, 1003 .access = OP_WRITE, 1004 .packed_size = SJA1105_SIZE_L2_FORWARDING_DYN_CMD, 1005 .addr = 0x2A, 1006 }, 1007 [BLK_IDX_MAC_CONFIG] = { 1008 .entry_packing = sja1105pqrs_mac_config_entry_packing, 1009 .cmd_packing = sja1105pqrs_mac_config_cmd_packing, 1010 .max_entry_count = SJA1105_MAX_MAC_CONFIG_COUNT, 1011 .access = (OP_READ | OP_WRITE), 1012 .packed_size = SJA1105PQRS_SIZE_MAC_CONFIG_DYN_CMD, 1013 .addr = 0x4B, 1014 }, 1015 [BLK_IDX_L2_LOOKUP_PARAMS] = { 1016 .entry_packing = sja1105pqrs_l2_lookup_params_entry_packing, 1017 .cmd_packing = sja1105pqrs_l2_lookup_params_cmd_packing, 1018 .max_entry_count = SJA1105_MAX_L2_LOOKUP_PARAMS_COUNT, 1019 .access = (OP_READ | OP_WRITE), 1020 .packed_size = SJA1105PQRS_SIZE_L2_LOOKUP_PARAMS_DYN_CMD, 1021 .addr = 0x54, 1022 }, 1023 [BLK_IDX_AVB_PARAMS] = { 1024 .entry_packing = sja1105pqrs_avb_params_entry_packing, 1025 .cmd_packing = sja1105pqrs_avb_params_cmd_packing, 1026 .max_entry_count = SJA1105_MAX_AVB_PARAMS_COUNT, 1027 .access = (OP_READ | OP_WRITE), 1028 .packed_size = SJA1105PQRS_SIZE_AVB_PARAMS_DYN_CMD, 1029 .addr = 0x8003, 1030 }, 1031 [BLK_IDX_GENERAL_PARAMS] = { 1032 .entry_packing = sja1105pqrs_general_params_entry_packing, 1033 .cmd_packing = sja1105pqrs_general_params_cmd_packing, 1034 .max_entry_count = SJA1105_MAX_GENERAL_PARAMS_COUNT, 1035 .access = (OP_READ | OP_WRITE), 1036 .packed_size = SJA1105PQRS_SIZE_GENERAL_PARAMS_DYN_CMD, 1037 .addr = 0x3B, 1038 }, 1039 [BLK_IDX_RETAGGING] = { 1040 .entry_packing = sja1105_retagging_entry_packing, 1041 .cmd_packing = sja1105_retagging_cmd_packing, 1042 .max_entry_count = SJA1105_MAX_RETAGGING_COUNT, 1043 .access = (OP_READ | OP_WRITE | OP_DEL), 1044 .packed_size = SJA1105_SIZE_RETAGGING_DYN_CMD, 1045 .addr = 0x38, 1046 }, 1047 [BLK_IDX_CBS] = { 1048 .entry_packing = sja1105pqrs_cbs_entry_packing, 1049 .cmd_packing = sja1105pqrs_cbs_cmd_packing, 1050 .max_entry_count = SJA1105PQRS_MAX_CBS_COUNT, 1051 .access = OP_WRITE, 1052 .packed_size = SJA1105PQRS_SIZE_CBS_DYN_CMD, 1053 .addr = 0x32, 1054 }, 1055 }; 1056 1057 /* SJA1110: Third generation */ 1058 const struct sja1105_dynamic_table_ops sja1110_dyn_ops[BLK_IDX_MAX_DYN] = { 1059 [BLK_IDX_VL_LOOKUP] = { 1060 .entry_packing = sja1110_vl_lookup_entry_packing, 1061 .cmd_packing = sja1110_vl_lookup_cmd_packing, 1062 .access = (OP_READ | OP_WRITE | OP_VALID_ANYWAY), 1063 .max_entry_count = SJA1110_MAX_VL_LOOKUP_COUNT, 1064 .packed_size = SJA1105PQRS_SIZE_VL_LOOKUP_DYN_CMD, 1065 .addr = SJA1110_SPI_ADDR(0x124), 1066 }, 1067 [BLK_IDX_VL_POLICING] = { 1068 .entry_packing = sja1110_vl_policing_entry_packing, 1069 .cmd_packing = sja1110_vl_policing_cmd_packing, 1070 .access = (OP_READ | OP_WRITE | OP_VALID_ANYWAY), 1071 .max_entry_count = SJA1110_MAX_VL_POLICING_COUNT, 1072 .packed_size = SJA1110_SIZE_VL_POLICING_DYN_CMD, 1073 .addr = SJA1110_SPI_ADDR(0x310), 1074 }, 1075 [BLK_IDX_L2_LOOKUP] = { 1076 .entry_packing = sja1110_dyn_l2_lookup_entry_packing, 1077 .cmd_packing = sja1110_l2_lookup_cmd_packing, 1078 .access = (OP_READ | OP_WRITE | OP_DEL | OP_SEARCH), 1079 .max_entry_count = SJA1105_MAX_L2_LOOKUP_COUNT, 1080 .packed_size = SJA1110_SIZE_L2_LOOKUP_DYN_CMD, 1081 .addr = SJA1110_SPI_ADDR(0x8c), 1082 }, 1083 [BLK_IDX_VLAN_LOOKUP] = { 1084 .entry_packing = sja1110_vlan_lookup_entry_packing, 1085 .cmd_packing = sja1110_vlan_lookup_cmd_packing, 1086 .access = (OP_READ | OP_WRITE | OP_DEL), 1087 .max_entry_count = SJA1105_MAX_VLAN_LOOKUP_COUNT, 1088 .packed_size = SJA1110_SIZE_VLAN_LOOKUP_DYN_CMD, 1089 .addr = SJA1110_SPI_ADDR(0xb4), 1090 }, 1091 [BLK_IDX_L2_FORWARDING] = { 1092 .entry_packing = sja1110_l2_forwarding_entry_packing, 1093 .cmd_packing = sja1110_l2_forwarding_cmd_packing, 1094 .max_entry_count = SJA1110_MAX_L2_FORWARDING_COUNT, 1095 .access = (OP_READ | OP_WRITE | OP_VALID_ANYWAY), 1096 .packed_size = SJA1105_SIZE_L2_FORWARDING_DYN_CMD, 1097 .addr = SJA1110_SPI_ADDR(0xa8), 1098 }, 1099 [BLK_IDX_MAC_CONFIG] = { 1100 .entry_packing = sja1110_mac_config_entry_packing, 1101 .cmd_packing = sja1110_mac_config_cmd_packing, 1102 .max_entry_count = SJA1110_MAX_MAC_CONFIG_COUNT, 1103 .access = (OP_READ | OP_WRITE | OP_VALID_ANYWAY), 1104 .packed_size = SJA1105PQRS_SIZE_MAC_CONFIG_DYN_CMD, 1105 .addr = SJA1110_SPI_ADDR(0x134), 1106 }, 1107 [BLK_IDX_L2_LOOKUP_PARAMS] = { 1108 .entry_packing = sja1110_l2_lookup_params_entry_packing, 1109 .cmd_packing = sja1110_l2_lookup_params_cmd_packing, 1110 .max_entry_count = SJA1105_MAX_L2_LOOKUP_PARAMS_COUNT, 1111 .access = (OP_READ | OP_WRITE | OP_VALID_ANYWAY), 1112 .packed_size = SJA1110_SIZE_L2_LOOKUP_PARAMS_DYN_CMD, 1113 .addr = SJA1110_SPI_ADDR(0x158), 1114 }, 1115 [BLK_IDX_AVB_PARAMS] = { 1116 .entry_packing = sja1105pqrs_avb_params_entry_packing, 1117 .cmd_packing = sja1105pqrs_avb_params_cmd_packing, 1118 .max_entry_count = SJA1105_MAX_AVB_PARAMS_COUNT, 1119 .access = (OP_READ | OP_WRITE | OP_VALID_ANYWAY), 1120 .packed_size = SJA1105PQRS_SIZE_AVB_PARAMS_DYN_CMD, 1121 .addr = SJA1110_SPI_ADDR(0x2000C), 1122 }, 1123 [BLK_IDX_GENERAL_PARAMS] = { 1124 .entry_packing = sja1110_general_params_entry_packing, 1125 .cmd_packing = sja1110_general_params_cmd_packing, 1126 .max_entry_count = SJA1105_MAX_GENERAL_PARAMS_COUNT, 1127 .access = (OP_READ | OP_WRITE | OP_VALID_ANYWAY), 1128 .packed_size = SJA1110_SIZE_GENERAL_PARAMS_DYN_CMD, 1129 .addr = SJA1110_SPI_ADDR(0xe8), 1130 }, 1131 [BLK_IDX_RETAGGING] = { 1132 .entry_packing = sja1110_retagging_entry_packing, 1133 .cmd_packing = sja1110_retagging_cmd_packing, 1134 .max_entry_count = SJA1105_MAX_RETAGGING_COUNT, 1135 .access = (OP_READ | OP_WRITE | OP_DEL), 1136 .packed_size = SJA1105_SIZE_RETAGGING_DYN_CMD, 1137 .addr = SJA1110_SPI_ADDR(0xdc), 1138 }, 1139 [BLK_IDX_CBS] = { 1140 .entry_packing = sja1110_cbs_entry_packing, 1141 .cmd_packing = sja1110_cbs_cmd_packing, 1142 .max_entry_count = SJA1110_MAX_CBS_COUNT, 1143 .access = (OP_READ | OP_WRITE | OP_VALID_ANYWAY), 1144 .packed_size = SJA1105PQRS_SIZE_CBS_DYN_CMD, 1145 .addr = SJA1110_SPI_ADDR(0xc4), 1146 }, 1147 [BLK_IDX_XMII_PARAMS] = { 1148 .entry_packing = sja1110_xmii_params_entry_packing, 1149 .cmd_packing = sja1110_dummy_cmd_packing, 1150 .max_entry_count = SJA1105_MAX_XMII_PARAMS_COUNT, 1151 .access = (OP_READ | OP_VALID_ANYWAY), 1152 .packed_size = SJA1110_SIZE_XMII_PARAMS_DYN_CMD, 1153 .addr = SJA1110_SPI_ADDR(0x3c), 1154 }, 1155 [BLK_IDX_L2_POLICING] = { 1156 .entry_packing = sja1110_l2_policing_entry_packing, 1157 .cmd_packing = sja1110_l2_policing_cmd_packing, 1158 .max_entry_count = SJA1110_MAX_L2_POLICING_COUNT, 1159 .access = (OP_READ | OP_WRITE | OP_VALID_ANYWAY), 1160 .packed_size = SJA1110_SIZE_L2_POLICING_DYN_CMD, 1161 .addr = SJA1110_SPI_ADDR(0x2fc), 1162 }, 1163 [BLK_IDX_L2_FORWARDING_PARAMS] = { 1164 .entry_packing = sja1110_l2_forwarding_params_entry_packing, 1165 .cmd_packing = sja1110_dummy_cmd_packing, 1166 .max_entry_count = SJA1105_MAX_L2_FORWARDING_PARAMS_COUNT, 1167 .access = (OP_READ | OP_VALID_ANYWAY), 1168 .packed_size = SJA1110_SIZE_L2_FORWARDING_PARAMS_DYN_CMD, 1169 .addr = SJA1110_SPI_ADDR(0x20000), 1170 }, 1171 }; 1172 1173 #define SJA1105_DYNAMIC_CONFIG_SLEEP_US 10 1174 #define SJA1105_DYNAMIC_CONFIG_TIMEOUT_US 100000 1175 1176 static int 1177 sja1105_dynamic_config_poll_valid(struct sja1105_private *priv, 1178 struct sja1105_dyn_cmd *cmd, 1179 const struct sja1105_dynamic_table_ops *ops) 1180 { 1181 u8 packed_buf[SJA1105_MAX_DYN_CMD_SIZE] = {}; 1182 int rc; 1183 1184 /* We don't _need_ to read the full entry, just the command area which 1185 * is a fixed SJA1105_SIZE_DYN_CMD. But our cmd_packing() API expects a 1186 * buffer that contains the full entry too. Additionally, our API 1187 * doesn't really know how many bytes into the buffer does the command 1188 * area really begin. So just read back the whole entry. 1189 */ 1190 rc = sja1105_xfer_buf(priv, SPI_READ, ops->addr, packed_buf, 1191 ops->packed_size); 1192 if (rc) 1193 return rc; 1194 1195 /* Unpack the command structure, and return it to the caller in case it 1196 * needs to perform further checks on it (VALIDENT). 1197 */ 1198 memset(cmd, 0, sizeof(*cmd)); 1199 ops->cmd_packing(packed_buf, cmd, UNPACK); 1200 1201 /* Hardware hasn't cleared VALID => still working on it */ 1202 return cmd->valid ? -EAGAIN : 0; 1203 } 1204 1205 /* Poll the dynamic config entry's control area until the hardware has 1206 * cleared the VALID bit, which means we have confirmation that it has 1207 * finished processing the command. 1208 */ 1209 static int 1210 sja1105_dynamic_config_wait_complete(struct sja1105_private *priv, 1211 struct sja1105_dyn_cmd *cmd, 1212 const struct sja1105_dynamic_table_ops *ops) 1213 { 1214 int rc; 1215 1216 return read_poll_timeout(sja1105_dynamic_config_poll_valid, 1217 rc, rc != -EAGAIN, 1218 SJA1105_DYNAMIC_CONFIG_SLEEP_US, 1219 SJA1105_DYNAMIC_CONFIG_TIMEOUT_US, 1220 false, priv, cmd, ops); 1221 } 1222 1223 /* Provides read access to the settings through the dynamic interface 1224 * of the switch. 1225 * @blk_idx is used as key to select from the sja1105_dynamic_table_ops. 1226 * The selection is limited by the hardware in respect to which 1227 * configuration blocks can be read through the dynamic interface. 1228 * @index is used to retrieve a particular table entry. If negative, 1229 * (and if the @blk_idx supports the searching operation) a search 1230 * is performed by the @entry parameter. 1231 * @entry Type-casted to an unpacked structure that holds a table entry 1232 * of the type specified in @blk_idx. 1233 * Usually an output argument. If @index is negative, then this 1234 * argument is used as input/output: it should be pre-populated 1235 * with the element to search for. Entries which support the 1236 * search operation will have an "index" field (not the @index 1237 * argument to this function) and that is where the found index 1238 * will be returned (or left unmodified - thus negative - if not 1239 * found). 1240 */ 1241 int sja1105_dynamic_config_read(struct sja1105_private *priv, 1242 enum sja1105_blk_idx blk_idx, 1243 int index, void *entry) 1244 { 1245 const struct sja1105_dynamic_table_ops *ops; 1246 struct sja1105_dyn_cmd cmd = {0}; 1247 /* SPI payload buffer */ 1248 u8 packed_buf[SJA1105_MAX_DYN_CMD_SIZE] = {0}; 1249 int rc; 1250 1251 if (blk_idx >= BLK_IDX_MAX_DYN) 1252 return -ERANGE; 1253 1254 ops = &priv->info->dyn_ops[blk_idx]; 1255 1256 if (index >= 0 && index >= ops->max_entry_count) 1257 return -ERANGE; 1258 if (index < 0 && !(ops->access & OP_SEARCH)) 1259 return -EOPNOTSUPP; 1260 if (!(ops->access & OP_READ)) 1261 return -EOPNOTSUPP; 1262 if (ops->packed_size > SJA1105_MAX_DYN_CMD_SIZE) 1263 return -ERANGE; 1264 if (!ops->cmd_packing) 1265 return -EOPNOTSUPP; 1266 if (!ops->entry_packing) 1267 return -EOPNOTSUPP; 1268 1269 cmd.valid = true; /* Trigger action on table entry */ 1270 cmd.rdwrset = SPI_READ; /* Action is read */ 1271 if (index < 0) { 1272 /* Avoid copying a signed negative number to an u64 */ 1273 cmd.index = 0; 1274 cmd.search = true; 1275 } else { 1276 cmd.index = index; 1277 cmd.search = false; 1278 } 1279 cmd.valident = true; 1280 ops->cmd_packing(packed_buf, &cmd, PACK); 1281 1282 if (cmd.search) 1283 ops->entry_packing(packed_buf, entry, PACK); 1284 1285 /* Send SPI write operation: read config table entry */ 1286 mutex_lock(&priv->dynamic_config_lock); 1287 rc = sja1105_xfer_buf(priv, SPI_WRITE, ops->addr, packed_buf, 1288 ops->packed_size); 1289 if (rc < 0) { 1290 mutex_unlock(&priv->dynamic_config_lock); 1291 return rc; 1292 } 1293 1294 rc = sja1105_dynamic_config_wait_complete(priv, &cmd, ops); 1295 mutex_unlock(&priv->dynamic_config_lock); 1296 if (rc < 0) 1297 return rc; 1298 1299 if (!cmd.valident && !(ops->access & OP_VALID_ANYWAY)) 1300 return -ENOENT; 1301 1302 /* Don't dereference possibly NULL pointer - maybe caller 1303 * only wanted to see whether the entry existed or not. 1304 */ 1305 if (entry) 1306 ops->entry_packing(packed_buf, entry, UNPACK); 1307 return 0; 1308 } 1309 1310 int sja1105_dynamic_config_write(struct sja1105_private *priv, 1311 enum sja1105_blk_idx blk_idx, 1312 int index, void *entry, bool keep) 1313 { 1314 const struct sja1105_dynamic_table_ops *ops; 1315 struct sja1105_dyn_cmd cmd = {0}; 1316 /* SPI payload buffer */ 1317 u8 packed_buf[SJA1105_MAX_DYN_CMD_SIZE] = {0}; 1318 int rc; 1319 1320 if (blk_idx >= BLK_IDX_MAX_DYN) 1321 return -ERANGE; 1322 1323 ops = &priv->info->dyn_ops[blk_idx]; 1324 1325 if (index >= ops->max_entry_count) 1326 return -ERANGE; 1327 if (index < 0) 1328 return -ERANGE; 1329 if (!(ops->access & OP_WRITE)) 1330 return -EOPNOTSUPP; 1331 if (!keep && !(ops->access & OP_DEL)) 1332 return -EOPNOTSUPP; 1333 if (ops->packed_size > SJA1105_MAX_DYN_CMD_SIZE) 1334 return -ERANGE; 1335 1336 cmd.valident = keep; /* If false, deletes entry */ 1337 cmd.valid = true; /* Trigger action on table entry */ 1338 cmd.rdwrset = SPI_WRITE; /* Action is write */ 1339 cmd.index = index; 1340 1341 if (!ops->cmd_packing) 1342 return -EOPNOTSUPP; 1343 ops->cmd_packing(packed_buf, &cmd, PACK); 1344 1345 if (!ops->entry_packing) 1346 return -EOPNOTSUPP; 1347 /* Don't dereference potentially NULL pointer if just 1348 * deleting a table entry is what was requested. For cases 1349 * where 'index' field is physically part of entry structure, 1350 * and needed here, we deal with that in the cmd_packing callback. 1351 */ 1352 if (keep) 1353 ops->entry_packing(packed_buf, entry, PACK); 1354 1355 /* Send SPI write operation: read config table entry */ 1356 mutex_lock(&priv->dynamic_config_lock); 1357 rc = sja1105_xfer_buf(priv, SPI_WRITE, ops->addr, packed_buf, 1358 ops->packed_size); 1359 if (rc < 0) { 1360 mutex_unlock(&priv->dynamic_config_lock); 1361 return rc; 1362 } 1363 1364 rc = sja1105_dynamic_config_wait_complete(priv, &cmd, ops); 1365 mutex_unlock(&priv->dynamic_config_lock); 1366 if (rc < 0) 1367 return rc; 1368 1369 cmd = (struct sja1105_dyn_cmd) {0}; 1370 ops->cmd_packing(packed_buf, &cmd, UNPACK); 1371 if (cmd.errors) 1372 return -EINVAL; 1373 1374 return 0; 1375 } 1376 1377 static u8 sja1105_crc8_add(u8 crc, u8 byte, u8 poly) 1378 { 1379 int i; 1380 1381 for (i = 0; i < 8; i++) { 1382 if ((crc ^ byte) & (1 << 7)) { 1383 crc <<= 1; 1384 crc ^= poly; 1385 } else { 1386 crc <<= 1; 1387 } 1388 byte <<= 1; 1389 } 1390 return crc; 1391 } 1392 1393 /* CRC8 algorithm with non-reversed input, non-reversed output, 1394 * no input xor and no output xor. Code customized for receiving 1395 * the SJA1105 E/T FDB keys (vlanid, macaddr) as input. CRC polynomial 1396 * is also received as argument in the Koopman notation that the switch 1397 * hardware stores it in. 1398 */ 1399 u8 sja1105et_fdb_hash(struct sja1105_private *priv, const u8 *addr, u16 vid) 1400 { 1401 struct sja1105_l2_lookup_params_entry *l2_lookup_params = 1402 priv->static_config.tables[BLK_IDX_L2_LOOKUP_PARAMS].entries; 1403 u64 input, poly_koopman = l2_lookup_params->poly; 1404 /* Convert polynomial from Koopman to 'normal' notation */ 1405 u8 poly = (u8)(1 + (poly_koopman << 1)); 1406 u8 crc = 0; /* seed */ 1407 int i; 1408 1409 input = ((u64)vid << 48) | ether_addr_to_u64(addr); 1410 1411 /* Mask the eight bytes starting from MSB one at a time */ 1412 for (i = 56; i >= 0; i -= 8) { 1413 u8 byte = (input & (0xffull << i)) >> i; 1414 1415 crc = sja1105_crc8_add(crc, byte, poly); 1416 } 1417 return crc; 1418 } 1419