1414 lines · c
1// SPDX-License-Identifier: GPL-2.02/* 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-like7 * view of some of the static configuration tables.8 * Many times the field organization of the dynamic tables is abbreviated (not9 * all fields are dynamically reconfigurable) and different from the static10 * ones, but the key reason for having it is that we can spare a switch reset11 * for settings that can be changed dynamically.12 *13 * This file creates a per-switch-family abstraction called14 * struct sja1105_dynamic_table_ops and two operations that work with it:15 * - sja1105_dynamic_config_write16 * - sja1105_dynamic_config_read17 *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_buf22 *23 * |24 * V25 * +-----------------------------------------+------------------+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 static32 * configuration table entry counterpart. When it does, the same packing33 * function is reused (bar exceptional cases - see34 * sja1105pqrs_dyn_l2_lookup_entry_packing).35 *36 * The reason for the COMMAND BUFFER being at the end is to be able to send37 * a dynamic write command through a single SPI burst. By the time the switch38 * reacts to the command, the ENTRY BUFFER is already populated with the data39 * sent by the core.40 *41 * The COMMAND BUFFER is always SJA1105_SIZE_DYN_CMD bytes (one 32-bit word) in42 * size.43 *44 * Sometimes the ENTRY BUFFER does not really exist (when the number of fields45 * that can be reconfigured is small), then the switch repurposes some of the46 * 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 structure50 * into an SPI buffer, or retrieving an ENTRY structure51 * from one.52 * The @packed_buf pointer it's given does always point to53 * the ENTRY portion of the buffer.54 * - .cmd_packing: A function that deals with packing/unpacking the COMMAND55 * 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* the58 * COMMAND offset inside the buffer.59 * To access the COMMAND portion of the buffer, the function60 * knows its correct offset.61 * Giving both functions the same pointer is handy because in62 * 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 the67 * dynamic configuration table buffer as R (readable) after68 * an SPI read command (the switch will populate the buffer).69 * OP_WRITE: Set if the manual marks the ENTRY portion of the dynamic70 * table buffer as W (writable) after an SPI write command71 * (the switch will read the fields provided in the buffer).72 * OP_DEL: Set if the manual says the VALIDENT bit is supported in the73 * COMMAND portion of this dynamic config buffer (i.e. the74 * specified entry can be invalidated through a SPI write75 * command).76 * OP_SEARCH: Set if the manual says that the index of an entry can77 * be retrieved in the COMMAND portion of the buffer based78 * 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 supports80 * this.81 * OP_VALID_ANYWAY: Reading some tables through the dynamic config82 * interface is possible even if the VALIDENT bit is not83 * 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 be85 * reconfigured through the dynamic interface. If a static86 * table can be reconfigured at all dynamically, this87 * number always matches the maximum number of supported88 * 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 in91 * it (see sja1105_vlan_lookup_cmd_packing). The @packed_buf is92 * contiguous however, so @packed_size includes any unused93 * bytes.94 * - .addr: The base SPI address at which the buffer must be written to the95 * switch's memory. When looking at the hardware manual, this must96 * always match the lowest documented address for the ENTRY, and not97 * that of the COMMAND, since the other 32-bit words will follow along98 * at the correct addresses.99 */100 101#define SJA1105_SIZE_DYN_CMD 4102 103#define SJA1105ET_SIZE_VL_LOOKUP_DYN_CMD \104 SJA1105_SIZE_DYN_CMD105 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_CMD114 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_CMD141 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_CMD150 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_ENTRY171 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_ENTRY177 178#define SJA1105_MAX_DYN_CMD_SIZE \179 SJA1110_SIZE_GENERAL_PARAMS_DYN_CMD180 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 void199sja1105et_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 void212sja1105pqrs_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 void225sja1110_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 void249sja1110_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 void261sja1105pqrs_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. UM10944275 * 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 cleared279 * for read accesses with the MGMTROUTE flag set.280 *281 * SJA1105 P/Q/R/S keeps the same behavior w.r.t. VALIDENT, but there282 * is now another flag called HOSTCMD which does more stuff (quoting283 * from UM11040):284 *285 * A write request is accepted only when HOSTCMD is set to write host286 * or invalid. A read request is accepted only when HOSTCMD is set to287 * search host or read host.288 *289 * So it is possible to translate a RDWRSET/VALIDENT combination into290 * HOSTCMD so that we keep the dynamic command API in place, and291 * at the same time achieve compatibility with the management route292 * command structure.293 */294 if (cmd->rdwrset == SPI_READ) {295 if (cmd->search)296 hostcmd = SJA1105_HOSTCMD_SEARCH;297 else298 hostcmd = SJA1105_HOSTCMD_READ;299 } else {300 /* SPI_WRITE */301 if (cmd->valident)302 hostcmd = SJA1105_HOSTCMD_WRITE;303 else304 hostcmd = SJA1105_HOSTCMD_INVALIDATE;305 }306 sja1105_packing(p, &hostcmd, 25, 23, size, op);307}308 309static void310sja1105pqrs_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 within318 * struct sja1105_l2_lookup_entry as the index on which this command319 * 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 entry323 * structure when e.g. a delete is requested.324 */325 sja1105_packing(buf, &cmd->index, 15, 6, entry_size, op);326}327 328static void329sja1110_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 abstraction340 * crumble apart.341 *342 * On P/Q/R/S, the switch tries to say whether a FDB entry343 * 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 found348 * set. The flag will also be found cleared in response to a read having the349 * MGMTROUTE flag set. In response to a read with the MGMTROUTE flag350 * cleared, the flag be set if the most recent access operated on an entry351 * that was either loaded by configuration or through dynamic reconfiguration352 * (as opposed to automatically learned entries).353 *354 * The trouble with this flag is that it's part of the *command* to access the355 * dynamic interface, and not part of the *entry* retrieved from it.356 * Otherwise said, for a sja1105_dynamic_config_read, LOCKEDS is supposed to be357 * an output from the switch into the command buffer, and for a358 * sja1105_dynamic_config_write, the switch treats LOCKEDS as an input359 * (hence we can write either static, or automatically learned entries, from360 * the core).361 * But the manual contradicts itself in the last phrase where it says that on362 * read, LOCKEDS will be set to 1 for all FDB entries written through the363 * dynamic interface (therefore, the value of LOCKEDS from the364 * sja1105_dynamic_config_write is not really used for anything, it'll store a365 * 1 anyway).366 * This means you can't really write a FDB entry with LOCKEDS=0 (automatically367 * learned) into the switch, which kind of makes sense.368 * As for reading through the dynamic interface, it doesn't make too much sense369 * to put LOCKEDS into the command, since the switch will inevitably have to370 * ignore it (otherwise a command would be like "read the FDB entry 123, but371 * only if it's dynamically learned" <- well how am I supposed to know?) and372 * just use it as an output buffer for its findings. But guess what... that's373 * what the entry buffer is for!374 * Unfortunately, what really breaks this abstraction is the fact that it375 * wasn't designed having the fact in mind that the switch can output376 * entry-related data as writeback through the command buffer.377 * However, whether a FDB entry is statically or dynamically learned *is* part378 * 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 the380 * sja1105pqrs_l2_lookup_entry_packing from sja1105_static_config.c, and take381 * a peek outside of the caller-supplied @buf (the entry buffer), to reach the382 * command buffer.383 */384static size_t385sja1105pqrs_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 void410sja1105et_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 void438sja1105et_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 on456 * each port upon transmission of the frame, the LSB of VLANID in the457 * ENTRY field provided by the host must be set.458 * Bit 1 of VLANID then specifies the register where the timestamp for459 * 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 void470sja1105pqrs_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 purpose488 * 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 gap501 * between entry (0x2d, 0x2e) and command (0x30).502 */503static void504sja1105_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 of514 * 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 void522sja1110_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 as533 * 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 to539 * 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_ENTRY541 * 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 void554sja1105_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 void567sja1110_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 void580sja1105et_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, drpnona664615 */616 /* Bogus return value, not used anywhere */617 return 0;618}619 620static void621sja1105pqrs_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 void634sja1110_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 void647sja1105et_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_t655sja1105et_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 void667sja1105pqrs_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 void679sja1110_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 void691sja1105et_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_t701sja1105et_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 void713sja1105pqrs_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 void725sja1110_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 void737sja1105pqrs_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 void749sja1105_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 void763sja1110_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 void863sja1110_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 101174#define SJA1105_DYNAMIC_CONFIG_TIMEOUT_US 1000001175 1176static int1177sja1105_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 it1193 * 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 caller1208 * 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 has1217 * cleared the VALID bit, which means we have confirmation that it has1218 * finished processing the command.1219 */1220static int1221sja1105_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 interface1238 * 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 which1241 * 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 search1244 * is performed by the @entry parameter.1245 * @entry Type-casted to an unpacked structure that holds a table entry1246 * of the type specified in @blk_idx.1247 * Usually an output argument. If @index is negative, then this1248 * argument is used as input/output: it should be pre-populated1249 * with the element to search for. Entries which support the1250 * search operation will have an "index" field (not the @index1251 * argument to this function) and that is where the found index1252 * will be returned (or left unmodified - thus negative - if not1253 * 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 just1351 * deleting a table entry is what was requested. For cases1352 * 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 receiving1390 * the SJA1105 E/T FDB keys (vlanid, macaddr) as input. CRC polynomial1391 * is also received as argument in the Koopman notation that the switch1392 * 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