1
2
3
4#include <uapi/linux/if_bridge.h>
5#include <soc/mscc/ocelot_vcap.h>
6#include <soc/mscc/ocelot_qsys.h>
7#include <soc/mscc/ocelot_sys.h>
8#include <soc/mscc/ocelot_dev.h>
9#include <soc/mscc/ocelot_ana.h>
10#include <soc/mscc/ocelot_ptp.h>
11#include <soc/mscc/ocelot.h>
12#include <linux/packing.h>
13#include <linux/module.h>
14#include <linux/of_net.h>
15#include <linux/pci.h>
16#include <linux/of.h>
17#include <net/pkt_sched.h>
18#include <net/dsa.h>
19#include "felix.h"
20
21static enum dsa_tag_protocol felix_get_tag_protocol(struct dsa_switch *ds,
22 int port,
23 enum dsa_tag_protocol mp)
24{
25 return DSA_TAG_PROTO_OCELOT;
26}
27
28static int felix_set_ageing_time(struct dsa_switch *ds,
29 unsigned int ageing_time)
30{
31 struct ocelot *ocelot = ds->priv;
32
33 ocelot_set_ageing_time(ocelot, ageing_time);
34
35 return 0;
36}
37
38static int felix_fdb_dump(struct dsa_switch *ds, int port,
39 dsa_fdb_dump_cb_t *cb, void *data)
40{
41 struct ocelot *ocelot = ds->priv;
42
43 return ocelot_fdb_dump(ocelot, port, cb, data);
44}
45
46static int felix_fdb_add(struct dsa_switch *ds, int port,
47 const unsigned char *addr, u16 vid)
48{
49 struct ocelot *ocelot = ds->priv;
50
51 return ocelot_fdb_add(ocelot, port, addr, vid);
52}
53
54static int felix_fdb_del(struct dsa_switch *ds, int port,
55 const unsigned char *addr, u16 vid)
56{
57 struct ocelot *ocelot = ds->priv;
58
59 return ocelot_fdb_del(ocelot, port, addr, vid);
60}
61
62static void felix_bridge_stp_state_set(struct dsa_switch *ds, int port,
63 u8 state)
64{
65 struct ocelot *ocelot = ds->priv;
66
67 return ocelot_bridge_stp_state_set(ocelot, port, state);
68}
69
70static int felix_bridge_join(struct dsa_switch *ds, int port,
71 struct net_device *br)
72{
73 struct ocelot *ocelot = ds->priv;
74
75 return ocelot_port_bridge_join(ocelot, port, br);
76}
77
78static void felix_bridge_leave(struct dsa_switch *ds, int port,
79 struct net_device *br)
80{
81 struct ocelot *ocelot = ds->priv;
82
83 ocelot_port_bridge_leave(ocelot, port, br);
84}
85
86
87static int felix_vlan_prepare(struct dsa_switch *ds, int port,
88 const struct switchdev_obj_port_vlan *vlan)
89{
90 return 0;
91}
92
93static int felix_vlan_filtering(struct dsa_switch *ds, int port, bool enabled)
94{
95 struct ocelot *ocelot = ds->priv;
96
97 ocelot_port_vlan_filtering(ocelot, port, enabled);
98
99 return 0;
100}
101
102static void felix_vlan_add(struct dsa_switch *ds, int port,
103 const struct switchdev_obj_port_vlan *vlan)
104{
105 struct ocelot *ocelot = ds->priv;
106 u16 flags = vlan->flags;
107 u16 vid;
108 int err;
109
110 if (dsa_is_cpu_port(ds, port))
111 flags &= ~BRIDGE_VLAN_INFO_UNTAGGED;
112
113 for (vid = vlan->vid_begin; vid <= vlan->vid_end; vid++) {
114 err = ocelot_vlan_add(ocelot, port, vid,
115 flags & BRIDGE_VLAN_INFO_PVID,
116 flags & BRIDGE_VLAN_INFO_UNTAGGED);
117 if (err) {
118 dev_err(ds->dev, "Failed to add VLAN %d to port %d: %d\n",
119 vid, port, err);
120 return;
121 }
122 }
123}
124
125static int felix_vlan_del(struct dsa_switch *ds, int port,
126 const struct switchdev_obj_port_vlan *vlan)
127{
128 struct ocelot *ocelot = ds->priv;
129 u16 vid;
130 int err;
131
132 for (vid = vlan->vid_begin; vid <= vlan->vid_end; vid++) {
133 err = ocelot_vlan_del(ocelot, port, vid);
134 if (err) {
135 dev_err(ds->dev, "Failed to remove VLAN %d from port %d: %d\n",
136 vid, port, err);
137 return err;
138 }
139 }
140 return 0;
141}
142
143static int felix_port_enable(struct dsa_switch *ds, int port,
144 struct phy_device *phy)
145{
146 struct ocelot *ocelot = ds->priv;
147
148 ocelot_port_enable(ocelot, port, phy);
149
150 return 0;
151}
152
153static void felix_port_disable(struct dsa_switch *ds, int port)
154{
155 struct ocelot *ocelot = ds->priv;
156
157 return ocelot_port_disable(ocelot, port);
158}
159
160static void felix_phylink_validate(struct dsa_switch *ds, int port,
161 unsigned long *supported,
162 struct phylink_link_state *state)
163{
164 struct ocelot *ocelot = ds->priv;
165 struct ocelot_port *ocelot_port = ocelot->ports[port];
166 __ETHTOOL_DECLARE_LINK_MODE_MASK(mask) = { 0, };
167
168 if (state->interface != PHY_INTERFACE_MODE_NA &&
169 state->interface != ocelot_port->phy_mode) {
170 bitmap_zero(supported, __ETHTOOL_LINK_MODE_MASK_NBITS);
171 return;
172 }
173
174
175 phylink_set_port_modes(mask);
176 phylink_set(mask, Autoneg);
177 phylink_set(mask, Pause);
178 phylink_set(mask, Asym_Pause);
179 phylink_set(mask, 10baseT_Full);
180 phylink_set(mask, 100baseT_Full);
181 phylink_set(mask, 1000baseT_Full);
182
183 if (state->interface == PHY_INTERFACE_MODE_INTERNAL ||
184 state->interface == PHY_INTERFACE_MODE_2500BASEX ||
185 state->interface == PHY_INTERFACE_MODE_USXGMII) {
186 phylink_set(mask, 2500baseT_Full);
187 phylink_set(mask, 2500baseX_Full);
188 }
189
190 bitmap_and(supported, supported, mask,
191 __ETHTOOL_LINK_MODE_MASK_NBITS);
192 bitmap_and(state->advertising, state->advertising, mask,
193 __ETHTOOL_LINK_MODE_MASK_NBITS);
194}
195
196static int felix_phylink_mac_pcs_get_state(struct dsa_switch *ds, int port,
197 struct phylink_link_state *state)
198{
199 struct ocelot *ocelot = ds->priv;
200 struct felix *felix = ocelot_to_felix(ocelot);
201
202 if (felix->info->pcs_link_state)
203 felix->info->pcs_link_state(ocelot, port, state);
204
205 return 0;
206}
207
208static void felix_phylink_mac_config(struct dsa_switch *ds, int port,
209 unsigned int link_an_mode,
210 const struct phylink_link_state *state)
211{
212 struct ocelot *ocelot = ds->priv;
213 struct ocelot_port *ocelot_port = ocelot->ports[port];
214 struct felix *felix = ocelot_to_felix(ocelot);
215 u32 mac_fc_cfg;
216
217
218
219
220 ocelot_port_writel(ocelot_port, DEV_CLOCK_CFG_LINK_SPEED(state->speed),
221 DEV_CLOCK_CFG);
222
223
224
225
226 mac_fc_cfg = SYS_MAC_FC_CFG_FC_LINK_SPEED(state->speed);
227
228
229
230
231 mac_fc_cfg |= SYS_MAC_FC_CFG_RX_FC_ENA;
232
233 if (state->pause & MLO_PAUSE_TX)
234 mac_fc_cfg |= SYS_MAC_FC_CFG_TX_FC_ENA |
235 SYS_MAC_FC_CFG_PAUSE_VAL_CFG(0xffff) |
236 SYS_MAC_FC_CFG_FC_LATENCY_CFG(0x7) |
237 SYS_MAC_FC_CFG_ZERO_PAUSE_ENA;
238 ocelot_write_rix(ocelot, mac_fc_cfg, SYS_MAC_FC_CFG, port);
239
240 ocelot_write_rix(ocelot, 0, ANA_POL_FLOWC, port);
241
242 if (felix->info->pcs_init)
243 felix->info->pcs_init(ocelot, port, link_an_mode, state);
244
245 if (felix->info->port_sched_speed_set)
246 felix->info->port_sched_speed_set(ocelot, port,
247 state->speed);
248}
249
250static void felix_phylink_mac_an_restart(struct dsa_switch *ds, int port)
251{
252 struct ocelot *ocelot = ds->priv;
253 struct felix *felix = ocelot_to_felix(ocelot);
254
255 if (felix->info->pcs_an_restart)
256 felix->info->pcs_an_restart(ocelot, port);
257}
258
259static void felix_phylink_mac_link_down(struct dsa_switch *ds, int port,
260 unsigned int link_an_mode,
261 phy_interface_t interface)
262{
263 struct ocelot *ocelot = ds->priv;
264 struct ocelot_port *ocelot_port = ocelot->ports[port];
265
266 ocelot_port_writel(ocelot_port, 0, DEV_MAC_ENA_CFG);
267 ocelot_rmw_rix(ocelot, 0, QSYS_SWITCH_PORT_MODE_PORT_ENA,
268 QSYS_SWITCH_PORT_MODE, port);
269}
270
271static void felix_phylink_mac_link_up(struct dsa_switch *ds, int port,
272 unsigned int link_an_mode,
273 phy_interface_t interface,
274 struct phy_device *phydev,
275 int speed, int duplex,
276 bool tx_pause, bool rx_pause)
277{
278 struct ocelot *ocelot = ds->priv;
279 struct ocelot_port *ocelot_port = ocelot->ports[port];
280
281
282 ocelot_port_writel(ocelot_port, DEV_MAC_ENA_CFG_RX_ENA |
283 DEV_MAC_ENA_CFG_TX_ENA, DEV_MAC_ENA_CFG);
284
285
286
287
288 ocelot_write_gix(ocelot, ANA_PORT_PORT_CFG_LEARNAUTO |
289 ANA_PORT_PORT_CFG_RECV_ENA |
290 ANA_PORT_PORT_CFG_PORTID_VAL(port),
291 ANA_PORT_PORT_CFG, port);
292
293
294 ocelot_write_rix(ocelot, QSYS_SWITCH_PORT_MODE_INGRESS_DROP_MODE |
295 QSYS_SWITCH_PORT_MODE_SCH_NEXT_CFG(1) |
296 QSYS_SWITCH_PORT_MODE_PORT_ENA,
297 QSYS_SWITCH_PORT_MODE, port);
298}
299
300static void felix_port_qos_map_init(struct ocelot *ocelot, int port)
301{
302 int i;
303
304 ocelot_rmw_gix(ocelot,
305 ANA_PORT_QOS_CFG_QOS_PCP_ENA,
306 ANA_PORT_QOS_CFG_QOS_PCP_ENA,
307 ANA_PORT_QOS_CFG,
308 port);
309
310 for (i = 0; i < FELIX_NUM_TC * 2; i++) {
311 ocelot_rmw_ix(ocelot,
312 (ANA_PORT_PCP_DEI_MAP_DP_PCP_DEI_VAL & i) |
313 ANA_PORT_PCP_DEI_MAP_QOS_PCP_DEI_VAL(i),
314 ANA_PORT_PCP_DEI_MAP_DP_PCP_DEI_VAL |
315 ANA_PORT_PCP_DEI_MAP_QOS_PCP_DEI_VAL_M,
316 ANA_PORT_PCP_DEI_MAP,
317 port, i);
318 }
319}
320
321static void felix_get_strings(struct dsa_switch *ds, int port,
322 u32 stringset, u8 *data)
323{
324 struct ocelot *ocelot = ds->priv;
325
326 return ocelot_get_strings(ocelot, port, stringset, data);
327}
328
329static void felix_get_ethtool_stats(struct dsa_switch *ds, int port, u64 *data)
330{
331 struct ocelot *ocelot = ds->priv;
332
333 ocelot_get_ethtool_stats(ocelot, port, data);
334}
335
336static int felix_get_sset_count(struct dsa_switch *ds, int port, int sset)
337{
338 struct ocelot *ocelot = ds->priv;
339
340 return ocelot_get_sset_count(ocelot, port, sset);
341}
342
343static int felix_get_ts_info(struct dsa_switch *ds, int port,
344 struct ethtool_ts_info *info)
345{
346 struct ocelot *ocelot = ds->priv;
347
348 return ocelot_get_ts_info(ocelot, port, info);
349}
350
351static int felix_parse_ports_node(struct felix *felix,
352 struct device_node *ports_node,
353 phy_interface_t *port_phy_modes)
354{
355 struct ocelot *ocelot = &felix->ocelot;
356 struct device *dev = felix->ocelot.dev;
357 struct device_node *child;
358
359 for_each_available_child_of_node(ports_node, child) {
360 phy_interface_t phy_mode;
361 u32 port;
362 int err;
363
364
365 if (of_property_read_u32(child, "reg", &port) < 0) {
366 dev_err(dev, "Port number not defined in device tree "
367 "(property \"reg\")\n");
368 of_node_put(child);
369 return -ENODEV;
370 }
371
372
373 err = of_get_phy_mode(child, &phy_mode);
374 if (err) {
375 dev_err(dev, "Failed to read phy-mode or "
376 "phy-interface-type property for port %d\n",
377 port);
378 of_node_put(child);
379 return -ENODEV;
380 }
381
382 err = felix->info->prevalidate_phy_mode(ocelot, port, phy_mode);
383 if (err < 0) {
384 dev_err(dev, "Unsupported PHY mode %s on port %d\n",
385 phy_modes(phy_mode), port);
386 return err;
387 }
388
389 port_phy_modes[port] = phy_mode;
390 }
391
392 return 0;
393}
394
395static int felix_parse_dt(struct felix *felix, phy_interface_t *port_phy_modes)
396{
397 struct device *dev = felix->ocelot.dev;
398 struct device_node *switch_node;
399 struct device_node *ports_node;
400 int err;
401
402 switch_node = dev->of_node;
403
404 ports_node = of_get_child_by_name(switch_node, "ports");
405 if (!ports_node) {
406 dev_err(dev, "Incorrect bindings: absent \"ports\" node\n");
407 return -ENODEV;
408 }
409
410 err = felix_parse_ports_node(felix, ports_node, port_phy_modes);
411 of_node_put(ports_node);
412
413 return err;
414}
415
416static int felix_init_structs(struct felix *felix, int num_phys_ports)
417{
418 struct ocelot *ocelot = &felix->ocelot;
419 phy_interface_t *port_phy_modes;
420 resource_size_t switch_base;
421 struct resource res;
422 int port, i, err;
423
424 ocelot->num_phys_ports = num_phys_ports;
425 ocelot->ports = devm_kcalloc(ocelot->dev, num_phys_ports,
426 sizeof(struct ocelot_port *), GFP_KERNEL);
427 if (!ocelot->ports)
428 return -ENOMEM;
429
430 ocelot->map = felix->info->map;
431 ocelot->stats_layout = felix->info->stats_layout;
432 ocelot->num_stats = felix->info->num_stats;
433 ocelot->shared_queue_sz = felix->info->shared_queue_sz;
434 ocelot->num_mact_rows = felix->info->num_mact_rows;
435 ocelot->vcap_is2_keys = felix->info->vcap_is2_keys;
436 ocelot->vcap_is2_actions= felix->info->vcap_is2_actions;
437 ocelot->vcap = felix->info->vcap;
438 ocelot->ops = felix->info->ops;
439
440 port_phy_modes = kcalloc(num_phys_ports, sizeof(phy_interface_t),
441 GFP_KERNEL);
442 if (!port_phy_modes)
443 return -ENOMEM;
444
445 err = felix_parse_dt(felix, port_phy_modes);
446 if (err) {
447 kfree(port_phy_modes);
448 return err;
449 }
450
451 switch_base = pci_resource_start(felix->pdev,
452 felix->info->switch_pci_bar);
453
454 for (i = 0; i < TARGET_MAX; i++) {
455 struct regmap *target;
456
457 if (!felix->info->target_io_res[i].name)
458 continue;
459
460 memcpy(&res, &felix->info->target_io_res[i], sizeof(res));
461 res.flags = IORESOURCE_MEM;
462 res.start += switch_base;
463 res.end += switch_base;
464
465 target = ocelot_regmap_init(ocelot, &res);
466 if (IS_ERR(target)) {
467 dev_err(ocelot->dev,
468 "Failed to map device memory space\n");
469 kfree(port_phy_modes);
470 return PTR_ERR(target);
471 }
472
473 ocelot->targets[i] = target;
474 }
475
476 err = ocelot_regfields_init(ocelot, felix->info->regfields);
477 if (err) {
478 dev_err(ocelot->dev, "failed to init reg fields map\n");
479 kfree(port_phy_modes);
480 return err;
481 }
482
483 for (port = 0; port < num_phys_ports; port++) {
484 struct ocelot_port *ocelot_port;
485 void __iomem *port_regs;
486
487 ocelot_port = devm_kzalloc(ocelot->dev,
488 sizeof(struct ocelot_port),
489 GFP_KERNEL);
490 if (!ocelot_port) {
491 dev_err(ocelot->dev,
492 "failed to allocate port memory\n");
493 kfree(port_phy_modes);
494 return -ENOMEM;
495 }
496
497 memcpy(&res, &felix->info->port_io_res[port], sizeof(res));
498 res.flags = IORESOURCE_MEM;
499 res.start += switch_base;
500 res.end += switch_base;
501
502 port_regs = devm_ioremap_resource(ocelot->dev, &res);
503 if (IS_ERR(port_regs)) {
504 dev_err(ocelot->dev,
505 "failed to map registers for port %d\n", port);
506 kfree(port_phy_modes);
507 return PTR_ERR(port_regs);
508 }
509
510 ocelot_port->phy_mode = port_phy_modes[port];
511 ocelot_port->ocelot = ocelot;
512 ocelot_port->regs = port_regs;
513 ocelot->ports[port] = ocelot_port;
514 }
515
516 kfree(port_phy_modes);
517
518 if (felix->info->mdio_bus_alloc) {
519 err = felix->info->mdio_bus_alloc(ocelot);
520 if (err < 0)
521 return err;
522 }
523
524 return 0;
525}
526
527static struct ptp_clock_info ocelot_ptp_clock_info = {
528 .owner = THIS_MODULE,
529 .name = "felix ptp",
530 .max_adj = 0x7fffffff,
531 .n_alarm = 0,
532 .n_ext_ts = 0,
533 .n_per_out = OCELOT_PTP_PINS_NUM,
534 .n_pins = OCELOT_PTP_PINS_NUM,
535 .pps = 0,
536 .gettime64 = ocelot_ptp_gettime64,
537 .settime64 = ocelot_ptp_settime64,
538 .adjtime = ocelot_ptp_adjtime,
539 .adjfine = ocelot_ptp_adjfine,
540 .verify = ocelot_ptp_verify,
541 .enable = ocelot_ptp_enable,
542};
543
544
545
546
547
548
549static int felix_setup(struct dsa_switch *ds)
550{
551 struct ocelot *ocelot = ds->priv;
552 struct felix *felix = ocelot_to_felix(ocelot);
553 int port, err;
554 int tc;
555
556 err = felix_init_structs(felix, ds->num_ports);
557 if (err)
558 return err;
559
560 ocelot_init(ocelot);
561 if (ocelot->ptp) {
562 err = ocelot_init_timestamp(ocelot, &ocelot_ptp_clock_info);
563 if (err) {
564 dev_err(ocelot->dev,
565 "Timestamp initialization failed\n");
566 ocelot->ptp = 0;
567 }
568 }
569
570 for (port = 0; port < ds->num_ports; port++) {
571 ocelot_init_port(ocelot, port);
572
573
574 if (dsa_is_cpu_port(ds, port))
575 ocelot_configure_cpu(ocelot, port,
576 OCELOT_TAG_PREFIX_NONE,
577 OCELOT_TAG_PREFIX_LONG);
578
579
580
581
582 felix_port_qos_map_init(ocelot, port);
583 }
584
585
586
587
588
589
590 ocelot_write_rix(ocelot,
591 ANA_PGID_PGID_PGID(GENMASK(ocelot->num_phys_ports, 0)),
592 ANA_PGID_PGID, PGID_UC);
593
594 for (tc = 0; tc < FELIX_NUM_TC; tc++)
595 ocelot_write_rix(ocelot, ANA_FLOODING_FLD_MULTICAST(PGID_MC) |
596 ANA_FLOODING_FLD_BROADCAST(PGID_MC) |
597 ANA_FLOODING_FLD_UNICAST(PGID_UC),
598 ANA_FLOODING, tc);
599
600 ds->mtu_enforcement_ingress = true;
601 ds->configure_vlan_while_not_filtering = true;
602
603
604
605
606 ds->pcs_poll = true;
607
608 return 0;
609}
610
611static void felix_teardown(struct dsa_switch *ds)
612{
613 struct ocelot *ocelot = ds->priv;
614 struct felix *felix = ocelot_to_felix(ocelot);
615
616 if (felix->info->mdio_bus_free)
617 felix->info->mdio_bus_free(ocelot);
618
619 ocelot_deinit_timestamp(ocelot);
620
621 ocelot_deinit(ocelot);
622}
623
624static int felix_hwtstamp_get(struct dsa_switch *ds, int port,
625 struct ifreq *ifr)
626{
627 struct ocelot *ocelot = ds->priv;
628
629 return ocelot_hwstamp_get(ocelot, port, ifr);
630}
631
632static int felix_hwtstamp_set(struct dsa_switch *ds, int port,
633 struct ifreq *ifr)
634{
635 struct ocelot *ocelot = ds->priv;
636
637 return ocelot_hwstamp_set(ocelot, port, ifr);
638}
639
640static bool felix_rxtstamp(struct dsa_switch *ds, int port,
641 struct sk_buff *skb, unsigned int type)
642{
643 struct skb_shared_hwtstamps *shhwtstamps;
644 struct ocelot *ocelot = ds->priv;
645 u8 *extraction = skb->data - ETH_HLEN - OCELOT_TAG_LEN;
646 u32 tstamp_lo, tstamp_hi;
647 struct timespec64 ts;
648 u64 tstamp, val;
649
650 ocelot_ptp_gettime64(&ocelot->ptp_info, &ts);
651 tstamp = ktime_set(ts.tv_sec, ts.tv_nsec);
652
653 packing(extraction, &val, 116, 85, OCELOT_TAG_LEN, UNPACK, 0);
654 tstamp_lo = (u32)val;
655
656 tstamp_hi = tstamp >> 32;
657 if ((tstamp & 0xffffffff) < tstamp_lo)
658 tstamp_hi--;
659
660 tstamp = ((u64)tstamp_hi << 32) | tstamp_lo;
661
662 shhwtstamps = skb_hwtstamps(skb);
663 memset(shhwtstamps, 0, sizeof(struct skb_shared_hwtstamps));
664 shhwtstamps->hwtstamp = tstamp;
665 return false;
666}
667
668static bool felix_txtstamp(struct dsa_switch *ds, int port,
669 struct sk_buff *clone, unsigned int type)
670{
671 struct ocelot *ocelot = ds->priv;
672 struct ocelot_port *ocelot_port = ocelot->ports[port];
673
674 if (!ocelot_port_add_txtstamp_skb(ocelot_port, clone))
675 return true;
676
677 return false;
678}
679
680static int felix_change_mtu(struct dsa_switch *ds, int port, int new_mtu)
681{
682 struct ocelot *ocelot = ds->priv;
683
684 ocelot_port_set_maxlen(ocelot, port, new_mtu);
685
686 return 0;
687}
688
689static int felix_get_max_mtu(struct dsa_switch *ds, int port)
690{
691 struct ocelot *ocelot = ds->priv;
692
693 return ocelot_get_max_mtu(ocelot, port);
694}
695
696static int felix_cls_flower_add(struct dsa_switch *ds, int port,
697 struct flow_cls_offload *cls, bool ingress)
698{
699 struct ocelot *ocelot = ds->priv;
700
701 return ocelot_cls_flower_replace(ocelot, port, cls, ingress);
702}
703
704static int felix_cls_flower_del(struct dsa_switch *ds, int port,
705 struct flow_cls_offload *cls, bool ingress)
706{
707 struct ocelot *ocelot = ds->priv;
708
709 return ocelot_cls_flower_destroy(ocelot, port, cls, ingress);
710}
711
712static int felix_cls_flower_stats(struct dsa_switch *ds, int port,
713 struct flow_cls_offload *cls, bool ingress)
714{
715 struct ocelot *ocelot = ds->priv;
716
717 return ocelot_cls_flower_stats(ocelot, port, cls, ingress);
718}
719
720static int felix_port_policer_add(struct dsa_switch *ds, int port,
721 struct dsa_mall_policer_tc_entry *policer)
722{
723 struct ocelot *ocelot = ds->priv;
724 struct ocelot_policer pol = {
725 .rate = div_u64(policer->rate_bytes_per_sec, 1000) * 8,
726 .burst = div_u64(policer->rate_bytes_per_sec *
727 PSCHED_NS2TICKS(policer->burst),
728 PSCHED_TICKS_PER_SEC),
729 };
730
731 return ocelot_port_policer_add(ocelot, port, &pol);
732}
733
734static void felix_port_policer_del(struct dsa_switch *ds, int port)
735{
736 struct ocelot *ocelot = ds->priv;
737
738 ocelot_port_policer_del(ocelot, port);
739}
740
741static int felix_port_setup_tc(struct dsa_switch *ds, int port,
742 enum tc_setup_type type,
743 void *type_data)
744{
745 struct ocelot *ocelot = ds->priv;
746 struct felix *felix = ocelot_to_felix(ocelot);
747
748 if (felix->info->port_setup_tc)
749 return felix->info->port_setup_tc(ds, port, type, type_data);
750 else
751 return -EOPNOTSUPP;
752}
753
754static const struct dsa_switch_ops felix_switch_ops = {
755 .get_tag_protocol = felix_get_tag_protocol,
756 .setup = felix_setup,
757 .teardown = felix_teardown,
758 .set_ageing_time = felix_set_ageing_time,
759 .get_strings = felix_get_strings,
760 .get_ethtool_stats = felix_get_ethtool_stats,
761 .get_sset_count = felix_get_sset_count,
762 .get_ts_info = felix_get_ts_info,
763 .phylink_validate = felix_phylink_validate,
764 .phylink_mac_link_state = felix_phylink_mac_pcs_get_state,
765 .phylink_mac_config = felix_phylink_mac_config,
766 .phylink_mac_an_restart = felix_phylink_mac_an_restart,
767 .phylink_mac_link_down = felix_phylink_mac_link_down,
768 .phylink_mac_link_up = felix_phylink_mac_link_up,
769 .port_enable = felix_port_enable,
770 .port_disable = felix_port_disable,
771 .port_fdb_dump = felix_fdb_dump,
772 .port_fdb_add = felix_fdb_add,
773 .port_fdb_del = felix_fdb_del,
774 .port_bridge_join = felix_bridge_join,
775 .port_bridge_leave = felix_bridge_leave,
776 .port_stp_state_set = felix_bridge_stp_state_set,
777 .port_vlan_prepare = felix_vlan_prepare,
778 .port_vlan_filtering = felix_vlan_filtering,
779 .port_vlan_add = felix_vlan_add,
780 .port_vlan_del = felix_vlan_del,
781 .port_hwtstamp_get = felix_hwtstamp_get,
782 .port_hwtstamp_set = felix_hwtstamp_set,
783 .port_rxtstamp = felix_rxtstamp,
784 .port_txtstamp = felix_txtstamp,
785 .port_change_mtu = felix_change_mtu,
786 .port_max_mtu = felix_get_max_mtu,
787 .port_policer_add = felix_port_policer_add,
788 .port_policer_del = felix_port_policer_del,
789 .cls_flower_add = felix_cls_flower_add,
790 .cls_flower_del = felix_cls_flower_del,
791 .cls_flower_stats = felix_cls_flower_stats,
792 .port_setup_tc = felix_port_setup_tc,
793};
794
795static struct felix_info *felix_instance_tbl[] = {
796 [FELIX_INSTANCE_VSC9959] = &felix_info_vsc9959,
797};
798
799static irqreturn_t felix_irq_handler(int irq, void *data)
800{
801 struct ocelot *ocelot = (struct ocelot *)data;
802
803
804
805
806
807
808
809
810
811 ocelot_get_txtstamp(ocelot);
812
813 return IRQ_HANDLED;
814}
815
816static int felix_pci_probe(struct pci_dev *pdev,
817 const struct pci_device_id *id)
818{
819 enum felix_instance instance = id->driver_data;
820 struct dsa_switch *ds;
821 struct ocelot *ocelot;
822 struct felix *felix;
823 int err;
824
825 if (pdev->dev.of_node && !of_device_is_available(pdev->dev.of_node)) {
826 dev_info(&pdev->dev, "device is disabled, skipping\n");
827 return -ENODEV;
828 }
829
830 err = pci_enable_device(pdev);
831 if (err) {
832 dev_err(&pdev->dev, "device enable failed\n");
833 goto err_pci_enable;
834 }
835
836
837 err = dma_set_mask_and_coherent(&pdev->dev, DMA_BIT_MASK(64));
838 if (err) {
839 err = dma_set_mask_and_coherent(&pdev->dev, DMA_BIT_MASK(32));
840 if (err) {
841 dev_err(&pdev->dev,
842 "DMA configuration failed: 0x%x\n", err);
843 goto err_dma;
844 }
845 }
846
847 felix = kzalloc(sizeof(struct felix), GFP_KERNEL);
848 if (!felix) {
849 err = -ENOMEM;
850 dev_err(&pdev->dev, "Failed to allocate driver memory\n");
851 goto err_alloc_felix;
852 }
853
854 pci_set_drvdata(pdev, felix);
855 ocelot = &felix->ocelot;
856 ocelot->dev = &pdev->dev;
857 felix->pdev = pdev;
858 felix->info = felix_instance_tbl[instance];
859
860 pci_set_master(pdev);
861
862 err = devm_request_threaded_irq(&pdev->dev, pdev->irq, NULL,
863 &felix_irq_handler, IRQF_ONESHOT,
864 "felix-intb", ocelot);
865 if (err) {
866 dev_err(&pdev->dev, "Failed to request irq\n");
867 goto err_alloc_irq;
868 }
869
870 ocelot->ptp = 1;
871
872 ds = kzalloc(sizeof(struct dsa_switch), GFP_KERNEL);
873 if (!ds) {
874 err = -ENOMEM;
875 dev_err(&pdev->dev, "Failed to allocate DSA switch\n");
876 goto err_alloc_ds;
877 }
878
879 ds->dev = &pdev->dev;
880 ds->num_ports = felix->info->num_ports;
881 ds->num_tx_queues = felix->info->num_tx_queues;
882 ds->ops = &felix_switch_ops;
883 ds->priv = ocelot;
884 felix->ds = ds;
885
886 err = dsa_register_switch(ds);
887 if (err) {
888 dev_err(&pdev->dev, "Failed to register DSA switch: %d\n", err);
889 goto err_register_ds;
890 }
891
892 return 0;
893
894err_register_ds:
895 kfree(ds);
896err_alloc_ds:
897err_alloc_irq:
898err_alloc_felix:
899 kfree(felix);
900err_dma:
901 pci_disable_device(pdev);
902err_pci_enable:
903 return err;
904}
905
906static void felix_pci_remove(struct pci_dev *pdev)
907{
908 struct felix *felix;
909
910 felix = pci_get_drvdata(pdev);
911
912 dsa_unregister_switch(felix->ds);
913
914 kfree(felix->ds);
915 kfree(felix);
916
917 pci_disable_device(pdev);
918}
919
920static struct pci_device_id felix_ids[] = {
921 {
922
923 PCI_DEVICE(PCI_VENDOR_ID_FREESCALE, 0xEEF0),
924 .driver_data = FELIX_INSTANCE_VSC9959,
925 },
926 { 0, }
927};
928MODULE_DEVICE_TABLE(pci, felix_ids);
929
930static struct pci_driver felix_pci_driver = {
931 .name = KBUILD_MODNAME,
932 .id_table = felix_ids,
933 .probe = felix_pci_probe,
934 .remove = felix_pci_remove,
935};
936
937module_pci_driver(felix_pci_driver);
938
939MODULE_DESCRIPTION("Felix Switch driver");
940MODULE_LICENSE("GPL v2");
941
