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 181struct sja1105_dyn_cmd { 182 bool search; 183 u64 valid; 184 u64 rdwrset; 185 u64 errors; 186 u64 valident; 187 u64 index; 188}; 189 190enum 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 */ 198static void 199sja1105et_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 */ 211static void 212sja1105pqrs_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 224static void 225sja1110_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 237static 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 248static void 249sja1110_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 260static void 261sja1105pqrs_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 309static void 310sja1105pqrs_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 328static void 329sja1110_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 */ 384static size_t 385sja1105pqrs_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 397static 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 409static void 410sja1105et_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 425static 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 437static void 438sja1105et_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 449static 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 469static void 470sja1105pqrs_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 481static 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 */ 503static void 504sja1105_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... */ 521static void 522sja1110_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 553static void 554sja1105_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 566static void 567sja1110_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 579static void 580sja1105et_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 591static 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 620static void 621sja1105pqrs_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 633static void 634sja1110_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 646static void 647sja1105et_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 654static size_t 655sja1105et_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 666static void 667sja1105pqrs_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 678static void 679sja1110_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 690static void 691sja1105et_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 700static size_t 701sja1105et_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 712static void 713sja1105pqrs_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 724static void 725sja1110_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 736static void 737sja1105pqrs_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 748static void 749sja1105_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 762static void 763sja1110_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 776static 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 786static 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 803static 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 815static 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 827static 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 842static 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 857static void sja1110_dummy_cmd_packing(void *buf, struct sja1105_dyn_cmd *cmd, 858 enum packing_op op) 859{ 860} 861 862static void 863sja1110_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 */ 882const 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 */ 966const 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 */ 1058const 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 1176static int 1177sja1105_dynamic_config_poll_valid(struct sja1105_private *priv, 1178 const struct sja1105_dynamic_table_ops *ops, 1179 void *entry, bool check_valident, 1180 bool check_errors) 1181{ 1182 u8 packed_buf[SJA1105_MAX_DYN_CMD_SIZE] = {}; 1183 struct sja1105_dyn_cmd cmd = {}; 1184 int rc; 1185 1186 /* Read back the whole entry + command structure. */ 1187 rc = sja1105_xfer_buf(priv, SPI_READ, ops->addr, packed_buf, 1188 ops->packed_size); 1189 if (rc) 1190 return rc; 1191 1192 /* Unpack the command structure, and return it to the caller in case it 1193 * needs to perform further checks on it (VALIDENT). 1194 */ 1195 ops->cmd_packing(packed_buf, &cmd, UNPACK); 1196 1197 /* Hardware hasn't cleared VALID => still working on it */ 1198 if (cmd.valid) 1199 return -EAGAIN; 1200 1201 if (check_valident && !cmd.valident && !(ops->access & OP_VALID_ANYWAY)) 1202 return -ENOENT; 1203 1204 if (check_errors && cmd.errors) 1205 return -EINVAL; 1206 1207 /* Don't dereference possibly NULL pointer - maybe caller 1208 * only wanted to see whether the entry existed or not. 1209 */ 1210 if (entry) 1211 ops->entry_packing(packed_buf, entry, UNPACK); 1212 1213 return 0; 1214} 1215 1216/* Poll the dynamic config entry's control area until the hardware has 1217 * cleared the VALID bit, which means we have confirmation that it has 1218 * finished processing the command. 1219 */ 1220static int 1221sja1105_dynamic_config_wait_complete(struct sja1105_private *priv, 1222 const struct sja1105_dynamic_table_ops *ops, 1223 void *entry, bool check_valident, 1224 bool check_errors) 1225{ 1226 int err, rc; 1227 1228 err = read_poll_timeout(sja1105_dynamic_config_poll_valid, 1229 rc, rc != -EAGAIN, 1230 SJA1105_DYNAMIC_CONFIG_SLEEP_US, 1231 SJA1105_DYNAMIC_CONFIG_TIMEOUT_US, 1232 false, priv, ops, entry, check_valident, 1233 check_errors); 1234 return err < 0 ? err : rc; 1235} 1236 1237/* Provides read access to the settings through the dynamic interface 1238 * of the switch. 1239 * @blk_idx is used as key to select from the sja1105_dynamic_table_ops. 1240 * The selection is limited by the hardware in respect to which 1241 * configuration blocks can be read through the dynamic interface. 1242 * @index is used to retrieve a particular table entry. If negative, 1243 * (and if the @blk_idx supports the searching operation) a search 1244 * is performed by the @entry parameter. 1245 * @entry Type-casted to an unpacked structure that holds a table entry 1246 * of the type specified in @blk_idx. 1247 * Usually an output argument. If @index is negative, then this 1248 * argument is used as input/output: it should be pre-populated 1249 * with the element to search for. Entries which support the 1250 * search operation will have an "index" field (not the @index 1251 * argument to this function) and that is where the found index 1252 * will be returned (or left unmodified - thus negative - if not 1253 * found). 1254 */ 1255int sja1105_dynamic_config_read(struct sja1105_private *priv, 1256 enum sja1105_blk_idx blk_idx, 1257 int index, void *entry) 1258{ 1259 const struct sja1105_dynamic_table_ops *ops; 1260 struct sja1105_dyn_cmd cmd = {0}; 1261 /* SPI payload buffer */ 1262 u8 packed_buf[SJA1105_MAX_DYN_CMD_SIZE] = {0}; 1263 int rc; 1264 1265 if (blk_idx >= BLK_IDX_MAX_DYN) 1266 return -ERANGE; 1267 1268 ops = &priv->info->dyn_ops[blk_idx]; 1269 1270 if (index >= 0 && index >= ops->max_entry_count) 1271 return -ERANGE; 1272 if (index < 0 && !(ops->access & OP_SEARCH)) 1273 return -EOPNOTSUPP; 1274 if (!(ops->access & OP_READ)) 1275 return -EOPNOTSUPP; 1276 if (ops->packed_size > SJA1105_MAX_DYN_CMD_SIZE) 1277 return -ERANGE; 1278 if (!ops->cmd_packing) 1279 return -EOPNOTSUPP; 1280 if (!ops->entry_packing) 1281 return -EOPNOTSUPP; 1282 1283 cmd.valid = true; /* Trigger action on table entry */ 1284 cmd.rdwrset = SPI_READ; /* Action is read */ 1285 if (index < 0) { 1286 /* Avoid copying a signed negative number to an u64 */ 1287 cmd.index = 0; 1288 cmd.search = true; 1289 } else { 1290 cmd.index = index; 1291 cmd.search = false; 1292 } 1293 cmd.valident = true; 1294 ops->cmd_packing(packed_buf, &cmd, PACK); 1295 1296 if (cmd.search) 1297 ops->entry_packing(packed_buf, entry, PACK); 1298 1299 /* Send SPI write operation: read config table entry */ 1300 mutex_lock(&priv->dynamic_config_lock); 1301 rc = sja1105_xfer_buf(priv, SPI_WRITE, ops->addr, packed_buf, 1302 ops->packed_size); 1303 if (rc < 0) 1304 goto out; 1305 1306 rc = sja1105_dynamic_config_wait_complete(priv, ops, entry, true, false); 1307out: 1308 mutex_unlock(&priv->dynamic_config_lock); 1309 1310 return rc; 1311} 1312 1313int sja1105_dynamic_config_write(struct sja1105_private *priv, 1314 enum sja1105_blk_idx blk_idx, 1315 int index, void *entry, bool keep) 1316{ 1317 const struct sja1105_dynamic_table_ops *ops; 1318 struct sja1105_dyn_cmd cmd = {0}; 1319 /* SPI payload buffer */ 1320 u8 packed_buf[SJA1105_MAX_DYN_CMD_SIZE] = {0}; 1321 int rc; 1322 1323 if (blk_idx >= BLK_IDX_MAX_DYN) 1324 return -ERANGE; 1325 1326 ops = &priv->info->dyn_ops[blk_idx]; 1327 1328 if (index >= ops->max_entry_count) 1329 return -ERANGE; 1330 if (index < 0) 1331 return -ERANGE; 1332 if (!(ops->access & OP_WRITE)) 1333 return -EOPNOTSUPP; 1334 if (!keep && !(ops->access & OP_DEL)) 1335 return -EOPNOTSUPP; 1336 if (ops->packed_size > SJA1105_MAX_DYN_CMD_SIZE) 1337 return -ERANGE; 1338 1339 cmd.valident = keep; /* If false, deletes entry */ 1340 cmd.valid = true; /* Trigger action on table entry */ 1341 cmd.rdwrset = SPI_WRITE; /* Action is write */ 1342 cmd.index = index; 1343 1344 if (!ops->cmd_packing) 1345 return -EOPNOTSUPP; 1346 ops->cmd_packing(packed_buf, &cmd, PACK); 1347 1348 if (!ops->entry_packing) 1349 return -EOPNOTSUPP; 1350 /* Don't dereference potentially NULL pointer if just 1351 * deleting a table entry is what was requested. For cases 1352 * where 'index' field is physically part of entry structure, 1353 * and needed here, we deal with that in the cmd_packing callback. 1354 */ 1355 if (keep) 1356 ops->entry_packing(packed_buf, entry, PACK); 1357 1358 /* Send SPI write operation: read config table entry */ 1359 mutex_lock(&priv->dynamic_config_lock); 1360 rc = sja1105_xfer_buf(priv, SPI_WRITE, ops->addr, packed_buf, 1361 ops->packed_size); 1362 if (rc < 0) 1363 goto out; 1364 1365 rc = sja1105_dynamic_config_wait_complete(priv, ops, NULL, false, true); 1366out: 1367 mutex_unlock(&priv->dynamic_config_lock); 1368 1369 return rc; 1370} 1371 1372static u8 sja1105_crc8_add(u8 crc, u8 byte, u8 poly) 1373{ 1374 int i; 1375 1376 for (i = 0; i < 8; i++) { 1377 if ((crc ^ byte) & (1 << 7)) { 1378 crc <<= 1; 1379 crc ^= poly; 1380 } else { 1381 crc <<= 1; 1382 } 1383 byte <<= 1; 1384 } 1385 return crc; 1386} 1387 1388/* CRC8 algorithm with non-reversed input, non-reversed output, 1389 * no input xor and no output xor. Code customized for receiving 1390 * the SJA1105 E/T FDB keys (vlanid, macaddr) as input. CRC polynomial 1391 * is also received as argument in the Koopman notation that the switch 1392 * hardware stores it in. 1393 */ 1394u8 sja1105et_fdb_hash(struct sja1105_private *priv, const u8 *addr, u16 vid) 1395{ 1396 struct sja1105_l2_lookup_params_entry *l2_lookup_params = 1397 priv->static_config.tables[BLK_IDX_L2_LOOKUP_PARAMS].entries; 1398 u64 input, poly_koopman = l2_lookup_params->poly; 1399 /* Convert polynomial from Koopman to 'normal' notation */ 1400 u8 poly = (u8)(1 + (poly_koopman << 1)); 1401 u8 crc = 0; /* seed */ 1402 int i; 1403 1404 input = ((u64)vid << 48) | ether_addr_to_u64(addr); 1405 1406 /* Mask the eight bytes starting from MSB one at a time */ 1407 for (i = 56; i >= 0; i -= 8) { 1408 u8 byte = (input & (0xffull << i)) >> i; 1409 1410 crc = sja1105_crc8_add(crc, byte, poly); 1411 } 1412 return crc; 1413} 1414