Loading...
1// SPDX-License-Identifier: GPL-2.0-or-later
2/*
3 * Marvell 88E6xxx Address Translation Unit (ATU) support
4 *
5 * Copyright (c) 2008 Marvell Semiconductor
6 * Copyright (c) 2017 Savoir-faire Linux, Inc.
7 */
8
9#include <linux/bitfield.h>
10#include <linux/interrupt.h>
11#include <linux/irqdomain.h>
12
13#include "chip.h"
14#include "global1.h"
15#include "switchdev.h"
16#include "trace.h"
17
18/* Offset 0x01: ATU FID Register */
19
20static int mv88e6xxx_g1_atu_fid_write(struct mv88e6xxx_chip *chip, u16 fid)
21{
22 return mv88e6xxx_g1_write(chip, MV88E6352_G1_ATU_FID, fid & 0xfff);
23}
24
25/* Offset 0x0A: ATU Control Register */
26
27int mv88e6xxx_g1_atu_set_learn2all(struct mv88e6xxx_chip *chip, bool learn2all)
28{
29 u16 val;
30 int err;
31
32 err = mv88e6xxx_g1_read(chip, MV88E6XXX_G1_ATU_CTL, &val);
33 if (err)
34 return err;
35
36 if (learn2all)
37 val |= MV88E6XXX_G1_ATU_CTL_LEARN2ALL;
38 else
39 val &= ~MV88E6XXX_G1_ATU_CTL_LEARN2ALL;
40
41 return mv88e6xxx_g1_write(chip, MV88E6XXX_G1_ATU_CTL, val);
42}
43
44int mv88e6xxx_g1_atu_set_age_time(struct mv88e6xxx_chip *chip,
45 unsigned int msecs)
46{
47 const unsigned int coeff = chip->info->age_time_coeff;
48 const unsigned int min = 0x01 * coeff;
49 const unsigned int max = 0xff * coeff;
50 u8 age_time;
51 u16 val;
52 int err;
53
54 if (msecs < min || msecs > max)
55 return -ERANGE;
56
57 /* Round to nearest multiple of coeff */
58 age_time = (msecs + coeff / 2) / coeff;
59
60 err = mv88e6xxx_g1_read(chip, MV88E6XXX_G1_ATU_CTL, &val);
61 if (err)
62 return err;
63
64 /* AgeTime is 11:4 bits */
65 val &= ~0xff0;
66 val |= age_time << 4;
67
68 err = mv88e6xxx_g1_write(chip, MV88E6XXX_G1_ATU_CTL, val);
69 if (err)
70 return err;
71
72 dev_dbg(chip->dev, "AgeTime set to 0x%02x (%d ms)\n", age_time,
73 age_time * coeff);
74
75 return 0;
76}
77
78int mv88e6165_g1_atu_get_hash(struct mv88e6xxx_chip *chip, u8 *hash)
79{
80 int err;
81 u16 val;
82
83 err = mv88e6xxx_g1_read(chip, MV88E6XXX_G1_ATU_CTL, &val);
84 if (err)
85 return err;
86
87 *hash = val & MV88E6161_G1_ATU_CTL_HASH_MASK;
88
89 return 0;
90}
91
92int mv88e6165_g1_atu_set_hash(struct mv88e6xxx_chip *chip, u8 hash)
93{
94 int err;
95 u16 val;
96
97 if (hash & ~MV88E6161_G1_ATU_CTL_HASH_MASK)
98 return -EINVAL;
99
100 err = mv88e6xxx_g1_read(chip, MV88E6XXX_G1_ATU_CTL, &val);
101 if (err)
102 return err;
103
104 val &= ~MV88E6161_G1_ATU_CTL_HASH_MASK;
105 val |= hash;
106
107 return mv88e6xxx_g1_write(chip, MV88E6XXX_G1_ATU_CTL, val);
108}
109
110/* Offset 0x0B: ATU Operation Register */
111
112static int mv88e6xxx_g1_atu_op_wait(struct mv88e6xxx_chip *chip)
113{
114 int bit = __bf_shf(MV88E6XXX_G1_ATU_OP_BUSY);
115
116 return mv88e6xxx_g1_wait_bit(chip, MV88E6XXX_G1_ATU_OP, bit, 0);
117}
118
119static int mv88e6xxx_g1_read_atu_violation(struct mv88e6xxx_chip *chip)
120{
121 int err;
122
123 err = mv88e6xxx_g1_write(chip, MV88E6XXX_G1_ATU_OP,
124 MV88E6XXX_G1_ATU_OP_BUSY |
125 MV88E6XXX_G1_ATU_OP_GET_CLR_VIOLATION);
126 if (err)
127 return err;
128
129 return mv88e6xxx_g1_atu_op_wait(chip);
130}
131
132static int mv88e6xxx_g1_atu_op(struct mv88e6xxx_chip *chip, u16 fid, u16 op)
133{
134 u16 val;
135 int err;
136
137 /* FID bits are dispatched all around gradually as more are supported */
138 if (mv88e6xxx_num_databases(chip) > 256) {
139 err = mv88e6xxx_g1_atu_fid_write(chip, fid);
140 if (err)
141 return err;
142 } else {
143 if (mv88e6xxx_num_databases(chip) > 64) {
144 /* ATU DBNum[7:4] are located in ATU Control 15:12 */
145 err = mv88e6xxx_g1_read(chip, MV88E6XXX_G1_ATU_CTL,
146 &val);
147 if (err)
148 return err;
149
150 val = (val & 0x0fff) | ((fid << 8) & 0xf000);
151 err = mv88e6xxx_g1_write(chip, MV88E6XXX_G1_ATU_CTL,
152 val);
153 if (err)
154 return err;
155 } else if (mv88e6xxx_num_databases(chip) > 16) {
156 /* ATU DBNum[5:4] are located in ATU Operation 9:8 */
157 op |= (fid & 0x30) << 4;
158 }
159
160 /* ATU DBNum[3:0] are located in ATU Operation 3:0 */
161 op |= fid & 0xf;
162 }
163
164 err = mv88e6xxx_g1_write(chip, MV88E6XXX_G1_ATU_OP,
165 MV88E6XXX_G1_ATU_OP_BUSY | op);
166 if (err)
167 return err;
168
169 return mv88e6xxx_g1_atu_op_wait(chip);
170}
171
172int mv88e6xxx_g1_atu_get_next(struct mv88e6xxx_chip *chip, u16 fid)
173{
174 return mv88e6xxx_g1_atu_op(chip, fid, MV88E6XXX_G1_ATU_OP_GET_NEXT_DB);
175}
176
177static int mv88e6xxx_g1_atu_fid_read(struct mv88e6xxx_chip *chip, u16 *fid)
178{
179 u16 val = 0, upper = 0, op = 0;
180 int err = -EOPNOTSUPP;
181
182 if (mv88e6xxx_num_databases(chip) > 256) {
183 err = mv88e6xxx_g1_read(chip, MV88E6352_G1_ATU_FID, &val);
184 val &= 0xfff;
185 if (err)
186 return err;
187 } else {
188 err = mv88e6xxx_g1_read(chip, MV88E6XXX_G1_ATU_OP, &op);
189 if (err)
190 return err;
191 if (mv88e6xxx_num_databases(chip) > 64) {
192 /* ATU DBNum[7:4] are located in ATU Control 15:12 */
193 err = mv88e6xxx_g1_read(chip, MV88E6XXX_G1_ATU_CTL,
194 &upper);
195 if (err)
196 return err;
197
198 upper = (upper >> 8) & 0x00f0;
199 } else if (mv88e6xxx_num_databases(chip) > 16) {
200 /* ATU DBNum[5:4] are located in ATU Operation 9:8 */
201 upper = (op >> 4) & 0x30;
202 }
203
204 /* ATU DBNum[3:0] are located in ATU Operation 3:0 */
205 val = (op & 0xf) | upper;
206 }
207 *fid = val;
208
209 return err;
210}
211
212/* Offset 0x0C: ATU Data Register */
213
214static int mv88e6xxx_g1_atu_data_read(struct mv88e6xxx_chip *chip,
215 struct mv88e6xxx_atu_entry *entry)
216{
217 u16 val;
218 int err;
219
220 err = mv88e6xxx_g1_read(chip, MV88E6XXX_G1_ATU_DATA, &val);
221 if (err)
222 return err;
223
224 entry->state = val & 0xf;
225 if (entry->state) {
226 entry->trunk = !!(val & MV88E6XXX_G1_ATU_DATA_TRUNK);
227 entry->portvec = (val >> 4) & mv88e6xxx_port_mask(chip);
228 }
229
230 return 0;
231}
232
233static int mv88e6xxx_g1_atu_data_write(struct mv88e6xxx_chip *chip,
234 struct mv88e6xxx_atu_entry *entry)
235{
236 u16 data = entry->state & 0xf;
237
238 if (entry->state) {
239 if (entry->trunk)
240 data |= MV88E6XXX_G1_ATU_DATA_TRUNK;
241
242 data |= (entry->portvec & mv88e6xxx_port_mask(chip)) << 4;
243 }
244
245 return mv88e6xxx_g1_write(chip, MV88E6XXX_G1_ATU_DATA, data);
246}
247
248/* Offset 0x0D: ATU MAC Address Register Bytes 0 & 1
249 * Offset 0x0E: ATU MAC Address Register Bytes 2 & 3
250 * Offset 0x0F: ATU MAC Address Register Bytes 4 & 5
251 */
252
253static int mv88e6xxx_g1_atu_mac_read(struct mv88e6xxx_chip *chip,
254 struct mv88e6xxx_atu_entry *entry)
255{
256 u16 val;
257 int i, err;
258
259 for (i = 0; i < 3; i++) {
260 err = mv88e6xxx_g1_read(chip, MV88E6XXX_G1_ATU_MAC01 + i, &val);
261 if (err)
262 return err;
263
264 entry->mac[i * 2] = val >> 8;
265 entry->mac[i * 2 + 1] = val & 0xff;
266 }
267
268 return 0;
269}
270
271static int mv88e6xxx_g1_atu_mac_write(struct mv88e6xxx_chip *chip,
272 struct mv88e6xxx_atu_entry *entry)
273{
274 u16 val;
275 int i, err;
276
277 for (i = 0; i < 3; i++) {
278 val = (entry->mac[i * 2] << 8) | entry->mac[i * 2 + 1];
279 err = mv88e6xxx_g1_write(chip, MV88E6XXX_G1_ATU_MAC01 + i, val);
280 if (err)
281 return err;
282 }
283
284 return 0;
285}
286
287/* Address Translation Unit operations */
288
289int mv88e6xxx_g1_atu_getnext(struct mv88e6xxx_chip *chip, u16 fid,
290 struct mv88e6xxx_atu_entry *entry)
291{
292 int err;
293
294 err = mv88e6xxx_g1_atu_op_wait(chip);
295 if (err)
296 return err;
297
298 /* Write the MAC address to iterate from only once */
299 if (!entry->state) {
300 err = mv88e6xxx_g1_atu_mac_write(chip, entry);
301 if (err)
302 return err;
303 }
304
305 err = mv88e6xxx_g1_atu_op(chip, fid, MV88E6XXX_G1_ATU_OP_GET_NEXT_DB);
306 if (err)
307 return err;
308
309 err = mv88e6xxx_g1_atu_data_read(chip, entry);
310 if (err)
311 return err;
312
313 return mv88e6xxx_g1_atu_mac_read(chip, entry);
314}
315
316int mv88e6xxx_g1_atu_loadpurge(struct mv88e6xxx_chip *chip, u16 fid,
317 struct mv88e6xxx_atu_entry *entry)
318{
319 int err;
320
321 err = mv88e6xxx_g1_atu_op_wait(chip);
322 if (err)
323 return err;
324
325 err = mv88e6xxx_g1_atu_mac_write(chip, entry);
326 if (err)
327 return err;
328
329 err = mv88e6xxx_g1_atu_data_write(chip, entry);
330 if (err)
331 return err;
332
333 return mv88e6xxx_g1_atu_op(chip, fid, MV88E6XXX_G1_ATU_OP_LOAD_DB);
334}
335
336static int mv88e6xxx_g1_atu_flushmove(struct mv88e6xxx_chip *chip, u16 fid,
337 struct mv88e6xxx_atu_entry *entry,
338 bool all)
339{
340 u16 op;
341 int err;
342
343 err = mv88e6xxx_g1_atu_op_wait(chip);
344 if (err)
345 return err;
346
347 err = mv88e6xxx_g1_atu_data_write(chip, entry);
348 if (err)
349 return err;
350
351 /* Flush/Move all or non-static entries from all or a given database */
352 if (all && fid)
353 op = MV88E6XXX_G1_ATU_OP_FLUSH_MOVE_ALL_DB;
354 else if (fid)
355 op = MV88E6XXX_G1_ATU_OP_FLUSH_MOVE_NON_STATIC_DB;
356 else if (all)
357 op = MV88E6XXX_G1_ATU_OP_FLUSH_MOVE_ALL;
358 else
359 op = MV88E6XXX_G1_ATU_OP_FLUSH_MOVE_NON_STATIC;
360
361 return mv88e6xxx_g1_atu_op(chip, fid, op);
362}
363
364int mv88e6xxx_g1_atu_flush(struct mv88e6xxx_chip *chip, u16 fid, bool all)
365{
366 struct mv88e6xxx_atu_entry entry = {
367 .state = 0, /* Null EntryState means Flush */
368 };
369
370 return mv88e6xxx_g1_atu_flushmove(chip, fid, &entry, all);
371}
372
373static int mv88e6xxx_g1_atu_move(struct mv88e6xxx_chip *chip, u16 fid,
374 int from_port, int to_port, bool all)
375{
376 struct mv88e6xxx_atu_entry entry = { 0 };
377 unsigned long mask;
378 int shift;
379
380 if (!chip->info->atu_move_port_mask)
381 return -EOPNOTSUPP;
382
383 mask = chip->info->atu_move_port_mask;
384 shift = bitmap_weight(&mask, 16);
385
386 entry.state = 0xf; /* Full EntryState means Move */
387 entry.portvec = from_port & mask;
388 entry.portvec |= (to_port & mask) << shift;
389
390 return mv88e6xxx_g1_atu_flushmove(chip, fid, &entry, all);
391}
392
393int mv88e6xxx_g1_atu_remove(struct mv88e6xxx_chip *chip, u16 fid, int port,
394 bool all)
395{
396 int from_port = port;
397 int to_port = chip->info->atu_move_port_mask;
398
399 return mv88e6xxx_g1_atu_move(chip, fid, from_port, to_port, all);
400}
401
402static irqreturn_t mv88e6xxx_g1_atu_prob_irq_thread_fn(int irq, void *dev_id)
403{
404 struct mv88e6xxx_chip *chip = dev_id;
405 struct mv88e6xxx_atu_entry entry;
406 int err, spid;
407 u16 val, fid;
408
409 mv88e6xxx_reg_lock(chip);
410
411 err = mv88e6xxx_g1_read_atu_violation(chip);
412 if (err)
413 goto out_unlock;
414
415 err = mv88e6xxx_g1_read(chip, MV88E6XXX_G1_ATU_OP, &val);
416 if (err)
417 goto out_unlock;
418
419 err = mv88e6xxx_g1_atu_fid_read(chip, &fid);
420 if (err)
421 goto out_unlock;
422
423 err = mv88e6xxx_g1_atu_data_read(chip, &entry);
424 if (err)
425 goto out_unlock;
426
427 err = mv88e6xxx_g1_atu_mac_read(chip, &entry);
428 if (err)
429 goto out_unlock;
430
431 mv88e6xxx_reg_unlock(chip);
432
433 spid = entry.state;
434
435 if (val & MV88E6XXX_G1_ATU_OP_MEMBER_VIOLATION) {
436 trace_mv88e6xxx_atu_member_violation(chip->dev, spid,
437 entry.portvec, entry.mac,
438 fid);
439 chip->ports[spid].atu_member_violation++;
440 }
441
442 if (val & MV88E6XXX_G1_ATU_OP_MISS_VIOLATION) {
443 trace_mv88e6xxx_atu_miss_violation(chip->dev, spid,
444 entry.portvec, entry.mac,
445 fid);
446 chip->ports[spid].atu_miss_violation++;
447
448 if (fid != MV88E6XXX_FID_STANDALONE && chip->ports[spid].mab) {
449 err = mv88e6xxx_handle_miss_violation(chip, spid,
450 &entry, fid);
451 if (err)
452 goto out;
453 }
454 }
455
456 if (val & MV88E6XXX_G1_ATU_OP_FULL_VIOLATION) {
457 trace_mv88e6xxx_atu_full_violation(chip->dev, spid,
458 entry.portvec, entry.mac,
459 fid);
460 chip->ports[spid].atu_full_violation++;
461 }
462
463 return IRQ_HANDLED;
464
465out_unlock:
466 mv88e6xxx_reg_unlock(chip);
467
468out:
469 dev_err(chip->dev, "ATU problem: error %d while handling interrupt\n",
470 err);
471 return IRQ_HANDLED;
472}
473
474int mv88e6xxx_g1_atu_prob_irq_setup(struct mv88e6xxx_chip *chip)
475{
476 int err;
477
478 chip->atu_prob_irq = irq_find_mapping(chip->g1_irq.domain,
479 MV88E6XXX_G1_STS_IRQ_ATU_PROB);
480 if (chip->atu_prob_irq < 0)
481 return chip->atu_prob_irq;
482
483 snprintf(chip->atu_prob_irq_name, sizeof(chip->atu_prob_irq_name),
484 "mv88e6xxx-%s-g1-atu-prob", dev_name(chip->dev));
485
486 err = request_threaded_irq(chip->atu_prob_irq, NULL,
487 mv88e6xxx_g1_atu_prob_irq_thread_fn,
488 IRQF_ONESHOT, chip->atu_prob_irq_name,
489 chip);
490 if (err)
491 irq_dispose_mapping(chip->atu_prob_irq);
492
493 return err;
494}
495
496void mv88e6xxx_g1_atu_prob_irq_free(struct mv88e6xxx_chip *chip)
497{
498 free_irq(chip->atu_prob_irq, chip);
499 irq_dispose_mapping(chip->atu_prob_irq);
500}
1// SPDX-License-Identifier: GPL-2.0-or-later
2/*
3 * Marvell 88E6xxx Address Translation Unit (ATU) support
4 *
5 * Copyright (c) 2008 Marvell Semiconductor
6 * Copyright (c) 2017 Savoir-faire Linux, Inc.
7 */
8
9#include <linux/bitfield.h>
10#include <linux/interrupt.h>
11#include <linux/irqdomain.h>
12
13#include "chip.h"
14#include "global1.h"
15
16/* Offset 0x01: ATU FID Register */
17
18static int mv88e6xxx_g1_atu_fid_write(struct mv88e6xxx_chip *chip, u16 fid)
19{
20 return mv88e6xxx_g1_write(chip, MV88E6352_G1_ATU_FID, fid & 0xfff);
21}
22
23/* Offset 0x0A: ATU Control Register */
24
25int mv88e6xxx_g1_atu_set_learn2all(struct mv88e6xxx_chip *chip, bool learn2all)
26{
27 u16 val;
28 int err;
29
30 err = mv88e6xxx_g1_read(chip, MV88E6XXX_G1_ATU_CTL, &val);
31 if (err)
32 return err;
33
34 if (learn2all)
35 val |= MV88E6XXX_G1_ATU_CTL_LEARN2ALL;
36 else
37 val &= ~MV88E6XXX_G1_ATU_CTL_LEARN2ALL;
38
39 return mv88e6xxx_g1_write(chip, MV88E6XXX_G1_ATU_CTL, val);
40}
41
42int mv88e6xxx_g1_atu_set_age_time(struct mv88e6xxx_chip *chip,
43 unsigned int msecs)
44{
45 const unsigned int coeff = chip->info->age_time_coeff;
46 const unsigned int min = 0x01 * coeff;
47 const unsigned int max = 0xff * coeff;
48 u8 age_time;
49 u16 val;
50 int err;
51
52 if (msecs < min || msecs > max)
53 return -ERANGE;
54
55 /* Round to nearest multiple of coeff */
56 age_time = (msecs + coeff / 2) / coeff;
57
58 err = mv88e6xxx_g1_read(chip, MV88E6XXX_G1_ATU_CTL, &val);
59 if (err)
60 return err;
61
62 /* AgeTime is 11:4 bits */
63 val &= ~0xff0;
64 val |= age_time << 4;
65
66 err = mv88e6xxx_g1_write(chip, MV88E6XXX_G1_ATU_CTL, val);
67 if (err)
68 return err;
69
70 dev_dbg(chip->dev, "AgeTime set to 0x%02x (%d ms)\n", age_time,
71 age_time * coeff);
72
73 return 0;
74}
75
76/* Offset 0x0B: ATU Operation Register */
77
78static int mv88e6xxx_g1_atu_op_wait(struct mv88e6xxx_chip *chip)
79{
80 int bit = __bf_shf(MV88E6XXX_G1_ATU_OP_BUSY);
81
82 return mv88e6xxx_g1_wait_bit(chip, MV88E6XXX_G1_ATU_OP, bit, 0);
83}
84
85static int mv88e6xxx_g1_atu_op(struct mv88e6xxx_chip *chip, u16 fid, u16 op)
86{
87 u16 val;
88 int err;
89
90 /* FID bits are dispatched all around gradually as more are supported */
91 if (mv88e6xxx_num_databases(chip) > 256) {
92 err = mv88e6xxx_g1_atu_fid_write(chip, fid);
93 if (err)
94 return err;
95 } else {
96 if (mv88e6xxx_num_databases(chip) > 64) {
97 /* ATU DBNum[7:4] are located in ATU Control 15:12 */
98 err = mv88e6xxx_g1_read(chip, MV88E6XXX_G1_ATU_CTL,
99 &val);
100 if (err)
101 return err;
102
103 val = (val & 0x0fff) | ((fid << 8) & 0xf000);
104 err = mv88e6xxx_g1_write(chip, MV88E6XXX_G1_ATU_CTL,
105 val);
106 if (err)
107 return err;
108 } else if (mv88e6xxx_num_databases(chip) > 16) {
109 /* ATU DBNum[5:4] are located in ATU Operation 9:8 */
110 op |= (fid & 0x30) << 4;
111 }
112
113 /* ATU DBNum[3:0] are located in ATU Operation 3:0 */
114 op |= fid & 0xf;
115 }
116
117 err = mv88e6xxx_g1_write(chip, MV88E6XXX_G1_ATU_OP,
118 MV88E6XXX_G1_ATU_OP_BUSY | op);
119 if (err)
120 return err;
121
122 return mv88e6xxx_g1_atu_op_wait(chip);
123}
124
125/* Offset 0x0C: ATU Data Register */
126
127static int mv88e6xxx_g1_atu_data_read(struct mv88e6xxx_chip *chip,
128 struct mv88e6xxx_atu_entry *entry)
129{
130 u16 val;
131 int err;
132
133 err = mv88e6xxx_g1_read(chip, MV88E6XXX_G1_ATU_DATA, &val);
134 if (err)
135 return err;
136
137 entry->state = val & 0xf;
138 if (entry->state) {
139 entry->trunk = !!(val & MV88E6XXX_G1_ATU_DATA_TRUNK);
140 entry->portvec = (val >> 4) & mv88e6xxx_port_mask(chip);
141 }
142
143 return 0;
144}
145
146static int mv88e6xxx_g1_atu_data_write(struct mv88e6xxx_chip *chip,
147 struct mv88e6xxx_atu_entry *entry)
148{
149 u16 data = entry->state & 0xf;
150
151 if (entry->state) {
152 if (entry->trunk)
153 data |= MV88E6XXX_G1_ATU_DATA_TRUNK;
154
155 data |= (entry->portvec & mv88e6xxx_port_mask(chip)) << 4;
156 }
157
158 return mv88e6xxx_g1_write(chip, MV88E6XXX_G1_ATU_DATA, data);
159}
160
161/* Offset 0x0D: ATU MAC Address Register Bytes 0 & 1
162 * Offset 0x0E: ATU MAC Address Register Bytes 2 & 3
163 * Offset 0x0F: ATU MAC Address Register Bytes 4 & 5
164 */
165
166static int mv88e6xxx_g1_atu_mac_read(struct mv88e6xxx_chip *chip,
167 struct mv88e6xxx_atu_entry *entry)
168{
169 u16 val;
170 int i, err;
171
172 for (i = 0; i < 3; i++) {
173 err = mv88e6xxx_g1_read(chip, MV88E6XXX_G1_ATU_MAC01 + i, &val);
174 if (err)
175 return err;
176
177 entry->mac[i * 2] = val >> 8;
178 entry->mac[i * 2 + 1] = val & 0xff;
179 }
180
181 return 0;
182}
183
184static int mv88e6xxx_g1_atu_mac_write(struct mv88e6xxx_chip *chip,
185 struct mv88e6xxx_atu_entry *entry)
186{
187 u16 val;
188 int i, err;
189
190 for (i = 0; i < 3; i++) {
191 val = (entry->mac[i * 2] << 8) | entry->mac[i * 2 + 1];
192 err = mv88e6xxx_g1_write(chip, MV88E6XXX_G1_ATU_MAC01 + i, val);
193 if (err)
194 return err;
195 }
196
197 return 0;
198}
199
200/* Address Translation Unit operations */
201
202int mv88e6xxx_g1_atu_getnext(struct mv88e6xxx_chip *chip, u16 fid,
203 struct mv88e6xxx_atu_entry *entry)
204{
205 int err;
206
207 err = mv88e6xxx_g1_atu_op_wait(chip);
208 if (err)
209 return err;
210
211 /* Write the MAC address to iterate from only once */
212 if (!entry->state) {
213 err = mv88e6xxx_g1_atu_mac_write(chip, entry);
214 if (err)
215 return err;
216 }
217
218 err = mv88e6xxx_g1_atu_op(chip, fid, MV88E6XXX_G1_ATU_OP_GET_NEXT_DB);
219 if (err)
220 return err;
221
222 err = mv88e6xxx_g1_atu_data_read(chip, entry);
223 if (err)
224 return err;
225
226 return mv88e6xxx_g1_atu_mac_read(chip, entry);
227}
228
229int mv88e6xxx_g1_atu_loadpurge(struct mv88e6xxx_chip *chip, u16 fid,
230 struct mv88e6xxx_atu_entry *entry)
231{
232 int err;
233
234 err = mv88e6xxx_g1_atu_op_wait(chip);
235 if (err)
236 return err;
237
238 err = mv88e6xxx_g1_atu_mac_write(chip, entry);
239 if (err)
240 return err;
241
242 err = mv88e6xxx_g1_atu_data_write(chip, entry);
243 if (err)
244 return err;
245
246 return mv88e6xxx_g1_atu_op(chip, fid, MV88E6XXX_G1_ATU_OP_LOAD_DB);
247}
248
249static int mv88e6xxx_g1_atu_flushmove(struct mv88e6xxx_chip *chip, u16 fid,
250 struct mv88e6xxx_atu_entry *entry,
251 bool all)
252{
253 u16 op;
254 int err;
255
256 err = mv88e6xxx_g1_atu_op_wait(chip);
257 if (err)
258 return err;
259
260 err = mv88e6xxx_g1_atu_data_write(chip, entry);
261 if (err)
262 return err;
263
264 /* Flush/Move all or non-static entries from all or a given database */
265 if (all && fid)
266 op = MV88E6XXX_G1_ATU_OP_FLUSH_MOVE_ALL_DB;
267 else if (fid)
268 op = MV88E6XXX_G1_ATU_OP_FLUSH_MOVE_NON_STATIC_DB;
269 else if (all)
270 op = MV88E6XXX_G1_ATU_OP_FLUSH_MOVE_ALL;
271 else
272 op = MV88E6XXX_G1_ATU_OP_FLUSH_MOVE_NON_STATIC;
273
274 return mv88e6xxx_g1_atu_op(chip, fid, op);
275}
276
277int mv88e6xxx_g1_atu_flush(struct mv88e6xxx_chip *chip, u16 fid, bool all)
278{
279 struct mv88e6xxx_atu_entry entry = {
280 .state = 0, /* Null EntryState means Flush */
281 };
282
283 return mv88e6xxx_g1_atu_flushmove(chip, fid, &entry, all);
284}
285
286static int mv88e6xxx_g1_atu_move(struct mv88e6xxx_chip *chip, u16 fid,
287 int from_port, int to_port, bool all)
288{
289 struct mv88e6xxx_atu_entry entry = { 0 };
290 unsigned long mask;
291 int shift;
292
293 if (!chip->info->atu_move_port_mask)
294 return -EOPNOTSUPP;
295
296 mask = chip->info->atu_move_port_mask;
297 shift = bitmap_weight(&mask, 16);
298
299 entry.state = 0xf, /* Full EntryState means Move */
300 entry.portvec = from_port & mask;
301 entry.portvec |= (to_port & mask) << shift;
302
303 return mv88e6xxx_g1_atu_flushmove(chip, fid, &entry, all);
304}
305
306int mv88e6xxx_g1_atu_remove(struct mv88e6xxx_chip *chip, u16 fid, int port,
307 bool all)
308{
309 int from_port = port;
310 int to_port = chip->info->atu_move_port_mask;
311
312 return mv88e6xxx_g1_atu_move(chip, fid, from_port, to_port, all);
313}
314
315static irqreturn_t mv88e6xxx_g1_atu_prob_irq_thread_fn(int irq, void *dev_id)
316{
317 struct mv88e6xxx_chip *chip = dev_id;
318 struct mv88e6xxx_atu_entry entry;
319 int spid;
320 int err;
321 u16 val;
322
323 mv88e6xxx_reg_lock(chip);
324
325 err = mv88e6xxx_g1_atu_op(chip, 0,
326 MV88E6XXX_G1_ATU_OP_GET_CLR_VIOLATION);
327 if (err)
328 goto out;
329
330 err = mv88e6xxx_g1_read(chip, MV88E6XXX_G1_ATU_OP, &val);
331 if (err)
332 goto out;
333
334 err = mv88e6xxx_g1_atu_data_read(chip, &entry);
335 if (err)
336 goto out;
337
338 err = mv88e6xxx_g1_atu_mac_read(chip, &entry);
339 if (err)
340 goto out;
341
342 spid = entry.state;
343
344 if (val & MV88E6XXX_G1_ATU_OP_AGE_OUT_VIOLATION) {
345 dev_err_ratelimited(chip->dev,
346 "ATU age out violation for %pM\n",
347 entry.mac);
348 }
349
350 if (val & MV88E6XXX_G1_ATU_OP_MEMBER_VIOLATION) {
351 dev_err_ratelimited(chip->dev,
352 "ATU member violation for %pM portvec %x spid %d\n",
353 entry.mac, entry.portvec, spid);
354 chip->ports[spid].atu_member_violation++;
355 }
356
357 if (val & MV88E6XXX_G1_ATU_OP_MISS_VIOLATION) {
358 dev_err_ratelimited(chip->dev,
359 "ATU miss violation for %pM portvec %x spid %d\n",
360 entry.mac, entry.portvec, spid);
361 chip->ports[spid].atu_miss_violation++;
362 }
363
364 if (val & MV88E6XXX_G1_ATU_OP_FULL_VIOLATION) {
365 dev_err_ratelimited(chip->dev,
366 "ATU full violation for %pM portvec %x spid %d\n",
367 entry.mac, entry.portvec, spid);
368 chip->ports[spid].atu_full_violation++;
369 }
370 mv88e6xxx_reg_unlock(chip);
371
372 return IRQ_HANDLED;
373
374out:
375 mv88e6xxx_reg_unlock(chip);
376
377 dev_err(chip->dev, "ATU problem: error %d while handling interrupt\n",
378 err);
379 return IRQ_HANDLED;
380}
381
382int mv88e6xxx_g1_atu_prob_irq_setup(struct mv88e6xxx_chip *chip)
383{
384 int err;
385
386 chip->atu_prob_irq = irq_find_mapping(chip->g1_irq.domain,
387 MV88E6XXX_G1_STS_IRQ_ATU_PROB);
388 if (chip->atu_prob_irq < 0)
389 return chip->atu_prob_irq;
390
391 err = request_threaded_irq(chip->atu_prob_irq, NULL,
392 mv88e6xxx_g1_atu_prob_irq_thread_fn,
393 IRQF_ONESHOT, "mv88e6xxx-g1-atu-prob",
394 chip);
395 if (err)
396 irq_dispose_mapping(chip->atu_prob_irq);
397
398 return err;
399}
400
401void mv88e6xxx_g1_atu_prob_irq_free(struct mv88e6xxx_chip *chip)
402{
403 free_irq(chip->atu_prob_irq, chip);
404 irq_dispose_mapping(chip->atu_prob_irq);
405}