generic: add b53 swconfig switch driver
[15.05/openwrt.git] / target / linux / generic / files / drivers / net / phy / 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/switch.h>
25
26 struct b53_device;
27
28 struct b53_io_ops {
29         int (*read8)(struct b53_device *dev, u8 page, u8 reg, u8 *value);
30         int (*read16)(struct b53_device *dev, u8 page, u8 reg, u16 *value);
31         int (*read32)(struct b53_device *dev, u8 page, u8 reg, u32 *value);
32         int (*read48)(struct b53_device *dev, u8 page, u8 reg, u64 *value);
33         int (*read64)(struct b53_device *dev, u8 page, u8 reg, u64 *value);
34         int (*write8)(struct b53_device *dev, u8 page, u8 reg, u8 value);
35         int (*write16)(struct b53_device *dev, u8 page, u8 reg, u16 value);
36         int (*write32)(struct b53_device *dev, u8 page, u8 reg, u32 value);
37         int (*write48)(struct b53_device *dev, u8 page, u8 reg, u64 value);
38         int (*write64)(struct b53_device *dev, u8 page, u8 reg, u64 value);
39 };
40
41 enum {
42         BCM5325_DEVICE_ID = 0x25,
43         BCM5365_DEVICE_ID = 0x65,
44         BCM5395_DEVICE_ID = 0x95,
45         BCM5397_DEVICE_ID = 0x97,
46         BCM5398_DEVICE_ID = 0x98,
47         BCM53115_DEVICE_ID = 0x53115,
48         BCM53125_DEVICE_ID = 0x53125,
49         BCM63XX_DEVICE_ID = 0x6300,
50 };
51
52 #define B53_N_PORTS     9
53 #define B53_N_PORTS_25  6
54
55 struct b53_vlan {
56         unsigned int    members:B53_N_PORTS;
57         unsigned int    untag:B53_N_PORTS;
58 };
59
60 struct b53_port {
61         unsigned int    pvid:12;
62 };
63
64 struct b53_device {
65         struct switch_dev sw_dev;
66         struct b53_platform_data *pdata;
67
68         struct mutex reg_mutex;
69         const struct b53_io_ops *ops;
70
71         /* chip specific data */
72         u32 chip_id;
73         u8 core_rev;
74         u8 vta_regs[3];
75         u8 duplex_reg;
76         u8 jumbo_pm_reg;
77         u8 jumbo_size_reg;
78
79         /* used ports mask */
80         u16 enabled_ports;
81
82         /* connect specific data */
83         u8 current_page;
84         struct device *dev;
85         void *priv;
86
87         /* run time configuration */
88         unsigned enable_vlan:1;
89         unsigned enable_jumbo:1;
90         unsigned allow_vid_4095:1;
91
92         struct b53_port *ports;
93         struct b53_vlan *vlans;
94
95         char *buf;
96 };
97
98 #define b53_for_each_port(dev, i) \
99         for (i = 0; i < B53_N_PORTS; i++) \
100                 if (dev->enabled_ports & BIT(i))
101
102
103
104 static inline int is5325(struct b53_device *dev)
105 {
106         return dev->chip_id == BCM5325_DEVICE_ID;
107 }
108
109 static inline int is5365(struct b53_device *dev)
110 {
111 #ifdef CONFIG_BCM47XX
112         return dev->chip_id == BCM5365_DEVICE_ID;
113 #else
114         return 0;
115 #endif
116 }
117
118 static inline int is5397_98(struct b53_device *dev)
119 {
120         return dev->chip_id == BCM5397_DEVICE_ID ||
121                 dev->chip_id == BCM5398_DEVICE_ID;
122 }
123
124 static inline int is531x5(struct b53_device *dev)
125 {
126         return dev->chip_id == BCM53115_DEVICE_ID ||
127                 dev->chip_id == BCM53125_DEVICE_ID;
128 }
129
130 static inline int is63xx(struct b53_device *dev)
131 {
132 #ifdef CONFIG_BCM63XX
133         return dev->chip_id == BCM63XX_DEVICE_ID;
134 #else
135         return 0;
136 #endif
137 }
138
139 #define B53_CPU_PORT_25 5
140 #define B53_CPU_PORT    8
141
142 static inline int is_cpu_port(struct b53_device *dev, int port)
143 {
144         return dev->sw_dev.cpu_port == port;
145 }
146
147 static inline struct b53_device *sw_to_b53(struct switch_dev *sw)
148 {
149         return container_of(sw, struct b53_device, sw_dev);
150 }
151
152 struct b53_device *b53_switch_alloc(struct device *base, struct b53_io_ops *ops,
153                                     void *priv);
154
155 int b53_switch_detect(struct b53_device *dev);
156
157 int b53_switch_register(struct b53_device *dev);
158
159 static inline void b53_switch_remove(struct b53_device *dev)
160 {
161         unregister_switch(&dev->sw_dev);
162 }
163
164 static inline int b53_read8(struct b53_device *dev, u8 page, u8 reg, u8 *val)
165 {
166         int ret;
167
168         mutex_lock(&dev->reg_mutex);
169         ret = dev->ops->read8(dev, page, reg, val);
170         mutex_unlock(&dev->reg_mutex);
171
172         return ret;
173 }
174
175 static inline int b53_read16(struct b53_device *dev, u8 page, u8 reg, u16 *val)
176 {
177         int ret;
178
179         mutex_lock(&dev->reg_mutex);
180         ret = dev->ops->read16(dev, page, reg, val);
181         mutex_unlock(&dev->reg_mutex);
182
183         return ret;
184 }
185
186 static inline int b53_read32(struct b53_device *dev, u8 page, u8 reg, u32 *val)
187 {
188         int ret;
189
190         mutex_lock(&dev->reg_mutex);
191         ret = dev->ops->read32(dev, page, reg, val);
192         mutex_unlock(&dev->reg_mutex);
193
194         return ret;
195 }
196
197 static inline int b53_read48(struct b53_device *dev, u8 page, u8 reg, u64 *val)
198 {
199         int ret;
200
201         mutex_lock(&dev->reg_mutex);
202         ret = dev->ops->read48(dev, page, reg, val);
203         mutex_unlock(&dev->reg_mutex);
204
205         return ret;
206 }
207
208 static inline int b53_read64(struct b53_device *dev, u8 page, u8 reg, u64 *val)
209 {
210         int ret;
211
212         mutex_lock(&dev->reg_mutex);
213         ret = dev->ops->read64(dev, page, reg, val);
214         mutex_unlock(&dev->reg_mutex);
215
216         return ret;
217 }
218
219 static inline int b53_write8(struct b53_device *dev, u8 page, u8 reg, u8 value)
220 {
221         int ret;
222
223         mutex_lock(&dev->reg_mutex);
224         ret = dev->ops->write8(dev, page, reg, value);
225         mutex_unlock(&dev->reg_mutex);
226
227         return ret;
228 }
229
230 static inline int b53_write16(struct b53_device *dev, u8 page, u8 reg,
231                               u16 value)
232 {
233         int ret;
234
235         mutex_lock(&dev->reg_mutex);
236         ret = dev->ops->write16(dev, page, reg, value);
237         mutex_unlock(&dev->reg_mutex);
238
239         return ret;
240 }
241
242 static inline int b53_write32(struct b53_device *dev, u8 page, u8 reg,
243                               u32 value)
244 {
245         int ret;
246
247         mutex_lock(&dev->reg_mutex);
248         ret = dev->ops->write32(dev, page, reg, value);
249         mutex_unlock(&dev->reg_mutex);
250
251         return ret;
252 }
253
254 static inline int b53_write48(struct b53_device *dev, u8 page, u8 reg,
255                               u64 value)
256 {
257         int ret;
258
259         mutex_lock(&dev->reg_mutex);
260         ret = dev->ops->write48(dev, page, reg, value);
261         mutex_unlock(&dev->reg_mutex);
262
263         return ret;
264 }
265
266 static inline int b53_write64(struct b53_device *dev, u8 page, u8 reg,
267                                u64 value)
268 {
269         int ret;
270
271         mutex_lock(&dev->reg_mutex);
272         ret = dev->ops->write64(dev, page, reg, value);
273         mutex_unlock(&dev->reg_mutex);
274
275         return ret;
276 }
277
278 #endif