Loading...
1// SPDX-License-Identifier: (GPL-2.0 OR MIT)
2/*
3 * Microsemi Ocelot Switch driver
4 *
5 * Copyright (c) 2017 Microsemi Corporation
6 */
7#include <linux/dsa/ocelot.h>
8#include <linux/interrupt.h>
9#include <linux/module.h>
10#include <linux/of_net.h>
11#include <linux/netdevice.h>
12#include <linux/phylink.h>
13#include <linux/of.h>
14#include <linux/of_mdio.h>
15#include <linux/platform_device.h>
16#include <linux/mfd/syscon.h>
17#include <linux/skbuff.h>
18#include <net/switchdev.h>
19
20#include <soc/mscc/ocelot.h>
21#include <soc/mscc/ocelot_vcap.h>
22#include <soc/mscc/vsc7514_regs.h>
23#include "ocelot_fdma.h"
24#include "ocelot.h"
25
26#define VSC7514_VCAP_POLICER_BASE 128
27#define VSC7514_VCAP_POLICER_MAX 191
28
29static int ocelot_chip_init(struct ocelot *ocelot, const struct ocelot_ops *ops)
30{
31 int ret;
32
33 ocelot->map = vsc7514_regmap;
34 ocelot->num_mact_rows = 1024;
35 ocelot->ops = ops;
36
37 ret = ocelot_regfields_init(ocelot, vsc7514_regfields);
38 if (ret)
39 return ret;
40
41 ocelot_pll5_init(ocelot);
42
43 eth_random_addr(ocelot->base_mac);
44 ocelot->base_mac[5] &= 0xf0;
45
46 return 0;
47}
48
49static irqreturn_t ocelot_xtr_irq_handler(int irq, void *arg)
50{
51 struct ocelot *ocelot = arg;
52 int grp = 0, err;
53
54 ocelot_lock_xtr_grp(ocelot, grp);
55
56 while (ocelot_read(ocelot, QS_XTR_DATA_PRESENT) & BIT(grp)) {
57 struct sk_buff *skb;
58
59 err = ocelot_xtr_poll_frame(ocelot, grp, &skb);
60 if (err)
61 goto out;
62
63 skb->dev->stats.rx_bytes += skb->len;
64 skb->dev->stats.rx_packets++;
65
66 if (!skb_defer_rx_timestamp(skb))
67 netif_rx(skb);
68 }
69
70out:
71 if (err < 0)
72 ocelot_drain_cpu_queue(ocelot, 0);
73
74 ocelot_unlock_xtr_grp(ocelot, grp);
75
76 return IRQ_HANDLED;
77}
78
79static irqreturn_t ocelot_ptp_rdy_irq_handler(int irq, void *arg)
80{
81 struct ocelot *ocelot = arg;
82
83 ocelot_get_txtstamp(ocelot);
84
85 return IRQ_HANDLED;
86}
87
88static const struct of_device_id mscc_ocelot_match[] = {
89 { .compatible = "mscc,vsc7514-switch" },
90 { }
91};
92MODULE_DEVICE_TABLE(of, mscc_ocelot_match);
93
94static const struct ocelot_ops ocelot_ops = {
95 .reset = ocelot_reset,
96 .wm_enc = ocelot_wm_enc,
97 .wm_dec = ocelot_wm_dec,
98 .wm_stat = ocelot_wm_stat,
99 .port_to_netdev = ocelot_port_to_netdev,
100 .netdev_to_port = ocelot_netdev_to_port,
101};
102
103static struct ptp_clock_info ocelot_ptp_clock_info = {
104 .owner = THIS_MODULE,
105 .name = "ocelot ptp",
106 .max_adj = 0x7fffffff,
107 .n_alarm = 0,
108 .n_ext_ts = 0,
109 .n_per_out = OCELOT_PTP_PINS_NUM,
110 .n_pins = OCELOT_PTP_PINS_NUM,
111 .pps = 0,
112 .gettime64 = ocelot_ptp_gettime64,
113 .settime64 = ocelot_ptp_settime64,
114 .adjtime = ocelot_ptp_adjtime,
115 .adjfine = ocelot_ptp_adjfine,
116 .verify = ocelot_ptp_verify,
117 .enable = ocelot_ptp_enable,
118};
119
120static void mscc_ocelot_teardown_devlink_ports(struct ocelot *ocelot)
121{
122 int port;
123
124 for (port = 0; port < ocelot->num_phys_ports; port++)
125 ocelot_port_devlink_teardown(ocelot, port);
126}
127
128static void mscc_ocelot_release_ports(struct ocelot *ocelot)
129{
130 int port;
131
132 for (port = 0; port < ocelot->num_phys_ports; port++) {
133 struct ocelot_port *ocelot_port;
134
135 ocelot_port = ocelot->ports[port];
136 if (!ocelot_port)
137 continue;
138
139 ocelot_deinit_port(ocelot, port);
140 ocelot_release_port(ocelot_port);
141 }
142}
143
144static int mscc_ocelot_init_ports(struct platform_device *pdev,
145 struct device_node *ports)
146{
147 struct ocelot *ocelot = platform_get_drvdata(pdev);
148 u32 devlink_ports_registered = 0;
149 struct device_node *portnp;
150 int port, err;
151 u32 reg;
152
153 ocelot->ports = devm_kcalloc(ocelot->dev, ocelot->num_phys_ports,
154 sizeof(struct ocelot_port *), GFP_KERNEL);
155 if (!ocelot->ports)
156 return -ENOMEM;
157
158 ocelot->devlink_ports = devm_kcalloc(ocelot->dev,
159 ocelot->num_phys_ports,
160 sizeof(*ocelot->devlink_ports),
161 GFP_KERNEL);
162 if (!ocelot->devlink_ports)
163 return -ENOMEM;
164
165 for_each_available_child_of_node(ports, portnp) {
166 struct regmap *target;
167 struct resource *res;
168 char res_name[8];
169
170 if (of_property_read_u32(portnp, "reg", ®))
171 continue;
172
173 port = reg;
174 if (port < 0 || port >= ocelot->num_phys_ports) {
175 dev_err(ocelot->dev,
176 "invalid port number: %d >= %d\n", port,
177 ocelot->num_phys_ports);
178 continue;
179 }
180
181 snprintf(res_name, sizeof(res_name), "port%d", port);
182
183 res = platform_get_resource_byname(pdev, IORESOURCE_MEM,
184 res_name);
185 target = ocelot_regmap_init(ocelot, res);
186 if (IS_ERR(target)) {
187 err = PTR_ERR(target);
188 of_node_put(portnp);
189 goto out_teardown;
190 }
191
192 err = ocelot_port_devlink_init(ocelot, port,
193 DEVLINK_PORT_FLAVOUR_PHYSICAL);
194 if (err) {
195 of_node_put(portnp);
196 goto out_teardown;
197 }
198
199 err = ocelot_probe_port(ocelot, port, target, portnp);
200 if (err) {
201 ocelot_port_devlink_teardown(ocelot, port);
202 continue;
203 }
204
205 devlink_ports_registered |= BIT(port);
206 }
207
208 /* Initialize unused devlink ports at the end */
209 for (port = 0; port < ocelot->num_phys_ports; port++) {
210 if (devlink_ports_registered & BIT(port))
211 continue;
212
213 err = ocelot_port_devlink_init(ocelot, port,
214 DEVLINK_PORT_FLAVOUR_UNUSED);
215 if (err)
216 goto out_teardown;
217
218 devlink_ports_registered |= BIT(port);
219 }
220
221 return 0;
222
223out_teardown:
224 /* Unregister the network interfaces */
225 mscc_ocelot_release_ports(ocelot);
226 /* Tear down devlink ports for the registered network interfaces */
227 for (port = 0; port < ocelot->num_phys_ports; port++) {
228 if (devlink_ports_registered & BIT(port))
229 ocelot_port_devlink_teardown(ocelot, port);
230 }
231 return err;
232}
233
234static int mscc_ocelot_probe(struct platform_device *pdev)
235{
236 struct device_node *np = pdev->dev.of_node;
237 int err, irq_xtr, irq_ptp_rdy;
238 struct device_node *ports;
239 struct devlink *devlink;
240 struct ocelot *ocelot;
241 struct regmap *hsio;
242 unsigned int i;
243
244 struct {
245 enum ocelot_target id;
246 char *name;
247 u8 optional:1;
248 } io_target[] = {
249 { SYS, "sys" },
250 { REW, "rew" },
251 { QSYS, "qsys" },
252 { ANA, "ana" },
253 { QS, "qs" },
254 { S0, "s0" },
255 { S1, "s1" },
256 { S2, "s2" },
257 { PTP, "ptp", 1 },
258 { FDMA, "fdma", 1 },
259 };
260
261 if (!np && !pdev->dev.platform_data)
262 return -ENODEV;
263
264 devlink =
265 devlink_alloc(&ocelot_devlink_ops, sizeof(*ocelot), &pdev->dev);
266 if (!devlink)
267 return -ENOMEM;
268
269 ocelot = devlink_priv(devlink);
270 ocelot->devlink = priv_to_devlink(ocelot);
271 platform_set_drvdata(pdev, ocelot);
272 ocelot->dev = &pdev->dev;
273
274 for (i = 0; i < ARRAY_SIZE(io_target); i++) {
275 struct regmap *target;
276 struct resource *res;
277
278 res = platform_get_resource_byname(pdev, IORESOURCE_MEM,
279 io_target[i].name);
280
281 target = ocelot_regmap_init(ocelot, res);
282 if (IS_ERR(target)) {
283 if (io_target[i].optional) {
284 ocelot->targets[io_target[i].id] = NULL;
285 continue;
286 }
287 err = PTR_ERR(target);
288 goto out_free_devlink;
289 }
290
291 ocelot->targets[io_target[i].id] = target;
292 }
293
294 if (ocelot->targets[FDMA])
295 ocelot_fdma_init(pdev, ocelot);
296
297 hsio = syscon_regmap_lookup_by_compatible("mscc,ocelot-hsio");
298 if (IS_ERR(hsio)) {
299 dev_err(&pdev->dev, "missing hsio syscon\n");
300 err = PTR_ERR(hsio);
301 goto out_free_devlink;
302 }
303
304 ocelot->targets[HSIO] = hsio;
305
306 err = ocelot_chip_init(ocelot, &ocelot_ops);
307 if (err)
308 goto out_free_devlink;
309
310 irq_xtr = platform_get_irq_byname(pdev, "xtr");
311 if (irq_xtr < 0) {
312 err = irq_xtr;
313 goto out_free_devlink;
314 }
315
316 err = devm_request_threaded_irq(&pdev->dev, irq_xtr, NULL,
317 ocelot_xtr_irq_handler, IRQF_ONESHOT,
318 "frame extraction", ocelot);
319 if (err)
320 goto out_free_devlink;
321
322 irq_ptp_rdy = platform_get_irq_byname(pdev, "ptp_rdy");
323 if (irq_ptp_rdy > 0 && ocelot->targets[PTP]) {
324 err = devm_request_threaded_irq(&pdev->dev, irq_ptp_rdy, NULL,
325 ocelot_ptp_rdy_irq_handler,
326 IRQF_ONESHOT, "ptp ready",
327 ocelot);
328 if (err)
329 goto out_free_devlink;
330
331 /* Both the PTP interrupt and the PTP bank are available */
332 ocelot->ptp = 1;
333 }
334
335 ports = of_get_child_by_name(np, "ethernet-ports");
336 if (!ports) {
337 dev_err(ocelot->dev, "no ethernet-ports child node found\n");
338 err = -ENODEV;
339 goto out_free_devlink;
340 }
341
342 ocelot->num_phys_ports = of_get_child_count(ports);
343 ocelot->num_flooding_pgids = 1;
344
345 ocelot->vcap = vsc7514_vcap_props;
346
347 ocelot->vcap_pol.base = VSC7514_VCAP_POLICER_BASE;
348 ocelot->vcap_pol.max = VSC7514_VCAP_POLICER_MAX;
349
350 ocelot->npi = -1;
351
352 err = ocelot_init(ocelot);
353 if (err)
354 goto out_put_ports;
355
356 err = mscc_ocelot_init_ports(pdev, ports);
357 if (err)
358 goto out_ocelot_devlink_unregister;
359
360 if (ocelot->fdma)
361 ocelot_fdma_start(ocelot);
362
363 err = ocelot_devlink_sb_register(ocelot);
364 if (err)
365 goto out_ocelot_release_ports;
366
367 if (ocelot->ptp) {
368 err = ocelot_init_timestamp(ocelot, &ocelot_ptp_clock_info);
369 if (err) {
370 dev_err(ocelot->dev,
371 "Timestamp initialization failed\n");
372 ocelot->ptp = 0;
373 }
374 }
375
376 register_netdevice_notifier(&ocelot_netdevice_nb);
377 register_switchdev_notifier(&ocelot_switchdev_nb);
378 register_switchdev_blocking_notifier(&ocelot_switchdev_blocking_nb);
379
380 of_node_put(ports);
381 devlink_register(devlink);
382
383 dev_info(&pdev->dev, "Ocelot switch probed\n");
384
385 return 0;
386
387out_ocelot_release_ports:
388 mscc_ocelot_release_ports(ocelot);
389 mscc_ocelot_teardown_devlink_ports(ocelot);
390out_ocelot_devlink_unregister:
391 ocelot_deinit(ocelot);
392out_put_ports:
393 of_node_put(ports);
394out_free_devlink:
395 devlink_free(devlink);
396 return err;
397}
398
399static void mscc_ocelot_remove(struct platform_device *pdev)
400{
401 struct ocelot *ocelot = platform_get_drvdata(pdev);
402
403 if (ocelot->fdma)
404 ocelot_fdma_deinit(ocelot);
405 devlink_unregister(ocelot->devlink);
406 ocelot_deinit_timestamp(ocelot);
407 ocelot_devlink_sb_unregister(ocelot);
408 mscc_ocelot_release_ports(ocelot);
409 mscc_ocelot_teardown_devlink_ports(ocelot);
410 ocelot_deinit(ocelot);
411 unregister_switchdev_blocking_notifier(&ocelot_switchdev_blocking_nb);
412 unregister_switchdev_notifier(&ocelot_switchdev_nb);
413 unregister_netdevice_notifier(&ocelot_netdevice_nb);
414 devlink_free(ocelot->devlink);
415}
416
417static struct platform_driver mscc_ocelot_driver = {
418 .probe = mscc_ocelot_probe,
419 .remove = mscc_ocelot_remove,
420 .driver = {
421 .name = "ocelot-switch",
422 .of_match_table = mscc_ocelot_match,
423 },
424};
425
426module_platform_driver(mscc_ocelot_driver);
427
428MODULE_DESCRIPTION("Microsemi Ocelot switch driver");
429MODULE_AUTHOR("Alexandre Belloni <alexandre.belloni@bootlin.com>");
430MODULE_LICENSE("Dual MIT/GPL");
1// SPDX-License-Identifier: (GPL-2.0 OR MIT)
2/*
3 * Microsemi Ocelot Switch driver
4 *
5 * Copyright (c) 2017 Microsemi Corporation
6 */
7#include <linux/dsa/ocelot.h>
8#include <linux/interrupt.h>
9#include <linux/module.h>
10#include <linux/of_net.h>
11#include <linux/netdevice.h>
12#include <linux/phylink.h>
13#include <linux/of.h>
14#include <linux/of_mdio.h>
15#include <linux/platform_device.h>
16#include <linux/mfd/syscon.h>
17#include <linux/skbuff.h>
18#include <net/switchdev.h>
19
20#include <soc/mscc/ocelot.h>
21#include <soc/mscc/ocelot_vcap.h>
22#include <soc/mscc/vsc7514_regs.h>
23#include "ocelot_fdma.h"
24#include "ocelot.h"
25
26#define VSC7514_VCAP_POLICER_BASE 128
27#define VSC7514_VCAP_POLICER_MAX 191
28
29static int ocelot_chip_init(struct ocelot *ocelot, const struct ocelot_ops *ops)
30{
31 int ret;
32
33 ocelot->map = vsc7514_regmap;
34 ocelot->num_mact_rows = 1024;
35 ocelot->ops = ops;
36
37 ret = ocelot_regfields_init(ocelot, vsc7514_regfields);
38 if (ret)
39 return ret;
40
41 ocelot_pll5_init(ocelot);
42
43 eth_random_addr(ocelot->base_mac);
44 ocelot->base_mac[5] &= 0xf0;
45
46 return 0;
47}
48
49static irqreturn_t ocelot_xtr_irq_handler(int irq, void *arg)
50{
51 struct ocelot *ocelot = arg;
52 int grp = 0, err;
53
54 while (ocelot_read(ocelot, QS_XTR_DATA_PRESENT) & BIT(grp)) {
55 struct sk_buff *skb;
56
57 err = ocelot_xtr_poll_frame(ocelot, grp, &skb);
58 if (err)
59 goto out;
60
61 skb->dev->stats.rx_bytes += skb->len;
62 skb->dev->stats.rx_packets++;
63
64 if (!skb_defer_rx_timestamp(skb))
65 netif_rx(skb);
66 }
67
68out:
69 if (err < 0)
70 ocelot_drain_cpu_queue(ocelot, 0);
71
72 return IRQ_HANDLED;
73}
74
75static irqreturn_t ocelot_ptp_rdy_irq_handler(int irq, void *arg)
76{
77 struct ocelot *ocelot = arg;
78
79 ocelot_get_txtstamp(ocelot);
80
81 return IRQ_HANDLED;
82}
83
84static const struct of_device_id mscc_ocelot_match[] = {
85 { .compatible = "mscc,vsc7514-switch" },
86 { }
87};
88MODULE_DEVICE_TABLE(of, mscc_ocelot_match);
89
90static const struct ocelot_ops ocelot_ops = {
91 .reset = ocelot_reset,
92 .wm_enc = ocelot_wm_enc,
93 .wm_dec = ocelot_wm_dec,
94 .wm_stat = ocelot_wm_stat,
95 .port_to_netdev = ocelot_port_to_netdev,
96 .netdev_to_port = ocelot_netdev_to_port,
97};
98
99static struct ptp_clock_info ocelot_ptp_clock_info = {
100 .owner = THIS_MODULE,
101 .name = "ocelot ptp",
102 .max_adj = 0x7fffffff,
103 .n_alarm = 0,
104 .n_ext_ts = 0,
105 .n_per_out = OCELOT_PTP_PINS_NUM,
106 .n_pins = OCELOT_PTP_PINS_NUM,
107 .pps = 0,
108 .gettime64 = ocelot_ptp_gettime64,
109 .settime64 = ocelot_ptp_settime64,
110 .adjtime = ocelot_ptp_adjtime,
111 .adjfine = ocelot_ptp_adjfine,
112 .verify = ocelot_ptp_verify,
113 .enable = ocelot_ptp_enable,
114};
115
116static void mscc_ocelot_teardown_devlink_ports(struct ocelot *ocelot)
117{
118 int port;
119
120 for (port = 0; port < ocelot->num_phys_ports; port++)
121 ocelot_port_devlink_teardown(ocelot, port);
122}
123
124static void mscc_ocelot_release_ports(struct ocelot *ocelot)
125{
126 int port;
127
128 for (port = 0; port < ocelot->num_phys_ports; port++) {
129 struct ocelot_port *ocelot_port;
130
131 ocelot_port = ocelot->ports[port];
132 if (!ocelot_port)
133 continue;
134
135 ocelot_deinit_port(ocelot, port);
136 ocelot_release_port(ocelot_port);
137 }
138}
139
140static int mscc_ocelot_init_ports(struct platform_device *pdev,
141 struct device_node *ports)
142{
143 struct ocelot *ocelot = platform_get_drvdata(pdev);
144 u32 devlink_ports_registered = 0;
145 struct device_node *portnp;
146 int port, err;
147 u32 reg;
148
149 ocelot->ports = devm_kcalloc(ocelot->dev, ocelot->num_phys_ports,
150 sizeof(struct ocelot_port *), GFP_KERNEL);
151 if (!ocelot->ports)
152 return -ENOMEM;
153
154 ocelot->devlink_ports = devm_kcalloc(ocelot->dev,
155 ocelot->num_phys_ports,
156 sizeof(*ocelot->devlink_ports),
157 GFP_KERNEL);
158 if (!ocelot->devlink_ports)
159 return -ENOMEM;
160
161 for_each_available_child_of_node(ports, portnp) {
162 struct regmap *target;
163 struct resource *res;
164 char res_name[8];
165
166 if (of_property_read_u32(portnp, "reg", ®))
167 continue;
168
169 port = reg;
170 if (port < 0 || port >= ocelot->num_phys_ports) {
171 dev_err(ocelot->dev,
172 "invalid port number: %d >= %d\n", port,
173 ocelot->num_phys_ports);
174 continue;
175 }
176
177 snprintf(res_name, sizeof(res_name), "port%d", port);
178
179 res = platform_get_resource_byname(pdev, IORESOURCE_MEM,
180 res_name);
181 target = ocelot_regmap_init(ocelot, res);
182 if (IS_ERR(target)) {
183 err = PTR_ERR(target);
184 of_node_put(portnp);
185 goto out_teardown;
186 }
187
188 err = ocelot_port_devlink_init(ocelot, port,
189 DEVLINK_PORT_FLAVOUR_PHYSICAL);
190 if (err) {
191 of_node_put(portnp);
192 goto out_teardown;
193 }
194
195 err = ocelot_probe_port(ocelot, port, target, portnp);
196 if (err) {
197 ocelot_port_devlink_teardown(ocelot, port);
198 continue;
199 }
200
201 devlink_ports_registered |= BIT(port);
202 }
203
204 /* Initialize unused devlink ports at the end */
205 for (port = 0; port < ocelot->num_phys_ports; port++) {
206 if (devlink_ports_registered & BIT(port))
207 continue;
208
209 err = ocelot_port_devlink_init(ocelot, port,
210 DEVLINK_PORT_FLAVOUR_UNUSED);
211 if (err)
212 goto out_teardown;
213
214 devlink_ports_registered |= BIT(port);
215 }
216
217 return 0;
218
219out_teardown:
220 /* Unregister the network interfaces */
221 mscc_ocelot_release_ports(ocelot);
222 /* Tear down devlink ports for the registered network interfaces */
223 for (port = 0; port < ocelot->num_phys_ports; port++) {
224 if (devlink_ports_registered & BIT(port))
225 ocelot_port_devlink_teardown(ocelot, port);
226 }
227 return err;
228}
229
230static int mscc_ocelot_probe(struct platform_device *pdev)
231{
232 struct device_node *np = pdev->dev.of_node;
233 int err, irq_xtr, irq_ptp_rdy;
234 struct device_node *ports;
235 struct devlink *devlink;
236 struct ocelot *ocelot;
237 struct regmap *hsio;
238 unsigned int i;
239
240 struct {
241 enum ocelot_target id;
242 char *name;
243 u8 optional:1;
244 } io_target[] = {
245 { SYS, "sys" },
246 { REW, "rew" },
247 { QSYS, "qsys" },
248 { ANA, "ana" },
249 { QS, "qs" },
250 { S0, "s0" },
251 { S1, "s1" },
252 { S2, "s2" },
253 { PTP, "ptp", 1 },
254 { FDMA, "fdma", 1 },
255 };
256
257 if (!np && !pdev->dev.platform_data)
258 return -ENODEV;
259
260 devlink =
261 devlink_alloc(&ocelot_devlink_ops, sizeof(*ocelot), &pdev->dev);
262 if (!devlink)
263 return -ENOMEM;
264
265 ocelot = devlink_priv(devlink);
266 ocelot->devlink = priv_to_devlink(ocelot);
267 platform_set_drvdata(pdev, ocelot);
268 ocelot->dev = &pdev->dev;
269
270 for (i = 0; i < ARRAY_SIZE(io_target); i++) {
271 struct regmap *target;
272 struct resource *res;
273
274 res = platform_get_resource_byname(pdev, IORESOURCE_MEM,
275 io_target[i].name);
276
277 target = ocelot_regmap_init(ocelot, res);
278 if (IS_ERR(target)) {
279 if (io_target[i].optional) {
280 ocelot->targets[io_target[i].id] = NULL;
281 continue;
282 }
283 err = PTR_ERR(target);
284 goto out_free_devlink;
285 }
286
287 ocelot->targets[io_target[i].id] = target;
288 }
289
290 if (ocelot->targets[FDMA])
291 ocelot_fdma_init(pdev, ocelot);
292
293 hsio = syscon_regmap_lookup_by_compatible("mscc,ocelot-hsio");
294 if (IS_ERR(hsio)) {
295 dev_err(&pdev->dev, "missing hsio syscon\n");
296 err = PTR_ERR(hsio);
297 goto out_free_devlink;
298 }
299
300 ocelot->targets[HSIO] = hsio;
301
302 err = ocelot_chip_init(ocelot, &ocelot_ops);
303 if (err)
304 goto out_free_devlink;
305
306 irq_xtr = platform_get_irq_byname(pdev, "xtr");
307 if (irq_xtr < 0) {
308 err = irq_xtr;
309 goto out_free_devlink;
310 }
311
312 err = devm_request_threaded_irq(&pdev->dev, irq_xtr, NULL,
313 ocelot_xtr_irq_handler, IRQF_ONESHOT,
314 "frame extraction", ocelot);
315 if (err)
316 goto out_free_devlink;
317
318 irq_ptp_rdy = platform_get_irq_byname(pdev, "ptp_rdy");
319 if (irq_ptp_rdy > 0 && ocelot->targets[PTP]) {
320 err = devm_request_threaded_irq(&pdev->dev, irq_ptp_rdy, NULL,
321 ocelot_ptp_rdy_irq_handler,
322 IRQF_ONESHOT, "ptp ready",
323 ocelot);
324 if (err)
325 goto out_free_devlink;
326
327 /* Both the PTP interrupt and the PTP bank are available */
328 ocelot->ptp = 1;
329 }
330
331 ports = of_get_child_by_name(np, "ethernet-ports");
332 if (!ports) {
333 dev_err(ocelot->dev, "no ethernet-ports child node found\n");
334 err = -ENODEV;
335 goto out_free_devlink;
336 }
337
338 ocelot->num_phys_ports = of_get_child_count(ports);
339 ocelot->num_flooding_pgids = 1;
340
341 ocelot->vcap = vsc7514_vcap_props;
342
343 ocelot->vcap_pol.base = VSC7514_VCAP_POLICER_BASE;
344 ocelot->vcap_pol.max = VSC7514_VCAP_POLICER_MAX;
345
346 ocelot->npi = -1;
347
348 err = ocelot_init(ocelot);
349 if (err)
350 goto out_put_ports;
351
352 err = mscc_ocelot_init_ports(pdev, ports);
353 if (err)
354 goto out_ocelot_devlink_unregister;
355
356 if (ocelot->fdma)
357 ocelot_fdma_start(ocelot);
358
359 err = ocelot_devlink_sb_register(ocelot);
360 if (err)
361 goto out_ocelot_release_ports;
362
363 if (ocelot->ptp) {
364 err = ocelot_init_timestamp(ocelot, &ocelot_ptp_clock_info);
365 if (err) {
366 dev_err(ocelot->dev,
367 "Timestamp initialization failed\n");
368 ocelot->ptp = 0;
369 }
370 }
371
372 register_netdevice_notifier(&ocelot_netdevice_nb);
373 register_switchdev_notifier(&ocelot_switchdev_nb);
374 register_switchdev_blocking_notifier(&ocelot_switchdev_blocking_nb);
375
376 of_node_put(ports);
377 devlink_register(devlink);
378
379 dev_info(&pdev->dev, "Ocelot switch probed\n");
380
381 return 0;
382
383out_ocelot_release_ports:
384 mscc_ocelot_release_ports(ocelot);
385 mscc_ocelot_teardown_devlink_ports(ocelot);
386out_ocelot_devlink_unregister:
387 ocelot_deinit(ocelot);
388out_put_ports:
389 of_node_put(ports);
390out_free_devlink:
391 devlink_free(devlink);
392 return err;
393}
394
395static void mscc_ocelot_remove(struct platform_device *pdev)
396{
397 struct ocelot *ocelot = platform_get_drvdata(pdev);
398
399 if (ocelot->fdma)
400 ocelot_fdma_deinit(ocelot);
401 devlink_unregister(ocelot->devlink);
402 ocelot_deinit_timestamp(ocelot);
403 ocelot_devlink_sb_unregister(ocelot);
404 mscc_ocelot_release_ports(ocelot);
405 mscc_ocelot_teardown_devlink_ports(ocelot);
406 ocelot_deinit(ocelot);
407 unregister_switchdev_blocking_notifier(&ocelot_switchdev_blocking_nb);
408 unregister_switchdev_notifier(&ocelot_switchdev_nb);
409 unregister_netdevice_notifier(&ocelot_netdevice_nb);
410 devlink_free(ocelot->devlink);
411}
412
413static struct platform_driver mscc_ocelot_driver = {
414 .probe = mscc_ocelot_probe,
415 .remove_new = mscc_ocelot_remove,
416 .driver = {
417 .name = "ocelot-switch",
418 .of_match_table = mscc_ocelot_match,
419 },
420};
421
422module_platform_driver(mscc_ocelot_driver);
423
424MODULE_DESCRIPTION("Microsemi Ocelot switch driver");
425MODULE_AUTHOR("Alexandre Belloni <alexandre.belloni@bootlin.com>");
426MODULE_LICENSE("Dual MIT/GPL");