cf2ff2cbc8ab83021eecc2a0ec15a49f0964a28a
[cascardo/linux.git] / drivers / net / dsa / b53 / b53_priv.h
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         BCM7445_DEVICE_ID = 0x7445,
64 };
65
66 #define B53_N_PORTS     9
67 #define B53_N_PORTS_25  6
68
69 struct b53_port {
70         u16             vlan_ctl_mask;
71         struct net_device *bridge_dev;
72 };
73
74 struct b53_vlan {
75         u16 members;
76         u16 untag;
77         bool valid;
78 };
79
80 struct b53_device {
81         struct dsa_switch *ds;
82         struct b53_platform_data *pdata;
83         const char *name;
84
85         struct mutex reg_mutex;
86         struct mutex stats_mutex;
87         const struct b53_io_ops *ops;
88
89         /* chip specific data */
90         u32 chip_id;
91         u8 core_rev;
92         u8 vta_regs[3];
93         u8 duplex_reg;
94         u8 jumbo_pm_reg;
95         u8 jumbo_size_reg;
96         int reset_gpio;
97         u8 num_arl_entries;
98
99         /* used ports mask */
100         u16 enabled_ports;
101         unsigned int cpu_port;
102
103         /* connect specific data */
104         u8 current_page;
105         struct device *dev;
106
107         /* Master MDIO bus we got probed from */
108         struct mii_bus *bus;
109
110         void *priv;
111
112         /* run time configuration */
113         bool enable_jumbo;
114
115         unsigned int num_vlans;
116         struct b53_vlan *vlans;
117         unsigned int num_ports;
118         struct b53_port *ports;
119 };
120
121 #define b53_for_each_port(dev, i) \
122         for (i = 0; i < B53_N_PORTS; i++) \
123                 if (dev->enabled_ports & BIT(i))
124
125
126 static inline int is5325(struct b53_device *dev)
127 {
128         return dev->chip_id == BCM5325_DEVICE_ID;
129 }
130
131 static inline int is5365(struct b53_device *dev)
132 {
133 #ifdef CONFIG_BCM47XX
134         return dev->chip_id == BCM5365_DEVICE_ID;
135 #else
136         return 0;
137 #endif
138 }
139
140 static inline int is5397_98(struct b53_device *dev)
141 {
142         return dev->chip_id == BCM5397_DEVICE_ID ||
143                 dev->chip_id == BCM5398_DEVICE_ID;
144 }
145
146 static inline int is539x(struct b53_device *dev)
147 {
148         return dev->chip_id == BCM5395_DEVICE_ID ||
149                 dev->chip_id == BCM5397_DEVICE_ID ||
150                 dev->chip_id == BCM5398_DEVICE_ID;
151 }
152
153 static inline int is531x5(struct b53_device *dev)
154 {
155         return dev->chip_id == BCM53115_DEVICE_ID ||
156                 dev->chip_id == BCM53125_DEVICE_ID ||
157                 dev->chip_id == BCM53128_DEVICE_ID;
158 }
159
160 static inline int is63xx(struct b53_device *dev)
161 {
162 #ifdef CONFIG_BCM63XX
163         return dev->chip_id == BCM63XX_DEVICE_ID;
164 #else
165         return 0;
166 #endif
167 }
168
169 static inline int is5301x(struct b53_device *dev)
170 {
171         return dev->chip_id == BCM53010_DEVICE_ID ||
172                 dev->chip_id == BCM53011_DEVICE_ID ||
173                 dev->chip_id == BCM53012_DEVICE_ID ||
174                 dev->chip_id == BCM53018_DEVICE_ID ||
175                 dev->chip_id == BCM53019_DEVICE_ID;
176 }
177
178 #define B53_CPU_PORT_25 5
179 #define B53_CPU_PORT    8
180
181 static inline int is_cpu_port(struct b53_device *dev, int port)
182 {
183         return dev->cpu_port;
184 }
185
186 struct b53_device *b53_switch_alloc(struct device *base,
187                                     const struct b53_io_ops *ops,
188                                     void *priv);
189
190 int b53_switch_detect(struct b53_device *dev);
191
192 int b53_switch_register(struct b53_device *dev);
193
194 static inline void b53_switch_remove(struct b53_device *dev)
195 {
196         dsa_unregister_switch(dev->ds);
197 }
198
199 static inline int b53_read8(struct b53_device *dev, u8 page, u8 reg, u8 *val)
200 {
201         int ret;
202
203         mutex_lock(&dev->reg_mutex);
204         ret = dev->ops->read8(dev, page, reg, val);
205         mutex_unlock(&dev->reg_mutex);
206
207         return ret;
208 }
209
210 static inline int b53_read16(struct b53_device *dev, u8 page, u8 reg, u16 *val)
211 {
212         int ret;
213
214         mutex_lock(&dev->reg_mutex);
215         ret = dev->ops->read16(dev, page, reg, val);
216         mutex_unlock(&dev->reg_mutex);
217
218         return ret;
219 }
220
221 static inline int b53_read32(struct b53_device *dev, u8 page, u8 reg, u32 *val)
222 {
223         int ret;
224
225         mutex_lock(&dev->reg_mutex);
226         ret = dev->ops->read32(dev, page, reg, val);
227         mutex_unlock(&dev->reg_mutex);
228
229         return ret;
230 }
231
232 static inline int b53_read48(struct b53_device *dev, u8 page, u8 reg, u64 *val)
233 {
234         int ret;
235
236         mutex_lock(&dev->reg_mutex);
237         ret = dev->ops->read48(dev, page, reg, val);
238         mutex_unlock(&dev->reg_mutex);
239
240         return ret;
241 }
242
243 static inline int b53_read64(struct b53_device *dev, u8 page, u8 reg, u64 *val)
244 {
245         int ret;
246
247         mutex_lock(&dev->reg_mutex);
248         ret = dev->ops->read64(dev, page, reg, val);
249         mutex_unlock(&dev->reg_mutex);
250
251         return ret;
252 }
253
254 static inline int b53_write8(struct b53_device *dev, u8 page, u8 reg, u8 value)
255 {
256         int ret;
257
258         mutex_lock(&dev->reg_mutex);
259         ret = dev->ops->write8(dev, page, reg, value);
260         mutex_unlock(&dev->reg_mutex);
261
262         return ret;
263 }
264
265 static inline int b53_write16(struct b53_device *dev, u8 page, u8 reg,
266                               u16 value)
267 {
268         int ret;
269
270         mutex_lock(&dev->reg_mutex);
271         ret = dev->ops->write16(dev, page, reg, value);
272         mutex_unlock(&dev->reg_mutex);
273
274         return ret;
275 }
276
277 static inline int b53_write32(struct b53_device *dev, u8 page, u8 reg,
278                               u32 value)
279 {
280         int ret;
281
282         mutex_lock(&dev->reg_mutex);
283         ret = dev->ops->write32(dev, page, reg, value);
284         mutex_unlock(&dev->reg_mutex);
285
286         return ret;
287 }
288
289 static inline int b53_write48(struct b53_device *dev, u8 page, u8 reg,
290                               u64 value)
291 {
292         int ret;
293
294         mutex_lock(&dev->reg_mutex);
295         ret = dev->ops->write48(dev, page, reg, value);
296         mutex_unlock(&dev->reg_mutex);
297
298         return ret;
299 }
300
301 static inline int b53_write64(struct b53_device *dev, u8 page, u8 reg,
302                                u64 value)
303 {
304         int ret;
305
306         mutex_lock(&dev->reg_mutex);
307         ret = dev->ops->write64(dev, page, reg, value);
308         mutex_unlock(&dev->reg_mutex);
309
310         return ret;
311 }
312
313 struct b53_arl_entry {
314         u8 port;
315         u8 mac[ETH_ALEN];
316         u16 vid;
317         u8 is_valid:1;
318         u8 is_age:1;
319         u8 is_static:1;
320 };
321
322 static inline void b53_mac_from_u64(u64 src, u8 *dst)
323 {
324         unsigned int i;
325
326         for (i = 0; i < ETH_ALEN; i++)
327                 dst[ETH_ALEN - 1 - i] = (src >> (8 * i)) & 0xff;
328 }
329
330 static inline u64 b53_mac_to_u64(const u8 *src)
331 {
332         unsigned int i;
333         u64 dst = 0;
334
335         for (i = 0; i < ETH_ALEN; i++)
336                 dst |= (u64)src[ETH_ALEN - 1 - i] << (8 * i);
337
338         return dst;
339 }
340
341 static inline void b53_arl_to_entry(struct b53_arl_entry *ent,
342                                     u64 mac_vid, u32 fwd_entry)
343 {
344         memset(ent, 0, sizeof(*ent));
345         ent->port = fwd_entry & ARLTBL_DATA_PORT_ID_MASK;
346         ent->is_valid = !!(fwd_entry & ARLTBL_VALID);
347         ent->is_age = !!(fwd_entry & ARLTBL_AGE);
348         ent->is_static = !!(fwd_entry & ARLTBL_STATIC);
349         b53_mac_from_u64(mac_vid, ent->mac);
350         ent->vid = mac_vid >> ARLTBL_VID_S;
351 }
352
353 static inline void b53_arl_from_entry(u64 *mac_vid, u32 *fwd_entry,
354                                       const struct b53_arl_entry *ent)
355 {
356         *mac_vid = b53_mac_to_u64(ent->mac);
357         *mac_vid |= (u64)(ent->vid & ARLTBL_VID_MASK) << ARLTBL_VID_S;
358         *fwd_entry = ent->port & ARLTBL_DATA_PORT_ID_MASK;
359         if (ent->is_valid)
360                 *fwd_entry |= ARLTBL_VALID;
361         if (ent->is_static)
362                 *fwd_entry |= ARLTBL_STATIC;
363         if (ent->is_age)
364                 *fwd_entry |= ARLTBL_AGE;
365 }
366
367 #ifdef CONFIG_BCM47XX
368
369 #include <linux/version.h>
370 #include <linux/bcm47xx_nvram.h>
371 #include <bcm47xx_board.h>
372 static inline int b53_switch_get_reset_gpio(struct b53_device *dev)
373 {
374         enum bcm47xx_board board = bcm47xx_board_get();
375
376         switch (board) {
377         case BCM47XX_BOARD_LINKSYS_WRT300NV11:
378         case BCM47XX_BOARD_LINKSYS_WRT310NV1:
379                 return 8;
380         default:
381                 return bcm47xx_nvram_gpio_pin("robo_reset");
382         }
383 }
384 #else
385 static inline int b53_switch_get_reset_gpio(struct b53_device *dev)
386 {
387         return -ENOENT;
388 }
389 #endif
390 #endif