OpenWrt – Blame information for rev 4

Subversion Repositories:
Rev:
Rev Author Line No. Line
4 office 1 /*
2 * rtl8306.c: RTL8306S switch driver
3 *
4 * Copyright (C) 2009 Felix Fietkau <nbd@nbd.name>
5 *
6 * This program is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU General Public License
8 * version 2 as published by the Free Software Foundation.
9 *
10 * This program is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 * GNU General Public License for more details.
14 */
15  
16 #include <linux/if.h>
17 #include <linux/module.h>
18 #include <linux/init.h>
19 #include <linux/list.h>
20 #include <linux/if_ether.h>
21 #include <linux/skbuff.h>
22 #include <linux/netdevice.h>
23 #include <linux/netlink.h>
24 #include <net/genetlink.h>
25 #include <linux/switch.h>
26 #include <linux/delay.h>
27 #include <linux/phy.h>
28 #include <linux/version.h>
29  
30 //#define DEBUG 1
31  
32 /* Global (PHY0) */
33 #define RTL8306_REG_PAGE 16
34 #define RTL8306_REG_PAGE_LO (1 << 15)
35 #define RTL8306_REG_PAGE_HI (1 << 1) /* inverted */
36  
37 #define RTL8306_NUM_VLANS 16
38 #define RTL8306_NUM_PORTS 6
39 #define RTL8306_PORT_CPU 5
40 #define RTL8306_NUM_PAGES 4
41 #define RTL8306_NUM_REGS 32
42  
43 #define RTL_NAME_S "RTL8306S"
44 #define RTL_NAME_SD "RTL8306SD"
45 #define RTL_NAME_SDM "RTL8306SDM"
46 #define RTL_NAME_UNKNOWN "RTL8306(unknown)"
47  
48 #define RTL8306_MAGIC 0x8306
49  
50 static LIST_HEAD(phydevs);
51  
52 struct rtl_priv {
53 struct list_head list;
54 struct switch_dev dev;
55 int page;
56 int type;
57 int do_cpu;
58 struct mii_bus *bus;
59 char hwname[sizeof(RTL_NAME_UNKNOWN)];
60 bool fixup;
61 };
62  
63 struct rtl_phyregs {
64 int nway;
65 int speed;
66 int duplex;
67 };
68  
69 #define to_rtl(_dev) container_of(_dev, struct rtl_priv, dev)
70  
71 enum {
72 RTL_TYPE_S,
73 RTL_TYPE_SD,
74 RTL_TYPE_SDM,
75 };
76  
77 struct rtl_reg {
78 int page;
79 int phy;
80 int reg;
81 int bits;
82 int shift;
83 int inverted;
84 };
85  
86 #define RTL_VLAN_REGOFS(name) \
87 (RTL_REG_VLAN1_##name - RTL_REG_VLAN0_##name)
88  
89 #define RTL_PORT_REGOFS(name) \
90 (RTL_REG_PORT1_##name - RTL_REG_PORT0_##name)
91  
92 #define RTL_PORT_REG(id, reg) \
93 (RTL_REG_PORT0_##reg + (id * RTL_PORT_REGOFS(reg)))
94  
95 #define RTL_VLAN_REG(id, reg) \
96 (RTL_REG_VLAN0_##reg + (id * RTL_VLAN_REGOFS(reg)))
97  
98 #define RTL_GLOBAL_REGATTR(reg) \
99 .id = RTL_REG_##reg, \
100 .type = SWITCH_TYPE_INT, \
101 .ofs = 0, \
102 .set = rtl_attr_set_int, \
103 .get = rtl_attr_get_int
104  
105 #define RTL_PORT_REGATTR(reg) \
106 .id = RTL_REG_PORT0_##reg, \
107 .type = SWITCH_TYPE_INT, \
108 .ofs = RTL_PORT_REGOFS(reg), \
109 .set = rtl_attr_set_port_int, \
110 .get = rtl_attr_get_port_int
111  
112 #define RTL_VLAN_REGATTR(reg) \
113 .id = RTL_REG_VLAN0_##reg, \
114 .type = SWITCH_TYPE_INT, \
115 .ofs = RTL_VLAN_REGOFS(reg), \
116 .set = rtl_attr_set_vlan_int, \
117 .get = rtl_attr_get_vlan_int
118  
119 enum rtl_regidx {
120 RTL_REG_CHIPID,
121 RTL_REG_CHIPVER,
122 RTL_REG_CHIPTYPE,
123 RTL_REG_CPUPORT,
124  
125 RTL_REG_EN_CPUPORT,
126 RTL_REG_EN_TAG_OUT,
127 RTL_REG_EN_TAG_CLR,
128 RTL_REG_EN_TAG_IN,
129 RTL_REG_TRAP_CPU,
130 RTL_REG_CPU_LINKUP,
131 RTL_REG_TRUNK_PORTSEL,
132 RTL_REG_EN_TRUNK,
133 RTL_REG_RESET,
134  
135 RTL_REG_VLAN_ENABLE,
136 RTL_REG_VLAN_FILTER,
137 RTL_REG_VLAN_TAG_ONLY,
138 RTL_REG_VLAN_TAG_AWARE,
139 #define RTL_VLAN_ENUM(id) \
140 RTL_REG_VLAN##id##_VID, \
141 RTL_REG_VLAN##id##_PORTMASK
142 RTL_VLAN_ENUM(0),
143 RTL_VLAN_ENUM(1),
144 RTL_VLAN_ENUM(2),
145 RTL_VLAN_ENUM(3),
146 RTL_VLAN_ENUM(4),
147 RTL_VLAN_ENUM(5),
148 RTL_VLAN_ENUM(6),
149 RTL_VLAN_ENUM(7),
150 RTL_VLAN_ENUM(8),
151 RTL_VLAN_ENUM(9),
152 RTL_VLAN_ENUM(10),
153 RTL_VLAN_ENUM(11),
154 RTL_VLAN_ENUM(12),
155 RTL_VLAN_ENUM(13),
156 RTL_VLAN_ENUM(14),
157 RTL_VLAN_ENUM(15),
158 #define RTL_PORT_ENUM(id) \
159 RTL_REG_PORT##id##_PVID, \
160 RTL_REG_PORT##id##_NULL_VID_REPLACE, \
161 RTL_REG_PORT##id##_NON_PVID_DISCARD, \
162 RTL_REG_PORT##id##_VID_INSERT, \
163 RTL_REG_PORT##id##_TAG_INSERT, \
164 RTL_REG_PORT##id##_LINK, \
165 RTL_REG_PORT##id##_SPEED, \
166 RTL_REG_PORT##id##_NWAY, \
167 RTL_REG_PORT##id##_NRESTART, \
168 RTL_REG_PORT##id##_DUPLEX, \
169 RTL_REG_PORT##id##_RXEN, \
170 RTL_REG_PORT##id##_TXEN
171 RTL_PORT_ENUM(0),
172 RTL_PORT_ENUM(1),
173 RTL_PORT_ENUM(2),
174 RTL_PORT_ENUM(3),
175 RTL_PORT_ENUM(4),
176 RTL_PORT_ENUM(5),
177 };
178  
179 static const struct rtl_reg rtl_regs[] = {
180 [RTL_REG_CHIPID] = { 0, 4, 30, 16, 0, 0 },
181 [RTL_REG_CHIPVER] = { 0, 4, 31, 8, 0, 0 },
182 [RTL_REG_CHIPTYPE] = { 0, 4, 31, 2, 8, 0 },
183  
184 /* CPU port number */
185 [RTL_REG_CPUPORT] = { 2, 4, 21, 3, 0, 0 },
186 /* Enable CPU port function */
187 [RTL_REG_EN_CPUPORT] = { 3, 2, 21, 1, 15, 1 },
188 /* Enable CPU port tag insertion */
189 [RTL_REG_EN_TAG_OUT] = { 3, 2, 21, 1, 12, 0 },
190 /* Enable CPU port tag removal */
191 [RTL_REG_EN_TAG_CLR] = { 3, 2, 21, 1, 11, 0 },
192 /* Enable CPU port tag checking */
193 [RTL_REG_EN_TAG_IN] = { 0, 4, 21, 1, 7, 0 },
194 [RTL_REG_EN_TRUNK] = { 0, 0, 19, 1, 11, 1 },
195 [RTL_REG_TRUNK_PORTSEL] = { 0, 0, 16, 1, 6, 1 },
196 [RTL_REG_RESET] = { 0, 0, 16, 1, 12, 0 },
197  
198 [RTL_REG_TRAP_CPU] = { 3, 2, 22, 1, 6, 0 },
199 [RTL_REG_CPU_LINKUP] = { 0, 6, 22, 1, 15, 0 },
200  
201 [RTL_REG_VLAN_TAG_ONLY] = { 0, 0, 16, 1, 8, 1 },
202 [RTL_REG_VLAN_FILTER] = { 0, 0, 16, 1, 9, 1 },
203 [RTL_REG_VLAN_TAG_AWARE] = { 0, 0, 16, 1, 10, 1 },
204 [RTL_REG_VLAN_ENABLE] = { 0, 0, 18, 1, 8, 1 },
205  
206 #define RTL_VLAN_REGS(id, phy, page, regofs) \
207 [RTL_REG_VLAN##id##_VID] = { page, phy, 25 + regofs, 12, 0, 0 }, \
208 [RTL_REG_VLAN##id##_PORTMASK] = { page, phy, 24 + regofs, 6, 0, 0 }
209 RTL_VLAN_REGS( 0, 0, 0, 0),
210 RTL_VLAN_REGS( 1, 1, 0, 0),
211 RTL_VLAN_REGS( 2, 2, 0, 0),
212 RTL_VLAN_REGS( 3, 3, 0, 0),
213 RTL_VLAN_REGS( 4, 4, 0, 0),
214 RTL_VLAN_REGS( 5, 0, 1, 2),
215 RTL_VLAN_REGS( 6, 1, 1, 2),
216 RTL_VLAN_REGS( 7, 2, 1, 2),
217 RTL_VLAN_REGS( 8, 3, 1, 2),
218 RTL_VLAN_REGS( 9, 4, 1, 2),
219 RTL_VLAN_REGS(10, 0, 1, 4),
220 RTL_VLAN_REGS(11, 1, 1, 4),
221 RTL_VLAN_REGS(12, 2, 1, 4),
222 RTL_VLAN_REGS(13, 3, 1, 4),
223 RTL_VLAN_REGS(14, 4, 1, 4),
224 RTL_VLAN_REGS(15, 0, 1, 6),
225  
226 #define REG_PORT_SETTING(port, phy) \
227 [RTL_REG_PORT##port##_SPEED] = { 0, phy, 0, 1, 13, 0 }, \
228 [RTL_REG_PORT##port##_NWAY] = { 0, phy, 0, 1, 12, 0 }, \
229 [RTL_REG_PORT##port##_NRESTART] = { 0, phy, 0, 1, 9, 0 }, \
230 [RTL_REG_PORT##port##_DUPLEX] = { 0, phy, 0, 1, 8, 0 }, \
231 [RTL_REG_PORT##port##_TXEN] = { 0, phy, 24, 1, 11, 0 }, \
232 [RTL_REG_PORT##port##_RXEN] = { 0, phy, 24, 1, 10, 0 }, \
233 [RTL_REG_PORT##port##_LINK] = { 0, phy, 1, 1, 2, 0 }, \
234 [RTL_REG_PORT##port##_NULL_VID_REPLACE] = { 0, phy, 22, 1, 12, 0 }, \
235 [RTL_REG_PORT##port##_NON_PVID_DISCARD] = { 0, phy, 22, 1, 11, 0 }, \
236 [RTL_REG_PORT##port##_VID_INSERT] = { 0, phy, 22, 2, 9, 0 }, \
237 [RTL_REG_PORT##port##_TAG_INSERT] = { 0, phy, 22, 2, 0, 0 }
238  
239 REG_PORT_SETTING(0, 0),
240 REG_PORT_SETTING(1, 1),
241 REG_PORT_SETTING(2, 2),
242 REG_PORT_SETTING(3, 3),
243 REG_PORT_SETTING(4, 4),
244 REG_PORT_SETTING(5, 6),
245  
246 #define REG_PORT_PVID(phy, page, regofs) \
247 { page, phy, 24 + regofs, 4, 12, 0 }
248 [RTL_REG_PORT0_PVID] = REG_PORT_PVID(0, 0, 0),
249 [RTL_REG_PORT1_PVID] = REG_PORT_PVID(1, 0, 0),
250 [RTL_REG_PORT2_PVID] = REG_PORT_PVID(2, 0, 0),
251 [RTL_REG_PORT3_PVID] = REG_PORT_PVID(3, 0, 0),
252 [RTL_REG_PORT4_PVID] = REG_PORT_PVID(4, 0, 0),
253 [RTL_REG_PORT5_PVID] = REG_PORT_PVID(0, 1, 2),
254 };
255  
256  
257 static inline void
258 rtl_set_page(struct rtl_priv *priv, unsigned int page)
259 {
260 struct mii_bus *bus = priv->bus;
261 u16 pgsel;
262  
263 if (priv->fixup)
264 return;
265  
266 if (priv->page == page)
267 return;
268  
269 BUG_ON(page > RTL8306_NUM_PAGES);
270 pgsel = bus->read(bus, 0, RTL8306_REG_PAGE);
271 pgsel &= ~(RTL8306_REG_PAGE_LO | RTL8306_REG_PAGE_HI);
272 if (page & (1 << 0))
273 pgsel |= RTL8306_REG_PAGE_LO;
274 if (!(page & (1 << 1))) /* bit is inverted */
275 pgsel |= RTL8306_REG_PAGE_HI;
276 bus->write(bus, 0, RTL8306_REG_PAGE, pgsel);
277 }
278  
279 static inline int
280 rtl_w16(struct switch_dev *dev, unsigned int page, unsigned int phy, unsigned int reg, u16 val)
281 {
282 struct rtl_priv *priv = to_rtl(dev);
283 struct mii_bus *bus = priv->bus;
284  
285 rtl_set_page(priv, page);
286 bus->write(bus, phy, reg, val);
287 bus->read(bus, phy, reg); /* flush */
288 return 0;
289 }
290  
291 static inline int
292 rtl_r16(struct switch_dev *dev, unsigned int page, unsigned int phy, unsigned int reg)
293 {
294 struct rtl_priv *priv = to_rtl(dev);
295 struct mii_bus *bus = priv->bus;
296  
297 rtl_set_page(priv, page);
298 return bus->read(bus, phy, reg);
299 }
300  
301 static inline u16
302 rtl_rmw(struct switch_dev *dev, unsigned int page, unsigned int phy, unsigned int reg, u16 mask, u16 val)
303 {
304 struct rtl_priv *priv = to_rtl(dev);
305 struct mii_bus *bus = priv->bus;
306 u16 r;
307  
308 rtl_set_page(priv, page);
309 r = bus->read(bus, phy, reg);
310 r &= ~mask;
311 r |= val;
312 bus->write(bus, phy, reg, r);
313 return bus->read(bus, phy, reg); /* flush */
314 }
315  
316  
317 static inline int
318 rtl_get(struct switch_dev *dev, enum rtl_regidx s)
319 {
320 const struct rtl_reg *r = &rtl_regs[s];
321 u16 val;
322  
323 BUG_ON(s >= ARRAY_SIZE(rtl_regs));
324 if (r->bits == 0) /* unimplemented */
325 return 0;
326  
327 val = rtl_r16(dev, r->page, r->phy, r->reg);
328  
329 if (r->shift > 0)
330 val >>= r->shift;
331  
332 if (r->inverted)
333 val = ~val;
334  
335 val &= (1 << r->bits) - 1;
336  
337 return val;
338 }
339  
340 static int
341 rtl_set(struct switch_dev *dev, enum rtl_regidx s, unsigned int val)
342 {
343 const struct rtl_reg *r = &rtl_regs[s];
344 u16 mask = 0xffff;
345  
346 BUG_ON(s >= ARRAY_SIZE(rtl_regs));
347  
348 if (r->bits == 0) /* unimplemented */
349 return 0;
350  
351 if (r->shift > 0)
352 val <<= r->shift;
353  
354 if (r->inverted)
355 val = ~val;
356  
357 if (r->bits != 16) {
358 mask = (1 << r->bits) - 1;
359 mask <<= r->shift;
360 }
361 val &= mask;
362 return rtl_rmw(dev, r->page, r->phy, r->reg, mask, val);
363 }
364  
365 static void
366 rtl_phy_save(struct switch_dev *dev, int port, struct rtl_phyregs *regs)
367 {
368 regs->nway = rtl_get(dev, RTL_PORT_REG(port, NWAY));
369 regs->speed = rtl_get(dev, RTL_PORT_REG(port, SPEED));
370 regs->duplex = rtl_get(dev, RTL_PORT_REG(port, DUPLEX));
371 }
372  
373 static void
374 rtl_phy_restore(struct switch_dev *dev, int port, struct rtl_phyregs *regs)
375 {
376 rtl_set(dev, RTL_PORT_REG(port, NWAY), regs->nway);
377 rtl_set(dev, RTL_PORT_REG(port, SPEED), regs->speed);
378 rtl_set(dev, RTL_PORT_REG(port, DUPLEX), regs->duplex);
379 }
380  
381 static void
382 rtl_port_set_enable(struct switch_dev *dev, int port, int enabled)
383 {
384 rtl_set(dev, RTL_PORT_REG(port, RXEN), enabled);
385 rtl_set(dev, RTL_PORT_REG(port, TXEN), enabled);
386  
387 if ((port >= 5) || !enabled)
388 return;
389  
390 /* restart autonegotiation if enabled */
391 rtl_set(dev, RTL_PORT_REG(port, NRESTART), 1);
392 }
393  
394 static int
395 rtl_hw_apply(struct switch_dev *dev)
396 {
397 int i;
398 int trunk_en, trunk_psel;
399 struct rtl_phyregs port5;
400  
401 rtl_phy_save(dev, 5, &port5);
402  
403 /* disable rx/tx from PHYs */
404 for (i = 0; i < RTL8306_NUM_PORTS - 1; i++) {
405 rtl_port_set_enable(dev, i, 0);
406 }
407  
408 /* save trunking status */
409 trunk_en = rtl_get(dev, RTL_REG_EN_TRUNK);
410 trunk_psel = rtl_get(dev, RTL_REG_TRUNK_PORTSEL);
411  
412 /* trunk port 3 and 4
413 * XXX: Big WTF, but RealTek seems to do it */
414 rtl_set(dev, RTL_REG_EN_TRUNK, 1);
415 rtl_set(dev, RTL_REG_TRUNK_PORTSEL, 1);
416  
417 /* execute the software reset */
418 rtl_set(dev, RTL_REG_RESET, 1);
419  
420 /* wait for the reset to complete,
421 * but don't wait for too long */
422 for (i = 0; i < 10; i++) {
423 if (rtl_get(dev, RTL_REG_RESET) == 0)
424 break;
425  
426 msleep(1);
427 }
428  
429 /* enable rx/tx from PHYs */
430 for (i = 0; i < RTL8306_NUM_PORTS - 1; i++) {
431 rtl_port_set_enable(dev, i, 1);
432 }
433  
434 /* restore trunking settings */
435 rtl_set(dev, RTL_REG_EN_TRUNK, trunk_en);
436 rtl_set(dev, RTL_REG_TRUNK_PORTSEL, trunk_psel);
437 rtl_phy_restore(dev, 5, &port5);
438  
439 rtl_set(dev, RTL_REG_CPU_LINKUP, 1);
440  
441 return 0;
442 }
443  
444 static void
445 rtl_hw_init(struct switch_dev *dev)
446 {
447 struct rtl_priv *priv = to_rtl(dev);
448 int cpu_mask = 1 << dev->cpu_port;
449 int i;
450  
451 rtl_set(dev, RTL_REG_VLAN_ENABLE, 0);
452 rtl_set(dev, RTL_REG_VLAN_FILTER, 0);
453 rtl_set(dev, RTL_REG_EN_TRUNK, 0);
454 rtl_set(dev, RTL_REG_TRUNK_PORTSEL, 0);
455  
456 /* initialize cpu port settings */
457 if (priv->do_cpu) {
458 rtl_set(dev, RTL_REG_CPUPORT, dev->cpu_port);
459 rtl_set(dev, RTL_REG_EN_CPUPORT, 1);
460 } else {
461 rtl_set(dev, RTL_REG_CPUPORT, 7);
462 rtl_set(dev, RTL_REG_EN_CPUPORT, 0);
463 }
464 rtl_set(dev, RTL_REG_EN_TAG_OUT, 0);
465 rtl_set(dev, RTL_REG_EN_TAG_IN, 0);
466 rtl_set(dev, RTL_REG_EN_TAG_CLR, 0);
467  
468 /* reset all vlans */
469 for (i = 0; i < RTL8306_NUM_VLANS; i++) {
470 rtl_set(dev, RTL_VLAN_REG(i, VID), i);
471 rtl_set(dev, RTL_VLAN_REG(i, PORTMASK), 0);
472 }
473  
474 /* default to port isolation */
475 for (i = 0; i < RTL8306_NUM_PORTS; i++) {
476 unsigned long mask;
477  
478 if ((1 << i) == cpu_mask)
479 mask = ((1 << RTL8306_NUM_PORTS) - 1) & ~cpu_mask; /* all bits set */
480 else
481 mask = cpu_mask | (1 << i);
482  
483 rtl_set(dev, RTL_VLAN_REG(i, PORTMASK), mask);
484 rtl_set(dev, RTL_PORT_REG(i, PVID), i);
485 rtl_set(dev, RTL_PORT_REG(i, NULL_VID_REPLACE), 1);
486 rtl_set(dev, RTL_PORT_REG(i, VID_INSERT), 1);
487 rtl_set(dev, RTL_PORT_REG(i, TAG_INSERT), 3);
488 }
489 rtl_hw_apply(dev);
490 }
491  
492 #ifdef DEBUG
493 static int
494 rtl_set_use_cpuport(struct switch_dev *dev, const struct switch_attr *attr, struct switch_val *val)
495 {
496 struct rtl_priv *priv = to_rtl(dev);
497 priv->do_cpu = val->value.i;
498 rtl_hw_init(dev);
499 return 0;
500 }
501  
502 static int
503 rtl_get_use_cpuport(struct switch_dev *dev, const struct switch_attr *attr, struct switch_val *val)
504 {
505 struct rtl_priv *priv = to_rtl(dev);
506 val->value.i = priv->do_cpu;
507 return 0;
508 }
509  
510 static int
511 rtl_set_cpuport(struct switch_dev *dev, const struct switch_attr *attr, struct switch_val *val)
512 {
513 dev->cpu_port = val->value.i;
514 rtl_hw_init(dev);
515 return 0;
516 }
517  
518 static int
519 rtl_get_cpuport(struct switch_dev *dev, const struct switch_attr *attr, struct switch_val *val)
520 {
521 val->value.i = dev->cpu_port;
522 return 0;
523 }
524 #endif
525  
526 static int
527 rtl_reset(struct switch_dev *dev)
528 {
529 rtl_hw_init(dev);
530 return 0;
531 }
532  
533 static int
534 rtl_attr_set_int(struct switch_dev *dev, const struct switch_attr *attr, struct switch_val *val)
535 {
536 int idx = attr->id + (val->port_vlan * attr->ofs);
537 struct rtl_phyregs port;
538  
539 if (attr->id >= ARRAY_SIZE(rtl_regs))
540 return -EINVAL;
541  
542 if ((attr->max > 0) && (val->value.i > attr->max))
543 return -EINVAL;
544  
545 /* access to phy register 22 on port 4/5
546 * needs phy status save/restore */
547 if ((val->port_vlan > 3) &&
548 (rtl_regs[idx].reg == 22) &&
549 (rtl_regs[idx].page == 0)) {
550  
551 rtl_phy_save(dev, val->port_vlan, &port);
552 rtl_set(dev, idx, val->value.i);
553 rtl_phy_restore(dev, val->port_vlan, &port);
554 } else {
555 rtl_set(dev, idx, val->value.i);
556 }
557  
558 return 0;
559 }
560  
561 static int
562 rtl_attr_get_int(struct switch_dev *dev, const struct switch_attr *attr, struct switch_val *val)
563 {
564 int idx = attr->id + (val->port_vlan * attr->ofs);
565  
566 if (idx >= ARRAY_SIZE(rtl_regs))
567 return -EINVAL;
568  
569 val->value.i = rtl_get(dev, idx);
570 return 0;
571 }
572  
573 static int
574 rtl_attr_set_port_int(struct switch_dev *dev, const struct switch_attr *attr, struct switch_val *val)
575 {
576 if (val->port_vlan >= RTL8306_NUM_PORTS)
577 return -EINVAL;
578  
579 return rtl_attr_set_int(dev, attr, val);
580 }
581  
582 static int
583 rtl_attr_get_port_int(struct switch_dev *dev, const struct switch_attr *attr, struct switch_val *val)
584 {
585 if (val->port_vlan >= RTL8306_NUM_PORTS)
586 return -EINVAL;
587 return rtl_attr_get_int(dev, attr, val);
588 }
589  
590 static int
591 rtl_get_port_link(struct switch_dev *dev, int port, struct switch_port_link *link)
592 {
593 if (port >= RTL8306_NUM_PORTS)
594 return -EINVAL;
595  
596 /* in case the link changes from down to up, the register is only updated on read */
597 link->link = rtl_get(dev, RTL_PORT_REG(port, LINK));
598 if (!link->link)
599 link->link = rtl_get(dev, RTL_PORT_REG(port, LINK));
600  
601 if (!link->link)
602 return 0;
603  
604 link->duplex = rtl_get(dev, RTL_PORT_REG(port, DUPLEX));
605 link->aneg = rtl_get(dev, RTL_PORT_REG(port, NWAY));
606  
607 if (rtl_get(dev, RTL_PORT_REG(port, SPEED)))
608 link->speed = SWITCH_PORT_SPEED_100;
609 else
610 link->speed = SWITCH_PORT_SPEED_10;
611  
612 return 0;
613 }
614  
615 static int
616 rtl_attr_set_vlan_int(struct switch_dev *dev, const struct switch_attr *attr, struct switch_val *val)
617 {
618 if (val->port_vlan >= dev->vlans)
619 return -EINVAL;
620  
621 return rtl_attr_set_int(dev, attr, val);
622 }
623  
624 static int
625 rtl_attr_get_vlan_int(struct switch_dev *dev, const struct switch_attr *attr, struct switch_val *val)
626 {
627 if (val->port_vlan >= dev->vlans)
628 return -EINVAL;
629  
630 return rtl_attr_get_int(dev, attr, val);
631 }
632  
633 static int
634 rtl_get_ports(struct switch_dev *dev, struct switch_val *val)
635 {
636 unsigned int i, mask;
637  
638 mask = rtl_get(dev, RTL_VLAN_REG(val->port_vlan, PORTMASK));
639 for (i = 0; i < RTL8306_NUM_PORTS; i++) {
640 struct switch_port *port;
641  
642 if (!(mask & (1 << i)))
643 continue;
644  
645 port = &val->value.ports[val->len];
646 port->id = i;
647 if (rtl_get(dev, RTL_PORT_REG(i, TAG_INSERT)) == 2 || i == dev->cpu_port)
648 port->flags = (1 << SWITCH_PORT_FLAG_TAGGED);
649 val->len++;
650 }
651  
652 return 0;
653 }
654  
655 static int
656 rtl_set_vlan(struct switch_dev *dev, const struct switch_attr *attr, struct switch_val *val)
657 {
658 struct rtl_priv *priv = to_rtl(dev);
659 struct rtl_phyregs port;
660 int en = val->value.i;
661 int i;
662  
663 rtl_set(dev, RTL_REG_EN_TAG_OUT, en && priv->do_cpu);
664 rtl_set(dev, RTL_REG_EN_TAG_IN, en && priv->do_cpu);
665 rtl_set(dev, RTL_REG_EN_TAG_CLR, en && priv->do_cpu);
666 rtl_set(dev, RTL_REG_VLAN_TAG_AWARE, en);
667 if (en)
668 rtl_set(dev, RTL_REG_VLAN_FILTER, en);
669  
670 for (i = 0; i < RTL8306_NUM_PORTS; i++) {
671 if (i > 3)
672 rtl_phy_save(dev, val->port_vlan, &port);
673 rtl_set(dev, RTL_PORT_REG(i, NULL_VID_REPLACE), 1);
674 rtl_set(dev, RTL_PORT_REG(i, VID_INSERT), (en ? (i == dev->cpu_port ? 0 : 1) : 1));
675 rtl_set(dev, RTL_PORT_REG(i, TAG_INSERT), (en ? (i == dev->cpu_port ? 2 : 1) : 3));
676 if (i > 3)
677 rtl_phy_restore(dev, val->port_vlan, &port);
678 }
679 rtl_set(dev, RTL_REG_VLAN_ENABLE, en);
680  
681 return 0;
682 }
683  
684 static int
685 rtl_get_vlan(struct switch_dev *dev, const struct switch_attr *attr, struct switch_val *val)
686 {
687 val->value.i = rtl_get(dev, RTL_REG_VLAN_ENABLE);
688 return 0;
689 }
690  
691 static int
692 rtl_set_ports(struct switch_dev *dev, struct switch_val *val)
693 {
694 unsigned int mask = 0;
695 unsigned int oldmask;
696 int i;
697  
698 for(i = 0; i < val->len; i++)
699 {
700 struct switch_port *port = &val->value.ports[i];
701 bool tagged = false;
702  
703 mask |= (1 << port->id);
704  
705 if (port->id == dev->cpu_port)
706 continue;
707  
708 if ((i == dev->cpu_port) ||
709 (port->flags & (1 << SWITCH_PORT_FLAG_TAGGED)))
710 tagged = true;
711  
712 /* fix up PVIDs for added ports */
713 if (!tagged)
714 rtl_set(dev, RTL_PORT_REG(port->id, PVID), val->port_vlan);
715  
716 rtl_set(dev, RTL_PORT_REG(port->id, NON_PVID_DISCARD), (tagged ? 0 : 1));
717 rtl_set(dev, RTL_PORT_REG(port->id, VID_INSERT), (tagged ? 0 : 1));
718 rtl_set(dev, RTL_PORT_REG(port->id, TAG_INSERT), (tagged ? 2 : 1));
719 }
720  
721 oldmask = rtl_get(dev, RTL_VLAN_REG(val->port_vlan, PORTMASK));
722 rtl_set(dev, RTL_VLAN_REG(val->port_vlan, PORTMASK), mask);
723  
724 /* fix up PVIDs for removed ports, default to last vlan */
725 oldmask &= ~mask;
726 for (i = 0; i < RTL8306_NUM_PORTS; i++) {
727 if (!(oldmask & (1 << i)))
728 continue;
729  
730 if (i == dev->cpu_port)
731 continue;
732  
733 if (rtl_get(dev, RTL_PORT_REG(i, PVID)) == val->port_vlan)
734 rtl_set(dev, RTL_PORT_REG(i, PVID), dev->vlans - 1);
735 }
736  
737 return 0;
738 }
739  
740 static struct switch_attr rtl_globals[] = {
741 {
742 .type = SWITCH_TYPE_INT,
743 .name = "enable_vlan",
744 .description = "Enable VLAN mode",
745 .max = 1,
746 .set = rtl_set_vlan,
747 .get = rtl_get_vlan,
748 },
749 {
750 RTL_GLOBAL_REGATTR(EN_TRUNK),
751 .name = "trunk",
752 .description = "Enable port trunking",
753 .max = 1,
754 },
755 {
756 RTL_GLOBAL_REGATTR(TRUNK_PORTSEL),
757 .name = "trunk_sel",
758 .description = "Select ports for trunking (0: 0,1 - 1: 3,4)",
759 .max = 1,
760 },
761 #ifdef DEBUG
762 {
763 RTL_GLOBAL_REGATTR(VLAN_FILTER),
764 .name = "vlan_filter",
765 .description = "Filter incoming packets for allowed VLANS",
766 .max = 1,
767 },
768 {
769 .type = SWITCH_TYPE_INT,
770 .name = "cpuport",
771 .description = "CPU Port",
772 .set = rtl_set_cpuport,
773 .get = rtl_get_cpuport,
774 .max = RTL8306_NUM_PORTS,
775 },
776 {
777 .type = SWITCH_TYPE_INT,
778 .name = "use_cpuport",
779 .description = "CPU Port handling flag",
780 .set = rtl_set_use_cpuport,
781 .get = rtl_get_use_cpuport,
782 .max = RTL8306_NUM_PORTS,
783 },
784 {
785 RTL_GLOBAL_REGATTR(TRAP_CPU),
786 .name = "trap_cpu",
787 .description = "VLAN trap to CPU",
788 .max = 1,
789 },
790 {
791 RTL_GLOBAL_REGATTR(VLAN_TAG_AWARE),
792 .name = "vlan_tag_aware",
793 .description = "Enable VLAN tag awareness",
794 .max = 1,
795 },
796 {
797 RTL_GLOBAL_REGATTR(VLAN_TAG_ONLY),
798 .name = "tag_only",
799 .description = "Only accept tagged packets",
800 .max = 1,
801 },
802 #endif
803 };
804 static struct switch_attr rtl_port[] = {
805 {
806 RTL_PORT_REGATTR(PVID),
807 .name = "pvid",
808 .description = "Port VLAN ID",
809 .max = RTL8306_NUM_VLANS - 1,
810 },
811 #ifdef DEBUG
812 {
813 RTL_PORT_REGATTR(NULL_VID_REPLACE),
814 .name = "null_vid",
815 .description = "NULL VID gets replaced by port default vid",
816 .max = 1,
817 },
818 {
819 RTL_PORT_REGATTR(NON_PVID_DISCARD),
820 .name = "non_pvid_discard",
821 .description = "discard packets with VID != PVID",
822 .max = 1,
823 },
824 {
825 RTL_PORT_REGATTR(VID_INSERT),
826 .name = "vid_insert_remove",
827 .description = "how should the switch insert and remove vids ?",
828 .max = 3,
829 },
830 {
831 RTL_PORT_REGATTR(TAG_INSERT),
832 .name = "tag_insert",
833 .description = "tag insertion handling",
834 .max = 3,
835 },
836 #endif
837 };
838  
839 static struct switch_attr rtl_vlan[] = {
840 {
841 RTL_VLAN_REGATTR(VID),
842 .name = "vid",
843 .description = "VLAN ID (1-4095)",
844 .max = 4095,
845 },
846 };
847  
848 static const struct switch_dev_ops rtl8306_ops = {
849 .attr_global = {
850 .attr = rtl_globals,
851 .n_attr = ARRAY_SIZE(rtl_globals),
852 },
853 .attr_port = {
854 .attr = rtl_port,
855 .n_attr = ARRAY_SIZE(rtl_port),
856 },
857 .attr_vlan = {
858 .attr = rtl_vlan,
859 .n_attr = ARRAY_SIZE(rtl_vlan),
860 },
861  
862 .get_vlan_ports = rtl_get_ports,
863 .set_vlan_ports = rtl_set_ports,
864 .apply_config = rtl_hw_apply,
865 .reset_switch = rtl_reset,
866 .get_port_link = rtl_get_port_link,
867 };
868  
869 static int
870 rtl8306_config_init(struct phy_device *pdev)
871 {
872 struct net_device *netdev = pdev->attached_dev;
873 struct rtl_priv *priv = pdev->priv;
874 struct switch_dev *dev = &priv->dev;
875 struct switch_val val;
876 unsigned int chipid, chipver, chiptype;
877 int err;
878  
879 /* Only init the switch for the primary PHY */
880 if (pdev->mdio.addr != 0)
881 return 0;
882  
883 val.value.i = 1;
884 priv->dev.cpu_port = RTL8306_PORT_CPU;
885 priv->dev.ports = RTL8306_NUM_PORTS;
886 priv->dev.vlans = RTL8306_NUM_VLANS;
887 priv->dev.ops = &rtl8306_ops;
888 priv->do_cpu = 0;
889 priv->page = -1;
890 priv->bus = pdev->mdio.bus;
891  
892 chipid = rtl_get(dev, RTL_REG_CHIPID);
893 chipver = rtl_get(dev, RTL_REG_CHIPVER);
894 chiptype = rtl_get(dev, RTL_REG_CHIPTYPE);
895 switch(chiptype) {
896 case 0:
897 case 2:
898 strncpy(priv->hwname, RTL_NAME_S, sizeof(priv->hwname));
899 priv->type = RTL_TYPE_S;
900 break;
901 case 1:
902 strncpy(priv->hwname, RTL_NAME_SD, sizeof(priv->hwname));
903 priv->type = RTL_TYPE_SD;
904 break;
905 case 3:
906 strncpy(priv->hwname, RTL_NAME_SDM, sizeof(priv->hwname));
907 priv->type = RTL_TYPE_SDM;
908 break;
909 default:
910 strncpy(priv->hwname, RTL_NAME_UNKNOWN, sizeof(priv->hwname));
911 break;
912 }
913  
914 dev->name = priv->hwname;
915 rtl_hw_init(dev);
916  
917 printk(KERN_INFO "Registering %s switch with Chip ID: 0x%04x, version: 0x%04x\n", priv->hwname, chipid, chipver);
918  
919 err = register_switch(dev, netdev);
920 if (err < 0) {
921 kfree(priv);
922 return err;
923 }
924  
925 return 0;
926 }
927  
928  
929 static int
930 rtl8306_fixup(struct phy_device *pdev)
931 {
932 struct rtl_priv priv;
933 u16 chipid;
934  
935 /* Attach to primary LAN port and WAN port */
936 if (pdev->mdio.addr != 0 && pdev->mdio.addr != 4)
937 return 0;
938  
939 memset(&priv, 0, sizeof(priv));
940 priv.fixup = true;
941 priv.page = -1;
942 priv.bus = pdev->mdio.bus;
943 chipid = rtl_get(&priv.dev, RTL_REG_CHIPID);
944 if (chipid == 0x5988)
945 pdev->phy_id = RTL8306_MAGIC;
946  
947 return 0;
948 }
949  
950 static int
951 rtl8306_probe(struct phy_device *pdev)
952 {
953 struct rtl_priv *priv;
954  
955 list_for_each_entry(priv, &phydevs, list) {
956 /*
957 * share one rtl_priv instance between virtual phy
958 * devices on the same bus
959 */
960 if (priv->bus == pdev->mdio.bus)
961 goto found;
962 }
963 priv = kzalloc(sizeof(struct rtl_priv), GFP_KERNEL);
964 if (!priv)
965 return -ENOMEM;
966  
967 priv->bus = pdev->mdio.bus;
968  
969 found:
970 pdev->priv = priv;
971 return 0;
972 }
973  
974 static void
975 rtl8306_remove(struct phy_device *pdev)
976 {
977 struct rtl_priv *priv = pdev->priv;
978 unregister_switch(&priv->dev);
979 kfree(priv);
980 }
981  
982 static int
983 rtl8306_config_aneg(struct phy_device *pdev)
984 {
985 struct rtl_priv *priv = pdev->priv;
986  
987 /* Only for WAN */
988 if (pdev->mdio.addr == 0)
989 return 0;
990  
991 /* Restart autonegotiation */
992 rtl_set(&priv->dev, RTL_PORT_REG(4, NWAY), 1);
993 rtl_set(&priv->dev, RTL_PORT_REG(4, NRESTART), 1);
994  
995 return 0;
996 }
997  
998 static int
999 rtl8306_read_status(struct phy_device *pdev)
1000 {
1001 struct rtl_priv *priv = pdev->priv;
1002 struct switch_dev *dev = &priv->dev;
1003  
1004 if (pdev->mdio.addr == 4) {
1005 /* WAN */
1006 pdev->speed = rtl_get(dev, RTL_PORT_REG(4, SPEED)) ? SPEED_100 : SPEED_10;
1007 pdev->duplex = rtl_get(dev, RTL_PORT_REG(4, DUPLEX)) ? DUPLEX_FULL : DUPLEX_HALF;
1008 pdev->link = !!rtl_get(dev, RTL_PORT_REG(4, LINK));
1009 } else {
1010 /* LAN */
1011 pdev->speed = SPEED_100;
1012 pdev->duplex = DUPLEX_FULL;
1013 pdev->link = 1;
1014 }
1015  
1016 /*
1017 * Bypass generic PHY status read,
1018 * it doesn't work with this switch
1019 */
1020 if (pdev->link) {
1021 pdev->state = PHY_RUNNING;
1022 netif_carrier_on(pdev->attached_dev);
1023 pdev->adjust_link(pdev->attached_dev);
1024 } else {
1025 pdev->state = PHY_NOLINK;
1026 netif_carrier_off(pdev->attached_dev);
1027 pdev->adjust_link(pdev->attached_dev);
1028 }
1029  
1030 return 0;
1031 }
1032  
1033  
1034 static struct phy_driver rtl8306_driver = {
1035 .name = "Realtek RTL8306S",
1036 #if (LINUX_VERSION_CODE < KERNEL_VERSION(4,13,0))
1037 .flags = PHY_HAS_MAGICANEG,
1038 #endif
1039 .phy_id = RTL8306_MAGIC,
1040 .phy_id_mask = 0xffffffff,
1041 .features = PHY_BASIC_FEATURES,
1042 .probe = &rtl8306_probe,
1043 .remove = &rtl8306_remove,
1044 .config_init = &rtl8306_config_init,
1045 .config_aneg = &rtl8306_config_aneg,
1046 .read_status = &rtl8306_read_status,
1047 };
1048  
1049  
1050 static int __init
1051 rtl_init(void)
1052 {
1053 phy_register_fixup_for_id(PHY_ANY_ID, rtl8306_fixup);
1054 return phy_driver_register(&rtl8306_driver, THIS_MODULE);
1055 }
1056  
1057 static void __exit
1058 rtl_exit(void)
1059 {
1060 phy_driver_unregister(&rtl8306_driver);
1061 }
1062  
1063 module_init(rtl_init);
1064 module_exit(rtl_exit);
1065 MODULE_LICENSE("GPL");
1066