1 /* 2 * B53 common definitions 3 * 4 * Copyright (C) 2011-2013 Jonas Gorski <jogo@openwrt.org> 5 * 6 * Permission to use, copy, modify, and/or distribute this software for any 7 * purpose with or without fee is hereby granted, provided that the above 8 * copyright notice and this permission notice appear in all copies. 9 * 10 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES 11 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF 12 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR 13 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES 14 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN 15 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF 16 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. 17 */ 18 19 #ifndef __B53_PRIV_H 20 #define __B53_PRIV_H 21 22 #include <linux/kernel.h> 23 #include <linux/mutex.h> 24 #include <linux/phy.h> 25 #include <net/dsa.h> 26 27 #include "b53_regs.h" 28 29 struct b53_device; 30 struct net_device; 31 32 struct b53_io_ops { 33 int (*read8)(struct b53_device *dev, u8 page, u8 reg, u8 *value); 34 int (*read16)(struct b53_device *dev, u8 page, u8 reg, u16 *value); 35 int (*read32)(struct b53_device *dev, u8 page, u8 reg, u32 *value); 36 int (*read48)(struct b53_device *dev, u8 page, u8 reg, u64 *value); 37 int (*read64)(struct b53_device *dev, u8 page, u8 reg, u64 *value); 38 int (*write8)(struct b53_device *dev, u8 page, u8 reg, u8 value); 39 int (*write16)(struct b53_device *dev, u8 page, u8 reg, u16 value); 40 int (*write32)(struct b53_device *dev, u8 page, u8 reg, u32 value); 41 int (*write48)(struct b53_device *dev, u8 page, u8 reg, u64 value); 42 int (*write64)(struct b53_device *dev, u8 page, u8 reg, u64 value); 43 int (*phy_read16)(struct b53_device *dev, int addr, int reg, u16 *value); 44 int (*phy_write16)(struct b53_device *dev, int addr, int reg, u16 value); 45 }; 46 47 enum { 48 BCM5325_DEVICE_ID = 0x25, 49 BCM5365_DEVICE_ID = 0x65, 50 BCM5395_DEVICE_ID = 0x95, 51 BCM5397_DEVICE_ID = 0x97, 52 BCM5398_DEVICE_ID = 0x98, 53 BCM53115_DEVICE_ID = 0x53115, 54 BCM53125_DEVICE_ID = 0x53125, 55 BCM53128_DEVICE_ID = 0x53128, 56 BCM63XX_DEVICE_ID = 0x6300, 57 BCM53010_DEVICE_ID = 0x53010, 58 BCM53011_DEVICE_ID = 0x53011, 59 BCM53012_DEVICE_ID = 0x53012, 60 BCM53018_DEVICE_ID = 0x53018, 61 BCM53019_DEVICE_ID = 0x53019, 62 BCM58XX_DEVICE_ID = 0x5800, 63 }; 64 65 #define B53_N_PORTS 9 66 #define B53_N_PORTS_25 6 67 68 struct b53_port { 69 u16 vlan_ctl_mask; 70 struct net_device *bridge_dev; 71 }; 72 73 struct b53_vlan { 74 u16 members; 75 u16 untag; 76 bool valid; 77 }; 78 79 struct b53_device { 80 struct dsa_switch *ds; 81 struct b53_platform_data *pdata; 82 const char *name; 83 84 struct mutex reg_mutex; 85 struct mutex stats_mutex; 86 const struct b53_io_ops *ops; 87 88 /* chip specific data */ 89 u32 chip_id; 90 u8 core_rev; 91 u8 vta_regs[3]; 92 u8 duplex_reg; 93 u8 jumbo_pm_reg; 94 u8 jumbo_size_reg; 95 int reset_gpio; 96 u8 num_arl_entries; 97 98 /* used ports mask */ 99 u16 enabled_ports; 100 unsigned int cpu_port; 101 102 /* connect specific data */ 103 u8 current_page; 104 struct device *dev; 105 106 /* Master MDIO bus we got probed from */ 107 struct mii_bus *bus; 108 109 void *priv; 110 111 /* run time configuration */ 112 bool enable_jumbo; 113 114 unsigned int num_vlans; 115 struct b53_vlan *vlans; 116 unsigned int num_ports; 117 struct b53_port *ports; 118 }; 119 120 #define b53_for_each_port(dev, i) \ 121 for (i = 0; i < B53_N_PORTS; i++) \ 122 if (dev->enabled_ports & BIT(i)) 123 124 125 static inline int is5325(struct b53_device *dev) 126 { 127 return dev->chip_id == BCM5325_DEVICE_ID; 128 } 129 130 static inline int is5365(struct b53_device *dev) 131 { 132 #ifdef CONFIG_BCM47XX 133 return dev->chip_id == BCM5365_DEVICE_ID; 134 #else 135 return 0; 136 #endif 137 } 138 139 static inline int is5397_98(struct b53_device *dev) 140 { 141 return dev->chip_id == BCM5397_DEVICE_ID || 142 dev->chip_id == BCM5398_DEVICE_ID; 143 } 144 145 static inline int is539x(struct b53_device *dev) 146 { 147 return dev->chip_id == BCM5395_DEVICE_ID || 148 dev->chip_id == BCM5397_DEVICE_ID || 149 dev->chip_id == BCM5398_DEVICE_ID; 150 } 151 152 static inline int is531x5(struct b53_device *dev) 153 { 154 return dev->chip_id == BCM53115_DEVICE_ID || 155 dev->chip_id == BCM53125_DEVICE_ID || 156 dev->chip_id == BCM53128_DEVICE_ID; 157 } 158 159 static inline int is63xx(struct b53_device *dev) 160 { 161 #ifdef CONFIG_BCM63XX 162 return dev->chip_id == BCM63XX_DEVICE_ID; 163 #else 164 return 0; 165 #endif 166 } 167 168 static inline int is5301x(struct b53_device *dev) 169 { 170 return dev->chip_id == BCM53010_DEVICE_ID || 171 dev->chip_id == BCM53011_DEVICE_ID || 172 dev->chip_id == BCM53012_DEVICE_ID || 173 dev->chip_id == BCM53018_DEVICE_ID || 174 dev->chip_id == BCM53019_DEVICE_ID; 175 } 176 177 #define B53_CPU_PORT_25 5 178 #define B53_CPU_PORT 8 179 180 static inline int is_cpu_port(struct b53_device *dev, int port) 181 { 182 return dev->cpu_port; 183 } 184 185 struct b53_device *b53_switch_alloc(struct device *base, struct b53_io_ops *ops, 186 void *priv); 187 188 int b53_switch_detect(struct b53_device *dev); 189 190 int b53_switch_register(struct b53_device *dev); 191 192 static inline void b53_switch_remove(struct b53_device *dev) 193 { 194 dsa_unregister_switch(dev->ds); 195 } 196 197 static inline int b53_read8(struct b53_device *dev, u8 page, u8 reg, u8 *val) 198 { 199 int ret; 200 201 mutex_lock(&dev->reg_mutex); 202 ret = dev->ops->read8(dev, page, reg, val); 203 mutex_unlock(&dev->reg_mutex); 204 205 return ret; 206 } 207 208 static inline int b53_read16(struct b53_device *dev, u8 page, u8 reg, u16 *val) 209 { 210 int ret; 211 212 mutex_lock(&dev->reg_mutex); 213 ret = dev->ops->read16(dev, page, reg, val); 214 mutex_unlock(&dev->reg_mutex); 215 216 return ret; 217 } 218 219 static inline int b53_read32(struct b53_device *dev, u8 page, u8 reg, u32 *val) 220 { 221 int ret; 222 223 mutex_lock(&dev->reg_mutex); 224 ret = dev->ops->read32(dev, page, reg, val); 225 mutex_unlock(&dev->reg_mutex); 226 227 return ret; 228 } 229 230 static inline int b53_read48(struct b53_device *dev, u8 page, u8 reg, u64 *val) 231 { 232 int ret; 233 234 mutex_lock(&dev->reg_mutex); 235 ret = dev->ops->read48(dev, page, reg, val); 236 mutex_unlock(&dev->reg_mutex); 237 238 return ret; 239 } 240 241 static inline int b53_read64(struct b53_device *dev, u8 page, u8 reg, u64 *val) 242 { 243 int ret; 244 245 mutex_lock(&dev->reg_mutex); 246 ret = dev->ops->read64(dev, page, reg, val); 247 mutex_unlock(&dev->reg_mutex); 248 249 return ret; 250 } 251 252 static inline int b53_write8(struct b53_device *dev, u8 page, u8 reg, u8 value) 253 { 254 int ret; 255 256 mutex_lock(&dev->reg_mutex); 257 ret = dev->ops->write8(dev, page, reg, value); 258 mutex_unlock(&dev->reg_mutex); 259 260 return ret; 261 } 262 263 static inline int b53_write16(struct b53_device *dev, u8 page, u8 reg, 264 u16 value) 265 { 266 int ret; 267 268 mutex_lock(&dev->reg_mutex); 269 ret = dev->ops->write16(dev, page, reg, value); 270 mutex_unlock(&dev->reg_mutex); 271 272 return ret; 273 } 274 275 static inline int b53_write32(struct b53_device *dev, u8 page, u8 reg, 276 u32 value) 277 { 278 int ret; 279 280 mutex_lock(&dev->reg_mutex); 281 ret = dev->ops->write32(dev, page, reg, value); 282 mutex_unlock(&dev->reg_mutex); 283 284 return ret; 285 } 286 287 static inline int b53_write48(struct b53_device *dev, u8 page, u8 reg, 288 u64 value) 289 { 290 int ret; 291 292 mutex_lock(&dev->reg_mutex); 293 ret = dev->ops->write48(dev, page, reg, value); 294 mutex_unlock(&dev->reg_mutex); 295 296 return ret; 297 } 298 299 static inline int b53_write64(struct b53_device *dev, u8 page, u8 reg, 300 u64 value) 301 { 302 int ret; 303 304 mutex_lock(&dev->reg_mutex); 305 ret = dev->ops->write64(dev, page, reg, value); 306 mutex_unlock(&dev->reg_mutex); 307 308 return ret; 309 } 310 311 struct b53_arl_entry { 312 u8 port; 313 u8 mac[ETH_ALEN]; 314 u16 vid; 315 u8 is_valid:1; 316 u8 is_age:1; 317 u8 is_static:1; 318 }; 319 320 static inline void b53_mac_from_u64(u64 src, u8 *dst) 321 { 322 unsigned int i; 323 324 for (i = 0; i < ETH_ALEN; i++) 325 dst[ETH_ALEN - 1 - i] = (src >> (8 * i)) & 0xff; 326 } 327 328 static inline u64 b53_mac_to_u64(const u8 *src) 329 { 330 unsigned int i; 331 u64 dst = 0; 332 333 for (i = 0; i < ETH_ALEN; i++) 334 dst |= (u64)src[ETH_ALEN - 1 - i] << (8 * i); 335 336 return dst; 337 } 338 339 static inline void b53_arl_to_entry(struct b53_arl_entry *ent, 340 u64 mac_vid, u32 fwd_entry) 341 { 342 memset(ent, 0, sizeof(*ent)); 343 ent->port = fwd_entry & ARLTBL_DATA_PORT_ID_MASK; 344 ent->is_valid = !!(fwd_entry & ARLTBL_VALID); 345 ent->is_age = !!(fwd_entry & ARLTBL_AGE); 346 ent->is_static = !!(fwd_entry & ARLTBL_STATIC); 347 b53_mac_from_u64(mac_vid, ent->mac); 348 ent->vid = mac_vid >> ARLTBL_VID_S; 349 } 350 351 static inline void b53_arl_from_entry(u64 *mac_vid, u32 *fwd_entry, 352 const struct b53_arl_entry *ent) 353 { 354 *mac_vid = b53_mac_to_u64(ent->mac); 355 *mac_vid |= (u64)(ent->vid & ARLTBL_VID_MASK) << ARLTBL_VID_S; 356 *fwd_entry = ent->port & ARLTBL_DATA_PORT_ID_MASK; 357 if (ent->is_valid) 358 *fwd_entry |= ARLTBL_VALID; 359 if (ent->is_static) 360 *fwd_entry |= ARLTBL_STATIC; 361 if (ent->is_age) 362 *fwd_entry |= ARLTBL_AGE; 363 } 364 365 #ifdef CONFIG_BCM47XX 366 367 #include <linux/version.h> 368 #include <linux/bcm47xx_nvram.h> 369 #include <bcm47xx_board.h> 370 static inline int b53_switch_get_reset_gpio(struct b53_device *dev) 371 { 372 enum bcm47xx_board board = bcm47xx_board_get(); 373 374 switch (board) { 375 case BCM47XX_BOARD_LINKSYS_WRT300NV11: 376 case BCM47XX_BOARD_LINKSYS_WRT310NV1: 377 return 8; 378 default: 379 return bcm47xx_nvram_gpio_pin("robo_reset"); 380 } 381 } 382 #else 383 static inline int b53_switch_get_reset_gpio(struct b53_device *dev) 384 { 385 return -ENOENT; 386 } 387 #endif 388 #endif 389