1 /*-
2 * Copyright (c) 2015 Semihalf
3 * Copyright (c) 2015 Stormshield
4 * All rights reserved.
5 *
6 * Redistribution and use in source and binary forms, with or without
7 * modification, are permitted provided that the following conditions
8 * are met:
9 * 1. Redistributions of source code must retain the above copyright
10 * notice, this list of conditions and the following disclaimer.
11 * 2. Redistributions in binary form must reproduce the above copyright
12 * notice, this list of conditions and the following disclaimer in the
13 * documentation and/or other materials provided with the distribution.
14 *
15 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
16 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
17 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
18 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
19 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
20 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
21 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
22 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
23 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
24 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
25 * SUCH DAMAGE.
26 */
27
28 #include <sys/cdefs.h>
29 __FBSDID("$FreeBSD$");
30
31 #include <sys/types.h>
32 #include <sys/param.h>
33 #include <sys/systm.h>
34 #include <sys/sockio.h>
35 #include <sys/kernel.h>
36 #include <sys/kthread.h>
37 #include <sys/socket.h>
38 #include <sys/module.h>
39 #include <sys/errno.h>
40 #include <sys/bus.h>
41 #include <sys/conf.h>
42 #include <sys/uio.h>
43 #include <sys/fcntl.h>
44
45 #include <net/if.h>
46 #include <net/if_media.h>
47 #include <net/if_types.h>
48
49 #include <machine/bus.h>
50 #include <machine/resource.h>
51
52 #include <arm/mv/mvwin.h>
53 #include <arm/mv/mvreg.h>
54 #include <arm/mv/mvvar.h>
55
56 #include <dev/etherswitch/etherswitch.h>
57 #include <dev/mdio/mdio.h>
58 #include <dev/mii/mii.h>
59 #include <dev/mii/miivar.h>
60 #include <dev/mge/if_mgevar.h>
61
62 #include "e6000swreg.h"
63 #include "etherswitch_if.h"
64 #include "miibus_if.h"
65 #include "mdio_if.h"
66
67 MALLOC_DECLARE(M_E6000SW);
68 MALLOC_DEFINE(M_E6000SW, "e6000sw", "e6000sw switch");
69
70 #define E6000SW_LOCK(_sc) \
71 sx_xlock(&(_sc)->sx)
72 #define E6000SW_UNLOCK(_sc) \
73 sx_unlock(&(_sc)->sx)
74 #define E6000SW_LOCK_ASSERT(_sc, _what) \
75 sx_assert(&(_sc)->sx, (_what))
76 #define E6000SW_TRYLOCK(_sc) \
77 sx_tryxlock(&(_sc)->sx)
78
79 typedef struct e6000sw_softc {
80 device_t dev;
81
82 struct sx sx;
83 struct ifnet *ifp[E6000SW_NUM_PHYS];
84 char *ifname[E6000SW_NUM_PHYS];
85 device_t miibus[E6000SW_NUM_PHYS];
86 struct mii_data *mii[E6000SW_NUM_PHYS];
87 struct callout tick_callout;
88
89 uint32_t cpuports_mask;
90
91 int vid[E6000SW_NUM_VGROUPS];
92 int members[E6000SW_NUM_VGROUPS];
93 int vgroup[E6000SW_NUM_PORTS];
94 } e6000sw_softc_t;
95
96 static etherswitch_info_t etherswitch_info = {
97 .es_nports = E6000SW_NUM_PORTS,
98 .es_nvlangroups = E6000SW_NUM_VGROUPS,
99 .es_name = "Marvell 6000 series switch"
100 };
101
102 static void e6000sw_identify(driver_t *driver, device_t parent);
103 static int e6000sw_probe(device_t dev);
104 static int e6000sw_attach(device_t dev);
105 static int e6000sw_detach(device_t dev);
106 static int e6000sw_readphy(device_t dev, int phy, int reg);
107 static int e6000sw_writephy(device_t dev, int phy, int reg, int data);
108 static etherswitch_info_t* e6000sw_getinfo(device_t dev);
109 static void e6000sw_lock(device_t dev);
110 static void e6000sw_unlock(device_t dev);
111 static int e6000sw_getport(device_t dev, etherswitch_port_t *p);
112 static int e6000sw_setport(device_t dev, etherswitch_port_t *p);
113 static int e6000sw_readreg_wrapper(device_t dev, int addr_reg);
114 static int e6000sw_writereg_wrapper(device_t dev, int addr_reg, int val);
115 static int e6000sw_readphy_wrapper(device_t dev, int phy, int reg);
116 static int e6000sw_writephy_wrapper(device_t dev, int phy, int reg, int data);
117 static int e6000sw_getvgroup_wrapper(device_t dev, etherswitch_vlangroup_t *vg);
118 static int e6000sw_setvgroup_wrapper(device_t dev, etherswitch_vlangroup_t *vg);
119 static int e6000sw_setvgroup(device_t dev, etherswitch_vlangroup_t *vg);
120 static int e6000sw_getvgroup(device_t dev, etherswitch_vlangroup_t *vg);
121 static void e6000sw_setup(device_t dev, e6000sw_softc_t *sc);
122 static void e6000sw_port_vlan_conf(e6000sw_softc_t *sc);
123 static void e6000sw_tick(void *arg);
124 static void e6000sw_set_atustat(device_t dev, e6000sw_softc_t *sc, int bin,
125 int flag);
126 static int e6000sw_atu_flush(device_t dev, e6000sw_softc_t *sc, int flag);
127 static __inline void e6000sw_writereg(e6000sw_softc_t *sc, int addr, int reg,
128 int val);
129 static __inline uint32_t e6000sw_readreg(e6000sw_softc_t *sc, int addr,
130 int reg);
131 static int e6000sw_ifmedia_upd(struct ifnet *ifp);
132 static void e6000sw_ifmedia_sts(struct ifnet *ifp, struct ifmediareq *ifmr);
133 static int e6000sw_atu_mac_table(device_t dev, e6000sw_softc_t *sc, struct
134 atu_opt *atu, int flag);
135 static int e6000sw_get_pvid(e6000sw_softc_t *sc, int port, int *pvid);
136 static int e6000sw_set_pvid(e6000sw_softc_t *sc, int port, int pvid);
137 static __inline int e6000sw_cpuport(e6000sw_softc_t *sc, int port);
138 static __inline struct mii_data *e6000sw_miiforphy(e6000sw_softc_t *sc,
139 unsigned int phy);
140
141 static struct proc *e6000sw_kproc;
142
143 static device_method_t e6000sw_methods[] = {
144 /* device interface */
145 DEVMETHOD(device_identify, e6000sw_identify),
146 DEVMETHOD(device_probe, e6000sw_probe),
147 DEVMETHOD(device_attach, e6000sw_attach),
148 DEVMETHOD(device_detach, e6000sw_detach),
149
150 /* bus interface */
151 DEVMETHOD(bus_add_child, device_add_child_ordered),
152
153 /* mii interface */
154 DEVMETHOD(miibus_readreg, e6000sw_readphy),
155 DEVMETHOD(miibus_writereg, e6000sw_writephy),
156
157 /* etherswitch interface */
158 DEVMETHOD(etherswitch_getinfo, e6000sw_getinfo),
159 DEVMETHOD(etherswitch_lock, e6000sw_lock),
160 DEVMETHOD(etherswitch_unlock, e6000sw_unlock),
161 DEVMETHOD(etherswitch_getport, e6000sw_getport),
162 DEVMETHOD(etherswitch_setport, e6000sw_setport),
163 DEVMETHOD(etherswitch_readreg, e6000sw_readreg_wrapper),
164 DEVMETHOD(etherswitch_writereg, e6000sw_writereg_wrapper),
165 DEVMETHOD(etherswitch_readphyreg, e6000sw_readphy_wrapper),
166 DEVMETHOD(etherswitch_writephyreg, e6000sw_writephy_wrapper),
167 DEVMETHOD(etherswitch_setvgroup, e6000sw_setvgroup_wrapper),
168 DEVMETHOD(etherswitch_getvgroup, e6000sw_getvgroup_wrapper),
169
170 DEVMETHOD_END
171 };
172
173 static devclass_t e6000sw_devclass;
174
175 DEFINE_CLASS_0(e6000sw, e6000sw_driver, e6000sw_methods,
176 sizeof(e6000sw_softc_t));
177
178 DRIVER_MODULE(e6000sw, mdio, e6000sw_driver, e6000sw_devclass, 0, 0);
179 DRIVER_MODULE(etherswitch, e6000sw, etherswitch_driver, etherswitch_devclass, 0,
180 0);
181 DRIVER_MODULE(miibus, e6000sw, miibus_driver, miibus_devclass, 0, 0);
182 MODULE_DEPEND(e6000sw, mdio, 1, 1, 1);
183
184 static void
e6000sw_identify(driver_t * driver,device_t parent)185 e6000sw_identify(driver_t *driver, device_t parent)
186 {
187
188 if (device_find_child(parent, "e6000sw", -1) == NULL)
189 BUS_ADD_CHILD(parent, 0, "e6000sw", -1);
190 }
191
192 static int
e6000sw_probe(device_t dev)193 e6000sw_probe(device_t dev)
194 {
195 e6000sw_softc_t *sc;
196 const char *description;
197 unsigned int id;
198
199 sc = device_get_softc(dev);
200 bzero(sc, sizeof(e6000sw_softc_t));
201 sc->dev = dev;
202 /* Lock is necessary due to assertions. */
203 sx_init(&sc->sx, "e6000sw");
204 E6000SW_LOCK(sc);
205
206 id = e6000sw_readreg(sc, REG_PORT(0), SWITCH_ID);
207
208 switch (id & 0xfff0) {
209 case 0x3520:
210 description = "Marvell 88E6352";
211 break;
212 case 0x1720:
213 description = "Marvell 88E6172";
214 break;
215 case 0x1760:
216 description = "Marvell 88E6176";
217 break;
218 default:
219 E6000SW_UNLOCK(sc);
220 sx_destroy(&sc->sx);
221 device_printf(dev, "Unrecognized device.\n");
222 return (ENXIO);
223 }
224
225 device_set_desc(dev, description);
226
227 E6000SW_UNLOCK(sc);
228
229 return (BUS_PROBE_DEFAULT);
230 }
231
232 static int
e6000sw_attach(device_t dev)233 e6000sw_attach(device_t dev)
234 {
235 e6000sw_softc_t *sc;
236 int phy, err, port;
237 char name[IFNAMSIZ];
238
239 err = 0;
240 sc = device_get_softc(dev);
241 E6000SW_LOCK(sc);
242 sc->cpuports_mask = E6000SW_CPUPORTS_MASK;
243 for (port = 0; port < E6000SW_NUM_PORTS; port++)
244 sc->vgroup[port] = E6000SW_PORT_NO_VGROUP;
245 e6000sw_setup(dev, sc);
246
247 snprintf(name, IFNAMSIZ, "%sport", device_get_nameunit(sc->dev));
248 for (phy = 0; phy < E6000SW_NUM_PHYS; phy++) {
249 sc->ifp[phy] = if_alloc(IFT_ETHER);
250 if (sc->ifp[phy] == NULL)
251 goto out_fail;
252 sc->ifp[phy]->if_softc = sc;
253 sc->ifp[phy]->if_flags |= IFF_UP | IFF_BROADCAST |
254 IFF_DRV_RUNNING | IFF_SIMPLEX;
255 sc->ifname[phy] = malloc(strlen(name) + 1, M_E6000SW, M_WAITOK);
256 if (sc->ifname[phy] == NULL)
257 goto out_fail;
258 bcopy(name, sc->ifname[phy], strlen(name) + 1);
259 if_initname(sc->ifp[phy], sc->ifname[phy], phy);
260 err = mii_attach(sc->dev, &sc->miibus[phy], sc->ifp[phy],
261 e6000sw_ifmedia_upd, e6000sw_ifmedia_sts, BMSR_DEFCAPMASK,
262 phy, MII_OFFSET_ANY, 0);
263 if (err != 0) {
264 device_printf(sc->dev,
265 "attaching PHY %d failed\n",
266 phy);
267 goto out_fail;
268 }
269 sc->mii[phy] = device_get_softc(sc->miibus[phy]);
270 }
271 E6000SW_UNLOCK(sc);
272
273 bus_generic_probe(dev);
274 bus_enumerate_hinted_children(dev);
275 bus_generic_attach(dev);
276
277 kproc_create(e6000sw_tick, sc, &e6000sw_kproc, 0, 0,
278 "e6000sw tick kproc");
279
280 return (0);
281
282 out_fail:
283 e6000sw_detach(dev);
284
285 return (ENXIO);
286 }
287
288 static __inline void
e6000sw_poll_done(e6000sw_softc_t * sc)289 e6000sw_poll_done(e6000sw_softc_t *sc)
290 {
291
292 while (e6000sw_readreg(sc, REG_GLOBAL2, PHY_CMD) &
293 (1 << PHY_CMD_SMI_BUSY))
294 continue;
295 }
296
297
298 /*
299 * PHY registers are paged. Put page index in reg 22 (accessible from every
300 * page), then access specific register.
301 */
302 static int
e6000sw_readphy(device_t dev,int phy,int reg)303 e6000sw_readphy(device_t dev, int phy, int reg)
304 {
305 e6000sw_softc_t *sc;
306 uint32_t val;
307
308 sc = device_get_softc(dev);
309 val = 0;
310
311 if (phy >= E6000SW_NUM_PHYS || reg >= E6000SW_NUM_PHY_REGS) {
312 device_printf(dev, "Wrong register address.\n");
313 return (EINVAL);
314 }
315
316 E6000SW_LOCK_ASSERT(sc, SA_XLOCKED);
317
318 e6000sw_poll_done(sc);
319 val |= 1 << PHY_CMD_SMI_BUSY;
320 val |= PHY_CMD_MODE_MDIO << PHY_CMD_MODE;
321 val |= PHY_CMD_OPCODE_READ << PHY_CMD_OPCODE;
322 val |= (reg << PHY_CMD_REG_ADDR) & PHY_CMD_REG_ADDR_MASK;
323 val |= (phy << PHY_CMD_DEV_ADDR) & PHY_CMD_DEV_ADDR_MASK;
324 e6000sw_writereg(sc, REG_GLOBAL2, SMI_PHY_CMD_REG, val);
325 e6000sw_poll_done(sc);
326 val = e6000sw_readreg(sc, REG_GLOBAL2, SMI_PHY_DATA_REG)
327 & PHY_DATA_MASK;
328
329 return (val);
330 }
331
332 static int
e6000sw_writephy(device_t dev,int phy,int reg,int data)333 e6000sw_writephy(device_t dev, int phy, int reg, int data)
334 {
335 e6000sw_softc_t *sc;
336 uint32_t val;
337
338 sc = device_get_softc(dev);
339 val = 0;
340
341 if (phy >= E6000SW_NUM_PHYS || reg >= E6000SW_NUM_PHY_REGS) {
342 device_printf(dev, "Wrong register address.\n");
343 return (EINVAL);
344 }
345
346 E6000SW_LOCK_ASSERT(sc, SA_XLOCKED);
347
348 e6000sw_poll_done(sc);
349 val |= PHY_CMD_MODE_MDIO << PHY_CMD_MODE;
350 val |= 1 << PHY_CMD_SMI_BUSY;
351 val |= PHY_CMD_OPCODE_WRITE << PHY_CMD_OPCODE;
352 val |= (reg << PHY_CMD_REG_ADDR) & PHY_CMD_REG_ADDR_MASK;
353 val |= (phy << PHY_CMD_DEV_ADDR) & PHY_CMD_DEV_ADDR_MASK;
354 e6000sw_writereg(sc, REG_GLOBAL2, SMI_PHY_DATA_REG,
355 data & PHY_DATA_MASK);
356 e6000sw_writereg(sc, REG_GLOBAL2, SMI_PHY_CMD_REG, val);
357 e6000sw_poll_done(sc);
358
359 return (0);
360 }
361
362 static int
e6000sw_detach(device_t dev)363 e6000sw_detach(device_t dev)
364 {
365 int phy;
366 e6000sw_softc_t *sc;
367
368 sc = device_get_softc(dev);
369 bus_generic_detach(dev);
370 sx_destroy(&sc->sx);
371 for (phy = 0; phy < E6000SW_NUM_PHYS; phy++) {
372 if (sc->miibus[phy] != NULL)
373 device_delete_child(dev, sc->miibus[phy]);
374 if (sc->ifp[phy] != NULL)
375 if_free(sc->ifp[phy]);
376 if (sc->ifname[phy] != NULL)
377 free(sc->ifname[phy], M_E6000SW);
378 }
379
380 return (0);
381 }
382
383 static etherswitch_info_t*
e6000sw_getinfo(device_t dev)384 e6000sw_getinfo(device_t dev)
385 {
386
387 return (ðerswitch_info);
388 }
389
390 static void
e6000sw_lock(device_t dev)391 e6000sw_lock(device_t dev)
392 {
393 struct e6000sw_softc *sc;
394
395 sc = device_get_softc(dev);
396
397 E6000SW_LOCK_ASSERT(sc, SA_UNLOCKED);
398 E6000SW_LOCK(sc);
399 }
400
401 static void
e6000sw_unlock(device_t dev)402 e6000sw_unlock(device_t dev)
403 {
404 struct e6000sw_softc *sc;
405
406 sc = device_get_softc(dev);
407
408 E6000SW_LOCK_ASSERT(sc, SA_XLOCKED);
409 E6000SW_UNLOCK(sc);
410 }
411
412 static int
e6000sw_getport(device_t dev,etherswitch_port_t * p)413 e6000sw_getport(device_t dev, etherswitch_port_t *p)
414 {
415 struct mii_data *mii;
416 int err;
417 struct ifmediareq *ifmr;
418
419 err = 0;
420 e6000sw_softc_t *sc = device_get_softc(dev);
421 E6000SW_LOCK_ASSERT(sc, SA_UNLOCKED);
422
423 E6000SW_LOCK(sc);
424
425 if (p->es_port >= E6000SW_NUM_PORTS ||
426 p->es_port < 0) {
427 err = EINVAL;
428 goto out;
429 }
430
431 e6000sw_get_pvid(sc, p->es_port, &p->es_pvid);
432
433 if (e6000sw_cpuport(sc, p->es_port)) {
434 p->es_flags |= ETHERSWITCH_PORT_CPU;
435 ifmr = &p->es_ifmr;
436 ifmr->ifm_status = IFM_ACTIVE | IFM_AVALID;
437 ifmr->ifm_count = 0;
438 ifmr->ifm_current = ifmr->ifm_active =
439 IFM_ETHER | IFM_1000_T | IFM_FDX;
440 ifmr->ifm_mask = 0;
441 } else {
442 mii = e6000sw_miiforphy(sc, p->es_port);
443 err = ifmedia_ioctl(mii->mii_ifp, &p->es_ifr,
444 &mii->mii_media, SIOCGIFMEDIA);
445 }
446
447 out:
448 E6000SW_UNLOCK(sc);
449 return (err);
450 }
451
452 static int
e6000sw_setport(device_t dev,etherswitch_port_t * p)453 e6000sw_setport(device_t dev, etherswitch_port_t *p)
454 {
455 e6000sw_softc_t *sc;
456 int err;
457 struct mii_data *mii;
458
459 err = 0;
460 sc = device_get_softc(dev);
461 E6000SW_LOCK_ASSERT(sc, SA_UNLOCKED);
462
463 E6000SW_LOCK(sc);
464
465 if (p->es_port >= E6000SW_NUM_PORTS ||
466 p->es_port < 0) {
467 err = EINVAL;
468 goto out;
469 }
470
471 if (p->es_pvid != 0)
472 e6000sw_set_pvid(sc, p->es_port, p->es_pvid);
473 if (!e6000sw_cpuport(sc, p->es_port)) {
474 mii = e6000sw_miiforphy(sc, p->es_port);
475 err = ifmedia_ioctl(mii->mii_ifp, &p->es_ifr, &mii->mii_media,
476 SIOCSIFMEDIA);
477 }
478
479 out:
480 E6000SW_UNLOCK(sc);
481 return (err);
482 }
483
484 /*
485 * Registers in this switch are divided into sections, specified in
486 * documentation. So as to access any of them, section index and reg index
487 * is necessary. etherswitchcfg uses only one variable, so indexes were
488 * compressed into addr_reg: 32 * section_index + reg_index.
489 */
490 static int
e6000sw_readreg_wrapper(device_t dev,int addr_reg)491 e6000sw_readreg_wrapper(device_t dev, int addr_reg)
492 {
493
494 if ((addr_reg > (REG_GLOBAL2 * 32 + REG_NUM_MAX)) ||
495 (addr_reg < (REG_PORT(0) * 32))) {
496 device_printf(dev, "Wrong register address.\n");
497 return (EINVAL);
498 }
499
500 return (e6000sw_readreg(device_get_softc(dev), addr_reg / 32,
501 addr_reg % 32));
502 }
503
504 static int
e6000sw_writereg_wrapper(device_t dev,int addr_reg,int val)505 e6000sw_writereg_wrapper(device_t dev, int addr_reg, int val)
506 {
507
508 if ((addr_reg > (REG_GLOBAL2 * 32 + REG_NUM_MAX)) ||
509 (addr_reg < (REG_PORT(0) * 32))) {
510 device_printf(dev, "Wrong register address.\n");
511 return (EINVAL);
512 }
513 e6000sw_writereg(device_get_softc(dev), addr_reg / 5,
514 addr_reg % 32, val);
515
516 return (0);
517 }
518
519 /*
520 * These wrappers are necessary because PHY accesses from etherswitchcfg
521 * need to be synchronized with locks, while miibus PHY accesses do not.
522 */
523 static int
e6000sw_readphy_wrapper(device_t dev,int phy,int reg)524 e6000sw_readphy_wrapper(device_t dev, int phy, int reg)
525 {
526 e6000sw_softc_t *sc;
527 int ret;
528
529 sc = device_get_softc(dev);
530 E6000SW_LOCK_ASSERT(sc, SA_UNLOCKED);
531
532 E6000SW_LOCK(sc);
533 ret = e6000sw_readphy(dev, phy, reg);
534 E6000SW_UNLOCK(sc);
535
536 return (ret);
537 }
538
539 static int
e6000sw_writephy_wrapper(device_t dev,int phy,int reg,int data)540 e6000sw_writephy_wrapper(device_t dev, int phy, int reg, int data)
541 {
542 e6000sw_softc_t *sc;
543 int ret;
544
545 sc = device_get_softc(dev);
546 E6000SW_LOCK_ASSERT(sc, SA_UNLOCKED);
547
548 E6000SW_LOCK(sc);
549 ret = e6000sw_writephy(dev, phy, reg, data);
550 E6000SW_UNLOCK(sc);
551
552 return (ret);
553 }
554
555 /*
556 * setvgroup/getvgroup called from etherswitchfcg need to be locked,
557 * while internal calls do not.
558 */
559 static int
e6000sw_setvgroup_wrapper(device_t dev,etherswitch_vlangroup_t * vg)560 e6000sw_setvgroup_wrapper(device_t dev, etherswitch_vlangroup_t *vg)
561 {
562 e6000sw_softc_t *sc;
563 int ret;
564
565 sc = device_get_softc(dev);
566 E6000SW_LOCK_ASSERT(sc, SA_UNLOCKED);
567
568 E6000SW_LOCK(sc);
569 ret = e6000sw_setvgroup(dev, vg);
570 E6000SW_UNLOCK(sc);
571
572 return (ret);
573 }
574
575 static int
e6000sw_getvgroup_wrapper(device_t dev,etherswitch_vlangroup_t * vg)576 e6000sw_getvgroup_wrapper(device_t dev, etherswitch_vlangroup_t *vg)
577 {
578 e6000sw_softc_t *sc;
579 int ret;
580
581 sc = device_get_softc(dev);
582 E6000SW_LOCK_ASSERT(sc, SA_UNLOCKED);
583
584 E6000SW_LOCK(sc);
585 ret = e6000sw_getvgroup(dev, vg);
586 E6000SW_UNLOCK(sc);
587
588 return (ret);
589 }
590
591 static __inline void
e6000sw_flush_port(e6000sw_softc_t * sc,int port)592 e6000sw_flush_port(e6000sw_softc_t *sc, int port)
593 {
594 uint32_t reg;
595
596 reg = e6000sw_readreg(sc, REG_PORT(port),
597 PORT_VLAN_MAP);
598 reg &= ~PORT_VLAN_MAP_TABLE_MASK;
599 reg &= ~PORT_VLAN_MAP_FID_MASK;
600 e6000sw_writereg(sc, REG_PORT(port),
601 PORT_VLAN_MAP, reg);
602 if (sc->vgroup[port] != E6000SW_PORT_NO_VGROUP) {
603 /*
604 * If port belonged somewhere, owner-group
605 * should have its entry removed.
606 */
607 sc->members[sc->vgroup[port]] &= ~(1 << port);
608 sc->vgroup[port] = E6000SW_PORT_NO_VGROUP;
609 }
610 }
611
612 static __inline void
e6000sw_port_assign_vgroup(e6000sw_softc_t * sc,int port,int fid,int vgroup,int members)613 e6000sw_port_assign_vgroup(e6000sw_softc_t *sc, int port, int fid, int vgroup,
614 int members)
615 {
616 uint32_t reg;
617
618 reg = e6000sw_readreg(sc, REG_PORT(port),
619 PORT_VLAN_MAP);
620 reg &= ~PORT_VLAN_MAP_TABLE_MASK;
621 reg &= ~PORT_VLAN_MAP_FID_MASK;
622 reg |= members & ~(1 << port);
623 reg |= (fid << PORT_VLAN_MAP_FID) & PORT_VLAN_MAP_FID_MASK;
624 e6000sw_writereg(sc, REG_PORT(port), PORT_VLAN_MAP,
625 reg);
626 sc->vgroup[port] = vgroup;
627 }
628
629 static int
e6000sw_setvgroup(device_t dev,etherswitch_vlangroup_t * vg)630 e6000sw_setvgroup(device_t dev, etherswitch_vlangroup_t *vg)
631 {
632 e6000sw_softc_t *sc;
633 int port, fid;
634
635 sc = device_get_softc(dev);
636 E6000SW_LOCK_ASSERT(sc, SA_XLOCKED);
637
638 if (vg->es_vlangroup >= E6000SW_NUM_VGROUPS)
639 return (EINVAL);
640 if (vg->es_member_ports != vg->es_untagged_ports) {
641 device_printf(dev, "Tagged ports not supported.\n");
642 return (EINVAL);
643 }
644
645 vg->es_untagged_ports &= PORT_VLAN_MAP_TABLE_MASK;
646 fid = vg->es_vlangroup + 1;
647 for (port = 0; port < E6000SW_NUM_PORTS; port++) {
648 if ((sc->members[vg->es_vlangroup] & (1 << port)) ||
649 (vg->es_untagged_ports & (1 << port)))
650 e6000sw_flush_port(sc, port);
651 if (vg->es_untagged_ports & (1 << port))
652 e6000sw_port_assign_vgroup(sc, port, fid,
653 vg->es_vlangroup, vg->es_untagged_ports);
654 }
655 sc->vid[vg->es_vlangroup] = vg->es_vid;
656 sc->members[vg->es_vlangroup] = vg->es_untagged_ports;
657
658 return (0);
659 }
660
661 static int
e6000sw_getvgroup(device_t dev,etherswitch_vlangroup_t * vg)662 e6000sw_getvgroup(device_t dev, etherswitch_vlangroup_t *vg)
663 {
664 e6000sw_softc_t *sc;
665
666 sc = device_get_softc(dev);
667 E6000SW_LOCK_ASSERT(sc, SA_XLOCKED);
668
669 if (vg->es_vlangroup >= E6000SW_NUM_VGROUPS)
670 return (EINVAL);
671 vg->es_untagged_ports = vg->es_member_ports =
672 sc->members[vg->es_vlangroup];
673 vg->es_vid = ETHERSWITCH_VID_VALID;
674
675 return (0);
676 }
677
678 static __inline struct mii_data*
e6000sw_miiforphy(e6000sw_softc_t * sc,unsigned int phy)679 e6000sw_miiforphy(e6000sw_softc_t *sc, unsigned int phy)
680 {
681
682 if (phy >= E6000SW_NUM_PHYS)
683 return (NULL);
684
685 return (device_get_softc(sc->miibus[phy]));
686 }
687
688 static int
e6000sw_ifmedia_upd(struct ifnet * ifp)689 e6000sw_ifmedia_upd(struct ifnet *ifp)
690 {
691 e6000sw_softc_t *sc;
692 struct mii_data *mii;
693
694 sc = ifp->if_softc;
695 mii = e6000sw_miiforphy(sc, ifp->if_dunit);
696 if (mii == NULL)
697 return (ENXIO);
698 mii_mediachg(mii);
699
700 return (0);
701 }
702
703 static void
e6000sw_ifmedia_sts(struct ifnet * ifp,struct ifmediareq * ifmr)704 e6000sw_ifmedia_sts(struct ifnet *ifp, struct ifmediareq *ifmr)
705 {
706 e6000sw_softc_t *sc;
707 struct mii_data *mii;
708
709 sc = ifp->if_softc;
710 mii = e6000sw_miiforphy(sc, ifp->if_dunit);
711
712 if (mii == NULL)
713 return;
714
715 mii_pollstat(mii);
716 ifmr->ifm_active = mii->mii_media_active;
717 ifmr->ifm_status = mii->mii_media_status;
718 }
719
720 static __inline uint32_t
e6000sw_readreg(e6000sw_softc_t * sc,int addr,int reg)721 e6000sw_readreg(e6000sw_softc_t *sc, int addr, int reg)
722 {
723
724 E6000SW_LOCK_ASSERT(sc, SA_XLOCKED);
725
726 return (MDIO_READREG(device_get_parent(sc->dev), addr, reg));
727 }
728
729 static __inline void
e6000sw_writereg(e6000sw_softc_t * sc,int addr,int reg,int val)730 e6000sw_writereg(e6000sw_softc_t *sc, int addr, int reg, int val)
731 {
732
733 E6000SW_LOCK_ASSERT(sc, SA_XLOCKED);
734
735 MDIO_WRITEREG(device_get_parent(sc->dev), addr, reg, val);
736 }
737
738 static __inline int
e6000sw_cpuport(e6000sw_softc_t * sc,int port)739 e6000sw_cpuport(e6000sw_softc_t *sc, int port)
740 {
741
742 return (sc->cpuports_mask & (1 << port));
743 }
744
745 static __inline int
e6000sw_set_pvid(e6000sw_softc_t * sc,int port,int pvid)746 e6000sw_set_pvid(e6000sw_softc_t *sc, int port, int pvid)
747 {
748
749 e6000sw_writereg(sc, REG_PORT(port), PORT_VID, pvid &
750 PORT_VID_DEF_VID_MASK);
751
752 return (0);
753 }
754
755 static __inline int
e6000sw_get_pvid(e6000sw_softc_t * sc,int port,int * pvid)756 e6000sw_get_pvid(e6000sw_softc_t *sc, int port, int *pvid)
757 {
758
759 if (pvid == NULL)
760 return (ENXIO);
761
762 *pvid = e6000sw_readreg(sc, REG_PORT(port), PORT_VID) &
763 PORT_VID_DEF_VID_MASK;
764
765 return (0);
766 }
767
768 static void
e6000sw_tick(void * arg)769 e6000sw_tick (void *arg)
770 {
771 e6000sw_softc_t *sc;
772 struct mii_softc *miisc;
773 int i;
774
775 sc = arg;
776
777 E6000SW_LOCK_ASSERT(sc, SA_UNLOCKED);
778 for (;;) {
779 E6000SW_LOCK(sc);
780 for (i = 0; i < E6000SW_NUM_PHYS; i++) {
781 mii_tick(sc->mii[i]);
782 LIST_FOREACH(miisc, &sc->mii[i]->mii_phys, mii_list) {
783 if (IFM_INST(sc->mii[i]->mii_media.ifm_cur->ifm_media)
784 != miisc->mii_inst)
785 continue;
786 mii_phy_update(miisc, MII_POLLSTAT);
787 }
788 }
789 E6000SW_UNLOCK(sc);
790 pause("e6000sw tick", 1000);
791 }
792 }
793
794 static void
e6000sw_setup(device_t dev,e6000sw_softc_t * sc)795 e6000sw_setup(device_t dev, e6000sw_softc_t *sc)
796 {
797 uint16_t atu_ctrl, atu_age;
798
799 /* Set aging time */
800 e6000sw_writereg(sc, REG_GLOBAL, ATU_CONTROL,
801 (E6000SW_DEFAULT_AGETIME << ATU_CONTROL_AGETIME) |
802 (1 << ATU_CONTROL_LEARN2ALL));
803
804 /* Send all with specific mac address to cpu port */
805 e6000sw_writereg(sc, REG_GLOBAL2, MGMT_EN_2x, MGMT_EN_ALL);
806 e6000sw_writereg(sc, REG_GLOBAL2, MGMT_EN_0x, MGMT_EN_ALL);
807
808 /* Disable Remote Managment */
809 e6000sw_writereg(sc, REG_GLOBAL, SWITCH_GLOBAL_CONTROL2, 0);
810
811 /* Disable loopback filter and flow control messages */
812 e6000sw_writereg(sc, REG_GLOBAL2, SWITCH_MGMT,
813 SWITCH_MGMT_PRI_MASK |
814 (1 << SWITCH_MGMT_RSVD2CPU) |
815 SWITCH_MGMT_FC_PRI_MASK |
816 (1 << SWITCH_MGMT_FORCEFLOW));
817
818 /* Set VLAN configuration */
819 e6000sw_port_vlan_conf(sc);
820
821 e6000sw_atu_flush(dev, sc, NO_OPERATION);
822 e6000sw_atu_mac_table(dev, sc, NULL, NO_OPERATION);
823 e6000sw_set_atustat(dev, sc, 0, COUNT_ALL);
824
825 /* Set ATU AgeTime to 15 seconds */
826 atu_age = 1;
827
828 atu_ctrl = e6000sw_readreg(sc, REG_GLOBAL, ATU_CONTROL);
829
830 /* Set new AgeTime field */
831 atu_ctrl &= ~ATU_CONTROL_AGETIME_MASK;
832 e6000sw_writereg(sc, REG_GLOBAL, ATU_CONTROL, atu_ctrl |
833 (atu_age << ATU_CONTROL_AGETIME));
834 }
835
836 static void
e6000sw_port_vlan_conf(e6000sw_softc_t * sc)837 e6000sw_port_vlan_conf(e6000sw_softc_t *sc)
838 {
839 int port, ret;
840 etherswitch_vlangroup_t vg;
841 device_t dev;
842
843 dev = sc->dev;
844 /* Disable all ports */
845 for (port = 0; port < E6000SW_NUM_PORTS; port++) {
846 ret = e6000sw_readreg(sc, REG_PORT(port), PORT_CONTROL);
847 e6000sw_writereg(sc, REG_PORT(port), PORT_CONTROL,
848 (ret & ~PORT_CONTROL_ENABLE));
849 }
850
851 /* Set port priority */
852 for (port = 0; port < E6000SW_NUM_PORTS; port++) {
853 ret = e6000sw_readreg(sc, REG_PORT(port), PORT_VID);
854 ret &= ~PORT_VID_PRIORITY_MASK;
855 e6000sw_writereg(sc, REG_PORT(port), PORT_VID, ret);
856 }
857
858 vg.es_vlangroup = 0;
859 vg.es_vid = 0;
860 vg.es_member_ports = vg.es_untagged_ports = E6000SW_DEF_VLANGROUP0;
861 e6000sw_setvgroup(dev, &vg);
862 vg.es_vlangroup = 1;
863 vg.es_vid = 1;
864 vg.es_member_ports = vg.es_untagged_ports = E6000SW_DEF_VLANGROUP1;
865 e6000sw_setvgroup(dev, &vg);
866
867 device_printf(dev, "Default vlangroups set.\n");
868 /* Set VID map */
869 for (port = 0; port < E6000SW_NUM_PORTS; port++) {
870 ret = e6000sw_readreg(sc, REG_PORT(port), PORT_VID);
871 ret &= ~PORT_VID_DEF_VID_MASK;
872 ret |= (port + 1);
873 e6000sw_writereg(sc, REG_PORT(port), PORT_VID, ret);
874 }
875
876 /* Enable all ports */
877 for (port = 0; port < E6000SW_NUM_PORTS; port++) {
878 ret = e6000sw_readreg(sc, REG_PORT(port), PORT_CONTROL);
879 e6000sw_writereg(sc, REG_PORT(port), PORT_CONTROL, (ret |
880 PORT_CONTROL_ENABLE));
881 }
882 }
883
884 static void
e6000sw_set_atustat(device_t dev,e6000sw_softc_t * sc,int bin,int flag)885 e6000sw_set_atustat(device_t dev, e6000sw_softc_t *sc, int bin, int flag)
886 {
887 uint16_t ret;
888
889 ret = e6000sw_readreg(sc, REG_GLOBAL2, ATU_STATS);
890 e6000sw_writereg(sc, REG_GLOBAL2, ATU_STATS, (bin << ATU_STATS_BIN ) |
891 (flag << ATU_STATS_FLAG));
892 }
893
894 static int
e6000sw_atu_mac_table(device_t dev,e6000sw_softc_t * sc,struct atu_opt * atu,int flag)895 e6000sw_atu_mac_table(device_t dev, e6000sw_softc_t *sc, struct atu_opt *atu,
896 int flag)
897 {
898 uint16_t ret_opt;
899 uint16_t ret_data;
900 int retries;
901
902 if (flag == NO_OPERATION)
903 return (0);
904 else if ((flag & (LOAD_FROM_FIB | PURGE_FROM_FIB | GET_NEXT_IN_FIB |
905 GET_VIOLATION_DATA | CLEAR_VIOLATION_DATA)) == 0) {
906 device_printf(dev, "Wrong Opcode for ATU operation\n");
907 return (EINVAL);
908 }
909
910 ret_opt = e6000sw_readreg(sc, REG_GLOBAL, ATU_OPERATION);
911
912 if (ret_opt & ATU_UNIT_BUSY) {
913 device_printf(dev, "ATU unit is busy, cannot access"
914 "register\n");
915 return (EBUSY);
916 } else {
917 if(flag & LOAD_FROM_FIB) {
918 ret_data = e6000sw_readreg(sc, REG_GLOBAL, ATU_DATA);
919 e6000sw_writereg(sc, REG_GLOBAL2, ATU_DATA, (ret_data &
920 ~ENTRY_STATE));
921 }
922 e6000sw_writereg(sc, REG_GLOBAL, ATU_MAC_ADDR01, atu->mac_01);
923 e6000sw_writereg(sc, REG_GLOBAL, ATU_MAC_ADDR23, atu->mac_23);
924 e6000sw_writereg(sc, REG_GLOBAL, ATU_MAC_ADDR45, atu->mac_45);
925 e6000sw_writereg(sc, REG_GLOBAL, ATU_FID, atu->fid);
926
927 e6000sw_writereg(sc, REG_GLOBAL, ATU_OPERATION, (ret_opt |
928 ATU_UNIT_BUSY | flag));
929
930 retries = E6000SW_RETRIES;
931 while (--retries & (e6000sw_readreg(sc, REG_GLOBAL,
932 ATU_OPERATION) & ATU_UNIT_BUSY))
933 DELAY(1);
934
935 if (retries == 0)
936 device_printf(dev, "Timeout while flushing\n");
937 else if (flag & GET_NEXT_IN_FIB) {
938 atu->mac_01 = e6000sw_readreg(sc, REG_GLOBAL,
939 ATU_MAC_ADDR01);
940 atu->mac_23 = e6000sw_readreg(sc, REG_GLOBAL,
941 ATU_MAC_ADDR23);
942 atu->mac_45 = e6000sw_readreg(sc, REG_GLOBAL,
943 ATU_MAC_ADDR45);
944 }
945 }
946
947 return (0);
948 }
949
950 static int
e6000sw_atu_flush(device_t dev,e6000sw_softc_t * sc,int flag)951 e6000sw_atu_flush(device_t dev, e6000sw_softc_t *sc, int flag)
952 {
953 uint16_t ret;
954 int retries;
955
956 if (flag == NO_OPERATION)
957 return (0);
958
959 ret = e6000sw_readreg(sc, REG_GLOBAL, ATU_OPERATION);
960 if (ret & ATU_UNIT_BUSY) {
961 device_printf(dev, "Atu unit is busy, cannot flush\n");
962 return (EBUSY);
963 } else {
964 e6000sw_writereg(sc, REG_GLOBAL, ATU_OPERATION, (ret |
965 ATU_UNIT_BUSY | flag));
966 retries = E6000SW_RETRIES;
967 while (--retries & (e6000sw_readreg(sc, REG_GLOBAL,
968 ATU_OPERATION) & ATU_UNIT_BUSY))
969 DELAY(1);
970
971 if (retries == 0)
972 device_printf(dev, "Timeout while flushing\n");
973 }
974
975 return (0);
976 }
977