drivers/net/ethernet/mellanox/mlxsw/core.h

   1 /*
   2  * drivers/net/ethernet/mellanox/mlxsw/core.h
   3  * Copyright (c) 2015 Mellanox Technologies. All rights reserved.
   4  * Copyright (c) 2015 Jiri Pirko <jiri@mellanox.com>
   5  * Copyright (c) 2015 Ido Schimmel <idosch@mellanox.com>
   6  * Copyright (c) 2015 Elad Raz <eladr@mellanox.com>
   7  *
   8  * Redistribution and use in source and binary forms, with or without
   9  * modification, are permitted provided that the following conditions are met:
  10  *
  11  * 1. Redistributions of source code must retain the above copyright
  12  *    notice, this list of conditions and the following disclaimer.
  13  * 2. Redistributions in binary form must reproduce the above copyright
  14  *    notice, this list of conditions and the following disclaimer in the
  15  *    documentation and/or other materials provided with the distribution.
  16  * 3. Neither the names of the copyright holders nor the names of its
  17  *    contributors may be used to endorse or promote products derived from
  18  *    this software without specific prior written permission.
  19  *
  20  * Alternatively, this software may be distributed under the terms of the
  21  * GNU General Public License ("GPL") version 2 as published by the Free
  22  * Software Foundation.
  23  *
  24  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
  25  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  26  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  27  * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
  28  * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  29  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  30  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  31  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  32  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  33  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  34  * POSSIBILITY OF SUCH DAMAGE.
  35  */
  36
  37 #ifndef _MLXSW_CORE_H
  38 #define _MLXSW_CORE_H
  39
  40 #include <linux/module.h>
  41 #include <linux/device.h>
  42 #include <linux/slab.h>
  43 #include <linux/gfp.h>
  44 #include <linux/types.h>
  45 #include <linux/skbuff.h>
  46
  47 #include "trap.h"
  48 #include "reg.h"
  49
  50 #include "cmd.h"
  51
  52 #define MLXSW_MODULE_ALIAS_PREFIX "mlxsw-driver-"
  53 #define MODULE_MLXSW_DRIVER_ALIAS(kind) \
  54         MODULE_ALIAS(MLXSW_MODULE_ALIAS_PREFIX kind)
  55
  56 #define MLXSW_DEVICE_KIND_SWITCHX2 "switchx2"
  57 #define MLXSW_DEVICE_KIND_SPECTRUM "spectrum"
  58
  59 struct mlxsw_core;
  60 struct mlxsw_driver;
  61 struct mlxsw_bus;
  62 struct mlxsw_bus_info;
  63
  64 int mlxsw_core_driver_register(struct mlxsw_driver *mlxsw_driver);
  65 void mlxsw_core_driver_unregister(struct mlxsw_driver *mlxsw_driver);
  66
  67 int mlxsw_core_bus_device_register(const struct mlxsw_bus_info *mlxsw_bus_info,
  68                                    const struct mlxsw_bus *mlxsw_bus,
  69                                    void *bus_priv);
  70 void mlxsw_core_bus_device_unregister(struct mlxsw_core *mlxsw_core);
  71
  72 struct mlxsw_tx_info {
  73         u8 local_port;
  74         bool is_emad;
  75 };
  76
  77 bool mlxsw_core_skb_transmit_busy(void *driver_priv,
  78                                   const struct mlxsw_tx_info *tx_info);
  79
  80 int mlxsw_core_skb_transmit(void *driver_priv, struct sk_buff *skb,
  81                             const struct mlxsw_tx_info *tx_info);
  82
  83 struct mlxsw_rx_listener {
  84         void (*func)(struct sk_buff *skb, u8 local_port, void *priv);
  85         u8 local_port;
  86         u16 trap_id;
  87 };
  88
  89 struct mlxsw_event_listener {
  90         void (*func)(const struct mlxsw_reg_info *reg,
  91                      char *payload, void *priv);
  92         enum mlxsw_event_trap_id trap_id;
  93 };
  94
  95 int mlxsw_core_rx_listener_register(struct mlxsw_core *mlxsw_core,
  96                                     const struct mlxsw_rx_listener *rxl,
  97                                     void *priv);
  98 void mlxsw_core_rx_listener_unregister(struct mlxsw_core *mlxsw_core,
  99                                        const struct mlxsw_rx_listener *rxl,
 100                                        void *priv);
 101
 102 int mlxsw_core_event_listener_register(struct mlxsw_core *mlxsw_core,
 103                                        const struct mlxsw_event_listener *el,
 104                                        void *priv);
 105 void mlxsw_core_event_listener_unregister(struct mlxsw_core *mlxsw_core,
 106                                           const struct mlxsw_event_listener *el,
 107                                           void *priv);
 108
 109 int mlxsw_reg_query(struct mlxsw_core *mlxsw_core,
 110                     const struct mlxsw_reg_info *reg, char *payload);
 111 int mlxsw_reg_write(struct mlxsw_core *mlxsw_core,
 112                     const struct mlxsw_reg_info *reg, char *payload);
 113
 114 struct mlxsw_rx_info {
 115         bool is_lag;
 116         union {
 117                 u16 sys_port;
 118                 u16 lag_id;
 119         } u;
 120         u8 lag_port_index;
 121         int trap_id;
 122 };
 123
 124 void mlxsw_core_skb_receive(struct mlxsw_core *mlxsw_core, struct sk_buff *skb,
 125                             struct mlxsw_rx_info *rx_info);
 126
 127 void mlxsw_core_lag_mapping_set(struct mlxsw_core *mlxsw_core,
 128                                 u16 lag_id, u8 port_index, u8 local_port);
 129 u8 mlxsw_core_lag_mapping_get(struct mlxsw_core *mlxsw_core,
 130                               u16 lag_id, u8 port_index);
 131 void mlxsw_core_lag_mapping_clear(struct mlxsw_core *mlxsw_core,
 132                                   u16 lag_id, u8 local_port);
 133
 134 #define MLXSW_CONFIG_PROFILE_SWID_COUNT 8
 135
 136 struct mlxsw_swid_config {
 137         u8      used_type:1,
 138                 used_properties:1;
 139         u8      type;
 140         u8      properties;
 141 };
 142
 143 struct mlxsw_config_profile {
 144         u16     used_max_vepa_channels:1,
 145                 used_max_lag:1,
 146                 used_max_port_per_lag:1,
 147                 used_max_mid:1,
 148                 used_max_pgt:1,
 149                 used_max_system_port:1,
 150                 used_max_vlan_groups:1,
 151                 used_max_regions:1,
 152                 used_flood_tables:1,
 153                 used_flood_mode:1,
 154                 used_max_ib_mc:1,
 155                 used_max_pkey:1,
 156                 used_ar_sec:1,
 157                 used_adaptive_routing_group_cap:1;
 158         u8      max_vepa_channels;
 159         u16     max_lag;
 160         u16     max_port_per_lag;
 161         u16     max_mid;
 162         u16     max_pgt;
 163         u16     max_system_port;
 164         u16     max_vlan_groups;
 165         u16     max_regions;
 166         u8      max_flood_tables;
 167         u8      max_vid_flood_tables;
 168         u8      flood_mode;
 169         u8      max_fid_offset_flood_tables;
 170         u16     fid_offset_flood_table_size;
 171         u8      max_fid_flood_tables;
 172         u16     fid_flood_table_size;
 173         u16     max_ib_mc;
 174         u16     max_pkey;
 175         u8      ar_sec;
 176         u16     adaptive_routing_group_cap;
 177         u8      arn;
 178         struct mlxsw_swid_config swid_config[MLXSW_CONFIG_PROFILE_SWID_COUNT];
 179 };
 180
 181 struct mlxsw_driver {
 182         struct list_head list;
 183         const char *kind;
 184         struct module *owner;
 185         size_t priv_size;
 186         int (*init)(void *driver_priv, struct mlxsw_core *mlxsw_core,
 187                     const struct mlxsw_bus_info *mlxsw_bus_info);
 188         void (*fini)(void *driver_priv);
 189         int (*port_split)(void *driver_priv, u8 local_port, unsigned int count);
 190         int (*port_unsplit)(void *driver_priv, u8 local_port);
 191         void (*txhdr_construct)(struct sk_buff *skb,
 192                                 const struct mlxsw_tx_info *tx_info);
 193         u8 txhdr_len;
 194         const struct mlxsw_config_profile *profile;
 195 };
 196
 197 struct mlxsw_bus {
 198         const char *kind;
 199         int (*init)(void *bus_priv, struct mlxsw_core *mlxsw_core,
 200                     const struct mlxsw_config_profile *profile);
 201         void (*fini)(void *bus_priv);
 202         bool (*skb_transmit_busy)(void *bus_priv,
 203                                   const struct mlxsw_tx_info *tx_info);
 204         int (*skb_transmit)(void *bus_priv, struct sk_buff *skb,
 205                             const struct mlxsw_tx_info *tx_info);
 206         int (*cmd_exec)(void *bus_priv, u16 opcode, u8 opcode_mod,
 207                         u32 in_mod, bool out_mbox_direct,
 208                         char *in_mbox, size_t in_mbox_size,
 209                         char *out_mbox, size_t out_mbox_size,
 210                         u8 *p_status);
 211 };
 212
 213 struct mlxsw_bus_info {
 214         const char *device_kind;
 215         const char *device_name;
 216         struct device *dev;
 217         struct {
 218                 u16 major;
 219                 u16 minor;
 220                 u16 subminor;
 221         } fw_rev;
 222         u8 vsd[MLXSW_CMD_BOARDINFO_VSD_LEN];
 223         u8 psid[MLXSW_CMD_BOARDINFO_PSID_LEN];
 224 };
 225
 226 struct mlxsw_hwmon;
 227
 228 #ifdef CONFIG_MLXSW_CORE_HWMON
 229
 230 int mlxsw_hwmon_init(struct mlxsw_core *mlxsw_core,
 231                      const struct mlxsw_bus_info *mlxsw_bus_info,
 232                      struct mlxsw_hwmon **p_hwmon);
 233 void mlxsw_hwmon_fini(struct mlxsw_hwmon *mlxsw_hwmon);
 234
 235 #else
 236
 237 static inline int mlxsw_hwmon_init(struct mlxsw_core *mlxsw_core,
 238                                    const struct mlxsw_bus_info *mlxsw_bus_info,
 239                                    struct mlxsw_hwmon **p_hwmon)
 240 {
 241         return 0;
 242 }
 243
 244 #endif
 245
 246 #endif