// SPDX-License-Identifier: GPL-2.0 /* Copyright (c) 2018-2019, Vladimir Oltean <[email protected]> */ #include "sja1105.h" /* In the dynamic configuration interface, the switch exposes a register-like * view of some of the static configuration tables. * Many times the field organization of the dynamic tables is abbreviated (not * all fields are dynamically reconfigurable) and different from the static * ones, but the key reason for having it is that we can spare a switch reset * for settings that can be changed dynamically. * * This file creates a per-switch-family abstraction called * struct sja1105_dynamic_table_ops and two operations that work with it: * - sja1105_dynamic_config_write * - sja1105_dynamic_config_read * * Compared to the struct sja1105_table_ops from sja1105_static_config.c, * the dynamic accessors work with a compound buffer: * * packed_buf * * | * V * +-----------------------------------------+------------------+ * | ENTRY BUFFER | COMMAND BUFFER | * +-----------------------------------------+------------------+ * * <----------------------- packed_size ------------------------> * * The ENTRY BUFFER may or may not have the same layout, or size, as its static * configuration table entry counterpart. When it does, the same packing * function is reused (bar exceptional cases - see * sja1105pqrs_dyn_l2_lookup_entry_packing). * * The reason for the COMMAND BUFFER being at the end is to be able to send * a dynamic write command through a single SPI burst. By the time the switch * reacts to the command, the ENTRY BUFFER is already populated with the data * sent by the core. * * The COMMAND BUFFER is always SJA1105_SIZE_DYN_CMD bytes (one 32-bit word) in * size. * * Sometimes the ENTRY BUFFER does not really exist (when the number of fields * that can be reconfigured is small), then the switch repurposes some of the * unused 32 bits of the COMMAND BUFFER to hold ENTRY data. * * The key members of struct sja1105_dynamic_table_ops are: * - .entry_packing: A function that deals with packing an ENTRY structure * into an SPI buffer, or retrieving an ENTRY structure * from one. * The @packed_buf pointer it's given does always point to * the ENTRY portion of the buffer. * - .cmd_packing: A function that deals with packing/unpacking the COMMAND * structure to/from the SPI buffer. * It is given the same @packed_buf pointer as .entry_packing, * so most of the time, the @packed_buf points *behind* the * COMMAND offset inside the buffer. * To access the COMMAND portion of the buffer, the function * knows its correct offset. * Giving both functions the same pointer is handy because in * extreme cases (see sja1105pqrs_dyn_l2_lookup_entry_packing) * the .entry_packing is able to jump to the COMMAND portion, * or vice-versa (sja1105pqrs_l2_lookup_cmd_packing). * - .access: A bitmap of: * OP_READ: Set if the hardware manual marks the ENTRY portion of the * dynamic configuration table buffer as R (readable) after * an SPI read command (the switch will populate the buffer). * OP_WRITE: Set if the manual marks the ENTRY portion of the dynamic * table buffer as W (writable) after an SPI write command * (the switch will read the fields provided in the buffer). * OP_DEL: Set if the manual says the VALIDENT bit is supported in the * COMMAND portion of this dynamic config buffer (i.e. the * specified entry can be invalidated through a SPI write * command). * OP_SEARCH: Set if the manual says that the index of an entry can * be retrieved in the COMMAND portion of the buffer based * on its ENTRY portion, as a result of a SPI write command. * Only the TCAM-based FDB table on SJA1105 P/Q/R/S supports * this. * OP_VALID_ANYWAY: Reading some tables through the dynamic config * interface is possible even if the VALIDENT bit is not * set in the writeback. So don't error out in that case. * - .max_entry_count: The number of entries, counting from zero, that can be * reconfigured through the dynamic interface. If a static * table can be reconfigured at all dynamically, this * number always matches the maximum number of supported * static entries. * - .packed_size: The length in bytes of the compound ENTRY + COMMAND BUFFER. * Note that sometimes the compound buffer may contain holes in * it (see sja1105_vlan_lookup_cmd_packing). The @packed_buf is * contiguous however, so @packed_size includes any unused * bytes. * - .addr: The base SPI address at which the buffer must be written to the * switch's memory. When looking at the hardware manual, this must * always match the lowest documented address for the ENTRY, and not * that of the COMMAND, since the other 32-bit words will follow along * at the correct addresses. */ #define SJA1105_SIZE_DYN_CMD … #define SJA1105ET_SIZE_VL_LOOKUP_DYN_CMD … #define SJA1105PQRS_SIZE_VL_LOOKUP_DYN_CMD … #define SJA1110_SIZE_VL_POLICING_DYN_CMD … #define SJA1105ET_SIZE_MAC_CONFIG_DYN_ENTRY … #define SJA1105ET_SIZE_L2_LOOKUP_DYN_CMD … #define SJA1105PQRS_SIZE_L2_LOOKUP_DYN_CMD … #define SJA1110_SIZE_L2_LOOKUP_DYN_CMD … #define SJA1105_SIZE_VLAN_LOOKUP_DYN_CMD … #define SJA1110_SIZE_VLAN_LOOKUP_DYN_CMD … #define SJA1105_SIZE_L2_FORWARDING_DYN_CMD … #define SJA1105ET_SIZE_MAC_CONFIG_DYN_CMD … #define SJA1105PQRS_SIZE_MAC_CONFIG_DYN_CMD … #define SJA1105ET_SIZE_L2_LOOKUP_PARAMS_DYN_CMD … #define SJA1105PQRS_SIZE_L2_LOOKUP_PARAMS_DYN_CMD … #define SJA1110_SIZE_L2_LOOKUP_PARAMS_DYN_CMD … #define SJA1105ET_SIZE_GENERAL_PARAMS_DYN_CMD … #define SJA1105PQRS_SIZE_GENERAL_PARAMS_DYN_CMD … #define SJA1110_SIZE_GENERAL_PARAMS_DYN_CMD … #define SJA1105PQRS_SIZE_AVB_PARAMS_DYN_CMD … #define SJA1105_SIZE_RETAGGING_DYN_CMD … #define SJA1105ET_SIZE_CBS_DYN_CMD … #define SJA1105PQRS_SIZE_CBS_DYN_CMD … #define SJA1110_SIZE_XMII_PARAMS_DYN_CMD … #define SJA1110_SIZE_L2_POLICING_DYN_CMD … #define SJA1110_SIZE_L2_FORWARDING_PARAMS_DYN_CMD … #define SJA1105_MAX_DYN_CMD_SIZE … struct sja1105_dyn_cmd { … }; enum sja1105_hostcmd { … }; /* Command and entry overlap */ static void sja1105et_vl_lookup_cmd_packing(void *buf, struct sja1105_dyn_cmd *cmd, enum packing_op op) { … } /* Command and entry are separate */ static void sja1105pqrs_vl_lookup_cmd_packing(void *buf, struct sja1105_dyn_cmd *cmd, enum packing_op op) { … } static void sja1110_vl_lookup_cmd_packing(void *buf, struct sja1105_dyn_cmd *cmd, enum packing_op op) { … } static size_t sja1105et_vl_lookup_entry_packing(void *buf, void *entry_ptr, enum packing_op op) { … } static void sja1110_vl_policing_cmd_packing(void *buf, struct sja1105_dyn_cmd *cmd, enum packing_op op) { … } static void sja1105pqrs_common_l2_lookup_cmd_packing(void *buf, struct sja1105_dyn_cmd *cmd, enum packing_op op, int entry_size) { … } static void sja1105pqrs_l2_lookup_cmd_packing(void *buf, struct sja1105_dyn_cmd *cmd, enum packing_op op) { … } static void sja1110_l2_lookup_cmd_packing(void *buf, struct sja1105_dyn_cmd *cmd, enum packing_op op) { … } /* The switch is so retarded that it makes our command/entry abstraction * crumble apart. * * On P/Q/R/S, the switch tries to say whether a FDB entry * is statically programmed or dynamically learned via a flag called LOCKEDS. * The hardware manual says about this fiels: * * On write will specify the format of ENTRY. * On read the flag will be found cleared at times the VALID flag is found * set. The flag will also be found cleared in response to a read having the * MGMTROUTE flag set. In response to a read with the MGMTROUTE flag * cleared, the flag be set if the most recent access operated on an entry * that was either loaded by configuration or through dynamic reconfiguration * (as opposed to automatically learned entries). * * The trouble with this flag is that it's part of the *command* to access the * dynamic interface, and not part of the *entry* retrieved from it. * Otherwise said, for a sja1105_dynamic_config_read, LOCKEDS is supposed to be * an output from the switch into the command buffer, and for a * sja1105_dynamic_config_write, the switch treats LOCKEDS as an input * (hence we can write either static, or automatically learned entries, from * the core). * But the manual contradicts itself in the last phrase where it says that on * read, LOCKEDS will be set to 1 for all FDB entries written through the * dynamic interface (therefore, the value of LOCKEDS from the * sja1105_dynamic_config_write is not really used for anything, it'll store a * 1 anyway). * This means you can't really write a FDB entry with LOCKEDS=0 (automatically * learned) into the switch, which kind of makes sense. * As for reading through the dynamic interface, it doesn't make too much sense * to put LOCKEDS into the command, since the switch will inevitably have to * ignore it (otherwise a command would be like "read the FDB entry 123, but * only if it's dynamically learned" <- well how am I supposed to know?) and * just use it as an output buffer for its findings. But guess what... that's * what the entry buffer is for! * Unfortunately, what really breaks this abstraction is the fact that it * wasn't designed having the fact in mind that the switch can output * entry-related data as writeback through the command buffer. * However, whether a FDB entry is statically or dynamically learned *is* part * of the entry and not the command data, no matter what the switch thinks. * In order to do that, we'll need to wrap around the * sja1105pqrs_l2_lookup_entry_packing from sja1105_static_config.c, and take * a peek outside of the caller-supplied @buf (the entry buffer), to reach the * command buffer. */ static size_t sja1105pqrs_dyn_l2_lookup_entry_packing(void *buf, void *entry_ptr, enum packing_op op) { … } static size_t sja1110_dyn_l2_lookup_entry_packing(void *buf, void *entry_ptr, enum packing_op op) { … } static void sja1105et_l2_lookup_cmd_packing(void *buf, struct sja1105_dyn_cmd *cmd, enum packing_op op) { … } static size_t sja1105et_dyn_l2_lookup_entry_packing(void *buf, void *entry_ptr, enum packing_op op) { … } static void sja1105et_mgmt_route_cmd_packing(void *buf, struct sja1105_dyn_cmd *cmd, enum packing_op op) { … } static size_t sja1105et_mgmt_route_entry_packing(void *buf, void *entry_ptr, enum packing_op op) { … } static void sja1105pqrs_mgmt_route_cmd_packing(void *buf, struct sja1105_dyn_cmd *cmd, enum packing_op op) { … } static size_t sja1105pqrs_mgmt_route_entry_packing(void *buf, void *entry_ptr, enum packing_op op) { … } /* In E/T, entry is at addresses 0x27-0x28. There is a 4 byte gap at 0x29, * and command is at 0x2a. Similarly in P/Q/R/S there is a 1 register gap * between entry (0x2d, 0x2e) and command (0x30). */ static void sja1105_vlan_lookup_cmd_packing(void *buf, struct sja1105_dyn_cmd *cmd, enum packing_op op) { … } /* In SJA1110 there is no gap between the command and the data, yay... */ static void sja1110_vlan_lookup_cmd_packing(void *buf, struct sja1105_dyn_cmd *cmd, enum packing_op op) { … } static void sja1105_l2_forwarding_cmd_packing(void *buf, struct sja1105_dyn_cmd *cmd, enum packing_op op) { … } static void sja1110_l2_forwarding_cmd_packing(void *buf, struct sja1105_dyn_cmd *cmd, enum packing_op op) { … } static void sja1105et_mac_config_cmd_packing(void *buf, struct sja1105_dyn_cmd *cmd, enum packing_op op) { … } static size_t sja1105et_mac_config_entry_packing(void *buf, void *entry_ptr, enum packing_op op) { … } static void sja1105pqrs_mac_config_cmd_packing(void *buf, struct sja1105_dyn_cmd *cmd, enum packing_op op) { … } static void sja1110_mac_config_cmd_packing(void *buf, struct sja1105_dyn_cmd *cmd, enum packing_op op) { … } static void sja1105et_l2_lookup_params_cmd_packing(void *buf, struct sja1105_dyn_cmd *cmd, enum packing_op op) { … } static size_t sja1105et_l2_lookup_params_entry_packing(void *buf, void *entry_ptr, enum packing_op op) { … } static void sja1105pqrs_l2_lookup_params_cmd_packing(void *buf, struct sja1105_dyn_cmd *cmd, enum packing_op op) { … } static void sja1110_l2_lookup_params_cmd_packing(void *buf, struct sja1105_dyn_cmd *cmd, enum packing_op op) { … } static void sja1105et_general_params_cmd_packing(void *buf, struct sja1105_dyn_cmd *cmd, enum packing_op op) { … } static size_t sja1105et_general_params_entry_packing(void *buf, void *entry_ptr, enum packing_op op) { … } static void sja1105pqrs_general_params_cmd_packing(void *buf, struct sja1105_dyn_cmd *cmd, enum packing_op op) { … } static void sja1110_general_params_cmd_packing(void *buf, struct sja1105_dyn_cmd *cmd, enum packing_op op) { … } static void sja1105pqrs_avb_params_cmd_packing(void *buf, struct sja1105_dyn_cmd *cmd, enum packing_op op) { … } static void sja1105_retagging_cmd_packing(void *buf, struct sja1105_dyn_cmd *cmd, enum packing_op op) { … } static void sja1110_retagging_cmd_packing(void *buf, struct sja1105_dyn_cmd *cmd, enum packing_op op) { … } static void sja1105et_cbs_cmd_packing(void *buf, struct sja1105_dyn_cmd *cmd, enum packing_op op) { … } static size_t sja1105et_cbs_entry_packing(void *buf, void *entry_ptr, enum packing_op op) { … } static void sja1105pqrs_cbs_cmd_packing(void *buf, struct sja1105_dyn_cmd *cmd, enum packing_op op) { … } static void sja1110_cbs_cmd_packing(void *buf, struct sja1105_dyn_cmd *cmd, enum packing_op op) { … } static size_t sja1105pqrs_cbs_entry_packing(void *buf, void *entry_ptr, enum packing_op op) { … } static size_t sja1110_cbs_entry_packing(void *buf, void *entry_ptr, enum packing_op op) { … } static void sja1110_dummy_cmd_packing(void *buf, struct sja1105_dyn_cmd *cmd, enum packing_op op) { … } static void sja1110_l2_policing_cmd_packing(void *buf, struct sja1105_dyn_cmd *cmd, enum packing_op op) { … } #define OP_READ … #define OP_WRITE … #define OP_DEL … #define OP_SEARCH … #define OP_VALID_ANYWAY … /* SJA1105E/T: First generation */ const struct sja1105_dynamic_table_ops sja1105et_dyn_ops[BLK_IDX_MAX_DYN] = …; /* SJA1105P/Q/R/S: Second generation */ const struct sja1105_dynamic_table_ops sja1105pqrs_dyn_ops[BLK_IDX_MAX_DYN] = …; /* SJA1110: Third generation */ const struct sja1105_dynamic_table_ops sja1110_dyn_ops[BLK_IDX_MAX_DYN] = …; #define SJA1105_DYNAMIC_CONFIG_SLEEP_US … #define SJA1105_DYNAMIC_CONFIG_TIMEOUT_US … static int sja1105_dynamic_config_poll_valid(struct sja1105_private *priv, const struct sja1105_dynamic_table_ops *ops, void *entry, bool check_valident, bool check_errors) { … } /* Poll the dynamic config entry's control area until the hardware has * cleared the VALID bit, which means we have confirmation that it has * finished processing the command. */ static int sja1105_dynamic_config_wait_complete(struct sja1105_private *priv, const struct sja1105_dynamic_table_ops *ops, void *entry, bool check_valident, bool check_errors) { … } /* Provides read access to the settings through the dynamic interface * of the switch. * @blk_idx is used as key to select from the sja1105_dynamic_table_ops. * The selection is limited by the hardware in respect to which * configuration blocks can be read through the dynamic interface. * @index is used to retrieve a particular table entry. If negative, * (and if the @blk_idx supports the searching operation) a search * is performed by the @entry parameter. * @entry Type-casted to an unpacked structure that holds a table entry * of the type specified in @blk_idx. * Usually an output argument. If @index is negative, then this * argument is used as input/output: it should be pre-populated * with the element to search for. Entries which support the * search operation will have an "index" field (not the @index * argument to this function) and that is where the found index * will be returned (or left unmodified - thus negative - if not * found). */ int sja1105_dynamic_config_read(struct sja1105_private *priv, enum sja1105_blk_idx blk_idx, int index, void *entry) { … } int sja1105_dynamic_config_write(struct sja1105_private *priv, enum sja1105_blk_idx blk_idx, int index, void *entry, bool keep) { … } static u8 sja1105_crc8_add(u8 crc, u8 byte, u8 poly) { … } /* CRC8 algorithm with non-reversed input, non-reversed output, * no input xor and no output xor. Code customized for receiving * the SJA1105 E/T FDB keys (vlanid, macaddr) as input. CRC polynomial * is also received as argument in the Koopman notation that the switch * hardware stores it in. */ u8 sja1105et_fdb_hash(struct sja1105_private *priv, const u8 *addr, u16 vid) { … }
Codebase Browser
linux