xref: /openbmc/linux/drivers/net/dsa/ocelot/felix.c (revision 28a134f5a0553110c623c31ceb653a21fbe92be7)
156051948SVladimir Oltean // SPDX-License-Identifier: GPL-2.0
256051948SVladimir Oltean /* Copyright 2019 NXP Semiconductors
356051948SVladimir Oltean  */
456051948SVladimir Oltean #include <uapi/linux/if_bridge.h>
5bdeced75SVladimir Oltean #include <soc/mscc/ocelot_qsys.h>
6bdeced75SVladimir Oltean #include <soc/mscc/ocelot_sys.h>
7bdeced75SVladimir Oltean #include <soc/mscc/ocelot_dev.h>
8bdeced75SVladimir Oltean #include <soc/mscc/ocelot_ana.h>
956051948SVladimir Oltean #include <soc/mscc/ocelot.h>
10c0bcf537SYangbo Lu #include <linux/packing.h>
1156051948SVladimir Oltean #include <linux/module.h>
12bdeced75SVladimir Oltean #include <linux/of_net.h>
1356051948SVladimir Oltean #include <linux/pci.h>
1456051948SVladimir Oltean #include <linux/of.h>
1556051948SVladimir Oltean #include <net/dsa.h>
1656051948SVladimir Oltean #include "felix.h"
1756051948SVladimir Oltean 
1856051948SVladimir Oltean static enum dsa_tag_protocol felix_get_tag_protocol(struct dsa_switch *ds,
194d776482SFlorian Fainelli 						    int port,
204d776482SFlorian Fainelli 						    enum dsa_tag_protocol mp)
2156051948SVladimir Oltean {
2256051948SVladimir Oltean 	return DSA_TAG_PROTO_OCELOT;
2356051948SVladimir Oltean }
2456051948SVladimir Oltean 
2556051948SVladimir Oltean static int felix_set_ageing_time(struct dsa_switch *ds,
2656051948SVladimir Oltean 				 unsigned int ageing_time)
2756051948SVladimir Oltean {
2856051948SVladimir Oltean 	struct ocelot *ocelot = ds->priv;
2956051948SVladimir Oltean 
3056051948SVladimir Oltean 	ocelot_set_ageing_time(ocelot, ageing_time);
3156051948SVladimir Oltean 
3256051948SVladimir Oltean 	return 0;
3356051948SVladimir Oltean }
3456051948SVladimir Oltean 
3556051948SVladimir Oltean static int felix_fdb_dump(struct dsa_switch *ds, int port,
3656051948SVladimir Oltean 			  dsa_fdb_dump_cb_t *cb, void *data)
3756051948SVladimir Oltean {
3856051948SVladimir Oltean 	struct ocelot *ocelot = ds->priv;
3956051948SVladimir Oltean 
4056051948SVladimir Oltean 	return ocelot_fdb_dump(ocelot, port, cb, data);
4156051948SVladimir Oltean }
4256051948SVladimir Oltean 
4356051948SVladimir Oltean static int felix_fdb_add(struct dsa_switch *ds, int port,
4456051948SVladimir Oltean 			 const unsigned char *addr, u16 vid)
4556051948SVladimir Oltean {
4656051948SVladimir Oltean 	struct ocelot *ocelot = ds->priv;
4756051948SVladimir Oltean 	bool vlan_aware;
4856051948SVladimir Oltean 
4956051948SVladimir Oltean 	vlan_aware = dsa_port_is_vlan_filtering(dsa_to_port(ds, port));
5056051948SVladimir Oltean 
5156051948SVladimir Oltean 	return ocelot_fdb_add(ocelot, port, addr, vid, vlan_aware);
5256051948SVladimir Oltean }
5356051948SVladimir Oltean 
5456051948SVladimir Oltean static int felix_fdb_del(struct dsa_switch *ds, int port,
5556051948SVladimir Oltean 			 const unsigned char *addr, u16 vid)
5656051948SVladimir Oltean {
5756051948SVladimir Oltean 	struct ocelot *ocelot = ds->priv;
5856051948SVladimir Oltean 
5956051948SVladimir Oltean 	return ocelot_fdb_del(ocelot, port, addr, vid);
6056051948SVladimir Oltean }
6156051948SVladimir Oltean 
6256051948SVladimir Oltean static void felix_bridge_stp_state_set(struct dsa_switch *ds, int port,
6356051948SVladimir Oltean 				       u8 state)
6456051948SVladimir Oltean {
6556051948SVladimir Oltean 	struct ocelot *ocelot = ds->priv;
6656051948SVladimir Oltean 
6756051948SVladimir Oltean 	return ocelot_bridge_stp_state_set(ocelot, port, state);
6856051948SVladimir Oltean }
6956051948SVladimir Oltean 
7056051948SVladimir Oltean static int felix_bridge_join(struct dsa_switch *ds, int port,
7156051948SVladimir Oltean 			     struct net_device *br)
7256051948SVladimir Oltean {
7356051948SVladimir Oltean 	struct ocelot *ocelot = ds->priv;
7456051948SVladimir Oltean 
7556051948SVladimir Oltean 	return ocelot_port_bridge_join(ocelot, port, br);
7656051948SVladimir Oltean }
7756051948SVladimir Oltean 
7856051948SVladimir Oltean static void felix_bridge_leave(struct dsa_switch *ds, int port,
7956051948SVladimir Oltean 			       struct net_device *br)
8056051948SVladimir Oltean {
8156051948SVladimir Oltean 	struct ocelot *ocelot = ds->priv;
8256051948SVladimir Oltean 
8356051948SVladimir Oltean 	ocelot_port_bridge_leave(ocelot, port, br);
8456051948SVladimir Oltean }
8556051948SVladimir Oltean 
8656051948SVladimir Oltean /* This callback needs to be present */
8756051948SVladimir Oltean static int felix_vlan_prepare(struct dsa_switch *ds, int port,
8856051948SVladimir Oltean 			      const struct switchdev_obj_port_vlan *vlan)
8956051948SVladimir Oltean {
9056051948SVladimir Oltean 	return 0;
9156051948SVladimir Oltean }
9256051948SVladimir Oltean 
9356051948SVladimir Oltean static int felix_vlan_filtering(struct dsa_switch *ds, int port, bool enabled)
9456051948SVladimir Oltean {
9556051948SVladimir Oltean 	struct ocelot *ocelot = ds->priv;
9656051948SVladimir Oltean 
9756051948SVladimir Oltean 	ocelot_port_vlan_filtering(ocelot, port, enabled);
9856051948SVladimir Oltean 
9956051948SVladimir Oltean 	return 0;
10056051948SVladimir Oltean }
10156051948SVladimir Oltean 
10256051948SVladimir Oltean static void felix_vlan_add(struct dsa_switch *ds, int port,
10356051948SVladimir Oltean 			   const struct switchdev_obj_port_vlan *vlan)
10456051948SVladimir Oltean {
10556051948SVladimir Oltean 	struct ocelot *ocelot = ds->priv;
10656051948SVladimir Oltean 	u16 vid;
10756051948SVladimir Oltean 	int err;
10856051948SVladimir Oltean 
10956051948SVladimir Oltean 	for (vid = vlan->vid_begin; vid <= vlan->vid_end; vid++) {
11056051948SVladimir Oltean 		err = ocelot_vlan_add(ocelot, port, vid,
11156051948SVladimir Oltean 				      vlan->flags & BRIDGE_VLAN_INFO_PVID,
11256051948SVladimir Oltean 				      vlan->flags & BRIDGE_VLAN_INFO_UNTAGGED);
11356051948SVladimir Oltean 		if (err) {
11456051948SVladimir Oltean 			dev_err(ds->dev, "Failed to add VLAN %d to port %d: %d\n",
11556051948SVladimir Oltean 				vid, port, err);
11656051948SVladimir Oltean 			return;
11756051948SVladimir Oltean 		}
11856051948SVladimir Oltean 	}
11956051948SVladimir Oltean }
12056051948SVladimir Oltean 
12156051948SVladimir Oltean static int felix_vlan_del(struct dsa_switch *ds, int port,
12256051948SVladimir Oltean 			  const struct switchdev_obj_port_vlan *vlan)
12356051948SVladimir Oltean {
12456051948SVladimir Oltean 	struct ocelot *ocelot = ds->priv;
12556051948SVladimir Oltean 	u16 vid;
12656051948SVladimir Oltean 	int err;
12756051948SVladimir Oltean 
12856051948SVladimir Oltean 	for (vid = vlan->vid_begin; vid <= vlan->vid_end; vid++) {
12956051948SVladimir Oltean 		err = ocelot_vlan_del(ocelot, port, vid);
13056051948SVladimir Oltean 		if (err) {
13156051948SVladimir Oltean 			dev_err(ds->dev, "Failed to remove VLAN %d from port %d: %d\n",
13256051948SVladimir Oltean 				vid, port, err);
13356051948SVladimir Oltean 			return err;
13456051948SVladimir Oltean 		}
13556051948SVladimir Oltean 	}
13656051948SVladimir Oltean 	return 0;
13756051948SVladimir Oltean }
13856051948SVladimir Oltean 
13956051948SVladimir Oltean static int felix_port_enable(struct dsa_switch *ds, int port,
14056051948SVladimir Oltean 			     struct phy_device *phy)
14156051948SVladimir Oltean {
14256051948SVladimir Oltean 	struct ocelot *ocelot = ds->priv;
14356051948SVladimir Oltean 
14456051948SVladimir Oltean 	ocelot_port_enable(ocelot, port, phy);
14556051948SVladimir Oltean 
14656051948SVladimir Oltean 	return 0;
14756051948SVladimir Oltean }
14856051948SVladimir Oltean 
14956051948SVladimir Oltean static void felix_port_disable(struct dsa_switch *ds, int port)
15056051948SVladimir Oltean {
15156051948SVladimir Oltean 	struct ocelot *ocelot = ds->priv;
15256051948SVladimir Oltean 
15356051948SVladimir Oltean 	return ocelot_port_disable(ocelot, port);
15456051948SVladimir Oltean }
15556051948SVladimir Oltean 
156bdeced75SVladimir Oltean static void felix_phylink_validate(struct dsa_switch *ds, int port,
157bdeced75SVladimir Oltean 				   unsigned long *supported,
158bdeced75SVladimir Oltean 				   struct phylink_link_state *state)
159bdeced75SVladimir Oltean {
160bdeced75SVladimir Oltean 	struct ocelot *ocelot = ds->priv;
161bdeced75SVladimir Oltean 	struct ocelot_port *ocelot_port = ocelot->ports[port];
162bdeced75SVladimir Oltean 	__ETHTOOL_DECLARE_LINK_MODE_MASK(mask) = { 0, };
163bdeced75SVladimir Oltean 
164bdeced75SVladimir Oltean 	if (state->interface != PHY_INTERFACE_MODE_NA &&
165bdeced75SVladimir Oltean 	    state->interface != ocelot_port->phy_mode) {
166bdeced75SVladimir Oltean 		bitmap_zero(supported, __ETHTOOL_LINK_MODE_MASK_NBITS);
167bdeced75SVladimir Oltean 		return;
168bdeced75SVladimir Oltean 	}
169bdeced75SVladimir Oltean 
170bdeced75SVladimir Oltean 	/* No half-duplex. */
171bdeced75SVladimir Oltean 	phylink_set_port_modes(mask);
172bdeced75SVladimir Oltean 	phylink_set(mask, Autoneg);
173bdeced75SVladimir Oltean 	phylink_set(mask, Pause);
174bdeced75SVladimir Oltean 	phylink_set(mask, Asym_Pause);
175bdeced75SVladimir Oltean 	phylink_set(mask, 10baseT_Full);
176bdeced75SVladimir Oltean 	phylink_set(mask, 100baseT_Full);
177bdeced75SVladimir Oltean 	phylink_set(mask, 1000baseT_Full);
17874984a19SAlex Marginean 
179*28a134f5SVladimir Oltean 	if (state->interface == PHY_INTERFACE_MODE_INTERNAL ||
180bdeced75SVladimir Oltean 	    state->interface == PHY_INTERFACE_MODE_2500BASEX ||
181bdeced75SVladimir Oltean 	    state->interface == PHY_INTERFACE_MODE_USXGMII) {
182bdeced75SVladimir Oltean 		phylink_set(mask, 2500baseT_Full);
183bdeced75SVladimir Oltean 		phylink_set(mask, 2500baseX_Full);
184bdeced75SVladimir Oltean 	}
185bdeced75SVladimir Oltean 
186bdeced75SVladimir Oltean 	bitmap_and(supported, supported, mask,
187bdeced75SVladimir Oltean 		   __ETHTOOL_LINK_MODE_MASK_NBITS);
188bdeced75SVladimir Oltean 	bitmap_and(state->advertising, state->advertising, mask,
189bdeced75SVladimir Oltean 		   __ETHTOOL_LINK_MODE_MASK_NBITS);
190bdeced75SVladimir Oltean }
191bdeced75SVladimir Oltean 
192bdeced75SVladimir Oltean static int felix_phylink_mac_pcs_get_state(struct dsa_switch *ds, int port,
193bdeced75SVladimir Oltean 					   struct phylink_link_state *state)
194bdeced75SVladimir Oltean {
195bdeced75SVladimir Oltean 	struct ocelot *ocelot = ds->priv;
196bdeced75SVladimir Oltean 	struct felix *felix = ocelot_to_felix(ocelot);
197bdeced75SVladimir Oltean 
198bdeced75SVladimir Oltean 	if (felix->info->pcs_link_state)
199bdeced75SVladimir Oltean 		felix->info->pcs_link_state(ocelot, port, state);
200bdeced75SVladimir Oltean 
201bdeced75SVladimir Oltean 	return 0;
202bdeced75SVladimir Oltean }
203bdeced75SVladimir Oltean 
204bdeced75SVladimir Oltean static void felix_phylink_mac_config(struct dsa_switch *ds, int port,
205bdeced75SVladimir Oltean 				     unsigned int link_an_mode,
206bdeced75SVladimir Oltean 				     const struct phylink_link_state *state)
207bdeced75SVladimir Oltean {
208bdeced75SVladimir Oltean 	struct ocelot *ocelot = ds->priv;
209bdeced75SVladimir Oltean 	struct ocelot_port *ocelot_port = ocelot->ports[port];
210bdeced75SVladimir Oltean 	struct felix *felix = ocelot_to_felix(ocelot);
211bdeced75SVladimir Oltean 	u32 mac_fc_cfg;
212bdeced75SVladimir Oltean 
213bdeced75SVladimir Oltean 	/* Take port out of reset by clearing the MAC_TX_RST, MAC_RX_RST and
214bdeced75SVladimir Oltean 	 * PORT_RST bits in CLOCK_CFG
215bdeced75SVladimir Oltean 	 */
216bdeced75SVladimir Oltean 	ocelot_port_writel(ocelot_port, DEV_CLOCK_CFG_LINK_SPEED(state->speed),
217bdeced75SVladimir Oltean 			   DEV_CLOCK_CFG);
218bdeced75SVladimir Oltean 
219bdeced75SVladimir Oltean 	/* Flow control. Link speed is only used here to evaluate the time
220bdeced75SVladimir Oltean 	 * specification in incoming pause frames.
221bdeced75SVladimir Oltean 	 */
222bdeced75SVladimir Oltean 	mac_fc_cfg = SYS_MAC_FC_CFG_FC_LINK_SPEED(state->speed);
223f3660937SAlex Marginean 
224f3660937SAlex Marginean 	/* handle Rx pause in all cases, with 2500base-X this is used for rate
225f3660937SAlex Marginean 	 * adaptation.
226f3660937SAlex Marginean 	 */
227bdeced75SVladimir Oltean 	mac_fc_cfg |= SYS_MAC_FC_CFG_RX_FC_ENA;
228f3660937SAlex Marginean 
229bdeced75SVladimir Oltean 	if (state->pause & MLO_PAUSE_TX)
230bdeced75SVladimir Oltean 		mac_fc_cfg |= SYS_MAC_FC_CFG_TX_FC_ENA |
231bdeced75SVladimir Oltean 			      SYS_MAC_FC_CFG_PAUSE_VAL_CFG(0xffff) |
232bdeced75SVladimir Oltean 			      SYS_MAC_FC_CFG_FC_LATENCY_CFG(0x7) |
233bdeced75SVladimir Oltean 			      SYS_MAC_FC_CFG_ZERO_PAUSE_ENA;
234bdeced75SVladimir Oltean 	ocelot_write_rix(ocelot, mac_fc_cfg, SYS_MAC_FC_CFG, port);
235bdeced75SVladimir Oltean 
236bdeced75SVladimir Oltean 	ocelot_write_rix(ocelot, 0, ANA_POL_FLOWC, port);
237bdeced75SVladimir Oltean 
238bdeced75SVladimir Oltean 	if (felix->info->pcs_init)
239bdeced75SVladimir Oltean 		felix->info->pcs_init(ocelot, port, link_an_mode, state);
240bdeced75SVladimir Oltean }
241bdeced75SVladimir Oltean 
242bdeced75SVladimir Oltean static void felix_phylink_mac_an_restart(struct dsa_switch *ds, int port)
243bdeced75SVladimir Oltean {
244bdeced75SVladimir Oltean 	struct ocelot *ocelot = ds->priv;
245bdeced75SVladimir Oltean 	struct felix *felix = ocelot_to_felix(ocelot);
246bdeced75SVladimir Oltean 
247bdeced75SVladimir Oltean 	if (felix->info->pcs_an_restart)
248bdeced75SVladimir Oltean 		felix->info->pcs_an_restart(ocelot, port);
249bdeced75SVladimir Oltean }
250bdeced75SVladimir Oltean 
251bdeced75SVladimir Oltean static void felix_phylink_mac_link_down(struct dsa_switch *ds, int port,
252bdeced75SVladimir Oltean 					unsigned int link_an_mode,
253bdeced75SVladimir Oltean 					phy_interface_t interface)
254bdeced75SVladimir Oltean {
255bdeced75SVladimir Oltean 	struct ocelot *ocelot = ds->priv;
256bdeced75SVladimir Oltean 	struct ocelot_port *ocelot_port = ocelot->ports[port];
257bdeced75SVladimir Oltean 
258bdeced75SVladimir Oltean 	ocelot_port_writel(ocelot_port, 0, DEV_MAC_ENA_CFG);
259bdeced75SVladimir Oltean 	ocelot_rmw_rix(ocelot, 0, QSYS_SWITCH_PORT_MODE_PORT_ENA,
260bdeced75SVladimir Oltean 		       QSYS_SWITCH_PORT_MODE, port);
261bdeced75SVladimir Oltean }
262bdeced75SVladimir Oltean 
263bdeced75SVladimir Oltean static void felix_phylink_mac_link_up(struct dsa_switch *ds, int port,
264bdeced75SVladimir Oltean 				      unsigned int link_an_mode,
265bdeced75SVladimir Oltean 				      phy_interface_t interface,
266bdeced75SVladimir Oltean 				      struct phy_device *phydev)
267bdeced75SVladimir Oltean {
268bdeced75SVladimir Oltean 	struct ocelot *ocelot = ds->priv;
269bdeced75SVladimir Oltean 	struct ocelot_port *ocelot_port = ocelot->ports[port];
270bdeced75SVladimir Oltean 
271bdeced75SVladimir Oltean 	/* Enable MAC module */
272bdeced75SVladimir Oltean 	ocelot_port_writel(ocelot_port, DEV_MAC_ENA_CFG_RX_ENA |
273bdeced75SVladimir Oltean 			   DEV_MAC_ENA_CFG_TX_ENA, DEV_MAC_ENA_CFG);
274bdeced75SVladimir Oltean 
275bdeced75SVladimir Oltean 	/* Enable receiving frames on the port, and activate auto-learning of
276bdeced75SVladimir Oltean 	 * MAC addresses.
277bdeced75SVladimir Oltean 	 */
278bdeced75SVladimir Oltean 	ocelot_write_gix(ocelot, ANA_PORT_PORT_CFG_LEARNAUTO |
279bdeced75SVladimir Oltean 			 ANA_PORT_PORT_CFG_RECV_ENA |
280bdeced75SVladimir Oltean 			 ANA_PORT_PORT_CFG_PORTID_VAL(port),
281bdeced75SVladimir Oltean 			 ANA_PORT_PORT_CFG, port);
282bdeced75SVladimir Oltean 
283bdeced75SVladimir Oltean 	/* Core: Enable port for frame transfer */
284bdeced75SVladimir Oltean 	ocelot_write_rix(ocelot, QSYS_SWITCH_PORT_MODE_INGRESS_DROP_MODE |
285bdeced75SVladimir Oltean 			 QSYS_SWITCH_PORT_MODE_SCH_NEXT_CFG(1) |
286bdeced75SVladimir Oltean 			 QSYS_SWITCH_PORT_MODE_PORT_ENA,
287bdeced75SVladimir Oltean 			 QSYS_SWITCH_PORT_MODE, port);
288bdeced75SVladimir Oltean }
289bdeced75SVladimir Oltean 
29056051948SVladimir Oltean static void felix_get_strings(struct dsa_switch *ds, int port,
29156051948SVladimir Oltean 			      u32 stringset, u8 *data)
29256051948SVladimir Oltean {
29356051948SVladimir Oltean 	struct ocelot *ocelot = ds->priv;
29456051948SVladimir Oltean 
29556051948SVladimir Oltean 	return ocelot_get_strings(ocelot, port, stringset, data);
29656051948SVladimir Oltean }
29756051948SVladimir Oltean 
29856051948SVladimir Oltean static void felix_get_ethtool_stats(struct dsa_switch *ds, int port, u64 *data)
29956051948SVladimir Oltean {
30056051948SVladimir Oltean 	struct ocelot *ocelot = ds->priv;
30156051948SVladimir Oltean 
30256051948SVladimir Oltean 	ocelot_get_ethtool_stats(ocelot, port, data);
30356051948SVladimir Oltean }
30456051948SVladimir Oltean 
30556051948SVladimir Oltean static int felix_get_sset_count(struct dsa_switch *ds, int port, int sset)
30656051948SVladimir Oltean {
30756051948SVladimir Oltean 	struct ocelot *ocelot = ds->priv;
30856051948SVladimir Oltean 
30956051948SVladimir Oltean 	return ocelot_get_sset_count(ocelot, port, sset);
31056051948SVladimir Oltean }
31156051948SVladimir Oltean 
31256051948SVladimir Oltean static int felix_get_ts_info(struct dsa_switch *ds, int port,
31356051948SVladimir Oltean 			     struct ethtool_ts_info *info)
31456051948SVladimir Oltean {
31556051948SVladimir Oltean 	struct ocelot *ocelot = ds->priv;
31656051948SVladimir Oltean 
31756051948SVladimir Oltean 	return ocelot_get_ts_info(ocelot, port, info);
31856051948SVladimir Oltean }
31956051948SVladimir Oltean 
320bdeced75SVladimir Oltean static int felix_parse_ports_node(struct felix *felix,
321bdeced75SVladimir Oltean 				  struct device_node *ports_node,
322bdeced75SVladimir Oltean 				  phy_interface_t *port_phy_modes)
323bdeced75SVladimir Oltean {
324bdeced75SVladimir Oltean 	struct ocelot *ocelot = &felix->ocelot;
325bdeced75SVladimir Oltean 	struct device *dev = felix->ocelot.dev;
326bdeced75SVladimir Oltean 	struct device_node *child;
327bdeced75SVladimir Oltean 
32837fe45adSVladimir Oltean 	for_each_available_child_of_node(ports_node, child) {
329bdeced75SVladimir Oltean 		phy_interface_t phy_mode;
330bdeced75SVladimir Oltean 		u32 port;
331bdeced75SVladimir Oltean 		int err;
332bdeced75SVladimir Oltean 
333bdeced75SVladimir Oltean 		/* Get switch port number from DT */
334bdeced75SVladimir Oltean 		if (of_property_read_u32(child, "reg", &port) < 0) {
335bdeced75SVladimir Oltean 			dev_err(dev, "Port number not defined in device tree "
336bdeced75SVladimir Oltean 				"(property \"reg\")\n");
337bdeced75SVladimir Oltean 			of_node_put(child);
338bdeced75SVladimir Oltean 			return -ENODEV;
339bdeced75SVladimir Oltean 		}
340bdeced75SVladimir Oltean 
341bdeced75SVladimir Oltean 		/* Get PHY mode from DT */
342bdeced75SVladimir Oltean 		err = of_get_phy_mode(child, &phy_mode);
343bdeced75SVladimir Oltean 		if (err) {
344bdeced75SVladimir Oltean 			dev_err(dev, "Failed to read phy-mode or "
345bdeced75SVladimir Oltean 				"phy-interface-type property for port %d\n",
346bdeced75SVladimir Oltean 				port);
347bdeced75SVladimir Oltean 			of_node_put(child);
348bdeced75SVladimir Oltean 			return -ENODEV;
349bdeced75SVladimir Oltean 		}
350bdeced75SVladimir Oltean 
351bdeced75SVladimir Oltean 		err = felix->info->prevalidate_phy_mode(ocelot, port, phy_mode);
352bdeced75SVladimir Oltean 		if (err < 0) {
353bdeced75SVladimir Oltean 			dev_err(dev, "Unsupported PHY mode %s on port %d\n",
354bdeced75SVladimir Oltean 				phy_modes(phy_mode), port);
355bdeced75SVladimir Oltean 			return err;
356bdeced75SVladimir Oltean 		}
357bdeced75SVladimir Oltean 
358bdeced75SVladimir Oltean 		port_phy_modes[port] = phy_mode;
359bdeced75SVladimir Oltean 	}
360bdeced75SVladimir Oltean 
361bdeced75SVladimir Oltean 	return 0;
362bdeced75SVladimir Oltean }
363bdeced75SVladimir Oltean 
364bdeced75SVladimir Oltean static int felix_parse_dt(struct felix *felix, phy_interface_t *port_phy_modes)
365bdeced75SVladimir Oltean {
366bdeced75SVladimir Oltean 	struct device *dev = felix->ocelot.dev;
367bdeced75SVladimir Oltean 	struct device_node *switch_node;
368bdeced75SVladimir Oltean 	struct device_node *ports_node;
369bdeced75SVladimir Oltean 	int err;
370bdeced75SVladimir Oltean 
371bdeced75SVladimir Oltean 	switch_node = dev->of_node;
372bdeced75SVladimir Oltean 
373bdeced75SVladimir Oltean 	ports_node = of_get_child_by_name(switch_node, "ports");
374bdeced75SVladimir Oltean 	if (!ports_node) {
375bdeced75SVladimir Oltean 		dev_err(dev, "Incorrect bindings: absent \"ports\" node\n");
376bdeced75SVladimir Oltean 		return -ENODEV;
377bdeced75SVladimir Oltean 	}
378bdeced75SVladimir Oltean 
379bdeced75SVladimir Oltean 	err = felix_parse_ports_node(felix, ports_node, port_phy_modes);
380bdeced75SVladimir Oltean 	of_node_put(ports_node);
381bdeced75SVladimir Oltean 
382bdeced75SVladimir Oltean 	return err;
383bdeced75SVladimir Oltean }
384bdeced75SVladimir Oltean 
38556051948SVladimir Oltean static int felix_init_structs(struct felix *felix, int num_phys_ports)
38656051948SVladimir Oltean {
38756051948SVladimir Oltean 	struct ocelot *ocelot = &felix->ocelot;
388bdeced75SVladimir Oltean 	phy_interface_t *port_phy_modes;
389bdeced75SVladimir Oltean 	resource_size_t switch_base;
39056051948SVladimir Oltean 	int port, i, err;
39156051948SVladimir Oltean 
39256051948SVladimir Oltean 	ocelot->num_phys_ports = num_phys_ports;
39356051948SVladimir Oltean 	ocelot->ports = devm_kcalloc(ocelot->dev, num_phys_ports,
39456051948SVladimir Oltean 				     sizeof(struct ocelot_port *), GFP_KERNEL);
39556051948SVladimir Oltean 	if (!ocelot->ports)
39656051948SVladimir Oltean 		return -ENOMEM;
39756051948SVladimir Oltean 
39856051948SVladimir Oltean 	ocelot->map		= felix->info->map;
39956051948SVladimir Oltean 	ocelot->stats_layout	= felix->info->stats_layout;
40056051948SVladimir Oltean 	ocelot->num_stats	= felix->info->num_stats;
40156051948SVladimir Oltean 	ocelot->shared_queue_sz	= felix->info->shared_queue_sz;
40256051948SVladimir Oltean 	ocelot->ops		= felix->info->ops;
40356051948SVladimir Oltean 
404bdeced75SVladimir Oltean 	port_phy_modes = kcalloc(num_phys_ports, sizeof(phy_interface_t),
405bdeced75SVladimir Oltean 				 GFP_KERNEL);
406bdeced75SVladimir Oltean 	if (!port_phy_modes)
407bdeced75SVladimir Oltean 		return -ENOMEM;
408bdeced75SVladimir Oltean 
409bdeced75SVladimir Oltean 	err = felix_parse_dt(felix, port_phy_modes);
410bdeced75SVladimir Oltean 	if (err) {
411bdeced75SVladimir Oltean 		kfree(port_phy_modes);
412bdeced75SVladimir Oltean 		return err;
413bdeced75SVladimir Oltean 	}
414bdeced75SVladimir Oltean 
415bdeced75SVladimir Oltean 	switch_base = pci_resource_start(felix->pdev,
416bdeced75SVladimir Oltean 					 felix->info->switch_pci_bar);
41756051948SVladimir Oltean 
41856051948SVladimir Oltean 	for (i = 0; i < TARGET_MAX; i++) {
41956051948SVladimir Oltean 		struct regmap *target;
42056051948SVladimir Oltean 		struct resource *res;
42156051948SVladimir Oltean 
42256051948SVladimir Oltean 		if (!felix->info->target_io_res[i].name)
42356051948SVladimir Oltean 			continue;
42456051948SVladimir Oltean 
42556051948SVladimir Oltean 		res = &felix->info->target_io_res[i];
42656051948SVladimir Oltean 		res->flags = IORESOURCE_MEM;
427bdeced75SVladimir Oltean 		res->start += switch_base;
428bdeced75SVladimir Oltean 		res->end += switch_base;
42956051948SVladimir Oltean 
43056051948SVladimir Oltean 		target = ocelot_regmap_init(ocelot, res);
43156051948SVladimir Oltean 		if (IS_ERR(target)) {
43256051948SVladimir Oltean 			dev_err(ocelot->dev,
43356051948SVladimir Oltean 				"Failed to map device memory space\n");
434bdeced75SVladimir Oltean 			kfree(port_phy_modes);
43556051948SVladimir Oltean 			return PTR_ERR(target);
43656051948SVladimir Oltean 		}
43756051948SVladimir Oltean 
43856051948SVladimir Oltean 		ocelot->targets[i] = target;
43956051948SVladimir Oltean 	}
44056051948SVladimir Oltean 
44156051948SVladimir Oltean 	err = ocelot_regfields_init(ocelot, felix->info->regfields);
44256051948SVladimir Oltean 	if (err) {
44356051948SVladimir Oltean 		dev_err(ocelot->dev, "failed to init reg fields map\n");
444bdeced75SVladimir Oltean 		kfree(port_phy_modes);
44556051948SVladimir Oltean 		return err;
44656051948SVladimir Oltean 	}
44756051948SVladimir Oltean 
44856051948SVladimir Oltean 	for (port = 0; port < num_phys_ports; port++) {
44956051948SVladimir Oltean 		struct ocelot_port *ocelot_port;
45056051948SVladimir Oltean 		void __iomem *port_regs;
45156051948SVladimir Oltean 		struct resource *res;
45256051948SVladimir Oltean 
45356051948SVladimir Oltean 		ocelot_port = devm_kzalloc(ocelot->dev,
45456051948SVladimir Oltean 					   sizeof(struct ocelot_port),
45556051948SVladimir Oltean 					   GFP_KERNEL);
45656051948SVladimir Oltean 		if (!ocelot_port) {
45756051948SVladimir Oltean 			dev_err(ocelot->dev,
45856051948SVladimir Oltean 				"failed to allocate port memory\n");
459bdeced75SVladimir Oltean 			kfree(port_phy_modes);
46056051948SVladimir Oltean 			return -ENOMEM;
46156051948SVladimir Oltean 		}
46256051948SVladimir Oltean 
46356051948SVladimir Oltean 		res = &felix->info->port_io_res[port];
46456051948SVladimir Oltean 		res->flags = IORESOURCE_MEM;
465bdeced75SVladimir Oltean 		res->start += switch_base;
466bdeced75SVladimir Oltean 		res->end += switch_base;
46756051948SVladimir Oltean 
46856051948SVladimir Oltean 		port_regs = devm_ioremap_resource(ocelot->dev, res);
46956051948SVladimir Oltean 		if (IS_ERR(port_regs)) {
47056051948SVladimir Oltean 			dev_err(ocelot->dev,
47156051948SVladimir Oltean 				"failed to map registers for port %d\n", port);
472bdeced75SVladimir Oltean 			kfree(port_phy_modes);
47356051948SVladimir Oltean 			return PTR_ERR(port_regs);
47456051948SVladimir Oltean 		}
47556051948SVladimir Oltean 
476bdeced75SVladimir Oltean 		ocelot_port->phy_mode = port_phy_modes[port];
47756051948SVladimir Oltean 		ocelot_port->ocelot = ocelot;
47856051948SVladimir Oltean 		ocelot_port->regs = port_regs;
47956051948SVladimir Oltean 		ocelot->ports[port] = ocelot_port;
48056051948SVladimir Oltean 	}
48156051948SVladimir Oltean 
482bdeced75SVladimir Oltean 	kfree(port_phy_modes);
483bdeced75SVladimir Oltean 
484bdeced75SVladimir Oltean 	if (felix->info->mdio_bus_alloc) {
485bdeced75SVladimir Oltean 		err = felix->info->mdio_bus_alloc(ocelot);
486bdeced75SVladimir Oltean 		if (err < 0)
487bdeced75SVladimir Oltean 			return err;
488bdeced75SVladimir Oltean 	}
489bdeced75SVladimir Oltean 
49056051948SVladimir Oltean 	return 0;
49156051948SVladimir Oltean }
49256051948SVladimir Oltean 
49356051948SVladimir Oltean /* Hardware initialization done here so that we can allocate structures with
49456051948SVladimir Oltean  * devm without fear of dsa_register_switch returning -EPROBE_DEFER and causing
49556051948SVladimir Oltean  * us to allocate structures twice (leak memory) and map PCI memory twice
49656051948SVladimir Oltean  * (which will not work).
49756051948SVladimir Oltean  */
49856051948SVladimir Oltean static int felix_setup(struct dsa_switch *ds)
49956051948SVladimir Oltean {
50056051948SVladimir Oltean 	struct ocelot *ocelot = ds->priv;
50156051948SVladimir Oltean 	struct felix *felix = ocelot_to_felix(ocelot);
50256051948SVladimir Oltean 	int port, err;
50356051948SVladimir Oltean 
50456051948SVladimir Oltean 	err = felix_init_structs(felix, ds->num_ports);
50556051948SVladimir Oltean 	if (err)
50656051948SVladimir Oltean 		return err;
50756051948SVladimir Oltean 
50856051948SVladimir Oltean 	ocelot_init(ocelot);
50956051948SVladimir Oltean 
51056051948SVladimir Oltean 	for (port = 0; port < ds->num_ports; port++) {
51156051948SVladimir Oltean 		ocelot_init_port(ocelot, port);
51256051948SVladimir Oltean 
513b8fc7177SVladimir Oltean 		if (dsa_is_cpu_port(ds, port))
51456051948SVladimir Oltean 			ocelot_set_cpu_port(ocelot, port,
51556051948SVladimir Oltean 					    OCELOT_TAG_PREFIX_NONE,
51656051948SVladimir Oltean 					    OCELOT_TAG_PREFIX_LONG);
51756051948SVladimir Oltean 	}
51856051948SVladimir Oltean 
519bdeced75SVladimir Oltean 	/* It looks like the MAC/PCS interrupt register - PM0_IEVENT (0x8040)
520bdeced75SVladimir Oltean 	 * isn't instantiated for the Felix PF.
521bdeced75SVladimir Oltean 	 * In-band AN may take a few ms to complete, so we need to poll.
522bdeced75SVladimir Oltean 	 */
523bdeced75SVladimir Oltean 	ds->pcs_poll = true;
524bdeced75SVladimir Oltean 
52556051948SVladimir Oltean 	return 0;
52656051948SVladimir Oltean }
52756051948SVladimir Oltean 
52856051948SVladimir Oltean static void felix_teardown(struct dsa_switch *ds)
52956051948SVladimir Oltean {
53056051948SVladimir Oltean 	struct ocelot *ocelot = ds->priv;
531bdeced75SVladimir Oltean 	struct felix *felix = ocelot_to_felix(ocelot);
532bdeced75SVladimir Oltean 
533bdeced75SVladimir Oltean 	if (felix->info->mdio_bus_free)
534bdeced75SVladimir Oltean 		felix->info->mdio_bus_free(ocelot);
53556051948SVladimir Oltean 
53656051948SVladimir Oltean 	/* stop workqueue thread */
53756051948SVladimir Oltean 	ocelot_deinit(ocelot);
53856051948SVladimir Oltean }
53956051948SVladimir Oltean 
540c0bcf537SYangbo Lu static int felix_hwtstamp_get(struct dsa_switch *ds, int port,
541c0bcf537SYangbo Lu 			      struct ifreq *ifr)
542c0bcf537SYangbo Lu {
543c0bcf537SYangbo Lu 	struct ocelot *ocelot = ds->priv;
544c0bcf537SYangbo Lu 
545c0bcf537SYangbo Lu 	return ocelot_hwstamp_get(ocelot, port, ifr);
546c0bcf537SYangbo Lu }
547c0bcf537SYangbo Lu 
548c0bcf537SYangbo Lu static int felix_hwtstamp_set(struct dsa_switch *ds, int port,
549c0bcf537SYangbo Lu 			      struct ifreq *ifr)
550c0bcf537SYangbo Lu {
551c0bcf537SYangbo Lu 	struct ocelot *ocelot = ds->priv;
552c0bcf537SYangbo Lu 
553c0bcf537SYangbo Lu 	return ocelot_hwstamp_set(ocelot, port, ifr);
554c0bcf537SYangbo Lu }
555c0bcf537SYangbo Lu 
556c0bcf537SYangbo Lu static bool felix_rxtstamp(struct dsa_switch *ds, int port,
557c0bcf537SYangbo Lu 			   struct sk_buff *skb, unsigned int type)
558c0bcf537SYangbo Lu {
559c0bcf537SYangbo Lu 	struct skb_shared_hwtstamps *shhwtstamps;
560c0bcf537SYangbo Lu 	struct ocelot *ocelot = ds->priv;
561c0bcf537SYangbo Lu 	u8 *extraction = skb->data - ETH_HLEN - OCELOT_TAG_LEN;
562c0bcf537SYangbo Lu 	u32 tstamp_lo, tstamp_hi;
563c0bcf537SYangbo Lu 	struct timespec64 ts;
564c0bcf537SYangbo Lu 	u64 tstamp, val;
565c0bcf537SYangbo Lu 
566c0bcf537SYangbo Lu 	ocelot_ptp_gettime64(&ocelot->ptp_info, &ts);
567c0bcf537SYangbo Lu 	tstamp = ktime_set(ts.tv_sec, ts.tv_nsec);
568c0bcf537SYangbo Lu 
569c0bcf537SYangbo Lu 	packing(extraction, &val,  116, 85, OCELOT_TAG_LEN, UNPACK, 0);
570c0bcf537SYangbo Lu 	tstamp_lo = (u32)val;
571c0bcf537SYangbo Lu 
572c0bcf537SYangbo Lu 	tstamp_hi = tstamp >> 32;
573c0bcf537SYangbo Lu 	if ((tstamp & 0xffffffff) < tstamp_lo)
574c0bcf537SYangbo Lu 		tstamp_hi--;
575c0bcf537SYangbo Lu 
576c0bcf537SYangbo Lu 	tstamp = ((u64)tstamp_hi << 32) | tstamp_lo;
577c0bcf537SYangbo Lu 
578c0bcf537SYangbo Lu 	shhwtstamps = skb_hwtstamps(skb);
579c0bcf537SYangbo Lu 	memset(shhwtstamps, 0, sizeof(struct skb_shared_hwtstamps));
580c0bcf537SYangbo Lu 	shhwtstamps->hwtstamp = tstamp;
581c0bcf537SYangbo Lu 	return false;
582c0bcf537SYangbo Lu }
583c0bcf537SYangbo Lu 
5843243e04aSChen Wandun static bool felix_txtstamp(struct dsa_switch *ds, int port,
585c0bcf537SYangbo Lu 			   struct sk_buff *clone, unsigned int type)
586c0bcf537SYangbo Lu {
587c0bcf537SYangbo Lu 	struct ocelot *ocelot = ds->priv;
588c0bcf537SYangbo Lu 	struct ocelot_port *ocelot_port = ocelot->ports[port];
589c0bcf537SYangbo Lu 
590c0bcf537SYangbo Lu 	if (!ocelot_port_add_txtstamp_skb(ocelot_port, clone))
591c0bcf537SYangbo Lu 		return true;
592c0bcf537SYangbo Lu 
593c0bcf537SYangbo Lu 	return false;
594c0bcf537SYangbo Lu }
595c0bcf537SYangbo Lu 
59656051948SVladimir Oltean static const struct dsa_switch_ops felix_switch_ops = {
59756051948SVladimir Oltean 	.get_tag_protocol	= felix_get_tag_protocol,
59856051948SVladimir Oltean 	.setup			= felix_setup,
59956051948SVladimir Oltean 	.teardown		= felix_teardown,
60056051948SVladimir Oltean 	.set_ageing_time	= felix_set_ageing_time,
60156051948SVladimir Oltean 	.get_strings		= felix_get_strings,
60256051948SVladimir Oltean 	.get_ethtool_stats	= felix_get_ethtool_stats,
60356051948SVladimir Oltean 	.get_sset_count		= felix_get_sset_count,
60456051948SVladimir Oltean 	.get_ts_info		= felix_get_ts_info,
605bdeced75SVladimir Oltean 	.phylink_validate	= felix_phylink_validate,
606bdeced75SVladimir Oltean 	.phylink_mac_link_state	= felix_phylink_mac_pcs_get_state,
607bdeced75SVladimir Oltean 	.phylink_mac_config	= felix_phylink_mac_config,
608bdeced75SVladimir Oltean 	.phylink_mac_an_restart	= felix_phylink_mac_an_restart,
609bdeced75SVladimir Oltean 	.phylink_mac_link_down	= felix_phylink_mac_link_down,
610bdeced75SVladimir Oltean 	.phylink_mac_link_up	= felix_phylink_mac_link_up,
61156051948SVladimir Oltean 	.port_enable		= felix_port_enable,
61256051948SVladimir Oltean 	.port_disable		= felix_port_disable,
61356051948SVladimir Oltean 	.port_fdb_dump		= felix_fdb_dump,
61456051948SVladimir Oltean 	.port_fdb_add		= felix_fdb_add,
61556051948SVladimir Oltean 	.port_fdb_del		= felix_fdb_del,
61656051948SVladimir Oltean 	.port_bridge_join	= felix_bridge_join,
61756051948SVladimir Oltean 	.port_bridge_leave	= felix_bridge_leave,
61856051948SVladimir Oltean 	.port_stp_state_set	= felix_bridge_stp_state_set,
61956051948SVladimir Oltean 	.port_vlan_prepare	= felix_vlan_prepare,
62056051948SVladimir Oltean 	.port_vlan_filtering	= felix_vlan_filtering,
62156051948SVladimir Oltean 	.port_vlan_add		= felix_vlan_add,
62256051948SVladimir Oltean 	.port_vlan_del		= felix_vlan_del,
623c0bcf537SYangbo Lu 	.port_hwtstamp_get	= felix_hwtstamp_get,
624c0bcf537SYangbo Lu 	.port_hwtstamp_set	= felix_hwtstamp_set,
625c0bcf537SYangbo Lu 	.port_rxtstamp		= felix_rxtstamp,
626c0bcf537SYangbo Lu 	.port_txtstamp		= felix_txtstamp,
62756051948SVladimir Oltean };
62856051948SVladimir Oltean 
62956051948SVladimir Oltean static struct felix_info *felix_instance_tbl[] = {
63056051948SVladimir Oltean 	[FELIX_INSTANCE_VSC9959] = &felix_info_vsc9959,
63156051948SVladimir Oltean };
63256051948SVladimir Oltean 
633c0bcf537SYangbo Lu static irqreturn_t felix_irq_handler(int irq, void *data)
634c0bcf537SYangbo Lu {
635c0bcf537SYangbo Lu 	struct ocelot *ocelot = (struct ocelot *)data;
636c0bcf537SYangbo Lu 
637c0bcf537SYangbo Lu 	/* The INTB interrupt is used for both PTP TX timestamp interrupt
638c0bcf537SYangbo Lu 	 * and preemption status change interrupt on each port.
639c0bcf537SYangbo Lu 	 *
640c0bcf537SYangbo Lu 	 * - Get txtstamp if have
641c0bcf537SYangbo Lu 	 * - TODO: handle preemption. Without handling it, driver may get
642c0bcf537SYangbo Lu 	 *   interrupt storm.
643c0bcf537SYangbo Lu 	 */
644c0bcf537SYangbo Lu 
645c0bcf537SYangbo Lu 	ocelot_get_txtstamp(ocelot);
646c0bcf537SYangbo Lu 
647c0bcf537SYangbo Lu 	return IRQ_HANDLED;
648c0bcf537SYangbo Lu }
649c0bcf537SYangbo Lu 
65056051948SVladimir Oltean static int felix_pci_probe(struct pci_dev *pdev,
65156051948SVladimir Oltean 			   const struct pci_device_id *id)
65256051948SVladimir Oltean {
65356051948SVladimir Oltean 	enum felix_instance instance = id->driver_data;
65456051948SVladimir Oltean 	struct dsa_switch *ds;
65556051948SVladimir Oltean 	struct ocelot *ocelot;
65656051948SVladimir Oltean 	struct felix *felix;
65756051948SVladimir Oltean 	int err;
65856051948SVladimir Oltean 
65956051948SVladimir Oltean 	err = pci_enable_device(pdev);
66056051948SVladimir Oltean 	if (err) {
66156051948SVladimir Oltean 		dev_err(&pdev->dev, "device enable failed\n");
66256051948SVladimir Oltean 		goto err_pci_enable;
66356051948SVladimir Oltean 	}
66456051948SVladimir Oltean 
66556051948SVladimir Oltean 	/* set up for high or low dma */
66656051948SVladimir Oltean 	err = dma_set_mask_and_coherent(&pdev->dev, DMA_BIT_MASK(64));
66756051948SVladimir Oltean 	if (err) {
66856051948SVladimir Oltean 		err = dma_set_mask_and_coherent(&pdev->dev, DMA_BIT_MASK(32));
66956051948SVladimir Oltean 		if (err) {
67056051948SVladimir Oltean 			dev_err(&pdev->dev,
67156051948SVladimir Oltean 				"DMA configuration failed: 0x%x\n", err);
67256051948SVladimir Oltean 			goto err_dma;
67356051948SVladimir Oltean 		}
67456051948SVladimir Oltean 	}
67556051948SVladimir Oltean 
67656051948SVladimir Oltean 	felix = kzalloc(sizeof(struct felix), GFP_KERNEL);
67756051948SVladimir Oltean 	if (!felix) {
67856051948SVladimir Oltean 		err = -ENOMEM;
67956051948SVladimir Oltean 		dev_err(&pdev->dev, "Failed to allocate driver memory\n");
68056051948SVladimir Oltean 		goto err_alloc_felix;
68156051948SVladimir Oltean 	}
68256051948SVladimir Oltean 
68356051948SVladimir Oltean 	pci_set_drvdata(pdev, felix);
68456051948SVladimir Oltean 	ocelot = &felix->ocelot;
68556051948SVladimir Oltean 	ocelot->dev = &pdev->dev;
68656051948SVladimir Oltean 	felix->pdev = pdev;
68756051948SVladimir Oltean 	felix->info = felix_instance_tbl[instance];
68856051948SVladimir Oltean 
68956051948SVladimir Oltean 	pci_set_master(pdev);
69056051948SVladimir Oltean 
691c0bcf537SYangbo Lu 	err = devm_request_threaded_irq(&pdev->dev, pdev->irq, NULL,
692c0bcf537SYangbo Lu 					&felix_irq_handler, IRQF_ONESHOT,
693c0bcf537SYangbo Lu 					"felix-intb", ocelot);
694c0bcf537SYangbo Lu 	if (err) {
695c0bcf537SYangbo Lu 		dev_err(&pdev->dev, "Failed to request irq\n");
696c0bcf537SYangbo Lu 		goto err_alloc_irq;
697c0bcf537SYangbo Lu 	}
698c0bcf537SYangbo Lu 
699c0bcf537SYangbo Lu 	ocelot->ptp = 1;
700c0bcf537SYangbo Lu 
70156051948SVladimir Oltean 	ds = kzalloc(sizeof(struct dsa_switch), GFP_KERNEL);
70256051948SVladimir Oltean 	if (!ds) {
70356051948SVladimir Oltean 		err = -ENOMEM;
70456051948SVladimir Oltean 		dev_err(&pdev->dev, "Failed to allocate DSA switch\n");
70556051948SVladimir Oltean 		goto err_alloc_ds;
70656051948SVladimir Oltean 	}
70756051948SVladimir Oltean 
70856051948SVladimir Oltean 	ds->dev = &pdev->dev;
70956051948SVladimir Oltean 	ds->num_ports = felix->info->num_ports;
71056051948SVladimir Oltean 	ds->ops = &felix_switch_ops;
71156051948SVladimir Oltean 	ds->priv = ocelot;
71256051948SVladimir Oltean 	felix->ds = ds;
71356051948SVladimir Oltean 
71456051948SVladimir Oltean 	err = dsa_register_switch(ds);
71556051948SVladimir Oltean 	if (err) {
71656051948SVladimir Oltean 		dev_err(&pdev->dev, "Failed to register DSA switch: %d\n", err);
71756051948SVladimir Oltean 		goto err_register_ds;
71856051948SVladimir Oltean 	}
71956051948SVladimir Oltean 
72056051948SVladimir Oltean 	return 0;
72156051948SVladimir Oltean 
72256051948SVladimir Oltean err_register_ds:
72356051948SVladimir Oltean 	kfree(ds);
72456051948SVladimir Oltean err_alloc_ds:
725c0bcf537SYangbo Lu err_alloc_irq:
72656051948SVladimir Oltean err_alloc_felix:
72756051948SVladimir Oltean 	kfree(felix);
72856051948SVladimir Oltean err_dma:
72956051948SVladimir Oltean 	pci_disable_device(pdev);
73056051948SVladimir Oltean err_pci_enable:
73156051948SVladimir Oltean 	return err;
73256051948SVladimir Oltean }
73356051948SVladimir Oltean 
73456051948SVladimir Oltean static void felix_pci_remove(struct pci_dev *pdev)
73556051948SVladimir Oltean {
73656051948SVladimir Oltean 	struct felix *felix;
73756051948SVladimir Oltean 
73856051948SVladimir Oltean 	felix = pci_get_drvdata(pdev);
73956051948SVladimir Oltean 
74056051948SVladimir Oltean 	dsa_unregister_switch(felix->ds);
74156051948SVladimir Oltean 
74256051948SVladimir Oltean 	kfree(felix->ds);
74356051948SVladimir Oltean 	kfree(felix);
74456051948SVladimir Oltean 
74556051948SVladimir Oltean 	pci_disable_device(pdev);
74656051948SVladimir Oltean }
74756051948SVladimir Oltean 
74856051948SVladimir Oltean static struct pci_device_id felix_ids[] = {
74956051948SVladimir Oltean 	{
75056051948SVladimir Oltean 		/* NXP LS1028A */
75156051948SVladimir Oltean 		PCI_DEVICE(PCI_VENDOR_ID_FREESCALE, 0xEEF0),
75256051948SVladimir Oltean 		.driver_data = FELIX_INSTANCE_VSC9959,
75356051948SVladimir Oltean 	},
75456051948SVladimir Oltean 	{ 0, }
75556051948SVladimir Oltean };
75656051948SVladimir Oltean MODULE_DEVICE_TABLE(pci, felix_ids);
75756051948SVladimir Oltean 
75856051948SVladimir Oltean static struct pci_driver felix_pci_driver = {
75956051948SVladimir Oltean 	.name		= KBUILD_MODNAME,
76056051948SVladimir Oltean 	.id_table	= felix_ids,
76156051948SVladimir Oltean 	.probe		= felix_pci_probe,
76256051948SVladimir Oltean 	.remove		= felix_pci_remove,
76356051948SVladimir Oltean };
76456051948SVladimir Oltean 
76556051948SVladimir Oltean module_pci_driver(felix_pci_driver);
76656051948SVladimir Oltean 
76756051948SVladimir Oltean MODULE_DESCRIPTION("Felix Switch driver");
76856051948SVladimir Oltean MODULE_LICENSE("GPL v2");
769