Loading...
1// SPDX-License-Identifier: GPL-2.0-only
2// Copyright (c) 2019 Pengutronix, Oleksij Rempel <kernel@pengutronix.de>
3/*
4 * +----------------------+
5 * GMAC1----RGMII----|--MAC0 |
6 * \---MDIO1----|--REGs |----MDIO3----\
7 * | | | +------+
8 * | | +--| |
9 * | MAC1-|----RMII--M-----| PHY0 |-o P0
10 * | | | | +------+
11 * | | | +--| |
12 * | MAC2-|----RMII--------| PHY1 |-o P1
13 * | | | | +------+
14 * | | | +--| |
15 * | MAC3-|----RMII--------| PHY2 |-o P2
16 * | | | | +------+
17 * | | | +--| |
18 * | MAC4-|----RMII--------| PHY3 |-o P3
19 * | | | | +------+
20 * | | | +--| |
21 * | MAC5-|--+-RMII--M-----|-PHY4-|-o P4
22 * | | | | +------+
23 * +----------------------+ | \--CFG_SW_PHY_SWAP
24 * GMAC0---------------RMII--------------------/ \-CFG_SW_PHY_ADDR_SWAP
25 * \---MDIO0--NC
26 *
27 * GMAC0 and MAC5 are connected together and use same PHY. Depending on
28 * configuration it can be PHY4 (default) or PHY0. Only GMAC0 or MAC5 can be
29 * used at same time. If GMAC0 is used (default) then MAC5 should be disabled.
30 *
31 * CFG_SW_PHY_SWAP - swap connections of PHY0 and PHY4. If this bit is not set
32 * PHY4 is connected to GMAC0/MAC5 bundle and PHY0 is connected to MAC1. If this
33 * bit is set, PHY4 is connected to MAC1 and PHY0 is connected to GMAC0/MAC5
34 * bundle.
35 *
36 * CFG_SW_PHY_ADDR_SWAP - swap addresses of PHY0 and PHY4
37 *
38 * CFG_SW_PHY_SWAP and CFG_SW_PHY_ADDR_SWAP are part of SoC specific register
39 * set and not related to switch internal registers.
40 */
41
42#include <linux/bitfield.h>
43#include <linux/module.h>
44#include <linux/of_irq.h>
45#include <linux/of_mdio.h>
46#include <linux/regmap.h>
47#include <linux/reset.h>
48#include <net/dsa.h>
49
50#define AR9331_SW_NAME "ar9331_switch"
51#define AR9331_SW_PORTS 6
52
53/* dummy reg to change page */
54#define AR9331_SW_REG_PAGE 0x40000
55
56/* Global Interrupt */
57#define AR9331_SW_REG_GINT 0x10
58#define AR9331_SW_REG_GINT_MASK 0x14
59#define AR9331_SW_GINT_PHY_INT BIT(2)
60
61#define AR9331_SW_REG_FLOOD_MASK 0x2c
62#define AR9331_SW_FLOOD_MASK_BROAD_TO_CPU BIT(26)
63
64#define AR9331_SW_REG_GLOBAL_CTRL 0x30
65#define AR9331_SW_GLOBAL_CTRL_MFS_M GENMASK(13, 0)
66
67#define AR9331_SW_REG_MDIO_CTRL 0x98
68#define AR9331_SW_MDIO_CTRL_BUSY BIT(31)
69#define AR9331_SW_MDIO_CTRL_MASTER_EN BIT(30)
70#define AR9331_SW_MDIO_CTRL_CMD_READ BIT(27)
71#define AR9331_SW_MDIO_CTRL_PHY_ADDR_M GENMASK(25, 21)
72#define AR9331_SW_MDIO_CTRL_REG_ADDR_M GENMASK(20, 16)
73#define AR9331_SW_MDIO_CTRL_DATA_M GENMASK(16, 0)
74
75#define AR9331_SW_REG_PORT_STATUS(_port) (0x100 + (_port) * 0x100)
76
77/* FLOW_LINK_EN - enable mac flow control config auto-neg with phy.
78 * If not set, mac can be config by software.
79 */
80#define AR9331_SW_PORT_STATUS_FLOW_LINK_EN BIT(12)
81
82/* LINK_EN - If set, MAC is configured from PHY link status.
83 * If not set, MAC should be configured by software.
84 */
85#define AR9331_SW_PORT_STATUS_LINK_EN BIT(9)
86#define AR9331_SW_PORT_STATUS_DUPLEX_MODE BIT(6)
87#define AR9331_SW_PORT_STATUS_RX_FLOW_EN BIT(5)
88#define AR9331_SW_PORT_STATUS_TX_FLOW_EN BIT(4)
89#define AR9331_SW_PORT_STATUS_RXMAC BIT(3)
90#define AR9331_SW_PORT_STATUS_TXMAC BIT(2)
91#define AR9331_SW_PORT_STATUS_SPEED_M GENMASK(1, 0)
92#define AR9331_SW_PORT_STATUS_SPEED_1000 2
93#define AR9331_SW_PORT_STATUS_SPEED_100 1
94#define AR9331_SW_PORT_STATUS_SPEED_10 0
95
96#define AR9331_SW_PORT_STATUS_MAC_MASK \
97 (AR9331_SW_PORT_STATUS_TXMAC | AR9331_SW_PORT_STATUS_RXMAC)
98
99#define AR9331_SW_PORT_STATUS_LINK_MASK \
100 (AR9331_SW_PORT_STATUS_DUPLEX_MODE | \
101 AR9331_SW_PORT_STATUS_RX_FLOW_EN | AR9331_SW_PORT_STATUS_TX_FLOW_EN | \
102 AR9331_SW_PORT_STATUS_SPEED_M)
103
104#define AR9331_SW_REG_PORT_CTRL(_port) (0x104 + (_port) * 0x100)
105#define AR9331_SW_PORT_CTRL_HEAD_EN BIT(11)
106#define AR9331_SW_PORT_CTRL_PORT_STATE GENMASK(2, 0)
107#define AR9331_SW_PORT_CTRL_PORT_STATE_DISABLED 0
108#define AR9331_SW_PORT_CTRL_PORT_STATE_BLOCKING 1
109#define AR9331_SW_PORT_CTRL_PORT_STATE_LISTENING 2
110#define AR9331_SW_PORT_CTRL_PORT_STATE_LEARNING 3
111#define AR9331_SW_PORT_CTRL_PORT_STATE_FORWARD 4
112
113#define AR9331_SW_REG_PORT_VLAN(_port) (0x108 + (_port) * 0x100)
114#define AR9331_SW_PORT_VLAN_8021Q_MODE GENMASK(31, 30)
115#define AR9331_SW_8021Q_MODE_SECURE 3
116#define AR9331_SW_8021Q_MODE_CHECK 2
117#define AR9331_SW_8021Q_MODE_FALLBACK 1
118#define AR9331_SW_8021Q_MODE_NONE 0
119#define AR9331_SW_PORT_VLAN_PORT_VID_MEMBER GENMASK(25, 16)
120
121/* MIB registers */
122#define AR9331_MIB_COUNTER(x) (0x20000 + ((x) * 0x100))
123
124/* Phy bypass mode
125 * ------------------------------------------------------------------------
126 * Bit: | 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 |10 |11 |12 |13 |14 |15 |
127 *
128 * real | start | OP | PhyAddr | Reg Addr | TA |
129 * atheros| start | OP | 2'b00 |PhyAdd[2:0]| Reg Addr[4:0] | TA |
130 *
131 *
132 * Bit: |16 |17 |18 |19 |20 |21 |22 |23 |24 |25 |26 |27 |28 |29 |30 |31 |
133 * real | Data |
134 * atheros| Data |
135 *
136 * ------------------------------------------------------------------------
137 * Page address mode
138 * ------------------------------------------------------------------------
139 * Bit: | 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 |10 |11 |12 |13 |14 |15 |
140 * real | start | OP | PhyAddr | Reg Addr | TA |
141 * atheros| start | OP | 2'b11 | 8'b0 | TA |
142 *
143 * Bit: |16 |17 |18 |19 |20 |21 |22 |23 |24 |25 |26 |27 |28 |29 |30 |31 |
144 * real | Data |
145 * atheros| | Page [9:0] |
146 */
147/* In case of Page Address mode, Bit[18:9] of 32 bit register address should be
148 * written to bits[9:0] of mdio data register.
149 */
150#define AR9331_SW_ADDR_PAGE GENMASK(18, 9)
151
152/* ------------------------------------------------------------------------
153 * Normal register access mode
154 * ------------------------------------------------------------------------
155 * Bit: | 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 |10 |11 |12 |13 |14 |15 |
156 * real | start | OP | PhyAddr | Reg Addr | TA |
157 * atheros| start | OP | 2'b10 | low_addr[7:0] | TA |
158 *
159 * Bit: |16 |17 |18 |19 |20 |21 |22 |23 |24 |25 |26 |27 |28 |29 |30 |31 |
160 * real | Data |
161 * atheros| Data |
162 * ------------------------------------------------------------------------
163 */
164#define AR9331_SW_LOW_ADDR_PHY GENMASK(8, 6)
165#define AR9331_SW_LOW_ADDR_REG GENMASK(5, 1)
166
167#define AR9331_SW_MDIO_PHY_MODE_M GENMASK(4, 3)
168#define AR9331_SW_MDIO_PHY_MODE_PAGE 3
169#define AR9331_SW_MDIO_PHY_MODE_REG 2
170#define AR9331_SW_MDIO_PHY_MODE_BYPASS 0
171#define AR9331_SW_MDIO_PHY_ADDR_M GENMASK(2, 0)
172
173/* Empirical determined values */
174#define AR9331_SW_MDIO_POLL_SLEEP_US 1
175#define AR9331_SW_MDIO_POLL_TIMEOUT_US 20
176
177/* The interval should be small enough to avoid overflow of 32bit MIBs */
178/*
179 * FIXME: until we can read MIBs from stats64 call directly (i.e. sleep
180 * there), we have to poll stats more frequently then it is actually needed.
181 * For overflow protection, normally, 100 sec interval should have been OK.
182 */
183#define STATS_INTERVAL_JIFFIES (3 * HZ)
184
185struct ar9331_sw_stats_raw {
186 u32 rxbroad; /* 0x00 */
187 u32 rxpause; /* 0x04 */
188 u32 rxmulti; /* 0x08 */
189 u32 rxfcserr; /* 0x0c */
190 u32 rxalignerr; /* 0x10 */
191 u32 rxrunt; /* 0x14 */
192 u32 rxfragment; /* 0x18 */
193 u32 rx64byte; /* 0x1c */
194 u32 rx128byte; /* 0x20 */
195 u32 rx256byte; /* 0x24 */
196 u32 rx512byte; /* 0x28 */
197 u32 rx1024byte; /* 0x2c */
198 u32 rx1518byte; /* 0x30 */
199 u32 rxmaxbyte; /* 0x34 */
200 u32 rxtoolong; /* 0x38 */
201 u32 rxgoodbyte; /* 0x3c */
202 u32 rxgoodbyte_hi;
203 u32 rxbadbyte; /* 0x44 */
204 u32 rxbadbyte_hi;
205 u32 rxoverflow; /* 0x4c */
206 u32 filtered; /* 0x50 */
207 u32 txbroad; /* 0x54 */
208 u32 txpause; /* 0x58 */
209 u32 txmulti; /* 0x5c */
210 u32 txunderrun; /* 0x60 */
211 u32 tx64byte; /* 0x64 */
212 u32 tx128byte; /* 0x68 */
213 u32 tx256byte; /* 0x6c */
214 u32 tx512byte; /* 0x70 */
215 u32 tx1024byte; /* 0x74 */
216 u32 tx1518byte; /* 0x78 */
217 u32 txmaxbyte; /* 0x7c */
218 u32 txoversize; /* 0x80 */
219 u32 txbyte; /* 0x84 */
220 u32 txbyte_hi;
221 u32 txcollision; /* 0x8c */
222 u32 txabortcol; /* 0x90 */
223 u32 txmulticol; /* 0x94 */
224 u32 txsinglecol; /* 0x98 */
225 u32 txexcdefer; /* 0x9c */
226 u32 txdefer; /* 0xa0 */
227 u32 txlatecol; /* 0xa4 */
228};
229
230struct ar9331_sw_port {
231 int idx;
232 struct delayed_work mib_read;
233 struct rtnl_link_stats64 stats;
234 struct ethtool_pause_stats pause_stats;
235 struct spinlock stats_lock;
236};
237
238struct ar9331_sw_priv {
239 struct device *dev;
240 struct dsa_switch ds;
241 struct dsa_switch_ops ops;
242 struct irq_domain *irqdomain;
243 u32 irq_mask;
244 struct mutex lock_irq;
245 struct mii_bus *mbus; /* mdio master */
246 struct mii_bus *sbus; /* mdio slave */
247 struct regmap *regmap;
248 struct reset_control *sw_reset;
249 struct ar9331_sw_port port[AR9331_SW_PORTS];
250};
251
252static struct ar9331_sw_priv *ar9331_sw_port_to_priv(struct ar9331_sw_port *port)
253{
254 struct ar9331_sw_port *p = port - port->idx;
255
256 return (struct ar9331_sw_priv *)((void *)p -
257 offsetof(struct ar9331_sw_priv, port));
258}
259
260/* Warning: switch reset will reset last AR9331_SW_MDIO_PHY_MODE_PAGE request
261 * If some kind of optimization is used, the request should be repeated.
262 */
263static int ar9331_sw_reset(struct ar9331_sw_priv *priv)
264{
265 int ret;
266
267 ret = reset_control_assert(priv->sw_reset);
268 if (ret)
269 goto error;
270
271 /* AR9331 doc do not provide any information about proper reset
272 * sequence. The AR8136 (the closes switch to the AR9331) doc says:
273 * reset duration should be greater than 10ms. So, let's use this value
274 * for now.
275 */
276 usleep_range(10000, 15000);
277 ret = reset_control_deassert(priv->sw_reset);
278 if (ret)
279 goto error;
280 /* There is no information on how long should we wait after reset.
281 * AR8136 has an EEPROM and there is an Interrupt for EEPROM load
282 * status. AR9331 has no EEPROM support.
283 * For now, do not wait. In case AR8136 will be needed, the after
284 * reset delay can be added as well.
285 */
286
287 return 0;
288error:
289 dev_err_ratelimited(priv->dev, "%s: %i\n", __func__, ret);
290 return ret;
291}
292
293static int ar9331_sw_mbus_write(struct mii_bus *mbus, int port, int regnum,
294 u16 data)
295{
296 struct ar9331_sw_priv *priv = mbus->priv;
297 struct regmap *regmap = priv->regmap;
298 u32 val;
299 int ret;
300
301 ret = regmap_write(regmap, AR9331_SW_REG_MDIO_CTRL,
302 AR9331_SW_MDIO_CTRL_BUSY |
303 AR9331_SW_MDIO_CTRL_MASTER_EN |
304 FIELD_PREP(AR9331_SW_MDIO_CTRL_PHY_ADDR_M, port) |
305 FIELD_PREP(AR9331_SW_MDIO_CTRL_REG_ADDR_M, regnum) |
306 FIELD_PREP(AR9331_SW_MDIO_CTRL_DATA_M, data));
307 if (ret)
308 goto error;
309
310 ret = regmap_read_poll_timeout(regmap, AR9331_SW_REG_MDIO_CTRL, val,
311 !(val & AR9331_SW_MDIO_CTRL_BUSY),
312 AR9331_SW_MDIO_POLL_SLEEP_US,
313 AR9331_SW_MDIO_POLL_TIMEOUT_US);
314 if (ret)
315 goto error;
316
317 return 0;
318error:
319 dev_err_ratelimited(priv->dev, "PHY write error: %i\n", ret);
320 return ret;
321}
322
323static int ar9331_sw_mbus_read(struct mii_bus *mbus, int port, int regnum)
324{
325 struct ar9331_sw_priv *priv = mbus->priv;
326 struct regmap *regmap = priv->regmap;
327 u32 val;
328 int ret;
329
330 ret = regmap_write(regmap, AR9331_SW_REG_MDIO_CTRL,
331 AR9331_SW_MDIO_CTRL_BUSY |
332 AR9331_SW_MDIO_CTRL_MASTER_EN |
333 AR9331_SW_MDIO_CTRL_CMD_READ |
334 FIELD_PREP(AR9331_SW_MDIO_CTRL_PHY_ADDR_M, port) |
335 FIELD_PREP(AR9331_SW_MDIO_CTRL_REG_ADDR_M, regnum));
336 if (ret)
337 goto error;
338
339 ret = regmap_read_poll_timeout(regmap, AR9331_SW_REG_MDIO_CTRL, val,
340 !(val & AR9331_SW_MDIO_CTRL_BUSY),
341 AR9331_SW_MDIO_POLL_SLEEP_US,
342 AR9331_SW_MDIO_POLL_TIMEOUT_US);
343 if (ret)
344 goto error;
345
346 ret = regmap_read(regmap, AR9331_SW_REG_MDIO_CTRL, &val);
347 if (ret)
348 goto error;
349
350 return FIELD_GET(AR9331_SW_MDIO_CTRL_DATA_M, val);
351
352error:
353 dev_err_ratelimited(priv->dev, "PHY read error: %i\n", ret);
354 return ret;
355}
356
357static int ar9331_sw_mbus_init(struct ar9331_sw_priv *priv)
358{
359 struct device *dev = priv->dev;
360 struct mii_bus *mbus;
361 struct device_node *np, *mnp;
362 int ret;
363
364 np = dev->of_node;
365
366 mbus = devm_mdiobus_alloc(dev);
367 if (!mbus)
368 return -ENOMEM;
369
370 mbus->name = np->full_name;
371 snprintf(mbus->id, MII_BUS_ID_SIZE, "%pOF", np);
372
373 mbus->read = ar9331_sw_mbus_read;
374 mbus->write = ar9331_sw_mbus_write;
375 mbus->priv = priv;
376 mbus->parent = dev;
377
378 mnp = of_get_child_by_name(np, "mdio");
379 if (!mnp)
380 return -ENODEV;
381
382 ret = devm_of_mdiobus_register(dev, mbus, mnp);
383 of_node_put(mnp);
384 if (ret)
385 return ret;
386
387 priv->mbus = mbus;
388
389 return 0;
390}
391
392static int ar9331_sw_setup_port(struct dsa_switch *ds, int port)
393{
394 struct ar9331_sw_priv *priv = ds->priv;
395 struct regmap *regmap = priv->regmap;
396 u32 port_mask, port_ctrl, val;
397 int ret;
398
399 /* Generate default port settings */
400 port_ctrl = FIELD_PREP(AR9331_SW_PORT_CTRL_PORT_STATE,
401 AR9331_SW_PORT_CTRL_PORT_STATE_FORWARD);
402
403 if (dsa_is_cpu_port(ds, port)) {
404 /* CPU port should be allowed to communicate with all user
405 * ports.
406 */
407 port_mask = dsa_user_ports(ds);
408 /* Enable Atheros header on CPU port. This will allow us
409 * communicate with each port separately
410 */
411 port_ctrl |= AR9331_SW_PORT_CTRL_HEAD_EN;
412 } else if (dsa_is_user_port(ds, port)) {
413 /* User ports should communicate only with the CPU port.
414 */
415 port_mask = BIT(dsa_upstream_port(ds, port));
416 } else {
417 /* Other ports do not need to communicate at all */
418 port_mask = 0;
419 }
420
421 val = FIELD_PREP(AR9331_SW_PORT_VLAN_8021Q_MODE,
422 AR9331_SW_8021Q_MODE_NONE) |
423 FIELD_PREP(AR9331_SW_PORT_VLAN_PORT_VID_MEMBER, port_mask);
424
425 ret = regmap_write(regmap, AR9331_SW_REG_PORT_VLAN(port), val);
426 if (ret)
427 goto error;
428
429 ret = regmap_write(regmap, AR9331_SW_REG_PORT_CTRL(port), port_ctrl);
430 if (ret)
431 goto error;
432
433 return 0;
434error:
435 dev_err(priv->dev, "%s: error: %i\n", __func__, ret);
436
437 return ret;
438}
439
440static int ar9331_sw_setup(struct dsa_switch *ds)
441{
442 struct ar9331_sw_priv *priv = ds->priv;
443 struct regmap *regmap = priv->regmap;
444 int ret, i;
445
446 ret = ar9331_sw_reset(priv);
447 if (ret)
448 return ret;
449
450 /* Reset will set proper defaults. CPU - Port0 will be enabled and
451 * configured. All other ports (ports 1 - 5) are disabled
452 */
453 ret = ar9331_sw_mbus_init(priv);
454 if (ret)
455 return ret;
456
457 /* Do not drop broadcast frames */
458 ret = regmap_write_bits(regmap, AR9331_SW_REG_FLOOD_MASK,
459 AR9331_SW_FLOOD_MASK_BROAD_TO_CPU,
460 AR9331_SW_FLOOD_MASK_BROAD_TO_CPU);
461 if (ret)
462 goto error;
463
464 /* Set max frame size to the maximum supported value */
465 ret = regmap_write_bits(regmap, AR9331_SW_REG_GLOBAL_CTRL,
466 AR9331_SW_GLOBAL_CTRL_MFS_M,
467 AR9331_SW_GLOBAL_CTRL_MFS_M);
468 if (ret)
469 goto error;
470
471 for (i = 0; i < ds->num_ports; i++) {
472 ret = ar9331_sw_setup_port(ds, i);
473 if (ret)
474 goto error;
475 }
476
477 ds->configure_vlan_while_not_filtering = false;
478
479 return 0;
480error:
481 dev_err_ratelimited(priv->dev, "%s: %i\n", __func__, ret);
482 return ret;
483}
484
485static void ar9331_sw_port_disable(struct dsa_switch *ds, int port)
486{
487 struct ar9331_sw_priv *priv = ds->priv;
488 struct regmap *regmap = priv->regmap;
489 int ret;
490
491 ret = regmap_write(regmap, AR9331_SW_REG_PORT_STATUS(port), 0);
492 if (ret)
493 dev_err_ratelimited(priv->dev, "%s: %i\n", __func__, ret);
494}
495
496static enum dsa_tag_protocol ar9331_sw_get_tag_protocol(struct dsa_switch *ds,
497 int port,
498 enum dsa_tag_protocol m)
499{
500 return DSA_TAG_PROTO_AR9331;
501}
502
503static void ar9331_sw_phylink_get_caps(struct dsa_switch *ds, int port,
504 struct phylink_config *config)
505{
506 config->mac_capabilities = MAC_ASYM_PAUSE | MAC_SYM_PAUSE |
507 MAC_10 | MAC_100;
508
509 switch (port) {
510 case 0:
511 __set_bit(PHY_INTERFACE_MODE_GMII,
512 config->supported_interfaces);
513 config->mac_capabilities |= MAC_1000;
514 break;
515 case 1:
516 case 2:
517 case 3:
518 case 4:
519 case 5:
520 __set_bit(PHY_INTERFACE_MODE_INTERNAL,
521 config->supported_interfaces);
522 break;
523 }
524}
525
526static void ar9331_sw_phylink_mac_config(struct dsa_switch *ds, int port,
527 unsigned int mode,
528 const struct phylink_link_state *state)
529{
530 struct ar9331_sw_priv *priv = ds->priv;
531 struct regmap *regmap = priv->regmap;
532 int ret;
533
534 ret = regmap_update_bits(regmap, AR9331_SW_REG_PORT_STATUS(port),
535 AR9331_SW_PORT_STATUS_LINK_EN |
536 AR9331_SW_PORT_STATUS_FLOW_LINK_EN, 0);
537 if (ret)
538 dev_err_ratelimited(priv->dev, "%s: %i\n", __func__, ret);
539}
540
541static void ar9331_sw_phylink_mac_link_down(struct dsa_switch *ds, int port,
542 unsigned int mode,
543 phy_interface_t interface)
544{
545 struct ar9331_sw_priv *priv = ds->priv;
546 struct ar9331_sw_port *p = &priv->port[port];
547 struct regmap *regmap = priv->regmap;
548 int ret;
549
550 ret = regmap_update_bits(regmap, AR9331_SW_REG_PORT_STATUS(port),
551 AR9331_SW_PORT_STATUS_MAC_MASK, 0);
552 if (ret)
553 dev_err_ratelimited(priv->dev, "%s: %i\n", __func__, ret);
554
555 cancel_delayed_work_sync(&p->mib_read);
556}
557
558static void ar9331_sw_phylink_mac_link_up(struct dsa_switch *ds, int port,
559 unsigned int mode,
560 phy_interface_t interface,
561 struct phy_device *phydev,
562 int speed, int duplex,
563 bool tx_pause, bool rx_pause)
564{
565 struct ar9331_sw_priv *priv = ds->priv;
566 struct ar9331_sw_port *p = &priv->port[port];
567 struct regmap *regmap = priv->regmap;
568 u32 val;
569 int ret;
570
571 schedule_delayed_work(&p->mib_read, 0);
572
573 val = AR9331_SW_PORT_STATUS_MAC_MASK;
574 switch (speed) {
575 case SPEED_1000:
576 val |= AR9331_SW_PORT_STATUS_SPEED_1000;
577 break;
578 case SPEED_100:
579 val |= AR9331_SW_PORT_STATUS_SPEED_100;
580 break;
581 case SPEED_10:
582 val |= AR9331_SW_PORT_STATUS_SPEED_10;
583 break;
584 default:
585 return;
586 }
587
588 if (duplex)
589 val |= AR9331_SW_PORT_STATUS_DUPLEX_MODE;
590
591 if (tx_pause)
592 val |= AR9331_SW_PORT_STATUS_TX_FLOW_EN;
593
594 if (rx_pause)
595 val |= AR9331_SW_PORT_STATUS_RX_FLOW_EN;
596
597 ret = regmap_update_bits(regmap, AR9331_SW_REG_PORT_STATUS(port),
598 AR9331_SW_PORT_STATUS_MAC_MASK |
599 AR9331_SW_PORT_STATUS_LINK_MASK,
600 val);
601 if (ret)
602 dev_err_ratelimited(priv->dev, "%s: %i\n", __func__, ret);
603}
604
605static void ar9331_read_stats(struct ar9331_sw_port *port)
606{
607 struct ar9331_sw_priv *priv = ar9331_sw_port_to_priv(port);
608 struct ethtool_pause_stats *pstats = &port->pause_stats;
609 struct rtnl_link_stats64 *stats = &port->stats;
610 struct ar9331_sw_stats_raw raw;
611 int ret;
612
613 /* Do the slowest part first, to avoid needless locking for long time */
614 ret = regmap_bulk_read(priv->regmap, AR9331_MIB_COUNTER(port->idx),
615 &raw, sizeof(raw) / sizeof(u32));
616 if (ret) {
617 dev_err_ratelimited(priv->dev, "%s: %i\n", __func__, ret);
618 return;
619 }
620 /* All MIB counters are cleared automatically on read */
621
622 spin_lock(&port->stats_lock);
623
624 stats->rx_bytes += raw.rxgoodbyte;
625 stats->tx_bytes += raw.txbyte;
626
627 stats->rx_packets += raw.rx64byte + raw.rx128byte + raw.rx256byte +
628 raw.rx512byte + raw.rx1024byte + raw.rx1518byte + raw.rxmaxbyte;
629 stats->tx_packets += raw.tx64byte + raw.tx128byte + raw.tx256byte +
630 raw.tx512byte + raw.tx1024byte + raw.tx1518byte + raw.txmaxbyte;
631
632 stats->rx_length_errors += raw.rxrunt + raw.rxfragment + raw.rxtoolong;
633 stats->rx_crc_errors += raw.rxfcserr;
634 stats->rx_frame_errors += raw.rxalignerr;
635 stats->rx_missed_errors += raw.rxoverflow;
636 stats->rx_dropped += raw.filtered;
637 stats->rx_errors += raw.rxfcserr + raw.rxalignerr + raw.rxrunt +
638 raw.rxfragment + raw.rxoverflow + raw.rxtoolong;
639
640 stats->tx_window_errors += raw.txlatecol;
641 stats->tx_fifo_errors += raw.txunderrun;
642 stats->tx_aborted_errors += raw.txabortcol;
643 stats->tx_errors += raw.txoversize + raw.txabortcol + raw.txunderrun +
644 raw.txlatecol;
645
646 stats->multicast += raw.rxmulti;
647 stats->collisions += raw.txcollision;
648
649 pstats->tx_pause_frames += raw.txpause;
650 pstats->rx_pause_frames += raw.rxpause;
651
652 spin_unlock(&port->stats_lock);
653}
654
655static void ar9331_do_stats_poll(struct work_struct *work)
656{
657 struct ar9331_sw_port *port = container_of(work, struct ar9331_sw_port,
658 mib_read.work);
659
660 ar9331_read_stats(port);
661
662 schedule_delayed_work(&port->mib_read, STATS_INTERVAL_JIFFIES);
663}
664
665static void ar9331_get_stats64(struct dsa_switch *ds, int port,
666 struct rtnl_link_stats64 *s)
667{
668 struct ar9331_sw_priv *priv = ds->priv;
669 struct ar9331_sw_port *p = &priv->port[port];
670
671 spin_lock(&p->stats_lock);
672 memcpy(s, &p->stats, sizeof(*s));
673 spin_unlock(&p->stats_lock);
674}
675
676static void ar9331_get_pause_stats(struct dsa_switch *ds, int port,
677 struct ethtool_pause_stats *pause_stats)
678{
679 struct ar9331_sw_priv *priv = ds->priv;
680 struct ar9331_sw_port *p = &priv->port[port];
681
682 spin_lock(&p->stats_lock);
683 memcpy(pause_stats, &p->pause_stats, sizeof(*pause_stats));
684 spin_unlock(&p->stats_lock);
685}
686
687static const struct dsa_switch_ops ar9331_sw_ops = {
688 .get_tag_protocol = ar9331_sw_get_tag_protocol,
689 .setup = ar9331_sw_setup,
690 .port_disable = ar9331_sw_port_disable,
691 .phylink_get_caps = ar9331_sw_phylink_get_caps,
692 .phylink_mac_config = ar9331_sw_phylink_mac_config,
693 .phylink_mac_link_down = ar9331_sw_phylink_mac_link_down,
694 .phylink_mac_link_up = ar9331_sw_phylink_mac_link_up,
695 .get_stats64 = ar9331_get_stats64,
696 .get_pause_stats = ar9331_get_pause_stats,
697};
698
699static irqreturn_t ar9331_sw_irq(int irq, void *data)
700{
701 struct ar9331_sw_priv *priv = data;
702 struct regmap *regmap = priv->regmap;
703 u32 stat;
704 int ret;
705
706 ret = regmap_read(regmap, AR9331_SW_REG_GINT, &stat);
707 if (ret) {
708 dev_err(priv->dev, "can't read interrupt status\n");
709 return IRQ_NONE;
710 }
711
712 if (!stat)
713 return IRQ_NONE;
714
715 if (stat & AR9331_SW_GINT_PHY_INT) {
716 int child_irq;
717
718 child_irq = irq_find_mapping(priv->irqdomain, 0);
719 handle_nested_irq(child_irq);
720 }
721
722 ret = regmap_write(regmap, AR9331_SW_REG_GINT, stat);
723 if (ret) {
724 dev_err(priv->dev, "can't write interrupt status\n");
725 return IRQ_NONE;
726 }
727
728 return IRQ_HANDLED;
729}
730
731static void ar9331_sw_mask_irq(struct irq_data *d)
732{
733 struct ar9331_sw_priv *priv = irq_data_get_irq_chip_data(d);
734
735 priv->irq_mask = 0;
736}
737
738static void ar9331_sw_unmask_irq(struct irq_data *d)
739{
740 struct ar9331_sw_priv *priv = irq_data_get_irq_chip_data(d);
741
742 priv->irq_mask = AR9331_SW_GINT_PHY_INT;
743}
744
745static void ar9331_sw_irq_bus_lock(struct irq_data *d)
746{
747 struct ar9331_sw_priv *priv = irq_data_get_irq_chip_data(d);
748
749 mutex_lock(&priv->lock_irq);
750}
751
752static void ar9331_sw_irq_bus_sync_unlock(struct irq_data *d)
753{
754 struct ar9331_sw_priv *priv = irq_data_get_irq_chip_data(d);
755 struct regmap *regmap = priv->regmap;
756 int ret;
757
758 ret = regmap_update_bits(regmap, AR9331_SW_REG_GINT_MASK,
759 AR9331_SW_GINT_PHY_INT, priv->irq_mask);
760 if (ret)
761 dev_err(priv->dev, "failed to change IRQ mask\n");
762
763 mutex_unlock(&priv->lock_irq);
764}
765
766static struct irq_chip ar9331_sw_irq_chip = {
767 .name = AR9331_SW_NAME,
768 .irq_mask = ar9331_sw_mask_irq,
769 .irq_unmask = ar9331_sw_unmask_irq,
770 .irq_bus_lock = ar9331_sw_irq_bus_lock,
771 .irq_bus_sync_unlock = ar9331_sw_irq_bus_sync_unlock,
772};
773
774static int ar9331_sw_irq_map(struct irq_domain *domain, unsigned int irq,
775 irq_hw_number_t hwirq)
776{
777 irq_set_chip_data(irq, domain->host_data);
778 irq_set_chip_and_handler(irq, &ar9331_sw_irq_chip, handle_simple_irq);
779 irq_set_nested_thread(irq, 1);
780 irq_set_noprobe(irq);
781
782 return 0;
783}
784
785static void ar9331_sw_irq_unmap(struct irq_domain *d, unsigned int irq)
786{
787 irq_set_nested_thread(irq, 0);
788 irq_set_chip_and_handler(irq, NULL, NULL);
789 irq_set_chip_data(irq, NULL);
790}
791
792static const struct irq_domain_ops ar9331_sw_irqdomain_ops = {
793 .map = ar9331_sw_irq_map,
794 .unmap = ar9331_sw_irq_unmap,
795 .xlate = irq_domain_xlate_onecell,
796};
797
798static int ar9331_sw_irq_init(struct ar9331_sw_priv *priv)
799{
800 struct device_node *np = priv->dev->of_node;
801 struct device *dev = priv->dev;
802 int ret, irq;
803
804 irq = of_irq_get(np, 0);
805 if (irq <= 0) {
806 dev_err(dev, "failed to get parent IRQ\n");
807 return irq ? irq : -EINVAL;
808 }
809
810 mutex_init(&priv->lock_irq);
811 ret = devm_request_threaded_irq(dev, irq, NULL, ar9331_sw_irq,
812 IRQF_ONESHOT, AR9331_SW_NAME, priv);
813 if (ret) {
814 dev_err(dev, "unable to request irq: %d\n", ret);
815 return ret;
816 }
817
818 priv->irqdomain = irq_domain_add_linear(np, 1, &ar9331_sw_irqdomain_ops,
819 priv);
820 if (!priv->irqdomain) {
821 dev_err(dev, "failed to create IRQ domain\n");
822 return -EINVAL;
823 }
824
825 irq_set_parent(irq_create_mapping(priv->irqdomain, 0), irq);
826
827 return 0;
828}
829
830static int __ar9331_mdio_write(struct mii_bus *sbus, u8 mode, u16 reg, u16 val)
831{
832 u8 r, p;
833
834 p = FIELD_PREP(AR9331_SW_MDIO_PHY_MODE_M, mode) |
835 FIELD_GET(AR9331_SW_LOW_ADDR_PHY, reg);
836 r = FIELD_GET(AR9331_SW_LOW_ADDR_REG, reg);
837
838 return __mdiobus_write(sbus, p, r, val);
839}
840
841static int __ar9331_mdio_read(struct mii_bus *sbus, u16 reg)
842{
843 u8 r, p;
844
845 p = FIELD_PREP(AR9331_SW_MDIO_PHY_MODE_M, AR9331_SW_MDIO_PHY_MODE_REG) |
846 FIELD_GET(AR9331_SW_LOW_ADDR_PHY, reg);
847 r = FIELD_GET(AR9331_SW_LOW_ADDR_REG, reg);
848
849 return __mdiobus_read(sbus, p, r);
850}
851
852static int ar9331_mdio_read(void *ctx, const void *reg_buf, size_t reg_len,
853 void *val_buf, size_t val_len)
854{
855 struct ar9331_sw_priv *priv = ctx;
856 struct mii_bus *sbus = priv->sbus;
857 u32 reg = *(u32 *)reg_buf;
858 int ret;
859
860 if (reg == AR9331_SW_REG_PAGE) {
861 /* We cannot read the page selector register from hardware and
862 * we cache its value in regmap. Return all bits set here,
863 * that regmap will always write the page on first use.
864 */
865 *(u32 *)val_buf = GENMASK(9, 0);
866 return 0;
867 }
868
869 mutex_lock_nested(&sbus->mdio_lock, MDIO_MUTEX_NESTED);
870
871 ret = __ar9331_mdio_read(sbus, reg);
872 if (ret < 0)
873 goto error;
874
875 *(u32 *)val_buf = ret;
876 ret = __ar9331_mdio_read(sbus, reg + 2);
877 if (ret < 0)
878 goto error;
879
880 *(u32 *)val_buf |= ret << 16;
881
882 mutex_unlock(&sbus->mdio_lock);
883
884 return 0;
885error:
886 mutex_unlock(&sbus->mdio_lock);
887 dev_err_ratelimited(&sbus->dev, "Bus error. Failed to read register.\n");
888
889 return ret;
890}
891
892static int ar9331_mdio_write(void *ctx, u32 reg, u32 val)
893{
894 struct ar9331_sw_priv *priv = (struct ar9331_sw_priv *)ctx;
895 struct mii_bus *sbus = priv->sbus;
896 int ret;
897
898 mutex_lock_nested(&sbus->mdio_lock, MDIO_MUTEX_NESTED);
899 if (reg == AR9331_SW_REG_PAGE) {
900 ret = __ar9331_mdio_write(sbus, AR9331_SW_MDIO_PHY_MODE_PAGE,
901 0, val);
902 if (ret < 0)
903 goto error;
904
905 mutex_unlock(&sbus->mdio_lock);
906
907 return 0;
908 }
909
910 /* In case of this switch we work with 32bit registers on top of 16bit
911 * bus. Some registers (for example access to forwarding database) have
912 * trigger bit on the first 16bit half of request, the result and
913 * configuration of request in the second half.
914 * To make it work properly, we should do the second part of transfer
915 * before the first one is done.
916 */
917 ret = __ar9331_mdio_write(sbus, AR9331_SW_MDIO_PHY_MODE_REG, reg + 2,
918 val >> 16);
919 if (ret < 0)
920 goto error;
921
922 ret = __ar9331_mdio_write(sbus, AR9331_SW_MDIO_PHY_MODE_REG, reg, val);
923 if (ret < 0)
924 goto error;
925
926 mutex_unlock(&sbus->mdio_lock);
927
928 return 0;
929
930error:
931 mutex_unlock(&sbus->mdio_lock);
932 dev_err_ratelimited(&sbus->dev, "Bus error. Failed to write register.\n");
933
934 return ret;
935}
936
937static int ar9331_sw_bus_write(void *context, const void *data, size_t count)
938{
939 u32 reg = *(u32 *)data;
940 u32 val = *((u32 *)data + 1);
941
942 return ar9331_mdio_write(context, reg, val);
943}
944
945static const struct regmap_range ar9331_valid_regs[] = {
946 regmap_reg_range(0x0, 0x0),
947 regmap_reg_range(0x10, 0x14),
948 regmap_reg_range(0x20, 0x24),
949 regmap_reg_range(0x2c, 0x30),
950 regmap_reg_range(0x40, 0x44),
951 regmap_reg_range(0x50, 0x78),
952 regmap_reg_range(0x80, 0x98),
953
954 regmap_reg_range(0x100, 0x120),
955 regmap_reg_range(0x200, 0x220),
956 regmap_reg_range(0x300, 0x320),
957 regmap_reg_range(0x400, 0x420),
958 regmap_reg_range(0x500, 0x520),
959 regmap_reg_range(0x600, 0x620),
960
961 regmap_reg_range(0x20000, 0x200a4),
962 regmap_reg_range(0x20100, 0x201a4),
963 regmap_reg_range(0x20200, 0x202a4),
964 regmap_reg_range(0x20300, 0x203a4),
965 regmap_reg_range(0x20400, 0x204a4),
966 regmap_reg_range(0x20500, 0x205a4),
967
968 /* dummy page selector reg */
969 regmap_reg_range(AR9331_SW_REG_PAGE, AR9331_SW_REG_PAGE),
970};
971
972static const struct regmap_range ar9331_nonvolatile_regs[] = {
973 regmap_reg_range(AR9331_SW_REG_PAGE, AR9331_SW_REG_PAGE),
974};
975
976static const struct regmap_range_cfg ar9331_regmap_range[] = {
977 {
978 .selector_reg = AR9331_SW_REG_PAGE,
979 .selector_mask = GENMASK(9, 0),
980 .selector_shift = 0,
981
982 .window_start = 0,
983 .window_len = 512,
984
985 .range_min = 0,
986 .range_max = AR9331_SW_REG_PAGE - 4,
987 },
988};
989
990static const struct regmap_access_table ar9331_register_set = {
991 .yes_ranges = ar9331_valid_regs,
992 .n_yes_ranges = ARRAY_SIZE(ar9331_valid_regs),
993};
994
995static const struct regmap_access_table ar9331_volatile_set = {
996 .no_ranges = ar9331_nonvolatile_regs,
997 .n_no_ranges = ARRAY_SIZE(ar9331_nonvolatile_regs),
998};
999
1000static const struct regmap_config ar9331_mdio_regmap_config = {
1001 .reg_bits = 32,
1002 .val_bits = 32,
1003 .reg_stride = 4,
1004 .max_register = AR9331_SW_REG_PAGE,
1005 .use_single_read = true,
1006 .use_single_write = true,
1007
1008 .ranges = ar9331_regmap_range,
1009 .num_ranges = ARRAY_SIZE(ar9331_regmap_range),
1010
1011 .volatile_table = &ar9331_volatile_set,
1012 .wr_table = &ar9331_register_set,
1013 .rd_table = &ar9331_register_set,
1014
1015 .cache_type = REGCACHE_MAPLE,
1016};
1017
1018static struct regmap_bus ar9331_sw_bus = {
1019 .reg_format_endian_default = REGMAP_ENDIAN_NATIVE,
1020 .val_format_endian_default = REGMAP_ENDIAN_NATIVE,
1021 .read = ar9331_mdio_read,
1022 .write = ar9331_sw_bus_write,
1023};
1024
1025static int ar9331_sw_probe(struct mdio_device *mdiodev)
1026{
1027 struct ar9331_sw_priv *priv;
1028 struct dsa_switch *ds;
1029 int ret, i;
1030
1031 priv = devm_kzalloc(&mdiodev->dev, sizeof(*priv), GFP_KERNEL);
1032 if (!priv)
1033 return -ENOMEM;
1034
1035 priv->regmap = devm_regmap_init(&mdiodev->dev, &ar9331_sw_bus, priv,
1036 &ar9331_mdio_regmap_config);
1037 if (IS_ERR(priv->regmap)) {
1038 ret = PTR_ERR(priv->regmap);
1039 dev_err(&mdiodev->dev, "regmap init failed: %d\n", ret);
1040 return ret;
1041 }
1042
1043 priv->sw_reset = devm_reset_control_get(&mdiodev->dev, "switch");
1044 if (IS_ERR(priv->sw_reset)) {
1045 dev_err(&mdiodev->dev, "missing switch reset\n");
1046 return PTR_ERR(priv->sw_reset);
1047 }
1048
1049 priv->sbus = mdiodev->bus;
1050 priv->dev = &mdiodev->dev;
1051
1052 ret = ar9331_sw_irq_init(priv);
1053 if (ret)
1054 return ret;
1055
1056 ds = &priv->ds;
1057 ds->dev = &mdiodev->dev;
1058 ds->num_ports = AR9331_SW_PORTS;
1059 ds->priv = priv;
1060 priv->ops = ar9331_sw_ops;
1061 ds->ops = &priv->ops;
1062 dev_set_drvdata(&mdiodev->dev, priv);
1063
1064 for (i = 0; i < ARRAY_SIZE(priv->port); i++) {
1065 struct ar9331_sw_port *port = &priv->port[i];
1066
1067 port->idx = i;
1068 spin_lock_init(&port->stats_lock);
1069 INIT_DELAYED_WORK(&port->mib_read, ar9331_do_stats_poll);
1070 }
1071
1072 ret = dsa_register_switch(ds);
1073 if (ret)
1074 goto err_remove_irq;
1075
1076 return 0;
1077
1078err_remove_irq:
1079 irq_domain_remove(priv->irqdomain);
1080
1081 return ret;
1082}
1083
1084static void ar9331_sw_remove(struct mdio_device *mdiodev)
1085{
1086 struct ar9331_sw_priv *priv = dev_get_drvdata(&mdiodev->dev);
1087 unsigned int i;
1088
1089 if (!priv)
1090 return;
1091
1092 for (i = 0; i < ARRAY_SIZE(priv->port); i++) {
1093 struct ar9331_sw_port *port = &priv->port[i];
1094
1095 cancel_delayed_work_sync(&port->mib_read);
1096 }
1097
1098 irq_domain_remove(priv->irqdomain);
1099 dsa_unregister_switch(&priv->ds);
1100
1101 reset_control_assert(priv->sw_reset);
1102}
1103
1104static void ar9331_sw_shutdown(struct mdio_device *mdiodev)
1105{
1106 struct ar9331_sw_priv *priv = dev_get_drvdata(&mdiodev->dev);
1107
1108 if (!priv)
1109 return;
1110
1111 dsa_switch_shutdown(&priv->ds);
1112
1113 dev_set_drvdata(&mdiodev->dev, NULL);
1114}
1115
1116static const struct of_device_id ar9331_sw_of_match[] = {
1117 { .compatible = "qca,ar9331-switch" },
1118 { },
1119};
1120
1121static struct mdio_driver ar9331_sw_mdio_driver = {
1122 .probe = ar9331_sw_probe,
1123 .remove = ar9331_sw_remove,
1124 .shutdown = ar9331_sw_shutdown,
1125 .mdiodrv.driver = {
1126 .name = AR9331_SW_NAME,
1127 .of_match_table = ar9331_sw_of_match,
1128 },
1129};
1130
1131mdio_module_driver(ar9331_sw_mdio_driver);
1132
1133MODULE_AUTHOR("Oleksij Rempel <kernel@pengutronix.de>");
1134MODULE_DESCRIPTION("Driver for Atheros AR9331 switch");
1135MODULE_LICENSE("GPL v2");
1// SPDX-License-Identifier: GPL-2.0-only
2// Copyright (c) 2019 Pengutronix, Oleksij Rempel <kernel@pengutronix.de>
3/*
4 * +----------------------+
5 * GMAC1----RGMII----|--MAC0 |
6 * \---MDIO1----|--REGs |----MDIO3----\
7 * | | | +------+
8 * | | +--| |
9 * | MAC1-|----RMII--M-----| PHY0 |-o P0
10 * | | | | +------+
11 * | | | +--| |
12 * | MAC2-|----RMII--------| PHY1 |-o P1
13 * | | | | +------+
14 * | | | +--| |
15 * | MAC3-|----RMII--------| PHY2 |-o P2
16 * | | | | +------+
17 * | | | +--| |
18 * | MAC4-|----RMII--------| PHY3 |-o P3
19 * | | | | +------+
20 * | | | +--| |
21 * | MAC5-|--+-RMII--M-----|-PHY4-|-o P4
22 * | | | | +------+
23 * +----------------------+ | \--CFG_SW_PHY_SWAP
24 * GMAC0---------------RMII--------------------/ \-CFG_SW_PHY_ADDR_SWAP
25 * \---MDIO0--NC
26 *
27 * GMAC0 and MAC5 are connected together and use same PHY. Depending on
28 * configuration it can be PHY4 (default) or PHY0. Only GMAC0 or MAC5 can be
29 * used at same time. If GMAC0 is used (default) then MAC5 should be disabled.
30 *
31 * CFG_SW_PHY_SWAP - swap connections of PHY0 and PHY4. If this bit is not set
32 * PHY4 is connected to GMAC0/MAC5 bundle and PHY0 is connected to MAC1. If this
33 * bit is set, PHY4 is connected to MAC1 and PHY0 is connected to GMAC0/MAC5
34 * bundle.
35 *
36 * CFG_SW_PHY_ADDR_SWAP - swap addresses of PHY0 and PHY4
37 *
38 * CFG_SW_PHY_SWAP and CFG_SW_PHY_ADDR_SWAP are part of SoC specific register
39 * set and not related to switch internal registers.
40 */
41
42#include <linux/bitfield.h>
43#include <linux/module.h>
44#include <linux/of_irq.h>
45#include <linux/of_mdio.h>
46#include <linux/regmap.h>
47#include <linux/reset.h>
48#include <net/dsa.h>
49
50#define AR9331_SW_NAME "ar9331_switch"
51#define AR9331_SW_PORTS 6
52
53/* dummy reg to change page */
54#define AR9331_SW_REG_PAGE 0x40000
55
56/* Global Interrupt */
57#define AR9331_SW_REG_GINT 0x10
58#define AR9331_SW_REG_GINT_MASK 0x14
59#define AR9331_SW_GINT_PHY_INT BIT(2)
60
61#define AR9331_SW_REG_FLOOD_MASK 0x2c
62#define AR9331_SW_FLOOD_MASK_BROAD_TO_CPU BIT(26)
63
64#define AR9331_SW_REG_GLOBAL_CTRL 0x30
65#define AR9331_SW_GLOBAL_CTRL_MFS_M GENMASK(13, 0)
66
67#define AR9331_SW_REG_MDIO_CTRL 0x98
68#define AR9331_SW_MDIO_CTRL_BUSY BIT(31)
69#define AR9331_SW_MDIO_CTRL_MASTER_EN BIT(30)
70#define AR9331_SW_MDIO_CTRL_CMD_READ BIT(27)
71#define AR9331_SW_MDIO_CTRL_PHY_ADDR_M GENMASK(25, 21)
72#define AR9331_SW_MDIO_CTRL_REG_ADDR_M GENMASK(20, 16)
73#define AR9331_SW_MDIO_CTRL_DATA_M GENMASK(16, 0)
74
75#define AR9331_SW_REG_PORT_STATUS(_port) (0x100 + (_port) * 0x100)
76
77/* FLOW_LINK_EN - enable mac flow control config auto-neg with phy.
78 * If not set, mac can be config by software.
79 */
80#define AR9331_SW_PORT_STATUS_FLOW_LINK_EN BIT(12)
81
82/* LINK_EN - If set, MAC is configured from PHY link status.
83 * If not set, MAC should be configured by software.
84 */
85#define AR9331_SW_PORT_STATUS_LINK_EN BIT(9)
86#define AR9331_SW_PORT_STATUS_DUPLEX_MODE BIT(6)
87#define AR9331_SW_PORT_STATUS_RX_FLOW_EN BIT(5)
88#define AR9331_SW_PORT_STATUS_TX_FLOW_EN BIT(4)
89#define AR9331_SW_PORT_STATUS_RXMAC BIT(3)
90#define AR9331_SW_PORT_STATUS_TXMAC BIT(2)
91#define AR9331_SW_PORT_STATUS_SPEED_M GENMASK(1, 0)
92#define AR9331_SW_PORT_STATUS_SPEED_1000 2
93#define AR9331_SW_PORT_STATUS_SPEED_100 1
94#define AR9331_SW_PORT_STATUS_SPEED_10 0
95
96#define AR9331_SW_PORT_STATUS_MAC_MASK \
97 (AR9331_SW_PORT_STATUS_TXMAC | AR9331_SW_PORT_STATUS_RXMAC)
98
99#define AR9331_SW_PORT_STATUS_LINK_MASK \
100 (AR9331_SW_PORT_STATUS_DUPLEX_MODE | \
101 AR9331_SW_PORT_STATUS_RX_FLOW_EN | AR9331_SW_PORT_STATUS_TX_FLOW_EN | \
102 AR9331_SW_PORT_STATUS_SPEED_M)
103
104/* Phy bypass mode
105 * ------------------------------------------------------------------------
106 * Bit: | 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 |10 |11 |12 |13 |14 |15 |
107 *
108 * real | start | OP | PhyAddr | Reg Addr | TA |
109 * atheros| start | OP | 2'b00 |PhyAdd[2:0]| Reg Addr[4:0] | TA |
110 *
111 *
112 * Bit: |16 |17 |18 |19 |20 |21 |22 |23 |24 |25 |26 |27 |28 |29 |30 |31 |
113 * real | Data |
114 * atheros| Data |
115 *
116 * ------------------------------------------------------------------------
117 * Page address mode
118 * ------------------------------------------------------------------------
119 * Bit: | 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 |10 |11 |12 |13 |14 |15 |
120 * real | start | OP | PhyAddr | Reg Addr | TA |
121 * atheros| start | OP | 2'b11 | 8'b0 | TA |
122 *
123 * Bit: |16 |17 |18 |19 |20 |21 |22 |23 |24 |25 |26 |27 |28 |29 |30 |31 |
124 * real | Data |
125 * atheros| | Page [9:0] |
126 */
127/* In case of Page Address mode, Bit[18:9] of 32 bit register address should be
128 * written to bits[9:0] of mdio data register.
129 */
130#define AR9331_SW_ADDR_PAGE GENMASK(18, 9)
131
132/* ------------------------------------------------------------------------
133 * Normal register access mode
134 * ------------------------------------------------------------------------
135 * Bit: | 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 |10 |11 |12 |13 |14 |15 |
136 * real | start | OP | PhyAddr | Reg Addr | TA |
137 * atheros| start | OP | 2'b10 | low_addr[7:0] | TA |
138 *
139 * Bit: |16 |17 |18 |19 |20 |21 |22 |23 |24 |25 |26 |27 |28 |29 |30 |31 |
140 * real | Data |
141 * atheros| Data |
142 * ------------------------------------------------------------------------
143 */
144#define AR9331_SW_LOW_ADDR_PHY GENMASK(8, 6)
145#define AR9331_SW_LOW_ADDR_REG GENMASK(5, 1)
146
147#define AR9331_SW_MDIO_PHY_MODE_M GENMASK(4, 3)
148#define AR9331_SW_MDIO_PHY_MODE_PAGE 3
149#define AR9331_SW_MDIO_PHY_MODE_REG 2
150#define AR9331_SW_MDIO_PHY_MODE_BYPASS 0
151#define AR9331_SW_MDIO_PHY_ADDR_M GENMASK(2, 0)
152
153/* Empirical determined values */
154#define AR9331_SW_MDIO_POLL_SLEEP_US 1
155#define AR9331_SW_MDIO_POLL_TIMEOUT_US 20
156
157struct ar9331_sw_priv {
158 struct device *dev;
159 struct dsa_switch ds;
160 struct dsa_switch_ops ops;
161 struct irq_domain *irqdomain;
162 struct mii_bus *mbus; /* mdio master */
163 struct mii_bus *sbus; /* mdio slave */
164 struct regmap *regmap;
165 struct reset_control *sw_reset;
166};
167
168/* Warning: switch reset will reset last AR9331_SW_MDIO_PHY_MODE_PAGE request
169 * If some kind of optimization is used, the request should be repeated.
170 */
171static int ar9331_sw_reset(struct ar9331_sw_priv *priv)
172{
173 int ret;
174
175 ret = reset_control_assert(priv->sw_reset);
176 if (ret)
177 goto error;
178
179 /* AR9331 doc do not provide any information about proper reset
180 * sequence. The AR8136 (the closes switch to the AR9331) doc says:
181 * reset duration should be greater than 10ms. So, let's use this value
182 * for now.
183 */
184 usleep_range(10000, 15000);
185 ret = reset_control_deassert(priv->sw_reset);
186 if (ret)
187 goto error;
188 /* There is no information on how long should we wait after reset.
189 * AR8136 has an EEPROM and there is an Interrupt for EEPROM load
190 * status. AR9331 has no EEPROM support.
191 * For now, do not wait. In case AR8136 will be needed, the after
192 * reset delay can be added as well.
193 */
194
195 return 0;
196error:
197 dev_err_ratelimited(priv->dev, "%s: %i\n", __func__, ret);
198 return ret;
199}
200
201static int ar9331_sw_mbus_write(struct mii_bus *mbus, int port, int regnum,
202 u16 data)
203{
204 struct ar9331_sw_priv *priv = mbus->priv;
205 struct regmap *regmap = priv->regmap;
206 u32 val;
207 int ret;
208
209 ret = regmap_write(regmap, AR9331_SW_REG_MDIO_CTRL,
210 AR9331_SW_MDIO_CTRL_BUSY |
211 AR9331_SW_MDIO_CTRL_MASTER_EN |
212 FIELD_PREP(AR9331_SW_MDIO_CTRL_PHY_ADDR_M, port) |
213 FIELD_PREP(AR9331_SW_MDIO_CTRL_REG_ADDR_M, regnum) |
214 FIELD_PREP(AR9331_SW_MDIO_CTRL_DATA_M, data));
215 if (ret)
216 goto error;
217
218 ret = regmap_read_poll_timeout(regmap, AR9331_SW_REG_MDIO_CTRL, val,
219 !(val & AR9331_SW_MDIO_CTRL_BUSY),
220 AR9331_SW_MDIO_POLL_SLEEP_US,
221 AR9331_SW_MDIO_POLL_TIMEOUT_US);
222 if (ret)
223 goto error;
224
225 return 0;
226error:
227 dev_err_ratelimited(priv->dev, "PHY write error: %i\n", ret);
228 return ret;
229}
230
231static int ar9331_sw_mbus_read(struct mii_bus *mbus, int port, int regnum)
232{
233 struct ar9331_sw_priv *priv = mbus->priv;
234 struct regmap *regmap = priv->regmap;
235 u32 val;
236 int ret;
237
238 ret = regmap_write(regmap, AR9331_SW_REG_MDIO_CTRL,
239 AR9331_SW_MDIO_CTRL_BUSY |
240 AR9331_SW_MDIO_CTRL_MASTER_EN |
241 AR9331_SW_MDIO_CTRL_CMD_READ |
242 FIELD_PREP(AR9331_SW_MDIO_CTRL_PHY_ADDR_M, port) |
243 FIELD_PREP(AR9331_SW_MDIO_CTRL_REG_ADDR_M, regnum));
244 if (ret)
245 goto error;
246
247 ret = regmap_read_poll_timeout(regmap, AR9331_SW_REG_MDIO_CTRL, val,
248 !(val & AR9331_SW_MDIO_CTRL_BUSY),
249 AR9331_SW_MDIO_POLL_SLEEP_US,
250 AR9331_SW_MDIO_POLL_TIMEOUT_US);
251 if (ret)
252 goto error;
253
254 ret = regmap_read(regmap, AR9331_SW_REG_MDIO_CTRL, &val);
255 if (ret)
256 goto error;
257
258 return FIELD_GET(AR9331_SW_MDIO_CTRL_DATA_M, val);
259
260error:
261 dev_err_ratelimited(priv->dev, "PHY read error: %i\n", ret);
262 return ret;
263}
264
265static int ar9331_sw_mbus_init(struct ar9331_sw_priv *priv)
266{
267 struct device *dev = priv->dev;
268 struct mii_bus *mbus;
269 struct device_node *np, *mnp;
270 int ret;
271
272 np = dev->of_node;
273
274 mbus = devm_mdiobus_alloc(dev);
275 if (!mbus)
276 return -ENOMEM;
277
278 mbus->name = np->full_name;
279 snprintf(mbus->id, MII_BUS_ID_SIZE, "%pOF", np);
280
281 mbus->read = ar9331_sw_mbus_read;
282 mbus->write = ar9331_sw_mbus_write;
283 mbus->priv = priv;
284 mbus->parent = dev;
285
286 mnp = of_get_child_by_name(np, "mdio");
287 if (!mnp)
288 return -ENODEV;
289
290 ret = of_mdiobus_register(mbus, mnp);
291 of_node_put(mnp);
292 if (ret)
293 return ret;
294
295 priv->mbus = mbus;
296
297 return 0;
298}
299
300static int ar9331_sw_setup(struct dsa_switch *ds)
301{
302 struct ar9331_sw_priv *priv = (struct ar9331_sw_priv *)ds->priv;
303 struct regmap *regmap = priv->regmap;
304 int ret;
305
306 ret = ar9331_sw_reset(priv);
307 if (ret)
308 return ret;
309
310 /* Reset will set proper defaults. CPU - Port0 will be enabled and
311 * configured. All other ports (ports 1 - 5) are disabled
312 */
313 ret = ar9331_sw_mbus_init(priv);
314 if (ret)
315 return ret;
316
317 /* Do not drop broadcast frames */
318 ret = regmap_write_bits(regmap, AR9331_SW_REG_FLOOD_MASK,
319 AR9331_SW_FLOOD_MASK_BROAD_TO_CPU,
320 AR9331_SW_FLOOD_MASK_BROAD_TO_CPU);
321 if (ret)
322 goto error;
323
324 /* Set max frame size to the maximum supported value */
325 ret = regmap_write_bits(regmap, AR9331_SW_REG_GLOBAL_CTRL,
326 AR9331_SW_GLOBAL_CTRL_MFS_M,
327 AR9331_SW_GLOBAL_CTRL_MFS_M);
328 if (ret)
329 goto error;
330
331 return 0;
332error:
333 dev_err_ratelimited(priv->dev, "%s: %i\n", __func__, ret);
334 return ret;
335}
336
337static void ar9331_sw_port_disable(struct dsa_switch *ds, int port)
338{
339 struct ar9331_sw_priv *priv = (struct ar9331_sw_priv *)ds->priv;
340 struct regmap *regmap = priv->regmap;
341 int ret;
342
343 ret = regmap_write(regmap, AR9331_SW_REG_PORT_STATUS(port), 0);
344 if (ret)
345 dev_err_ratelimited(priv->dev, "%s: %i\n", __func__, ret);
346}
347
348static enum dsa_tag_protocol ar9331_sw_get_tag_protocol(struct dsa_switch *ds,
349 int port,
350 enum dsa_tag_protocol m)
351{
352 return DSA_TAG_PROTO_AR9331;
353}
354
355static void ar9331_sw_phylink_validate(struct dsa_switch *ds, int port,
356 unsigned long *supported,
357 struct phylink_link_state *state)
358{
359 __ETHTOOL_DECLARE_LINK_MODE_MASK(mask) = { 0, };
360
361 switch (port) {
362 case 0:
363 if (state->interface != PHY_INTERFACE_MODE_GMII)
364 goto unsupported;
365
366 phylink_set(mask, 1000baseT_Full);
367 phylink_set(mask, 1000baseT_Half);
368 break;
369 case 1:
370 case 2:
371 case 3:
372 case 4:
373 case 5:
374 if (state->interface != PHY_INTERFACE_MODE_INTERNAL)
375 goto unsupported;
376 break;
377 default:
378 bitmap_zero(supported, __ETHTOOL_LINK_MODE_MASK_NBITS);
379 dev_err(ds->dev, "Unsupported port: %i\n", port);
380 return;
381 }
382
383 phylink_set_port_modes(mask);
384 phylink_set(mask, Pause);
385 phylink_set(mask, Asym_Pause);
386
387 phylink_set(mask, 10baseT_Half);
388 phylink_set(mask, 10baseT_Full);
389 phylink_set(mask, 100baseT_Half);
390 phylink_set(mask, 100baseT_Full);
391
392 bitmap_and(supported, supported, mask,
393 __ETHTOOL_LINK_MODE_MASK_NBITS);
394 bitmap_and(state->advertising, state->advertising, mask,
395 __ETHTOOL_LINK_MODE_MASK_NBITS);
396
397 return;
398
399unsupported:
400 bitmap_zero(supported, __ETHTOOL_LINK_MODE_MASK_NBITS);
401 dev_err(ds->dev, "Unsupported interface: %d, port: %d\n",
402 state->interface, port);
403}
404
405static void ar9331_sw_phylink_mac_config(struct dsa_switch *ds, int port,
406 unsigned int mode,
407 const struct phylink_link_state *state)
408{
409 struct ar9331_sw_priv *priv = (struct ar9331_sw_priv *)ds->priv;
410 struct regmap *regmap = priv->regmap;
411 int ret;
412
413 ret = regmap_update_bits(regmap, AR9331_SW_REG_PORT_STATUS(port),
414 AR9331_SW_PORT_STATUS_LINK_EN |
415 AR9331_SW_PORT_STATUS_FLOW_LINK_EN, 0);
416 if (ret)
417 dev_err_ratelimited(priv->dev, "%s: %i\n", __func__, ret);
418}
419
420static void ar9331_sw_phylink_mac_link_down(struct dsa_switch *ds, int port,
421 unsigned int mode,
422 phy_interface_t interface)
423{
424 struct ar9331_sw_priv *priv = (struct ar9331_sw_priv *)ds->priv;
425 struct regmap *regmap = priv->regmap;
426 int ret;
427
428 ret = regmap_update_bits(regmap, AR9331_SW_REG_PORT_STATUS(port),
429 AR9331_SW_PORT_STATUS_MAC_MASK, 0);
430 if (ret)
431 dev_err_ratelimited(priv->dev, "%s: %i\n", __func__, ret);
432}
433
434static void ar9331_sw_phylink_mac_link_up(struct dsa_switch *ds, int port,
435 unsigned int mode,
436 phy_interface_t interface,
437 struct phy_device *phydev,
438 int speed, int duplex,
439 bool tx_pause, bool rx_pause)
440{
441 struct ar9331_sw_priv *priv = (struct ar9331_sw_priv *)ds->priv;
442 struct regmap *regmap = priv->regmap;
443 u32 val;
444 int ret;
445
446 val = AR9331_SW_PORT_STATUS_MAC_MASK;
447 switch (speed) {
448 case SPEED_1000:
449 val |= AR9331_SW_PORT_STATUS_SPEED_1000;
450 break;
451 case SPEED_100:
452 val |= AR9331_SW_PORT_STATUS_SPEED_100;
453 break;
454 case SPEED_10:
455 val |= AR9331_SW_PORT_STATUS_SPEED_10;
456 break;
457 default:
458 return;
459 }
460
461 if (duplex)
462 val |= AR9331_SW_PORT_STATUS_DUPLEX_MODE;
463
464 if (tx_pause)
465 val |= AR9331_SW_PORT_STATUS_TX_FLOW_EN;
466
467 if (rx_pause)
468 val |= AR9331_SW_PORT_STATUS_RX_FLOW_EN;
469
470 ret = regmap_update_bits(regmap, AR9331_SW_REG_PORT_STATUS(port),
471 AR9331_SW_PORT_STATUS_MAC_MASK |
472 AR9331_SW_PORT_STATUS_LINK_MASK,
473 val);
474 if (ret)
475 dev_err_ratelimited(priv->dev, "%s: %i\n", __func__, ret);
476}
477
478static const struct dsa_switch_ops ar9331_sw_ops = {
479 .get_tag_protocol = ar9331_sw_get_tag_protocol,
480 .setup = ar9331_sw_setup,
481 .port_disable = ar9331_sw_port_disable,
482 .phylink_validate = ar9331_sw_phylink_validate,
483 .phylink_mac_config = ar9331_sw_phylink_mac_config,
484 .phylink_mac_link_down = ar9331_sw_phylink_mac_link_down,
485 .phylink_mac_link_up = ar9331_sw_phylink_mac_link_up,
486};
487
488static irqreturn_t ar9331_sw_irq(int irq, void *data)
489{
490 struct ar9331_sw_priv *priv = data;
491 struct regmap *regmap = priv->regmap;
492 u32 stat;
493 int ret;
494
495 ret = regmap_read(regmap, AR9331_SW_REG_GINT, &stat);
496 if (ret) {
497 dev_err(priv->dev, "can't read interrupt status\n");
498 return IRQ_NONE;
499 }
500
501 if (!stat)
502 return IRQ_NONE;
503
504 if (stat & AR9331_SW_GINT_PHY_INT) {
505 int child_irq;
506
507 child_irq = irq_find_mapping(priv->irqdomain, 0);
508 handle_nested_irq(child_irq);
509 }
510
511 ret = regmap_write(regmap, AR9331_SW_REG_GINT, stat);
512 if (ret) {
513 dev_err(priv->dev, "can't write interrupt status\n");
514 return IRQ_NONE;
515 }
516
517 return IRQ_HANDLED;
518}
519
520static void ar9331_sw_mask_irq(struct irq_data *d)
521{
522 struct ar9331_sw_priv *priv = irq_data_get_irq_chip_data(d);
523 struct regmap *regmap = priv->regmap;
524 int ret;
525
526 ret = regmap_update_bits(regmap, AR9331_SW_REG_GINT_MASK,
527 AR9331_SW_GINT_PHY_INT, 0);
528 if (ret)
529 dev_err(priv->dev, "could not mask IRQ\n");
530}
531
532static void ar9331_sw_unmask_irq(struct irq_data *d)
533{
534 struct ar9331_sw_priv *priv = irq_data_get_irq_chip_data(d);
535 struct regmap *regmap = priv->regmap;
536 int ret;
537
538 ret = regmap_update_bits(regmap, AR9331_SW_REG_GINT_MASK,
539 AR9331_SW_GINT_PHY_INT,
540 AR9331_SW_GINT_PHY_INT);
541 if (ret)
542 dev_err(priv->dev, "could not unmask IRQ\n");
543}
544
545static struct irq_chip ar9331_sw_irq_chip = {
546 .name = AR9331_SW_NAME,
547 .irq_mask = ar9331_sw_mask_irq,
548 .irq_unmask = ar9331_sw_unmask_irq,
549};
550
551static int ar9331_sw_irq_map(struct irq_domain *domain, unsigned int irq,
552 irq_hw_number_t hwirq)
553{
554 irq_set_chip_data(irq, domain->host_data);
555 irq_set_chip_and_handler(irq, &ar9331_sw_irq_chip, handle_simple_irq);
556 irq_set_nested_thread(irq, 1);
557 irq_set_noprobe(irq);
558
559 return 0;
560}
561
562static void ar9331_sw_irq_unmap(struct irq_domain *d, unsigned int irq)
563{
564 irq_set_nested_thread(irq, 0);
565 irq_set_chip_and_handler(irq, NULL, NULL);
566 irq_set_chip_data(irq, NULL);
567}
568
569static const struct irq_domain_ops ar9331_sw_irqdomain_ops = {
570 .map = ar9331_sw_irq_map,
571 .unmap = ar9331_sw_irq_unmap,
572 .xlate = irq_domain_xlate_onecell,
573};
574
575static int ar9331_sw_irq_init(struct ar9331_sw_priv *priv)
576{
577 struct device_node *np = priv->dev->of_node;
578 struct device *dev = priv->dev;
579 int ret, irq;
580
581 irq = of_irq_get(np, 0);
582 if (irq <= 0) {
583 dev_err(dev, "failed to get parent IRQ\n");
584 return irq ? irq : -EINVAL;
585 }
586
587 ret = devm_request_threaded_irq(dev, irq, NULL, ar9331_sw_irq,
588 IRQF_ONESHOT, AR9331_SW_NAME, priv);
589 if (ret) {
590 dev_err(dev, "unable to request irq: %d\n", ret);
591 return ret;
592 }
593
594 priv->irqdomain = irq_domain_add_linear(np, 1, &ar9331_sw_irqdomain_ops,
595 priv);
596 if (!priv->irqdomain) {
597 dev_err(dev, "failed to create IRQ domain\n");
598 return -EINVAL;
599 }
600
601 irq_set_parent(irq_create_mapping(priv->irqdomain, 0), irq);
602
603 return 0;
604}
605
606static int __ar9331_mdio_write(struct mii_bus *sbus, u8 mode, u16 reg, u16 val)
607{
608 u8 r, p;
609
610 p = FIELD_PREP(AR9331_SW_MDIO_PHY_MODE_M, mode) |
611 FIELD_GET(AR9331_SW_LOW_ADDR_PHY, reg);
612 r = FIELD_GET(AR9331_SW_LOW_ADDR_REG, reg);
613
614 return mdiobus_write(sbus, p, r, val);
615}
616
617static int __ar9331_mdio_read(struct mii_bus *sbus, u16 reg)
618{
619 u8 r, p;
620
621 p = FIELD_PREP(AR9331_SW_MDIO_PHY_MODE_M, AR9331_SW_MDIO_PHY_MODE_REG) |
622 FIELD_GET(AR9331_SW_LOW_ADDR_PHY, reg);
623 r = FIELD_GET(AR9331_SW_LOW_ADDR_REG, reg);
624
625 return mdiobus_read(sbus, p, r);
626}
627
628static int ar9331_mdio_read(void *ctx, const void *reg_buf, size_t reg_len,
629 void *val_buf, size_t val_len)
630{
631 struct ar9331_sw_priv *priv = ctx;
632 struct mii_bus *sbus = priv->sbus;
633 u32 reg = *(u32 *)reg_buf;
634 int ret;
635
636 if (reg == AR9331_SW_REG_PAGE) {
637 /* We cannot read the page selector register from hardware and
638 * we cache its value in regmap. Return all bits set here,
639 * that regmap will always write the page on first use.
640 */
641 *(u32 *)val_buf = GENMASK(9, 0);
642 return 0;
643 }
644
645 ret = __ar9331_mdio_read(sbus, reg);
646 if (ret < 0)
647 goto error;
648
649 *(u32 *)val_buf = ret;
650 ret = __ar9331_mdio_read(sbus, reg + 2);
651 if (ret < 0)
652 goto error;
653
654 *(u32 *)val_buf |= ret << 16;
655
656 return 0;
657error:
658 dev_err_ratelimited(&sbus->dev, "Bus error. Failed to read register.\n");
659 return ret;
660}
661
662static int ar9331_mdio_write(void *ctx, u32 reg, u32 val)
663{
664 struct ar9331_sw_priv *priv = (struct ar9331_sw_priv *)ctx;
665 struct mii_bus *sbus = priv->sbus;
666 int ret;
667
668 if (reg == AR9331_SW_REG_PAGE) {
669 ret = __ar9331_mdio_write(sbus, AR9331_SW_MDIO_PHY_MODE_PAGE,
670 0, val);
671 if (ret < 0)
672 goto error;
673
674 return 0;
675 }
676
677 ret = __ar9331_mdio_write(sbus, AR9331_SW_MDIO_PHY_MODE_REG, reg, val);
678 if (ret < 0)
679 goto error;
680
681 ret = __ar9331_mdio_write(sbus, AR9331_SW_MDIO_PHY_MODE_REG, reg + 2,
682 val >> 16);
683 if (ret < 0)
684 goto error;
685
686 return 0;
687error:
688 dev_err_ratelimited(&sbus->dev, "Bus error. Failed to write register.\n");
689 return ret;
690}
691
692static int ar9331_sw_bus_write(void *context, const void *data, size_t count)
693{
694 u32 reg = *(u32 *)data;
695 u32 val = *((u32 *)data + 1);
696
697 return ar9331_mdio_write(context, reg, val);
698}
699
700static const struct regmap_range ar9331_valid_regs[] = {
701 regmap_reg_range(0x0, 0x0),
702 regmap_reg_range(0x10, 0x14),
703 regmap_reg_range(0x20, 0x24),
704 regmap_reg_range(0x2c, 0x30),
705 regmap_reg_range(0x40, 0x44),
706 regmap_reg_range(0x50, 0x78),
707 regmap_reg_range(0x80, 0x98),
708
709 regmap_reg_range(0x100, 0x120),
710 regmap_reg_range(0x200, 0x220),
711 regmap_reg_range(0x300, 0x320),
712 regmap_reg_range(0x400, 0x420),
713 regmap_reg_range(0x500, 0x520),
714 regmap_reg_range(0x600, 0x620),
715
716 regmap_reg_range(0x20000, 0x200a4),
717 regmap_reg_range(0x20100, 0x201a4),
718 regmap_reg_range(0x20200, 0x202a4),
719 regmap_reg_range(0x20300, 0x203a4),
720 regmap_reg_range(0x20400, 0x204a4),
721 regmap_reg_range(0x20500, 0x205a4),
722
723 /* dummy page selector reg */
724 regmap_reg_range(AR9331_SW_REG_PAGE, AR9331_SW_REG_PAGE),
725};
726
727static const struct regmap_range ar9331_nonvolatile_regs[] = {
728 regmap_reg_range(AR9331_SW_REG_PAGE, AR9331_SW_REG_PAGE),
729};
730
731static const struct regmap_range_cfg ar9331_regmap_range[] = {
732 {
733 .selector_reg = AR9331_SW_REG_PAGE,
734 .selector_mask = GENMASK(9, 0),
735 .selector_shift = 0,
736
737 .window_start = 0,
738 .window_len = 512,
739
740 .range_min = 0,
741 .range_max = AR9331_SW_REG_PAGE - 4,
742 },
743};
744
745static const struct regmap_access_table ar9331_register_set = {
746 .yes_ranges = ar9331_valid_regs,
747 .n_yes_ranges = ARRAY_SIZE(ar9331_valid_regs),
748};
749
750static const struct regmap_access_table ar9331_volatile_set = {
751 .no_ranges = ar9331_nonvolatile_regs,
752 .n_no_ranges = ARRAY_SIZE(ar9331_nonvolatile_regs),
753};
754
755static const struct regmap_config ar9331_mdio_regmap_config = {
756 .reg_bits = 32,
757 .val_bits = 32,
758 .reg_stride = 4,
759 .max_register = AR9331_SW_REG_PAGE,
760
761 .ranges = ar9331_regmap_range,
762 .num_ranges = ARRAY_SIZE(ar9331_regmap_range),
763
764 .volatile_table = &ar9331_volatile_set,
765 .wr_table = &ar9331_register_set,
766 .rd_table = &ar9331_register_set,
767
768 .cache_type = REGCACHE_RBTREE,
769};
770
771static struct regmap_bus ar9331_sw_bus = {
772 .reg_format_endian_default = REGMAP_ENDIAN_NATIVE,
773 .val_format_endian_default = REGMAP_ENDIAN_NATIVE,
774 .read = ar9331_mdio_read,
775 .write = ar9331_sw_bus_write,
776 .max_raw_read = 4,
777 .max_raw_write = 4,
778};
779
780static int ar9331_sw_probe(struct mdio_device *mdiodev)
781{
782 struct ar9331_sw_priv *priv;
783 struct dsa_switch *ds;
784 int ret;
785
786 priv = devm_kzalloc(&mdiodev->dev, sizeof(*priv), GFP_KERNEL);
787 if (!priv)
788 return -ENOMEM;
789
790 priv->regmap = devm_regmap_init(&mdiodev->dev, &ar9331_sw_bus, priv,
791 &ar9331_mdio_regmap_config);
792 if (IS_ERR(priv->regmap)) {
793 ret = PTR_ERR(priv->regmap);
794 dev_err(&mdiodev->dev, "regmap init failed: %d\n", ret);
795 return ret;
796 }
797
798 priv->sw_reset = devm_reset_control_get(&mdiodev->dev, "switch");
799 if (IS_ERR(priv->sw_reset)) {
800 dev_err(&mdiodev->dev, "missing switch reset\n");
801 return PTR_ERR(priv->sw_reset);
802 }
803
804 priv->sbus = mdiodev->bus;
805 priv->dev = &mdiodev->dev;
806
807 ret = ar9331_sw_irq_init(priv);
808 if (ret)
809 return ret;
810
811 ds = &priv->ds;
812 ds->dev = &mdiodev->dev;
813 ds->num_ports = AR9331_SW_PORTS;
814 ds->priv = priv;
815 priv->ops = ar9331_sw_ops;
816 ds->ops = &priv->ops;
817 dev_set_drvdata(&mdiodev->dev, priv);
818
819 ret = dsa_register_switch(ds);
820 if (ret)
821 goto err_remove_irq;
822
823 return 0;
824
825err_remove_irq:
826 irq_domain_remove(priv->irqdomain);
827
828 return ret;
829}
830
831static void ar9331_sw_remove(struct mdio_device *mdiodev)
832{
833 struct ar9331_sw_priv *priv = dev_get_drvdata(&mdiodev->dev);
834
835 irq_domain_remove(priv->irqdomain);
836 mdiobus_unregister(priv->mbus);
837 dsa_unregister_switch(&priv->ds);
838
839 reset_control_assert(priv->sw_reset);
840}
841
842static const struct of_device_id ar9331_sw_of_match[] = {
843 { .compatible = "qca,ar9331-switch" },
844 { },
845};
846
847static struct mdio_driver ar9331_sw_mdio_driver = {
848 .probe = ar9331_sw_probe,
849 .remove = ar9331_sw_remove,
850 .mdiodrv.driver = {
851 .name = AR9331_SW_NAME,
852 .of_match_table = ar9331_sw_of_match,
853 },
854};
855
856mdio_module_driver(ar9331_sw_mdio_driver);
857
858MODULE_AUTHOR("Oleksij Rempel <kernel@pengutronix.de>");
859MODULE_DESCRIPTION("Driver for Atheros AR9331 switch");
860MODULE_LICENSE("GPL v2");