1 // SPDX-License-Identifier: GPL-2.0
2 /*
3 * Microchip switch driver main logic
4 *
5 * Copyright (C) 2017-2019 Microchip Technology Inc.
6 */
7
8 #include <linux/delay.h>
9 #include <linux/export.h>
10 #include <linux/gpio/consumer.h>
11 #include <linux/kernel.h>
12 #include <linux/module.h>
13 #include <linux/platform_data/microchip-ksz.h>
14 #include <linux/phy.h>
15 #include <linux/etherdevice.h>
16 #include <linux/if_bridge.h>
17 #include <linux/of_net.h>
18 #include <net/dsa.h>
19 #include <net/switchdev.h>
20
21 #include "ksz_common.h"
22
ksz_update_port_member(struct ksz_device * dev,int port)23 void ksz_update_port_member(struct ksz_device *dev, int port)
24 {
25 struct ksz_port *p;
26 int i;
27
28 for (i = 0; i < dev->port_cnt; i++) {
29 if (i == port || i == dev->cpu_port)
30 continue;
31 p = &dev->ports[i];
32 if (!(dev->member & (1 << i)))
33 continue;
34
35 /* Port is a member of the bridge and is forwarding. */
36 if (p->stp_state == BR_STATE_FORWARDING &&
37 p->member != dev->member)
38 dev->dev_ops->cfg_port_member(dev, i, dev->member);
39 }
40 }
41 EXPORT_SYMBOL_GPL(ksz_update_port_member);
42
port_r_cnt(struct ksz_device * dev,int port)43 static void port_r_cnt(struct ksz_device *dev, int port)
44 {
45 struct ksz_port_mib *mib = &dev->ports[port].mib;
46 u64 *dropped;
47
48 /* Some ports may not have MIB counters before SWITCH_COUNTER_NUM. */
49 while (mib->cnt_ptr < dev->reg_mib_cnt) {
50 dev->dev_ops->r_mib_cnt(dev, port, mib->cnt_ptr,
51 &mib->counters[mib->cnt_ptr]);
52 ++mib->cnt_ptr;
53 }
54
55 /* last one in storage */
56 dropped = &mib->counters[dev->mib_cnt];
57
58 /* Some ports may not have MIB counters after SWITCH_COUNTER_NUM. */
59 while (mib->cnt_ptr < dev->mib_cnt) {
60 dev->dev_ops->r_mib_pkt(dev, port, mib->cnt_ptr,
61 dropped, &mib->counters[mib->cnt_ptr]);
62 ++mib->cnt_ptr;
63 }
64 mib->cnt_ptr = 0;
65 }
66
ksz_mib_read_work(struct work_struct * work)67 static void ksz_mib_read_work(struct work_struct *work)
68 {
69 struct ksz_device *dev = container_of(work, struct ksz_device,
70 mib_read);
71 struct ksz_port_mib *mib;
72 struct ksz_port *p;
73 int i;
74
75 for (i = 0; i < dev->mib_port_cnt; i++) {
76 if (dsa_is_unused_port(dev->ds, i))
77 continue;
78
79 p = &dev->ports[i];
80 mib = &p->mib;
81 mutex_lock(&mib->cnt_mutex);
82
83 /* Only read MIB counters when the port is told to do.
84 * If not, read only dropped counters when link is not up.
85 */
86 if (!p->read) {
87 const struct dsa_port *dp = dsa_to_port(dev->ds, i);
88
89 if (!netif_carrier_ok(dp->slave))
90 mib->cnt_ptr = dev->reg_mib_cnt;
91 }
92 port_r_cnt(dev, i);
93 p->read = false;
94 mutex_unlock(&mib->cnt_mutex);
95 }
96 }
97
mib_monitor(struct timer_list * t)98 static void mib_monitor(struct timer_list *t)
99 {
100 struct ksz_device *dev = from_timer(dev, t, mib_read_timer);
101
102 mod_timer(&dev->mib_read_timer, jiffies + dev->mib_read_interval);
103 schedule_work(&dev->mib_read);
104 }
105
ksz_init_mib_timer(struct ksz_device * dev)106 void ksz_init_mib_timer(struct ksz_device *dev)
107 {
108 int i;
109
110 /* Read MIB counters every 30 seconds to avoid overflow. */
111 dev->mib_read_interval = msecs_to_jiffies(30000);
112
113 INIT_WORK(&dev->mib_read, ksz_mib_read_work);
114 timer_setup(&dev->mib_read_timer, mib_monitor, 0);
115
116 for (i = 0; i < dev->mib_port_cnt; i++)
117 dev->dev_ops->port_init_cnt(dev, i);
118
119 /* Start the timer 2 seconds later. */
120 dev->mib_read_timer.expires = jiffies + msecs_to_jiffies(2000);
121 add_timer(&dev->mib_read_timer);
122 }
123 EXPORT_SYMBOL_GPL(ksz_init_mib_timer);
124
ksz_phy_read16(struct dsa_switch * ds,int addr,int reg)125 int ksz_phy_read16(struct dsa_switch *ds, int addr, int reg)
126 {
127 struct ksz_device *dev = ds->priv;
128 u16 val = 0xffff;
129
130 dev->dev_ops->r_phy(dev, addr, reg, &val);
131
132 return val;
133 }
134 EXPORT_SYMBOL_GPL(ksz_phy_read16);
135
ksz_phy_write16(struct dsa_switch * ds,int addr,int reg,u16 val)136 int ksz_phy_write16(struct dsa_switch *ds, int addr, int reg, u16 val)
137 {
138 struct ksz_device *dev = ds->priv;
139
140 dev->dev_ops->w_phy(dev, addr, reg, val);
141
142 return 0;
143 }
144 EXPORT_SYMBOL_GPL(ksz_phy_write16);
145
ksz_adjust_link(struct dsa_switch * ds,int port,struct phy_device * phydev)146 void ksz_adjust_link(struct dsa_switch *ds, int port,
147 struct phy_device *phydev)
148 {
149 struct ksz_device *dev = ds->priv;
150 struct ksz_port *p = &dev->ports[port];
151
152 /* Read all MIB counters when the link is going down. */
153 if (!phydev->link) {
154 p->read = true;
155 schedule_work(&dev->mib_read);
156 }
157 mutex_lock(&dev->dev_mutex);
158 if (!phydev->link)
159 dev->live_ports &= ~(1 << port);
160 else
161 /* Remember which port is connected and active. */
162 dev->live_ports |= (1 << port) & dev->on_ports;
163 mutex_unlock(&dev->dev_mutex);
164 }
165 EXPORT_SYMBOL_GPL(ksz_adjust_link);
166
ksz_sset_count(struct dsa_switch * ds,int port,int sset)167 int ksz_sset_count(struct dsa_switch *ds, int port, int sset)
168 {
169 struct ksz_device *dev = ds->priv;
170
171 if (sset != ETH_SS_STATS)
172 return 0;
173
174 return dev->mib_cnt;
175 }
176 EXPORT_SYMBOL_GPL(ksz_sset_count);
177
ksz_get_ethtool_stats(struct dsa_switch * ds,int port,uint64_t * buf)178 void ksz_get_ethtool_stats(struct dsa_switch *ds, int port, uint64_t *buf)
179 {
180 const struct dsa_port *dp = dsa_to_port(ds, port);
181 struct ksz_device *dev = ds->priv;
182 struct ksz_port_mib *mib;
183
184 mib = &dev->ports[port].mib;
185 mutex_lock(&mib->cnt_mutex);
186
187 /* Only read dropped counters if no link. */
188 if (!netif_carrier_ok(dp->slave))
189 mib->cnt_ptr = dev->reg_mib_cnt;
190 port_r_cnt(dev, port);
191 memcpy(buf, mib->counters, dev->mib_cnt * sizeof(u64));
192 mutex_unlock(&mib->cnt_mutex);
193 }
194 EXPORT_SYMBOL_GPL(ksz_get_ethtool_stats);
195
ksz_port_bridge_join(struct dsa_switch * ds,int port,struct net_device * br)196 int ksz_port_bridge_join(struct dsa_switch *ds, int port,
197 struct net_device *br)
198 {
199 struct ksz_device *dev = ds->priv;
200
201 mutex_lock(&dev->dev_mutex);
202 dev->br_member |= (1 << port);
203 mutex_unlock(&dev->dev_mutex);
204
205 /* port_stp_state_set() will be called after to put the port in
206 * appropriate state so there is no need to do anything.
207 */
208
209 return 0;
210 }
211 EXPORT_SYMBOL_GPL(ksz_port_bridge_join);
212
ksz_port_bridge_leave(struct dsa_switch * ds,int port,struct net_device * br)213 void ksz_port_bridge_leave(struct dsa_switch *ds, int port,
214 struct net_device *br)
215 {
216 struct ksz_device *dev = ds->priv;
217
218 mutex_lock(&dev->dev_mutex);
219 dev->br_member &= ~(1 << port);
220 dev->member &= ~(1 << port);
221 mutex_unlock(&dev->dev_mutex);
222
223 /* port_stp_state_set() will be called after to put the port in
224 * forwarding state so there is no need to do anything.
225 */
226 }
227 EXPORT_SYMBOL_GPL(ksz_port_bridge_leave);
228
ksz_port_fast_age(struct dsa_switch * ds,int port)229 void ksz_port_fast_age(struct dsa_switch *ds, int port)
230 {
231 struct ksz_device *dev = ds->priv;
232
233 dev->dev_ops->flush_dyn_mac_table(dev, port);
234 }
235 EXPORT_SYMBOL_GPL(ksz_port_fast_age);
236
ksz_port_vlan_prepare(struct dsa_switch * ds,int port,const struct switchdev_obj_port_vlan * vlan)237 int ksz_port_vlan_prepare(struct dsa_switch *ds, int port,
238 const struct switchdev_obj_port_vlan *vlan)
239 {
240 /* nothing needed */
241
242 return 0;
243 }
244 EXPORT_SYMBOL_GPL(ksz_port_vlan_prepare);
245
ksz_port_fdb_dump(struct dsa_switch * ds,int port,dsa_fdb_dump_cb_t * cb,void * data)246 int ksz_port_fdb_dump(struct dsa_switch *ds, int port, dsa_fdb_dump_cb_t *cb,
247 void *data)
248 {
249 struct ksz_device *dev = ds->priv;
250 int ret = 0;
251 u16 i = 0;
252 u16 entries = 0;
253 u8 timestamp = 0;
254 u8 fid;
255 u8 member;
256 struct alu_struct alu;
257
258 do {
259 alu.is_static = false;
260 ret = dev->dev_ops->r_dyn_mac_table(dev, i, alu.mac, &fid,
261 &member, ×tamp,
262 &entries);
263 if (!ret && (member & BIT(port))) {
264 ret = cb(alu.mac, alu.fid, alu.is_static, data);
265 if (ret)
266 break;
267 }
268 i++;
269 } while (i < entries);
270 if (i >= entries)
271 ret = 0;
272
273 return ret;
274 }
275 EXPORT_SYMBOL_GPL(ksz_port_fdb_dump);
276
ksz_port_mdb_prepare(struct dsa_switch * ds,int port,const struct switchdev_obj_port_mdb * mdb)277 int ksz_port_mdb_prepare(struct dsa_switch *ds, int port,
278 const struct switchdev_obj_port_mdb *mdb)
279 {
280 /* nothing to do */
281 return 0;
282 }
283 EXPORT_SYMBOL_GPL(ksz_port_mdb_prepare);
284
ksz_port_mdb_add(struct dsa_switch * ds,int port,const struct switchdev_obj_port_mdb * mdb)285 void ksz_port_mdb_add(struct dsa_switch *ds, int port,
286 const struct switchdev_obj_port_mdb *mdb)
287 {
288 struct ksz_device *dev = ds->priv;
289 struct alu_struct alu;
290 int index;
291 int empty = 0;
292
293 alu.port_forward = 0;
294 for (index = 0; index < dev->num_statics; index++) {
295 if (!dev->dev_ops->r_sta_mac_table(dev, index, &alu)) {
296 /* Found one already in static MAC table. */
297 if (!memcmp(alu.mac, mdb->addr, ETH_ALEN) &&
298 alu.fid == mdb->vid)
299 break;
300 /* Remember the first empty entry. */
301 } else if (!empty) {
302 empty = index + 1;
303 }
304 }
305
306 /* no available entry */
307 if (index == dev->num_statics && !empty)
308 return;
309
310 /* add entry */
311 if (index == dev->num_statics) {
312 index = empty - 1;
313 memset(&alu, 0, sizeof(alu));
314 memcpy(alu.mac, mdb->addr, ETH_ALEN);
315 alu.is_static = true;
316 }
317 alu.port_forward |= BIT(port);
318 if (mdb->vid) {
319 alu.is_use_fid = true;
320
321 /* Need a way to map VID to FID. */
322 alu.fid = mdb->vid;
323 }
324 dev->dev_ops->w_sta_mac_table(dev, index, &alu);
325 }
326 EXPORT_SYMBOL_GPL(ksz_port_mdb_add);
327
ksz_port_mdb_del(struct dsa_switch * ds,int port,const struct switchdev_obj_port_mdb * mdb)328 int ksz_port_mdb_del(struct dsa_switch *ds, int port,
329 const struct switchdev_obj_port_mdb *mdb)
330 {
331 struct ksz_device *dev = ds->priv;
332 struct alu_struct alu;
333 int index;
334 int ret = 0;
335
336 for (index = 0; index < dev->num_statics; index++) {
337 if (!dev->dev_ops->r_sta_mac_table(dev, index, &alu)) {
338 /* Found one already in static MAC table. */
339 if (!memcmp(alu.mac, mdb->addr, ETH_ALEN) &&
340 alu.fid == mdb->vid)
341 break;
342 }
343 }
344
345 /* no available entry */
346 if (index == dev->num_statics)
347 goto exit;
348
349 /* clear port */
350 alu.port_forward &= ~BIT(port);
351 if (!alu.port_forward)
352 alu.is_static = false;
353 dev->dev_ops->w_sta_mac_table(dev, index, &alu);
354
355 exit:
356 return ret;
357 }
358 EXPORT_SYMBOL_GPL(ksz_port_mdb_del);
359
ksz_enable_port(struct dsa_switch * ds,int port,struct phy_device * phy)360 int ksz_enable_port(struct dsa_switch *ds, int port, struct phy_device *phy)
361 {
362 struct ksz_device *dev = ds->priv;
363
364 if (!dsa_is_user_port(ds, port))
365 return 0;
366
367 /* setup slave port */
368 dev->dev_ops->port_setup(dev, port, false);
369 if (dev->dev_ops->phy_setup)
370 dev->dev_ops->phy_setup(dev, port, phy);
371
372 /* port_stp_state_set() will be called after to enable the port so
373 * there is no need to do anything.
374 */
375
376 return 0;
377 }
378 EXPORT_SYMBOL_GPL(ksz_enable_port);
379
ksz_disable_port(struct dsa_switch * ds,int port)380 void ksz_disable_port(struct dsa_switch *ds, int port)
381 {
382 struct ksz_device *dev = ds->priv;
383
384 if (!dsa_is_user_port(ds, port))
385 return;
386
387 dev->on_ports &= ~(1 << port);
388 dev->live_ports &= ~(1 << port);
389
390 /* port_stp_state_set() will be called after to disable the port so
391 * there is no need to do anything.
392 */
393 }
394 EXPORT_SYMBOL_GPL(ksz_disable_port);
395
ksz_switch_alloc(struct device * base,void * priv)396 struct ksz_device *ksz_switch_alloc(struct device *base, void *priv)
397 {
398 struct dsa_switch *ds;
399 struct ksz_device *swdev;
400
401 ds = dsa_switch_alloc(base, DSA_MAX_PORTS);
402 if (!ds)
403 return NULL;
404
405 swdev = devm_kzalloc(base, sizeof(*swdev), GFP_KERNEL);
406 if (!swdev)
407 return NULL;
408
409 ds->priv = swdev;
410 swdev->dev = base;
411
412 swdev->ds = ds;
413 swdev->priv = priv;
414
415 return swdev;
416 }
417 EXPORT_SYMBOL(ksz_switch_alloc);
418
ksz_switch_register(struct ksz_device * dev,const struct ksz_dev_ops * ops)419 int ksz_switch_register(struct ksz_device *dev,
420 const struct ksz_dev_ops *ops)
421 {
422 int ret;
423
424 if (dev->pdata)
425 dev->chip_id = dev->pdata->chip_id;
426
427 dev->reset_gpio = devm_gpiod_get_optional(dev->dev, "reset",
428 GPIOD_OUT_LOW);
429 if (IS_ERR(dev->reset_gpio))
430 return PTR_ERR(dev->reset_gpio);
431
432 if (dev->reset_gpio) {
433 gpiod_set_value_cansleep(dev->reset_gpio, 1);
434 mdelay(10);
435 gpiod_set_value_cansleep(dev->reset_gpio, 0);
436 }
437
438 mutex_init(&dev->dev_mutex);
439 mutex_init(&dev->regmap_mutex);
440 mutex_init(&dev->alu_mutex);
441 mutex_init(&dev->vlan_mutex);
442
443 dev->dev_ops = ops;
444
445 if (dev->dev_ops->detect(dev))
446 return -EINVAL;
447
448 ret = dev->dev_ops->init(dev);
449 if (ret)
450 return ret;
451
452 /* Host port interface will be self detected, or specifically set in
453 * device tree.
454 */
455 if (dev->dev->of_node) {
456 ret = of_get_phy_mode(dev->dev->of_node);
457 if (ret >= 0)
458 dev->interface = ret;
459 dev->synclko_125 = of_property_read_bool(dev->dev->of_node,
460 "microchip,synclko-125");
461 }
462
463 ret = dsa_register_switch(dev->ds);
464 if (ret) {
465 dev->dev_ops->exit(dev);
466 return ret;
467 }
468
469 return 0;
470 }
471 EXPORT_SYMBOL(ksz_switch_register);
472
ksz_switch_remove(struct ksz_device * dev)473 void ksz_switch_remove(struct ksz_device *dev)
474 {
475 /* timer started */
476 if (dev->mib_read_timer.expires) {
477 del_timer_sync(&dev->mib_read_timer);
478 flush_work(&dev->mib_read);
479 }
480
481 dev->dev_ops->exit(dev);
482 dsa_unregister_switch(dev->ds);
483
484 if (dev->reset_gpio)
485 gpiod_set_value_cansleep(dev->reset_gpio, 1);
486
487 }
488 EXPORT_SYMBOL(ksz_switch_remove);
489
490 MODULE_AUTHOR("Woojung Huh <Woojung.Huh@microchip.com>");
491 MODULE_DESCRIPTION("Microchip KSZ Series Switch DSA Driver");
492 MODULE_LICENSE("GPL");
493
