Loading...
Note: File does not exist in v4.6.
1// SPDX-License-Identifier: (GPL-2.0 OR MIT)
2/*
3 * DSA driver for:
4 * Hirschmann Hellcreek TSN switch.
5 *
6 * Copyright (C) 2019-2021 Linutronix GmbH
7 * Author Kurt Kanzenbach <kurt@linutronix.de>
8 */
9
10#include <linux/kernel.h>
11#include <linux/module.h>
12#include <linux/device.h>
13#include <linux/of.h>
14#include <linux/of_mdio.h>
15#include <linux/platform_device.h>
16#include <linux/bitops.h>
17#include <linux/if_bridge.h>
18#include <linux/if_vlan.h>
19#include <linux/etherdevice.h>
20#include <linux/random.h>
21#include <linux/iopoll.h>
22#include <linux/mutex.h>
23#include <linux/delay.h>
24#include <net/dsa.h>
25
26#include "hellcreek.h"
27#include "hellcreek_ptp.h"
28#include "hellcreek_hwtstamp.h"
29
30static const struct hellcreek_counter hellcreek_counter[] = {
31 { 0x00, "RxFiltered", },
32 { 0x01, "RxOctets1k", },
33 { 0x02, "RxVTAG", },
34 { 0x03, "RxL2BAD", },
35 { 0x04, "RxOverloadDrop", },
36 { 0x05, "RxUC", },
37 { 0x06, "RxMC", },
38 { 0x07, "RxBC", },
39 { 0x08, "RxRS<64", },
40 { 0x09, "RxRS64", },
41 { 0x0a, "RxRS65_127", },
42 { 0x0b, "RxRS128_255", },
43 { 0x0c, "RxRS256_511", },
44 { 0x0d, "RxRS512_1023", },
45 { 0x0e, "RxRS1024_1518", },
46 { 0x0f, "RxRS>1518", },
47 { 0x10, "TxTailDropQueue0", },
48 { 0x11, "TxTailDropQueue1", },
49 { 0x12, "TxTailDropQueue2", },
50 { 0x13, "TxTailDropQueue3", },
51 { 0x14, "TxTailDropQueue4", },
52 { 0x15, "TxTailDropQueue5", },
53 { 0x16, "TxTailDropQueue6", },
54 { 0x17, "TxTailDropQueue7", },
55 { 0x18, "RxTrafficClass0", },
56 { 0x19, "RxTrafficClass1", },
57 { 0x1a, "RxTrafficClass2", },
58 { 0x1b, "RxTrafficClass3", },
59 { 0x1c, "RxTrafficClass4", },
60 { 0x1d, "RxTrafficClass5", },
61 { 0x1e, "RxTrafficClass6", },
62 { 0x1f, "RxTrafficClass7", },
63 { 0x21, "TxOctets1k", },
64 { 0x22, "TxVTAG", },
65 { 0x23, "TxL2BAD", },
66 { 0x25, "TxUC", },
67 { 0x26, "TxMC", },
68 { 0x27, "TxBC", },
69 { 0x28, "TxTS<64", },
70 { 0x29, "TxTS64", },
71 { 0x2a, "TxTS65_127", },
72 { 0x2b, "TxTS128_255", },
73 { 0x2c, "TxTS256_511", },
74 { 0x2d, "TxTS512_1023", },
75 { 0x2e, "TxTS1024_1518", },
76 { 0x2f, "TxTS>1518", },
77 { 0x30, "TxTrafficClassOverrun0", },
78 { 0x31, "TxTrafficClassOverrun1", },
79 { 0x32, "TxTrafficClassOverrun2", },
80 { 0x33, "TxTrafficClassOverrun3", },
81 { 0x34, "TxTrafficClassOverrun4", },
82 { 0x35, "TxTrafficClassOverrun5", },
83 { 0x36, "TxTrafficClassOverrun6", },
84 { 0x37, "TxTrafficClassOverrun7", },
85 { 0x38, "TxTrafficClass0", },
86 { 0x39, "TxTrafficClass1", },
87 { 0x3a, "TxTrafficClass2", },
88 { 0x3b, "TxTrafficClass3", },
89 { 0x3c, "TxTrafficClass4", },
90 { 0x3d, "TxTrafficClass5", },
91 { 0x3e, "TxTrafficClass6", },
92 { 0x3f, "TxTrafficClass7", },
93};
94
95static u16 hellcreek_read(struct hellcreek *hellcreek, unsigned int offset)
96{
97 return readw(hellcreek->base + offset);
98}
99
100static u16 hellcreek_read_ctrl(struct hellcreek *hellcreek)
101{
102 return readw(hellcreek->base + HR_CTRL_C);
103}
104
105static u16 hellcreek_read_stat(struct hellcreek *hellcreek)
106{
107 return readw(hellcreek->base + HR_SWSTAT);
108}
109
110static void hellcreek_write(struct hellcreek *hellcreek, u16 data,
111 unsigned int offset)
112{
113 writew(data, hellcreek->base + offset);
114}
115
116static void hellcreek_select_port(struct hellcreek *hellcreek, int port)
117{
118 u16 val = port << HR_PSEL_PTWSEL_SHIFT;
119
120 hellcreek_write(hellcreek, val, HR_PSEL);
121}
122
123static void hellcreek_select_prio(struct hellcreek *hellcreek, int prio)
124{
125 u16 val = prio << HR_PSEL_PRTCWSEL_SHIFT;
126
127 hellcreek_write(hellcreek, val, HR_PSEL);
128}
129
130static void hellcreek_select_port_prio(struct hellcreek *hellcreek, int port,
131 int prio)
132{
133 u16 val = port << HR_PSEL_PTWSEL_SHIFT;
134
135 val |= prio << HR_PSEL_PRTCWSEL_SHIFT;
136
137 hellcreek_write(hellcreek, val, HR_PSEL);
138}
139
140static void hellcreek_select_counter(struct hellcreek *hellcreek, int counter)
141{
142 u16 val = counter << HR_CSEL_SHIFT;
143
144 hellcreek_write(hellcreek, val, HR_CSEL);
145
146 /* Data sheet states to wait at least 20 internal clock cycles */
147 ndelay(200);
148}
149
150static void hellcreek_select_vlan(struct hellcreek *hellcreek, int vid,
151 bool pvid)
152{
153 u16 val = 0;
154
155 /* Set pvid bit first */
156 if (pvid)
157 val |= HR_VIDCFG_PVID;
158 hellcreek_write(hellcreek, val, HR_VIDCFG);
159
160 /* Set vlan */
161 val |= vid << HR_VIDCFG_VID_SHIFT;
162 hellcreek_write(hellcreek, val, HR_VIDCFG);
163}
164
165static void hellcreek_select_tgd(struct hellcreek *hellcreek, int port)
166{
167 u16 val = port << TR_TGDSEL_TDGSEL_SHIFT;
168
169 hellcreek_write(hellcreek, val, TR_TGDSEL);
170}
171
172static int hellcreek_wait_until_ready(struct hellcreek *hellcreek)
173{
174 u16 val;
175
176 /* Wait up to 1ms, although 3 us should be enough */
177 return readx_poll_timeout(hellcreek_read_ctrl, hellcreek,
178 val, val & HR_CTRL_C_READY,
179 3, 1000);
180}
181
182static int hellcreek_wait_until_transitioned(struct hellcreek *hellcreek)
183{
184 u16 val;
185
186 return readx_poll_timeout_atomic(hellcreek_read_ctrl, hellcreek,
187 val, !(val & HR_CTRL_C_TRANSITION),
188 1, 1000);
189}
190
191static int hellcreek_wait_fdb_ready(struct hellcreek *hellcreek)
192{
193 u16 val;
194
195 return readx_poll_timeout_atomic(hellcreek_read_stat, hellcreek,
196 val, !(val & HR_SWSTAT_BUSY),
197 1, 1000);
198}
199
200static int hellcreek_detect(struct hellcreek *hellcreek)
201{
202 u16 id, rel_low, rel_high, date_low, date_high, tgd_ver;
203 u8 tgd_maj, tgd_min;
204 u32 rel, date;
205
206 id = hellcreek_read(hellcreek, HR_MODID_C);
207 rel_low = hellcreek_read(hellcreek, HR_REL_L_C);
208 rel_high = hellcreek_read(hellcreek, HR_REL_H_C);
209 date_low = hellcreek_read(hellcreek, HR_BLD_L_C);
210 date_high = hellcreek_read(hellcreek, HR_BLD_H_C);
211 tgd_ver = hellcreek_read(hellcreek, TR_TGDVER);
212
213 if (id != hellcreek->pdata->module_id)
214 return -ENODEV;
215
216 rel = rel_low | (rel_high << 16);
217 date = date_low | (date_high << 16);
218 tgd_maj = (tgd_ver & TR_TGDVER_REV_MAJ_MASK) >> TR_TGDVER_REV_MAJ_SHIFT;
219 tgd_min = (tgd_ver & TR_TGDVER_REV_MIN_MASK) >> TR_TGDVER_REV_MIN_SHIFT;
220
221 dev_info(hellcreek->dev, "Module ID=%02x Release=%04x Date=%04x TGD Version=%02x.%02x\n",
222 id, rel, date, tgd_maj, tgd_min);
223
224 return 0;
225}
226
227static void hellcreek_feature_detect(struct hellcreek *hellcreek)
228{
229 u16 features;
230
231 features = hellcreek_read(hellcreek, HR_FEABITS0);
232
233 /* Only detect the size of the FDB table. The size and current
234 * utilization can be queried via devlink.
235 */
236 hellcreek->fdb_entries = ((features & HR_FEABITS0_FDBBINS_MASK) >>
237 HR_FEABITS0_FDBBINS_SHIFT) * 32;
238}
239
240static enum dsa_tag_protocol hellcreek_get_tag_protocol(struct dsa_switch *ds,
241 int port,
242 enum dsa_tag_protocol mp)
243{
244 return DSA_TAG_PROTO_HELLCREEK;
245}
246
247static int hellcreek_port_enable(struct dsa_switch *ds, int port,
248 struct phy_device *phy)
249{
250 struct hellcreek *hellcreek = ds->priv;
251 struct hellcreek_port *hellcreek_port;
252 u16 val;
253
254 hellcreek_port = &hellcreek->ports[port];
255
256 dev_dbg(hellcreek->dev, "Enable port %d\n", port);
257
258 mutex_lock(&hellcreek->reg_lock);
259
260 hellcreek_select_port(hellcreek, port);
261 val = hellcreek_port->ptcfg;
262 val |= HR_PTCFG_ADMIN_EN;
263 hellcreek_write(hellcreek, val, HR_PTCFG);
264 hellcreek_port->ptcfg = val;
265
266 mutex_unlock(&hellcreek->reg_lock);
267
268 return 0;
269}
270
271static void hellcreek_port_disable(struct dsa_switch *ds, int port)
272{
273 struct hellcreek *hellcreek = ds->priv;
274 struct hellcreek_port *hellcreek_port;
275 u16 val;
276
277 hellcreek_port = &hellcreek->ports[port];
278
279 dev_dbg(hellcreek->dev, "Disable port %d\n", port);
280
281 mutex_lock(&hellcreek->reg_lock);
282
283 hellcreek_select_port(hellcreek, port);
284 val = hellcreek_port->ptcfg;
285 val &= ~HR_PTCFG_ADMIN_EN;
286 hellcreek_write(hellcreek, val, HR_PTCFG);
287 hellcreek_port->ptcfg = val;
288
289 mutex_unlock(&hellcreek->reg_lock);
290}
291
292static void hellcreek_get_strings(struct dsa_switch *ds, int port,
293 u32 stringset, uint8_t *data)
294{
295 int i;
296
297 for (i = 0; i < ARRAY_SIZE(hellcreek_counter); ++i) {
298 const struct hellcreek_counter *counter = &hellcreek_counter[i];
299
300 strscpy(data + i * ETH_GSTRING_LEN,
301 counter->name, ETH_GSTRING_LEN);
302 }
303}
304
305static int hellcreek_get_sset_count(struct dsa_switch *ds, int port, int sset)
306{
307 if (sset != ETH_SS_STATS)
308 return 0;
309
310 return ARRAY_SIZE(hellcreek_counter);
311}
312
313static void hellcreek_get_ethtool_stats(struct dsa_switch *ds, int port,
314 uint64_t *data)
315{
316 struct hellcreek *hellcreek = ds->priv;
317 struct hellcreek_port *hellcreek_port;
318 int i;
319
320 hellcreek_port = &hellcreek->ports[port];
321
322 for (i = 0; i < ARRAY_SIZE(hellcreek_counter); ++i) {
323 const struct hellcreek_counter *counter = &hellcreek_counter[i];
324 u8 offset = counter->offset + port * 64;
325 u16 high, low;
326 u64 value;
327
328 mutex_lock(&hellcreek->reg_lock);
329
330 hellcreek_select_counter(hellcreek, offset);
331
332 /* The registers are locked internally by selecting the
333 * counter. So low and high can be read without reading high
334 * again.
335 */
336 high = hellcreek_read(hellcreek, HR_CRDH);
337 low = hellcreek_read(hellcreek, HR_CRDL);
338 value = ((u64)high << 16) | low;
339
340 hellcreek_port->counter_values[i] += value;
341 data[i] = hellcreek_port->counter_values[i];
342
343 mutex_unlock(&hellcreek->reg_lock);
344 }
345}
346
347static u16 hellcreek_private_vid(int port)
348{
349 return VLAN_N_VID - port + 1;
350}
351
352static int hellcreek_vlan_prepare(struct dsa_switch *ds, int port,
353 const struct switchdev_obj_port_vlan *vlan,
354 struct netlink_ext_ack *extack)
355{
356 struct hellcreek *hellcreek = ds->priv;
357 int i;
358
359 dev_dbg(hellcreek->dev, "VLAN prepare for port %d\n", port);
360
361 /* Restriction: Make sure that nobody uses the "private" VLANs. These
362 * VLANs are internally used by the driver to ensure port
363 * separation. Thus, they cannot be used by someone else.
364 */
365 for (i = 0; i < hellcreek->pdata->num_ports; ++i) {
366 const u16 restricted_vid = hellcreek_private_vid(i);
367
368 if (!dsa_is_user_port(ds, i))
369 continue;
370
371 if (vlan->vid == restricted_vid) {
372 NL_SET_ERR_MSG_MOD(extack, "VID restricted by driver");
373 return -EBUSY;
374 }
375 }
376
377 return 0;
378}
379
380static void hellcreek_select_vlan_params(struct hellcreek *hellcreek, int port,
381 int *shift, int *mask)
382{
383 switch (port) {
384 case 0:
385 *shift = HR_VIDMBRCFG_P0MBR_SHIFT;
386 *mask = HR_VIDMBRCFG_P0MBR_MASK;
387 break;
388 case 1:
389 *shift = HR_VIDMBRCFG_P1MBR_SHIFT;
390 *mask = HR_VIDMBRCFG_P1MBR_MASK;
391 break;
392 case 2:
393 *shift = HR_VIDMBRCFG_P2MBR_SHIFT;
394 *mask = HR_VIDMBRCFG_P2MBR_MASK;
395 break;
396 case 3:
397 *shift = HR_VIDMBRCFG_P3MBR_SHIFT;
398 *mask = HR_VIDMBRCFG_P3MBR_MASK;
399 break;
400 default:
401 *shift = *mask = 0;
402 dev_err(hellcreek->dev, "Unknown port %d selected!\n", port);
403 }
404}
405
406static void hellcreek_apply_vlan(struct hellcreek *hellcreek, int port, u16 vid,
407 bool pvid, bool untagged)
408{
409 int shift, mask;
410 u16 val;
411
412 dev_dbg(hellcreek->dev, "Apply VLAN: port=%d vid=%u pvid=%d untagged=%d",
413 port, vid, pvid, untagged);
414
415 mutex_lock(&hellcreek->reg_lock);
416
417 hellcreek_select_port(hellcreek, port);
418 hellcreek_select_vlan(hellcreek, vid, pvid);
419
420 /* Setup port vlan membership */
421 hellcreek_select_vlan_params(hellcreek, port, &shift, &mask);
422 val = hellcreek->vidmbrcfg[vid];
423 val &= ~mask;
424 if (untagged)
425 val |= HELLCREEK_VLAN_UNTAGGED_MEMBER << shift;
426 else
427 val |= HELLCREEK_VLAN_TAGGED_MEMBER << shift;
428
429 hellcreek_write(hellcreek, val, HR_VIDMBRCFG);
430 hellcreek->vidmbrcfg[vid] = val;
431
432 mutex_unlock(&hellcreek->reg_lock);
433}
434
435static void hellcreek_unapply_vlan(struct hellcreek *hellcreek, int port,
436 u16 vid)
437{
438 int shift, mask;
439 u16 val;
440
441 dev_dbg(hellcreek->dev, "Unapply VLAN: port=%d vid=%u\n", port, vid);
442
443 mutex_lock(&hellcreek->reg_lock);
444
445 hellcreek_select_vlan(hellcreek, vid, false);
446
447 /* Setup port vlan membership */
448 hellcreek_select_vlan_params(hellcreek, port, &shift, &mask);
449 val = hellcreek->vidmbrcfg[vid];
450 val &= ~mask;
451 val |= HELLCREEK_VLAN_NO_MEMBER << shift;
452
453 hellcreek_write(hellcreek, val, HR_VIDMBRCFG);
454 hellcreek->vidmbrcfg[vid] = val;
455
456 mutex_unlock(&hellcreek->reg_lock);
457}
458
459static int hellcreek_vlan_add(struct dsa_switch *ds, int port,
460 const struct switchdev_obj_port_vlan *vlan,
461 struct netlink_ext_ack *extack)
462{
463 bool untagged = vlan->flags & BRIDGE_VLAN_INFO_UNTAGGED;
464 bool pvid = vlan->flags & BRIDGE_VLAN_INFO_PVID;
465 struct hellcreek *hellcreek = ds->priv;
466 int err;
467
468 err = hellcreek_vlan_prepare(ds, port, vlan, extack);
469 if (err)
470 return err;
471
472 dev_dbg(hellcreek->dev, "Add VLAN %d on port %d, %s, %s\n",
473 vlan->vid, port, untagged ? "untagged" : "tagged",
474 pvid ? "PVID" : "no PVID");
475
476 hellcreek_apply_vlan(hellcreek, port, vlan->vid, pvid, untagged);
477
478 return 0;
479}
480
481static int hellcreek_vlan_del(struct dsa_switch *ds, int port,
482 const struct switchdev_obj_port_vlan *vlan)
483{
484 struct hellcreek *hellcreek = ds->priv;
485
486 dev_dbg(hellcreek->dev, "Remove VLAN %d on port %d\n", vlan->vid, port);
487
488 hellcreek_unapply_vlan(hellcreek, port, vlan->vid);
489
490 return 0;
491}
492
493static void hellcreek_port_stp_state_set(struct dsa_switch *ds, int port,
494 u8 state)
495{
496 struct hellcreek *hellcreek = ds->priv;
497 struct hellcreek_port *hellcreek_port;
498 const char *new_state;
499 u16 val;
500
501 mutex_lock(&hellcreek->reg_lock);
502
503 hellcreek_port = &hellcreek->ports[port];
504 val = hellcreek_port->ptcfg;
505
506 switch (state) {
507 case BR_STATE_DISABLED:
508 new_state = "DISABLED";
509 val |= HR_PTCFG_BLOCKED;
510 val &= ~HR_PTCFG_LEARNING_EN;
511 break;
512 case BR_STATE_BLOCKING:
513 new_state = "BLOCKING";
514 val |= HR_PTCFG_BLOCKED;
515 val &= ~HR_PTCFG_LEARNING_EN;
516 break;
517 case BR_STATE_LISTENING:
518 new_state = "LISTENING";
519 val |= HR_PTCFG_BLOCKED;
520 val &= ~HR_PTCFG_LEARNING_EN;
521 break;
522 case BR_STATE_LEARNING:
523 new_state = "LEARNING";
524 val |= HR_PTCFG_BLOCKED;
525 val |= HR_PTCFG_LEARNING_EN;
526 break;
527 case BR_STATE_FORWARDING:
528 new_state = "FORWARDING";
529 val &= ~HR_PTCFG_BLOCKED;
530 val |= HR_PTCFG_LEARNING_EN;
531 break;
532 default:
533 new_state = "UNKNOWN";
534 }
535
536 hellcreek_select_port(hellcreek, port);
537 hellcreek_write(hellcreek, val, HR_PTCFG);
538 hellcreek_port->ptcfg = val;
539
540 mutex_unlock(&hellcreek->reg_lock);
541
542 dev_dbg(hellcreek->dev, "Configured STP state for port %d: %s\n",
543 port, new_state);
544}
545
546static void hellcreek_setup_ingressflt(struct hellcreek *hellcreek, int port,
547 bool enable)
548{
549 struct hellcreek_port *hellcreek_port = &hellcreek->ports[port];
550 u16 ptcfg;
551
552 mutex_lock(&hellcreek->reg_lock);
553
554 ptcfg = hellcreek_port->ptcfg;
555
556 if (enable)
557 ptcfg |= HR_PTCFG_INGRESSFLT;
558 else
559 ptcfg &= ~HR_PTCFG_INGRESSFLT;
560
561 hellcreek_select_port(hellcreek, port);
562 hellcreek_write(hellcreek, ptcfg, HR_PTCFG);
563 hellcreek_port->ptcfg = ptcfg;
564
565 mutex_unlock(&hellcreek->reg_lock);
566}
567
568static void hellcreek_setup_vlan_awareness(struct hellcreek *hellcreek,
569 bool enable)
570{
571 u16 swcfg;
572
573 mutex_lock(&hellcreek->reg_lock);
574
575 swcfg = hellcreek->swcfg;
576
577 if (enable)
578 swcfg |= HR_SWCFG_VLAN_UNAWARE;
579 else
580 swcfg &= ~HR_SWCFG_VLAN_UNAWARE;
581
582 hellcreek_write(hellcreek, swcfg, HR_SWCFG);
583
584 mutex_unlock(&hellcreek->reg_lock);
585}
586
587/* Default setup for DSA: VLAN <X>: CPU and Port <X> egress untagged. */
588static void hellcreek_setup_vlan_membership(struct dsa_switch *ds, int port,
589 bool enabled)
590{
591 const u16 vid = hellcreek_private_vid(port);
592 int upstream = dsa_upstream_port(ds, port);
593 struct hellcreek *hellcreek = ds->priv;
594
595 /* Apply vid to port as egress untagged and port vlan id */
596 if (enabled)
597 hellcreek_apply_vlan(hellcreek, port, vid, true, true);
598 else
599 hellcreek_unapply_vlan(hellcreek, port, vid);
600
601 /* Apply vid to cpu port as well */
602 if (enabled)
603 hellcreek_apply_vlan(hellcreek, upstream, vid, false, true);
604 else
605 hellcreek_unapply_vlan(hellcreek, upstream, vid);
606}
607
608static void hellcreek_port_set_ucast_flood(struct hellcreek *hellcreek,
609 int port, bool enable)
610{
611 struct hellcreek_port *hellcreek_port;
612 u16 val;
613
614 hellcreek_port = &hellcreek->ports[port];
615
616 dev_dbg(hellcreek->dev, "%s unicast flooding on port %d\n",
617 enable ? "Enable" : "Disable", port);
618
619 mutex_lock(&hellcreek->reg_lock);
620
621 hellcreek_select_port(hellcreek, port);
622 val = hellcreek_port->ptcfg;
623 if (enable)
624 val &= ~HR_PTCFG_UUC_FLT;
625 else
626 val |= HR_PTCFG_UUC_FLT;
627 hellcreek_write(hellcreek, val, HR_PTCFG);
628 hellcreek_port->ptcfg = val;
629
630 mutex_unlock(&hellcreek->reg_lock);
631}
632
633static void hellcreek_port_set_mcast_flood(struct hellcreek *hellcreek,
634 int port, bool enable)
635{
636 struct hellcreek_port *hellcreek_port;
637 u16 val;
638
639 hellcreek_port = &hellcreek->ports[port];
640
641 dev_dbg(hellcreek->dev, "%s multicast flooding on port %d\n",
642 enable ? "Enable" : "Disable", port);
643
644 mutex_lock(&hellcreek->reg_lock);
645
646 hellcreek_select_port(hellcreek, port);
647 val = hellcreek_port->ptcfg;
648 if (enable)
649 val &= ~HR_PTCFG_UMC_FLT;
650 else
651 val |= HR_PTCFG_UMC_FLT;
652 hellcreek_write(hellcreek, val, HR_PTCFG);
653 hellcreek_port->ptcfg = val;
654
655 mutex_unlock(&hellcreek->reg_lock);
656}
657
658static int hellcreek_pre_bridge_flags(struct dsa_switch *ds, int port,
659 struct switchdev_brport_flags flags,
660 struct netlink_ext_ack *extack)
661{
662 if (flags.mask & ~(BR_FLOOD | BR_MCAST_FLOOD))
663 return -EINVAL;
664
665 return 0;
666}
667
668static int hellcreek_bridge_flags(struct dsa_switch *ds, int port,
669 struct switchdev_brport_flags flags,
670 struct netlink_ext_ack *extack)
671{
672 struct hellcreek *hellcreek = ds->priv;
673
674 if (flags.mask & BR_FLOOD)
675 hellcreek_port_set_ucast_flood(hellcreek, port,
676 !!(flags.val & BR_FLOOD));
677
678 if (flags.mask & BR_MCAST_FLOOD)
679 hellcreek_port_set_mcast_flood(hellcreek, port,
680 !!(flags.val & BR_MCAST_FLOOD));
681
682 return 0;
683}
684
685static int hellcreek_port_bridge_join(struct dsa_switch *ds, int port,
686 struct dsa_bridge bridge,
687 bool *tx_fwd_offload,
688 struct netlink_ext_ack *extack)
689{
690 struct hellcreek *hellcreek = ds->priv;
691
692 dev_dbg(hellcreek->dev, "Port %d joins a bridge\n", port);
693
694 /* When joining a vlan_filtering bridge, keep the switch VLAN aware */
695 if (!ds->vlan_filtering)
696 hellcreek_setup_vlan_awareness(hellcreek, false);
697
698 /* Drop private vlans */
699 hellcreek_setup_vlan_membership(ds, port, false);
700
701 return 0;
702}
703
704static void hellcreek_port_bridge_leave(struct dsa_switch *ds, int port,
705 struct dsa_bridge bridge)
706{
707 struct hellcreek *hellcreek = ds->priv;
708
709 dev_dbg(hellcreek->dev, "Port %d leaves a bridge\n", port);
710
711 /* Enable VLAN awareness */
712 hellcreek_setup_vlan_awareness(hellcreek, true);
713
714 /* Enable private vlans */
715 hellcreek_setup_vlan_membership(ds, port, true);
716}
717
718static int __hellcreek_fdb_add(struct hellcreek *hellcreek,
719 const struct hellcreek_fdb_entry *entry)
720{
721 u16 meta = 0;
722
723 dev_dbg(hellcreek->dev, "Add static FDB entry: MAC=%pM, MASK=0x%02x, "
724 "OBT=%d, PASS_BLOCKED=%d, REPRIO_EN=%d, PRIO=%d\n", entry->mac,
725 entry->portmask, entry->is_obt, entry->pass_blocked,
726 entry->reprio_en, entry->reprio_tc);
727
728 /* Add mac address */
729 hellcreek_write(hellcreek, entry->mac[1] | (entry->mac[0] << 8), HR_FDBWDH);
730 hellcreek_write(hellcreek, entry->mac[3] | (entry->mac[2] << 8), HR_FDBWDM);
731 hellcreek_write(hellcreek, entry->mac[5] | (entry->mac[4] << 8), HR_FDBWDL);
732
733 /* Meta data */
734 meta |= entry->portmask << HR_FDBWRM0_PORTMASK_SHIFT;
735 if (entry->is_obt)
736 meta |= HR_FDBWRM0_OBT;
737 if (entry->pass_blocked)
738 meta |= HR_FDBWRM0_PASS_BLOCKED;
739 if (entry->reprio_en) {
740 meta |= HR_FDBWRM0_REPRIO_EN;
741 meta |= entry->reprio_tc << HR_FDBWRM0_REPRIO_TC_SHIFT;
742 }
743 hellcreek_write(hellcreek, meta, HR_FDBWRM0);
744
745 /* Commit */
746 hellcreek_write(hellcreek, 0x00, HR_FDBWRCMD);
747
748 /* Wait until done */
749 return hellcreek_wait_fdb_ready(hellcreek);
750}
751
752static int __hellcreek_fdb_del(struct hellcreek *hellcreek,
753 const struct hellcreek_fdb_entry *entry)
754{
755 dev_dbg(hellcreek->dev, "Delete FDB entry: MAC=%pM!\n", entry->mac);
756
757 /* Delete by matching idx */
758 hellcreek_write(hellcreek, entry->idx | HR_FDBWRCMD_FDBDEL, HR_FDBWRCMD);
759
760 /* Wait until done */
761 return hellcreek_wait_fdb_ready(hellcreek);
762}
763
764static void hellcreek_populate_fdb_entry(struct hellcreek *hellcreek,
765 struct hellcreek_fdb_entry *entry,
766 size_t idx)
767{
768 unsigned char addr[ETH_ALEN];
769 u16 meta, mac;
770
771 /* Read values */
772 meta = hellcreek_read(hellcreek, HR_FDBMDRD);
773 mac = hellcreek_read(hellcreek, HR_FDBRDL);
774 addr[5] = mac & 0xff;
775 addr[4] = (mac & 0xff00) >> 8;
776 mac = hellcreek_read(hellcreek, HR_FDBRDM);
777 addr[3] = mac & 0xff;
778 addr[2] = (mac & 0xff00) >> 8;
779 mac = hellcreek_read(hellcreek, HR_FDBRDH);
780 addr[1] = mac & 0xff;
781 addr[0] = (mac & 0xff00) >> 8;
782
783 /* Populate @entry */
784 memcpy(entry->mac, addr, sizeof(addr));
785 entry->idx = idx;
786 entry->portmask = (meta & HR_FDBMDRD_PORTMASK_MASK) >>
787 HR_FDBMDRD_PORTMASK_SHIFT;
788 entry->age = (meta & HR_FDBMDRD_AGE_MASK) >>
789 HR_FDBMDRD_AGE_SHIFT;
790 entry->is_obt = !!(meta & HR_FDBMDRD_OBT);
791 entry->pass_blocked = !!(meta & HR_FDBMDRD_PASS_BLOCKED);
792 entry->is_static = !!(meta & HR_FDBMDRD_STATIC);
793 entry->reprio_tc = (meta & HR_FDBMDRD_REPRIO_TC_MASK) >>
794 HR_FDBMDRD_REPRIO_TC_SHIFT;
795 entry->reprio_en = !!(meta & HR_FDBMDRD_REPRIO_EN);
796}
797
798/* Retrieve the index of a FDB entry by mac address. Currently we search through
799 * the complete table in hardware. If that's too slow, we might have to cache
800 * the complete FDB table in software.
801 */
802static int hellcreek_fdb_get(struct hellcreek *hellcreek,
803 const unsigned char *dest,
804 struct hellcreek_fdb_entry *entry)
805{
806 size_t i;
807
808 /* Set read pointer to zero: The read of HR_FDBMAX (read-only register)
809 * should reset the internal pointer. But, that doesn't work. The vendor
810 * suggested a subsequent write as workaround. Same for HR_FDBRDH below.
811 */
812 hellcreek_read(hellcreek, HR_FDBMAX);
813 hellcreek_write(hellcreek, 0x00, HR_FDBMAX);
814
815 /* We have to read the complete table, because the switch/driver might
816 * enter new entries anywhere.
817 */
818 for (i = 0; i < hellcreek->fdb_entries; ++i) {
819 struct hellcreek_fdb_entry tmp = { 0 };
820
821 /* Read entry */
822 hellcreek_populate_fdb_entry(hellcreek, &tmp, i);
823
824 /* Force next entry */
825 hellcreek_write(hellcreek, 0x00, HR_FDBRDH);
826
827 if (memcmp(tmp.mac, dest, ETH_ALEN))
828 continue;
829
830 /* Match found */
831 memcpy(entry, &tmp, sizeof(*entry));
832
833 return 0;
834 }
835
836 return -ENOENT;
837}
838
839static int hellcreek_fdb_add(struct dsa_switch *ds, int port,
840 const unsigned char *addr, u16 vid,
841 struct dsa_db db)
842{
843 struct hellcreek_fdb_entry entry = { 0 };
844 struct hellcreek *hellcreek = ds->priv;
845 int ret;
846
847 dev_dbg(hellcreek->dev, "Add FDB entry for MAC=%pM\n", addr);
848
849 mutex_lock(&hellcreek->reg_lock);
850
851 ret = hellcreek_fdb_get(hellcreek, addr, &entry);
852 if (ret) {
853 /* Not found */
854 memcpy(entry.mac, addr, sizeof(entry.mac));
855 entry.portmask = BIT(port);
856
857 ret = __hellcreek_fdb_add(hellcreek, &entry);
858 if (ret) {
859 dev_err(hellcreek->dev, "Failed to add FDB entry!\n");
860 goto out;
861 }
862 } else {
863 /* Found */
864 ret = __hellcreek_fdb_del(hellcreek, &entry);
865 if (ret) {
866 dev_err(hellcreek->dev, "Failed to delete FDB entry!\n");
867 goto out;
868 }
869
870 entry.portmask |= BIT(port);
871
872 ret = __hellcreek_fdb_add(hellcreek, &entry);
873 if (ret) {
874 dev_err(hellcreek->dev, "Failed to add FDB entry!\n");
875 goto out;
876 }
877 }
878
879out:
880 mutex_unlock(&hellcreek->reg_lock);
881
882 return ret;
883}
884
885static int hellcreek_fdb_del(struct dsa_switch *ds, int port,
886 const unsigned char *addr, u16 vid,
887 struct dsa_db db)
888{
889 struct hellcreek_fdb_entry entry = { 0 };
890 struct hellcreek *hellcreek = ds->priv;
891 int ret;
892
893 dev_dbg(hellcreek->dev, "Delete FDB entry for MAC=%pM\n", addr);
894
895 mutex_lock(&hellcreek->reg_lock);
896
897 ret = hellcreek_fdb_get(hellcreek, addr, &entry);
898 if (ret) {
899 /* Not found */
900 dev_err(hellcreek->dev, "FDB entry for deletion not found!\n");
901 } else {
902 /* Found */
903 ret = __hellcreek_fdb_del(hellcreek, &entry);
904 if (ret) {
905 dev_err(hellcreek->dev, "Failed to delete FDB entry!\n");
906 goto out;
907 }
908
909 entry.portmask &= ~BIT(port);
910
911 if (entry.portmask != 0x00) {
912 ret = __hellcreek_fdb_add(hellcreek, &entry);
913 if (ret) {
914 dev_err(hellcreek->dev, "Failed to add FDB entry!\n");
915 goto out;
916 }
917 }
918 }
919
920out:
921 mutex_unlock(&hellcreek->reg_lock);
922
923 return ret;
924}
925
926static int hellcreek_fdb_dump(struct dsa_switch *ds, int port,
927 dsa_fdb_dump_cb_t *cb, void *data)
928{
929 struct hellcreek *hellcreek = ds->priv;
930 u16 entries;
931 int ret = 0;
932 size_t i;
933
934 mutex_lock(&hellcreek->reg_lock);
935
936 /* Set read pointer to zero: The read of HR_FDBMAX (read-only register)
937 * should reset the internal pointer. But, that doesn't work. The vendor
938 * suggested a subsequent write as workaround. Same for HR_FDBRDH below.
939 */
940 entries = hellcreek_read(hellcreek, HR_FDBMAX);
941 hellcreek_write(hellcreek, 0x00, HR_FDBMAX);
942
943 dev_dbg(hellcreek->dev, "FDB dump for port %d, entries=%d!\n", port, entries);
944
945 /* Read table */
946 for (i = 0; i < hellcreek->fdb_entries; ++i) {
947 struct hellcreek_fdb_entry entry = { 0 };
948
949 /* Read entry */
950 hellcreek_populate_fdb_entry(hellcreek, &entry, i);
951
952 /* Force next entry */
953 hellcreek_write(hellcreek, 0x00, HR_FDBRDH);
954
955 /* Check valid */
956 if (is_zero_ether_addr(entry.mac))
957 continue;
958
959 /* Check port mask */
960 if (!(entry.portmask & BIT(port)))
961 continue;
962
963 ret = cb(entry.mac, 0, entry.is_static, data);
964 if (ret)
965 break;
966 }
967
968 mutex_unlock(&hellcreek->reg_lock);
969
970 return ret;
971}
972
973static int hellcreek_vlan_filtering(struct dsa_switch *ds, int port,
974 bool vlan_filtering,
975 struct netlink_ext_ack *extack)
976{
977 struct hellcreek *hellcreek = ds->priv;
978
979 dev_dbg(hellcreek->dev, "%s VLAN filtering on port %d\n",
980 vlan_filtering ? "Enable" : "Disable", port);
981
982 /* Configure port to drop packages with not known vids */
983 hellcreek_setup_ingressflt(hellcreek, port, vlan_filtering);
984
985 /* Enable VLAN awareness on the switch. This save due to
986 * ds->vlan_filtering_is_global.
987 */
988 hellcreek_setup_vlan_awareness(hellcreek, vlan_filtering);
989
990 return 0;
991}
992
993static int hellcreek_enable_ip_core(struct hellcreek *hellcreek)
994{
995 int ret;
996 u16 val;
997
998 mutex_lock(&hellcreek->reg_lock);
999
1000 val = hellcreek_read(hellcreek, HR_CTRL_C);
1001 val |= HR_CTRL_C_ENABLE;
1002 hellcreek_write(hellcreek, val, HR_CTRL_C);
1003 ret = hellcreek_wait_until_transitioned(hellcreek);
1004
1005 mutex_unlock(&hellcreek->reg_lock);
1006
1007 return ret;
1008}
1009
1010static void hellcreek_setup_cpu_and_tunnel_port(struct hellcreek *hellcreek)
1011{
1012 struct hellcreek_port *tunnel_port = &hellcreek->ports[TUNNEL_PORT];
1013 struct hellcreek_port *cpu_port = &hellcreek->ports[CPU_PORT];
1014 u16 ptcfg = 0;
1015
1016 ptcfg |= HR_PTCFG_LEARNING_EN | HR_PTCFG_ADMIN_EN;
1017
1018 mutex_lock(&hellcreek->reg_lock);
1019
1020 hellcreek_select_port(hellcreek, CPU_PORT);
1021 hellcreek_write(hellcreek, ptcfg, HR_PTCFG);
1022
1023 hellcreek_select_port(hellcreek, TUNNEL_PORT);
1024 hellcreek_write(hellcreek, ptcfg, HR_PTCFG);
1025
1026 cpu_port->ptcfg = ptcfg;
1027 tunnel_port->ptcfg = ptcfg;
1028
1029 mutex_unlock(&hellcreek->reg_lock);
1030}
1031
1032static void hellcreek_setup_tc_identity_mapping(struct hellcreek *hellcreek)
1033{
1034 int i;
1035
1036 /* The switch has multiple egress queues per port. The queue is selected
1037 * via the PCP field in the VLAN header. The switch internally deals
1038 * with traffic classes instead of PCP values and this mapping is
1039 * configurable.
1040 *
1041 * The default mapping is (PCP - TC):
1042 * 7 - 7
1043 * 6 - 6
1044 * 5 - 5
1045 * 4 - 4
1046 * 3 - 3
1047 * 2 - 1
1048 * 1 - 0
1049 * 0 - 2
1050 *
1051 * The default should be an identity mapping.
1052 */
1053
1054 for (i = 0; i < 8; ++i) {
1055 mutex_lock(&hellcreek->reg_lock);
1056
1057 hellcreek_select_prio(hellcreek, i);
1058 hellcreek_write(hellcreek,
1059 i << HR_PRTCCFG_PCP_TC_MAP_SHIFT,
1060 HR_PRTCCFG);
1061
1062 mutex_unlock(&hellcreek->reg_lock);
1063 }
1064}
1065
1066static int hellcreek_setup_fdb(struct hellcreek *hellcreek)
1067{
1068 static struct hellcreek_fdb_entry l2_ptp = {
1069 /* MAC: 01-1B-19-00-00-00 */
1070 .mac = { 0x01, 0x1b, 0x19, 0x00, 0x00, 0x00 },
1071 .portmask = 0x03, /* Management ports */
1072 .age = 0,
1073 .is_obt = 0,
1074 .pass_blocked = 0,
1075 .is_static = 1,
1076 .reprio_tc = 6, /* TC: 6 as per IEEE 802.1AS */
1077 .reprio_en = 1,
1078 };
1079 static struct hellcreek_fdb_entry udp4_ptp = {
1080 /* MAC: 01-00-5E-00-01-81 */
1081 .mac = { 0x01, 0x00, 0x5e, 0x00, 0x01, 0x81 },
1082 .portmask = 0x03, /* Management ports */
1083 .age = 0,
1084 .is_obt = 0,
1085 .pass_blocked = 0,
1086 .is_static = 1,
1087 .reprio_tc = 6,
1088 .reprio_en = 1,
1089 };
1090 static struct hellcreek_fdb_entry udp6_ptp = {
1091 /* MAC: 33-33-00-00-01-81 */
1092 .mac = { 0x33, 0x33, 0x00, 0x00, 0x01, 0x81 },
1093 .portmask = 0x03, /* Management ports */
1094 .age = 0,
1095 .is_obt = 0,
1096 .pass_blocked = 0,
1097 .is_static = 1,
1098 .reprio_tc = 6,
1099 .reprio_en = 1,
1100 };
1101 static struct hellcreek_fdb_entry l2_p2p = {
1102 /* MAC: 01-80-C2-00-00-0E */
1103 .mac = { 0x01, 0x80, 0xc2, 0x00, 0x00, 0x0e },
1104 .portmask = 0x03, /* Management ports */
1105 .age = 0,
1106 .is_obt = 0,
1107 .pass_blocked = 1,
1108 .is_static = 1,
1109 .reprio_tc = 6, /* TC: 6 as per IEEE 802.1AS */
1110 .reprio_en = 1,
1111 };
1112 static struct hellcreek_fdb_entry udp4_p2p = {
1113 /* MAC: 01-00-5E-00-00-6B */
1114 .mac = { 0x01, 0x00, 0x5e, 0x00, 0x00, 0x6b },
1115 .portmask = 0x03, /* Management ports */
1116 .age = 0,
1117 .is_obt = 0,
1118 .pass_blocked = 1,
1119 .is_static = 1,
1120 .reprio_tc = 6,
1121 .reprio_en = 1,
1122 };
1123 static struct hellcreek_fdb_entry udp6_p2p = {
1124 /* MAC: 33-33-00-00-00-6B */
1125 .mac = { 0x33, 0x33, 0x00, 0x00, 0x00, 0x6b },
1126 .portmask = 0x03, /* Management ports */
1127 .age = 0,
1128 .is_obt = 0,
1129 .pass_blocked = 1,
1130 .is_static = 1,
1131 .reprio_tc = 6,
1132 .reprio_en = 1,
1133 };
1134 static struct hellcreek_fdb_entry stp = {
1135 /* MAC: 01-80-C2-00-00-00 */
1136 .mac = { 0x01, 0x80, 0xc2, 0x00, 0x00, 0x00 },
1137 .portmask = 0x03, /* Management ports */
1138 .age = 0,
1139 .is_obt = 0,
1140 .pass_blocked = 1,
1141 .is_static = 1,
1142 .reprio_tc = 6,
1143 .reprio_en = 1,
1144 };
1145 int ret;
1146
1147 mutex_lock(&hellcreek->reg_lock);
1148 ret = __hellcreek_fdb_add(hellcreek, &l2_ptp);
1149 if (ret)
1150 goto out;
1151 ret = __hellcreek_fdb_add(hellcreek, &udp4_ptp);
1152 if (ret)
1153 goto out;
1154 ret = __hellcreek_fdb_add(hellcreek, &udp6_ptp);
1155 if (ret)
1156 goto out;
1157 ret = __hellcreek_fdb_add(hellcreek, &l2_p2p);
1158 if (ret)
1159 goto out;
1160 ret = __hellcreek_fdb_add(hellcreek, &udp4_p2p);
1161 if (ret)
1162 goto out;
1163 ret = __hellcreek_fdb_add(hellcreek, &udp6_p2p);
1164 if (ret)
1165 goto out;
1166 ret = __hellcreek_fdb_add(hellcreek, &stp);
1167out:
1168 mutex_unlock(&hellcreek->reg_lock);
1169
1170 return ret;
1171}
1172
1173static int hellcreek_devlink_info_get(struct dsa_switch *ds,
1174 struct devlink_info_req *req,
1175 struct netlink_ext_ack *extack)
1176{
1177 struct hellcreek *hellcreek = ds->priv;
1178
1179 return devlink_info_version_fixed_put(req,
1180 DEVLINK_INFO_VERSION_GENERIC_ASIC_ID,
1181 hellcreek->pdata->name);
1182}
1183
1184static u64 hellcreek_devlink_vlan_table_get(void *priv)
1185{
1186 struct hellcreek *hellcreek = priv;
1187 u64 count = 0;
1188 int i;
1189
1190 mutex_lock(&hellcreek->reg_lock);
1191 for (i = 0; i < VLAN_N_VID; ++i)
1192 if (hellcreek->vidmbrcfg[i])
1193 count++;
1194 mutex_unlock(&hellcreek->reg_lock);
1195
1196 return count;
1197}
1198
1199static u64 hellcreek_devlink_fdb_table_get(void *priv)
1200{
1201 struct hellcreek *hellcreek = priv;
1202 u64 count = 0;
1203
1204 /* Reading this register has side effects. Synchronize against the other
1205 * FDB operations.
1206 */
1207 mutex_lock(&hellcreek->reg_lock);
1208 count = hellcreek_read(hellcreek, HR_FDBMAX);
1209 mutex_unlock(&hellcreek->reg_lock);
1210
1211 return count;
1212}
1213
1214static int hellcreek_setup_devlink_resources(struct dsa_switch *ds)
1215{
1216 struct devlink_resource_size_params size_vlan_params;
1217 struct devlink_resource_size_params size_fdb_params;
1218 struct hellcreek *hellcreek = ds->priv;
1219 int err;
1220
1221 devlink_resource_size_params_init(&size_vlan_params, VLAN_N_VID,
1222 VLAN_N_VID,
1223 1, DEVLINK_RESOURCE_UNIT_ENTRY);
1224
1225 devlink_resource_size_params_init(&size_fdb_params,
1226 hellcreek->fdb_entries,
1227 hellcreek->fdb_entries,
1228 1, DEVLINK_RESOURCE_UNIT_ENTRY);
1229
1230 err = dsa_devlink_resource_register(ds, "VLAN", VLAN_N_VID,
1231 HELLCREEK_DEVLINK_PARAM_ID_VLAN_TABLE,
1232 DEVLINK_RESOURCE_ID_PARENT_TOP,
1233 &size_vlan_params);
1234 if (err)
1235 goto out;
1236
1237 err = dsa_devlink_resource_register(ds, "FDB", hellcreek->fdb_entries,
1238 HELLCREEK_DEVLINK_PARAM_ID_FDB_TABLE,
1239 DEVLINK_RESOURCE_ID_PARENT_TOP,
1240 &size_fdb_params);
1241 if (err)
1242 goto out;
1243
1244 dsa_devlink_resource_occ_get_register(ds,
1245 HELLCREEK_DEVLINK_PARAM_ID_VLAN_TABLE,
1246 hellcreek_devlink_vlan_table_get,
1247 hellcreek);
1248
1249 dsa_devlink_resource_occ_get_register(ds,
1250 HELLCREEK_DEVLINK_PARAM_ID_FDB_TABLE,
1251 hellcreek_devlink_fdb_table_get,
1252 hellcreek);
1253
1254 return 0;
1255
1256out:
1257 dsa_devlink_resources_unregister(ds);
1258
1259 return err;
1260}
1261
1262static int hellcreek_devlink_region_vlan_snapshot(struct devlink *dl,
1263 const struct devlink_region_ops *ops,
1264 struct netlink_ext_ack *extack,
1265 u8 **data)
1266{
1267 struct hellcreek_devlink_vlan_entry *table, *entry;
1268 struct dsa_switch *ds = dsa_devlink_to_ds(dl);
1269 struct hellcreek *hellcreek = ds->priv;
1270 int i;
1271
1272 table = kcalloc(VLAN_N_VID, sizeof(*entry), GFP_KERNEL);
1273 if (!table)
1274 return -ENOMEM;
1275
1276 entry = table;
1277
1278 mutex_lock(&hellcreek->reg_lock);
1279 for (i = 0; i < VLAN_N_VID; ++i, ++entry) {
1280 entry->member = hellcreek->vidmbrcfg[i];
1281 entry->vid = i;
1282 }
1283 mutex_unlock(&hellcreek->reg_lock);
1284
1285 *data = (u8 *)table;
1286
1287 return 0;
1288}
1289
1290static int hellcreek_devlink_region_fdb_snapshot(struct devlink *dl,
1291 const struct devlink_region_ops *ops,
1292 struct netlink_ext_ack *extack,
1293 u8 **data)
1294{
1295 struct dsa_switch *ds = dsa_devlink_to_ds(dl);
1296 struct hellcreek_fdb_entry *table, *entry;
1297 struct hellcreek *hellcreek = ds->priv;
1298 size_t i;
1299
1300 table = kcalloc(hellcreek->fdb_entries, sizeof(*entry), GFP_KERNEL);
1301 if (!table)
1302 return -ENOMEM;
1303
1304 entry = table;
1305
1306 mutex_lock(&hellcreek->reg_lock);
1307
1308 /* Start table read */
1309 hellcreek_read(hellcreek, HR_FDBMAX);
1310 hellcreek_write(hellcreek, 0x00, HR_FDBMAX);
1311
1312 for (i = 0; i < hellcreek->fdb_entries; ++i, ++entry) {
1313 /* Read current entry */
1314 hellcreek_populate_fdb_entry(hellcreek, entry, i);
1315
1316 /* Advance read pointer */
1317 hellcreek_write(hellcreek, 0x00, HR_FDBRDH);
1318 }
1319
1320 mutex_unlock(&hellcreek->reg_lock);
1321
1322 *data = (u8 *)table;
1323
1324 return 0;
1325}
1326
1327static struct devlink_region_ops hellcreek_region_vlan_ops = {
1328 .name = "vlan",
1329 .snapshot = hellcreek_devlink_region_vlan_snapshot,
1330 .destructor = kfree,
1331};
1332
1333static struct devlink_region_ops hellcreek_region_fdb_ops = {
1334 .name = "fdb",
1335 .snapshot = hellcreek_devlink_region_fdb_snapshot,
1336 .destructor = kfree,
1337};
1338
1339static int hellcreek_setup_devlink_regions(struct dsa_switch *ds)
1340{
1341 struct hellcreek *hellcreek = ds->priv;
1342 struct devlink_region_ops *ops;
1343 struct devlink_region *region;
1344 u64 size;
1345 int ret;
1346
1347 /* VLAN table */
1348 size = VLAN_N_VID * sizeof(struct hellcreek_devlink_vlan_entry);
1349 ops = &hellcreek_region_vlan_ops;
1350
1351 region = dsa_devlink_region_create(ds, ops, 1, size);
1352 if (IS_ERR(region))
1353 return PTR_ERR(region);
1354
1355 hellcreek->vlan_region = region;
1356
1357 /* FDB table */
1358 size = hellcreek->fdb_entries * sizeof(struct hellcreek_fdb_entry);
1359 ops = &hellcreek_region_fdb_ops;
1360
1361 region = dsa_devlink_region_create(ds, ops, 1, size);
1362 if (IS_ERR(region)) {
1363 ret = PTR_ERR(region);
1364 goto err_fdb;
1365 }
1366
1367 hellcreek->fdb_region = region;
1368
1369 return 0;
1370
1371err_fdb:
1372 dsa_devlink_region_destroy(hellcreek->vlan_region);
1373
1374 return ret;
1375}
1376
1377static void hellcreek_teardown_devlink_regions(struct dsa_switch *ds)
1378{
1379 struct hellcreek *hellcreek = ds->priv;
1380
1381 dsa_devlink_region_destroy(hellcreek->fdb_region);
1382 dsa_devlink_region_destroy(hellcreek->vlan_region);
1383}
1384
1385static int hellcreek_setup(struct dsa_switch *ds)
1386{
1387 struct hellcreek *hellcreek = ds->priv;
1388 u16 swcfg = 0;
1389 int ret, i;
1390
1391 dev_dbg(hellcreek->dev, "Set up the switch\n");
1392
1393 /* Let's go */
1394 ret = hellcreek_enable_ip_core(hellcreek);
1395 if (ret) {
1396 dev_err(hellcreek->dev, "Failed to enable IP core!\n");
1397 return ret;
1398 }
1399
1400 /* Enable CPU/Tunnel ports */
1401 hellcreek_setup_cpu_and_tunnel_port(hellcreek);
1402
1403 /* Switch config: Keep defaults, enable FDB aging and learning and tag
1404 * each frame from/to cpu port for DSA tagging. Also enable the length
1405 * aware shaping mode. This eliminates the need for Qbv guard bands.
1406 */
1407 swcfg |= HR_SWCFG_FDBAGE_EN |
1408 HR_SWCFG_FDBLRN_EN |
1409 HR_SWCFG_ALWAYS_OBT |
1410 (HR_SWCFG_LAS_ON << HR_SWCFG_LAS_MODE_SHIFT);
1411 hellcreek->swcfg = swcfg;
1412 hellcreek_write(hellcreek, swcfg, HR_SWCFG);
1413
1414 /* Initial vlan membership to reflect port separation */
1415 for (i = 0; i < ds->num_ports; ++i) {
1416 if (!dsa_is_user_port(ds, i))
1417 continue;
1418
1419 hellcreek_setup_vlan_membership(ds, i, true);
1420 }
1421
1422 /* Configure PCP <-> TC mapping */
1423 hellcreek_setup_tc_identity_mapping(hellcreek);
1424
1425 /* The VLAN awareness is a global switch setting. Therefore, mixed vlan
1426 * filtering setups are not supported.
1427 */
1428 ds->vlan_filtering_is_global = true;
1429 ds->needs_standalone_vlan_filtering = true;
1430
1431 /* Intercept _all_ PTP multicast traffic */
1432 ret = hellcreek_setup_fdb(hellcreek);
1433 if (ret) {
1434 dev_err(hellcreek->dev,
1435 "Failed to insert static PTP FDB entries\n");
1436 return ret;
1437 }
1438
1439 /* Register devlink resources with DSA */
1440 ret = hellcreek_setup_devlink_resources(ds);
1441 if (ret) {
1442 dev_err(hellcreek->dev,
1443 "Failed to setup devlink resources!\n");
1444 return ret;
1445 }
1446
1447 ret = hellcreek_setup_devlink_regions(ds);
1448 if (ret) {
1449 dev_err(hellcreek->dev,
1450 "Failed to setup devlink regions!\n");
1451 goto err_regions;
1452 }
1453
1454 return 0;
1455
1456err_regions:
1457 dsa_devlink_resources_unregister(ds);
1458
1459 return ret;
1460}
1461
1462static void hellcreek_teardown(struct dsa_switch *ds)
1463{
1464 hellcreek_teardown_devlink_regions(ds);
1465 dsa_devlink_resources_unregister(ds);
1466}
1467
1468static void hellcreek_phylink_get_caps(struct dsa_switch *ds, int port,
1469 struct phylink_config *config)
1470{
1471 struct hellcreek *hellcreek = ds->priv;
1472
1473 __set_bit(PHY_INTERFACE_MODE_MII, config->supported_interfaces);
1474 __set_bit(PHY_INTERFACE_MODE_RGMII, config->supported_interfaces);
1475
1476 /* Include GMII - the hardware does not support this interface
1477 * mode, but it's the default interface mode for phylib, so we
1478 * need it for compatibility with existing DT.
1479 */
1480 __set_bit(PHY_INTERFACE_MODE_GMII, config->supported_interfaces);
1481
1482 /* The MAC settings are a hardware configuration option and cannot be
1483 * changed at run time or by strapping. Therefore the attached PHYs
1484 * should be programmed to only advertise settings which are supported
1485 * by the hardware.
1486 */
1487 if (hellcreek->pdata->is_100_mbits)
1488 config->mac_capabilities = MAC_100FD;
1489 else
1490 config->mac_capabilities = MAC_1000FD;
1491}
1492
1493static int
1494hellcreek_port_prechangeupper(struct dsa_switch *ds, int port,
1495 struct netdev_notifier_changeupper_info *info)
1496{
1497 struct hellcreek *hellcreek = ds->priv;
1498 bool used = true;
1499 int ret = -EBUSY;
1500 u16 vid;
1501 int i;
1502
1503 dev_dbg(hellcreek->dev, "Pre change upper for port %d\n", port);
1504
1505 /*
1506 * Deny VLAN devices on top of lan ports with the same VLAN ids, because
1507 * it breaks the port separation due to the private VLANs. Example:
1508 *
1509 * lan0.100 *and* lan1.100 cannot be used in parallel. However, lan0.99
1510 * and lan1.100 works.
1511 */
1512
1513 if (!is_vlan_dev(info->upper_dev))
1514 return 0;
1515
1516 vid = vlan_dev_vlan_id(info->upper_dev);
1517
1518 /* For all ports, check bitmaps */
1519 mutex_lock(&hellcreek->vlan_lock);
1520 for (i = 0; i < hellcreek->pdata->num_ports; ++i) {
1521 if (!dsa_is_user_port(ds, i))
1522 continue;
1523
1524 if (port == i)
1525 continue;
1526
1527 used = used && test_bit(vid, hellcreek->ports[i].vlan_dev_bitmap);
1528 }
1529
1530 if (used)
1531 goto out;
1532
1533 /* Update bitmap */
1534 set_bit(vid, hellcreek->ports[port].vlan_dev_bitmap);
1535
1536 ret = 0;
1537
1538out:
1539 mutex_unlock(&hellcreek->vlan_lock);
1540
1541 return ret;
1542}
1543
1544static void hellcreek_setup_maxsdu(struct hellcreek *hellcreek, int port,
1545 const struct tc_taprio_qopt_offload *schedule)
1546{
1547 int tc;
1548
1549 for (tc = 0; tc < 8; ++tc) {
1550 u32 max_sdu = schedule->max_sdu[tc] + VLAN_ETH_HLEN - ETH_FCS_LEN;
1551 u16 val;
1552
1553 if (!schedule->max_sdu[tc])
1554 continue;
1555
1556 dev_dbg(hellcreek->dev, "Configure max-sdu %u for tc %d on port %d\n",
1557 max_sdu, tc, port);
1558
1559 hellcreek_select_port_prio(hellcreek, port, tc);
1560
1561 val = (max_sdu & HR_PTPRTCCFG_MAXSDU_MASK) << HR_PTPRTCCFG_MAXSDU_SHIFT;
1562
1563 hellcreek_write(hellcreek, val, HR_PTPRTCCFG);
1564 }
1565}
1566
1567static void hellcreek_reset_maxsdu(struct hellcreek *hellcreek, int port)
1568{
1569 int tc;
1570
1571 for (tc = 0; tc < 8; ++tc) {
1572 u16 val;
1573
1574 hellcreek_select_port_prio(hellcreek, port, tc);
1575
1576 val = (HELLCREEK_DEFAULT_MAX_SDU & HR_PTPRTCCFG_MAXSDU_MASK)
1577 << HR_PTPRTCCFG_MAXSDU_SHIFT;
1578
1579 hellcreek_write(hellcreek, val, HR_PTPRTCCFG);
1580 }
1581}
1582
1583static void hellcreek_setup_gcl(struct hellcreek *hellcreek, int port,
1584 const struct tc_taprio_qopt_offload *schedule)
1585{
1586 const struct tc_taprio_sched_entry *cur, *initial, *next;
1587 size_t i;
1588
1589 cur = initial = &schedule->entries[0];
1590 next = cur + 1;
1591
1592 for (i = 1; i <= schedule->num_entries; ++i) {
1593 u16 data;
1594 u8 gates;
1595
1596 if (i == schedule->num_entries)
1597 gates = initial->gate_mask ^
1598 cur->gate_mask;
1599 else
1600 gates = next->gate_mask ^
1601 cur->gate_mask;
1602
1603 data = gates;
1604
1605 if (i == schedule->num_entries)
1606 data |= TR_GCLDAT_GCLWRLAST;
1607
1608 /* Gates states */
1609 hellcreek_write(hellcreek, data, TR_GCLDAT);
1610
1611 /* Time interval */
1612 hellcreek_write(hellcreek,
1613 cur->interval & 0x0000ffff,
1614 TR_GCLTIL);
1615 hellcreek_write(hellcreek,
1616 (cur->interval & 0xffff0000) >> 16,
1617 TR_GCLTIH);
1618
1619 /* Commit entry */
1620 data = ((i - 1) << TR_GCLCMD_GCLWRADR_SHIFT) |
1621 (initial->gate_mask <<
1622 TR_GCLCMD_INIT_GATE_STATES_SHIFT);
1623 hellcreek_write(hellcreek, data, TR_GCLCMD);
1624
1625 cur++;
1626 next++;
1627 }
1628}
1629
1630static void hellcreek_set_cycle_time(struct hellcreek *hellcreek,
1631 const struct tc_taprio_qopt_offload *schedule)
1632{
1633 u32 cycle_time = schedule->cycle_time;
1634
1635 hellcreek_write(hellcreek, cycle_time & 0x0000ffff, TR_CTWRL);
1636 hellcreek_write(hellcreek, (cycle_time & 0xffff0000) >> 16, TR_CTWRH);
1637}
1638
1639static void hellcreek_switch_schedule(struct hellcreek *hellcreek,
1640 ktime_t start_time)
1641{
1642 struct timespec64 ts = ktime_to_timespec64(start_time);
1643
1644 /* Start schedule at this point of time */
1645 hellcreek_write(hellcreek, ts.tv_nsec & 0x0000ffff, TR_ESTWRL);
1646 hellcreek_write(hellcreek, (ts.tv_nsec & 0xffff0000) >> 16, TR_ESTWRH);
1647
1648 /* Arm timer, set seconds and switch schedule */
1649 hellcreek_write(hellcreek, TR_ESTCMD_ESTARM | TR_ESTCMD_ESTSWCFG |
1650 ((ts.tv_sec & TR_ESTCMD_ESTSEC_MASK) <<
1651 TR_ESTCMD_ESTSEC_SHIFT), TR_ESTCMD);
1652}
1653
1654static bool hellcreek_schedule_startable(struct hellcreek *hellcreek, int port)
1655{
1656 struct hellcreek_port *hellcreek_port = &hellcreek->ports[port];
1657 s64 base_time_ns, current_ns;
1658
1659 /* The switch allows a schedule to be started only eight seconds within
1660 * the future. Therefore, check the current PTP time if the schedule is
1661 * startable or not.
1662 */
1663
1664 /* Use the "cached" time. That should be alright, as it's updated quite
1665 * frequently in the PTP code.
1666 */
1667 mutex_lock(&hellcreek->ptp_lock);
1668 current_ns = hellcreek->seconds * NSEC_PER_SEC + hellcreek->last_ts;
1669 mutex_unlock(&hellcreek->ptp_lock);
1670
1671 /* Calculate difference to admin base time */
1672 base_time_ns = ktime_to_ns(hellcreek_port->current_schedule->base_time);
1673
1674 return base_time_ns - current_ns < (s64)4 * NSEC_PER_SEC;
1675}
1676
1677static void hellcreek_start_schedule(struct hellcreek *hellcreek, int port)
1678{
1679 struct hellcreek_port *hellcreek_port = &hellcreek->ports[port];
1680 ktime_t base_time, current_time;
1681 s64 current_ns;
1682 u32 cycle_time;
1683
1684 /* First select port */
1685 hellcreek_select_tgd(hellcreek, port);
1686
1687 /* Forward base time into the future if needed */
1688 mutex_lock(&hellcreek->ptp_lock);
1689 current_ns = hellcreek->seconds * NSEC_PER_SEC + hellcreek->last_ts;
1690 mutex_unlock(&hellcreek->ptp_lock);
1691
1692 current_time = ns_to_ktime(current_ns);
1693 base_time = hellcreek_port->current_schedule->base_time;
1694 cycle_time = hellcreek_port->current_schedule->cycle_time;
1695
1696 if (ktime_compare(current_time, base_time) > 0) {
1697 s64 n;
1698
1699 n = div64_s64(ktime_sub_ns(current_time, base_time),
1700 cycle_time);
1701 base_time = ktime_add_ns(base_time, (n + 1) * cycle_time);
1702 }
1703
1704 /* Set admin base time and switch schedule */
1705 hellcreek_switch_schedule(hellcreek, base_time);
1706
1707 taprio_offload_free(hellcreek_port->current_schedule);
1708 hellcreek_port->current_schedule = NULL;
1709
1710 dev_dbg(hellcreek->dev, "Armed EST timer for port %d\n",
1711 hellcreek_port->port);
1712}
1713
1714static void hellcreek_check_schedule(struct work_struct *work)
1715{
1716 struct delayed_work *dw = to_delayed_work(work);
1717 struct hellcreek_port *hellcreek_port;
1718 struct hellcreek *hellcreek;
1719 bool startable;
1720
1721 hellcreek_port = dw_to_hellcreek_port(dw);
1722 hellcreek = hellcreek_port->hellcreek;
1723
1724 mutex_lock(&hellcreek->reg_lock);
1725
1726 /* Check starting time */
1727 startable = hellcreek_schedule_startable(hellcreek,
1728 hellcreek_port->port);
1729 if (startable) {
1730 hellcreek_start_schedule(hellcreek, hellcreek_port->port);
1731 mutex_unlock(&hellcreek->reg_lock);
1732 return;
1733 }
1734
1735 mutex_unlock(&hellcreek->reg_lock);
1736
1737 /* Reschedule */
1738 schedule_delayed_work(&hellcreek_port->schedule_work,
1739 HELLCREEK_SCHEDULE_PERIOD);
1740}
1741
1742static int hellcreek_port_set_schedule(struct dsa_switch *ds, int port,
1743 struct tc_taprio_qopt_offload *taprio)
1744{
1745 struct hellcreek *hellcreek = ds->priv;
1746 struct hellcreek_port *hellcreek_port;
1747 bool startable;
1748 u16 ctrl;
1749
1750 hellcreek_port = &hellcreek->ports[port];
1751
1752 dev_dbg(hellcreek->dev, "Configure traffic schedule on port %d\n",
1753 port);
1754
1755 /* First cancel delayed work */
1756 cancel_delayed_work_sync(&hellcreek_port->schedule_work);
1757
1758 mutex_lock(&hellcreek->reg_lock);
1759
1760 if (hellcreek_port->current_schedule) {
1761 taprio_offload_free(hellcreek_port->current_schedule);
1762 hellcreek_port->current_schedule = NULL;
1763 }
1764 hellcreek_port->current_schedule = taprio_offload_get(taprio);
1765
1766 /* Configure max sdu */
1767 hellcreek_setup_maxsdu(hellcreek, port, hellcreek_port->current_schedule);
1768
1769 /* Select tdg */
1770 hellcreek_select_tgd(hellcreek, port);
1771
1772 /* Enable gating and keep defaults */
1773 ctrl = (0xff << TR_TGDCTRL_ADMINGATESTATES_SHIFT) | TR_TGDCTRL_GATE_EN;
1774 hellcreek_write(hellcreek, ctrl, TR_TGDCTRL);
1775
1776 /* Cancel pending schedule */
1777 hellcreek_write(hellcreek, 0x00, TR_ESTCMD);
1778
1779 /* Setup a new schedule */
1780 hellcreek_setup_gcl(hellcreek, port, hellcreek_port->current_schedule);
1781
1782 /* Configure cycle time */
1783 hellcreek_set_cycle_time(hellcreek, hellcreek_port->current_schedule);
1784
1785 /* Check starting time */
1786 startable = hellcreek_schedule_startable(hellcreek, port);
1787 if (startable) {
1788 hellcreek_start_schedule(hellcreek, port);
1789 mutex_unlock(&hellcreek->reg_lock);
1790 return 0;
1791 }
1792
1793 mutex_unlock(&hellcreek->reg_lock);
1794
1795 /* Schedule periodic schedule check */
1796 schedule_delayed_work(&hellcreek_port->schedule_work,
1797 HELLCREEK_SCHEDULE_PERIOD);
1798
1799 return 0;
1800}
1801
1802static int hellcreek_port_del_schedule(struct dsa_switch *ds, int port)
1803{
1804 struct hellcreek *hellcreek = ds->priv;
1805 struct hellcreek_port *hellcreek_port;
1806
1807 hellcreek_port = &hellcreek->ports[port];
1808
1809 dev_dbg(hellcreek->dev, "Remove traffic schedule on port %d\n", port);
1810
1811 /* First cancel delayed work */
1812 cancel_delayed_work_sync(&hellcreek_port->schedule_work);
1813
1814 mutex_lock(&hellcreek->reg_lock);
1815
1816 if (hellcreek_port->current_schedule) {
1817 taprio_offload_free(hellcreek_port->current_schedule);
1818 hellcreek_port->current_schedule = NULL;
1819 }
1820
1821 /* Reset max sdu */
1822 hellcreek_reset_maxsdu(hellcreek, port);
1823
1824 /* Select tgd */
1825 hellcreek_select_tgd(hellcreek, port);
1826
1827 /* Disable gating and return to regular switching flow */
1828 hellcreek_write(hellcreek, 0xff << TR_TGDCTRL_ADMINGATESTATES_SHIFT,
1829 TR_TGDCTRL);
1830
1831 mutex_unlock(&hellcreek->reg_lock);
1832
1833 return 0;
1834}
1835
1836static bool hellcreek_validate_schedule(struct hellcreek *hellcreek,
1837 struct tc_taprio_qopt_offload *schedule)
1838{
1839 size_t i;
1840
1841 /* Does this hellcreek version support Qbv in hardware? */
1842 if (!hellcreek->pdata->qbv_support)
1843 return false;
1844
1845 /* cycle time can only be 32bit */
1846 if (schedule->cycle_time > (u32)-1)
1847 return false;
1848
1849 /* cycle time extension is not supported */
1850 if (schedule->cycle_time_extension)
1851 return false;
1852
1853 /* Only set command is supported */
1854 for (i = 0; i < schedule->num_entries; ++i)
1855 if (schedule->entries[i].command != TC_TAPRIO_CMD_SET_GATES)
1856 return false;
1857
1858 return true;
1859}
1860
1861static int hellcreek_tc_query_caps(struct tc_query_caps_base *base)
1862{
1863 switch (base->type) {
1864 case TC_SETUP_QDISC_TAPRIO: {
1865 struct tc_taprio_caps *caps = base->caps;
1866
1867 caps->supports_queue_max_sdu = true;
1868
1869 return 0;
1870 }
1871 default:
1872 return -EOPNOTSUPP;
1873 }
1874}
1875
1876static int hellcreek_port_setup_tc(struct dsa_switch *ds, int port,
1877 enum tc_setup_type type, void *type_data)
1878{
1879 struct hellcreek *hellcreek = ds->priv;
1880
1881 switch (type) {
1882 case TC_QUERY_CAPS:
1883 return hellcreek_tc_query_caps(type_data);
1884 case TC_SETUP_QDISC_TAPRIO: {
1885 struct tc_taprio_qopt_offload *taprio = type_data;
1886
1887 switch (taprio->cmd) {
1888 case TAPRIO_CMD_REPLACE:
1889 if (!hellcreek_validate_schedule(hellcreek, taprio))
1890 return -EOPNOTSUPP;
1891
1892 return hellcreek_port_set_schedule(ds, port, taprio);
1893 case TAPRIO_CMD_DESTROY:
1894 return hellcreek_port_del_schedule(ds, port);
1895 default:
1896 return -EOPNOTSUPP;
1897 }
1898 }
1899 default:
1900 return -EOPNOTSUPP;
1901 }
1902}
1903
1904static const struct dsa_switch_ops hellcreek_ds_ops = {
1905 .devlink_info_get = hellcreek_devlink_info_get,
1906 .get_ethtool_stats = hellcreek_get_ethtool_stats,
1907 .get_sset_count = hellcreek_get_sset_count,
1908 .get_strings = hellcreek_get_strings,
1909 .get_tag_protocol = hellcreek_get_tag_protocol,
1910 .get_ts_info = hellcreek_get_ts_info,
1911 .phylink_get_caps = hellcreek_phylink_get_caps,
1912 .port_bridge_flags = hellcreek_bridge_flags,
1913 .port_bridge_join = hellcreek_port_bridge_join,
1914 .port_bridge_leave = hellcreek_port_bridge_leave,
1915 .port_disable = hellcreek_port_disable,
1916 .port_enable = hellcreek_port_enable,
1917 .port_fdb_add = hellcreek_fdb_add,
1918 .port_fdb_del = hellcreek_fdb_del,
1919 .port_fdb_dump = hellcreek_fdb_dump,
1920 .port_hwtstamp_set = hellcreek_port_hwtstamp_set,
1921 .port_hwtstamp_get = hellcreek_port_hwtstamp_get,
1922 .port_pre_bridge_flags = hellcreek_pre_bridge_flags,
1923 .port_prechangeupper = hellcreek_port_prechangeupper,
1924 .port_rxtstamp = hellcreek_port_rxtstamp,
1925 .port_setup_tc = hellcreek_port_setup_tc,
1926 .port_stp_state_set = hellcreek_port_stp_state_set,
1927 .port_txtstamp = hellcreek_port_txtstamp,
1928 .port_vlan_add = hellcreek_vlan_add,
1929 .port_vlan_del = hellcreek_vlan_del,
1930 .port_vlan_filtering = hellcreek_vlan_filtering,
1931 .setup = hellcreek_setup,
1932 .teardown = hellcreek_teardown,
1933};
1934
1935static int hellcreek_probe(struct platform_device *pdev)
1936{
1937 struct device *dev = &pdev->dev;
1938 struct hellcreek *hellcreek;
1939 struct resource *res;
1940 int ret, i;
1941
1942 hellcreek = devm_kzalloc(dev, sizeof(*hellcreek), GFP_KERNEL);
1943 if (!hellcreek)
1944 return -ENOMEM;
1945
1946 hellcreek->vidmbrcfg = devm_kcalloc(dev, VLAN_N_VID,
1947 sizeof(*hellcreek->vidmbrcfg),
1948 GFP_KERNEL);
1949 if (!hellcreek->vidmbrcfg)
1950 return -ENOMEM;
1951
1952 hellcreek->pdata = of_device_get_match_data(dev);
1953
1954 hellcreek->ports = devm_kcalloc(dev, hellcreek->pdata->num_ports,
1955 sizeof(*hellcreek->ports),
1956 GFP_KERNEL);
1957 if (!hellcreek->ports)
1958 return -ENOMEM;
1959
1960 for (i = 0; i < hellcreek->pdata->num_ports; ++i) {
1961 struct hellcreek_port *port = &hellcreek->ports[i];
1962
1963 port->counter_values =
1964 devm_kcalloc(dev,
1965 ARRAY_SIZE(hellcreek_counter),
1966 sizeof(*port->counter_values),
1967 GFP_KERNEL);
1968 if (!port->counter_values)
1969 return -ENOMEM;
1970
1971 port->vlan_dev_bitmap = devm_bitmap_zalloc(dev, VLAN_N_VID,
1972 GFP_KERNEL);
1973 if (!port->vlan_dev_bitmap)
1974 return -ENOMEM;
1975
1976 port->hellcreek = hellcreek;
1977 port->port = i;
1978
1979 INIT_DELAYED_WORK(&port->schedule_work,
1980 hellcreek_check_schedule);
1981 }
1982
1983 mutex_init(&hellcreek->reg_lock);
1984 mutex_init(&hellcreek->vlan_lock);
1985 mutex_init(&hellcreek->ptp_lock);
1986
1987 hellcreek->dev = dev;
1988
1989 res = platform_get_resource_byname(pdev, IORESOURCE_MEM, "tsn");
1990 if (!res) {
1991 dev_err(dev, "No memory region provided!\n");
1992 return -ENODEV;
1993 }
1994
1995 hellcreek->base = devm_ioremap_resource(dev, res);
1996 if (IS_ERR(hellcreek->base))
1997 return PTR_ERR(hellcreek->base);
1998
1999 res = platform_get_resource_byname(pdev, IORESOURCE_MEM, "ptp");
2000 if (!res) {
2001 dev_err(dev, "No PTP memory region provided!\n");
2002 return -ENODEV;
2003 }
2004
2005 hellcreek->ptp_base = devm_ioremap_resource(dev, res);
2006 if (IS_ERR(hellcreek->ptp_base))
2007 return PTR_ERR(hellcreek->ptp_base);
2008
2009 ret = hellcreek_detect(hellcreek);
2010 if (ret) {
2011 dev_err(dev, "No (known) chip found!\n");
2012 return ret;
2013 }
2014
2015 ret = hellcreek_wait_until_ready(hellcreek);
2016 if (ret) {
2017 dev_err(dev, "Switch didn't become ready!\n");
2018 return ret;
2019 }
2020
2021 hellcreek_feature_detect(hellcreek);
2022
2023 hellcreek->ds = devm_kzalloc(dev, sizeof(*hellcreek->ds), GFP_KERNEL);
2024 if (!hellcreek->ds)
2025 return -ENOMEM;
2026
2027 hellcreek->ds->dev = dev;
2028 hellcreek->ds->priv = hellcreek;
2029 hellcreek->ds->ops = &hellcreek_ds_ops;
2030 hellcreek->ds->num_ports = hellcreek->pdata->num_ports;
2031 hellcreek->ds->num_tx_queues = HELLCREEK_NUM_EGRESS_QUEUES;
2032
2033 ret = dsa_register_switch(hellcreek->ds);
2034 if (ret) {
2035 dev_err_probe(dev, ret, "Unable to register switch\n");
2036 return ret;
2037 }
2038
2039 ret = hellcreek_ptp_setup(hellcreek);
2040 if (ret) {
2041 dev_err(dev, "Failed to setup PTP!\n");
2042 goto err_ptp_setup;
2043 }
2044
2045 ret = hellcreek_hwtstamp_setup(hellcreek);
2046 if (ret) {
2047 dev_err(dev, "Failed to setup hardware timestamping!\n");
2048 goto err_tstamp_setup;
2049 }
2050
2051 platform_set_drvdata(pdev, hellcreek);
2052
2053 return 0;
2054
2055err_tstamp_setup:
2056 hellcreek_ptp_free(hellcreek);
2057err_ptp_setup:
2058 dsa_unregister_switch(hellcreek->ds);
2059
2060 return ret;
2061}
2062
2063static void hellcreek_remove(struct platform_device *pdev)
2064{
2065 struct hellcreek *hellcreek = platform_get_drvdata(pdev);
2066
2067 if (!hellcreek)
2068 return;
2069
2070 hellcreek_hwtstamp_free(hellcreek);
2071 hellcreek_ptp_free(hellcreek);
2072 dsa_unregister_switch(hellcreek->ds);
2073}
2074
2075static void hellcreek_shutdown(struct platform_device *pdev)
2076{
2077 struct hellcreek *hellcreek = platform_get_drvdata(pdev);
2078
2079 if (!hellcreek)
2080 return;
2081
2082 dsa_switch_shutdown(hellcreek->ds);
2083
2084 platform_set_drvdata(pdev, NULL);
2085}
2086
2087static const struct hellcreek_platform_data de1soc_r1_pdata = {
2088 .name = "r4c30",
2089 .num_ports = 4,
2090 .is_100_mbits = 1,
2091 .qbv_support = 1,
2092 .qbv_on_cpu_port = 1,
2093 .qbu_support = 0,
2094 .module_id = 0x4c30,
2095};
2096
2097static const struct of_device_id hellcreek_of_match[] = {
2098 {
2099 .compatible = "hirschmann,hellcreek-de1soc-r1",
2100 .data = &de1soc_r1_pdata,
2101 },
2102 { /* sentinel */ },
2103};
2104MODULE_DEVICE_TABLE(of, hellcreek_of_match);
2105
2106static struct platform_driver hellcreek_driver = {
2107 .probe = hellcreek_probe,
2108 .remove_new = hellcreek_remove,
2109 .shutdown = hellcreek_shutdown,
2110 .driver = {
2111 .name = "hellcreek",
2112 .of_match_table = hellcreek_of_match,
2113 },
2114};
2115module_platform_driver(hellcreek_driver);
2116
2117MODULE_AUTHOR("Kurt Kanzenbach <kurt@linutronix.de>");
2118MODULE_DESCRIPTION("Hirschmann Hellcreek driver");
2119MODULE_LICENSE("Dual MIT/GPL");