1 // SPDX-License-Identifier: GPL-2.0+
2 /*
3 * Copyright 2019-2021 NXP
4 */
5
6 #include <net/dsa.h>
7 #include <dm/lists.h>
8 #include <dm/device_compat.h>
9 #include <dm/device-internal.h>
10 #include <dm/uclass-internal.h>
11 #include <linux/bitmap.h>
12 #include <miiphy.h>
13
14 #define DSA_PORT_CHILD_DRV_NAME "dsa-port"
15
16 /* per-device internal state structure */
17 struct dsa_priv {
18 struct phy_device *cpu_port_fixed_phy;
19 struct udevice *master_dev;
20 int num_ports;
21 u32 cpu_port;
22 int headroom;
23 int tailroom;
24 };
25
26 /* external API */
dsa_set_tagging(struct udevice * dev,ushort headroom,ushort tailroom)27 int dsa_set_tagging(struct udevice *dev, ushort headroom, ushort tailroom)
28 {
29 struct dsa_priv *priv;
30
31 if (!dev)
32 return -EINVAL;
33
34 if (headroom + tailroom > DSA_MAX_OVR)
35 return -EINVAL;
36
37 priv = dev_get_uclass_priv(dev);
38
39 if (headroom > 0)
40 priv->headroom = headroom;
41 if (tailroom > 0)
42 priv->tailroom = tailroom;
43
44 return 0;
45 }
46
47 /* returns the DSA master Ethernet device */
dsa_get_master(struct udevice * dev)48 struct udevice *dsa_get_master(struct udevice *dev)
49 {
50 struct dsa_priv *priv;
51
52 if (!dev)
53 return NULL;
54
55 priv = dev_get_uclass_priv(dev);
56
57 return priv->master_dev;
58 }
59
60 /*
61 * Start the desired port, the CPU port and the master Eth interface.
62 * TODO: if cascaded we may need to _start ports in other switches too
63 */
dsa_port_start(struct udevice * pdev)64 static int dsa_port_start(struct udevice *pdev)
65 {
66 struct udevice *dev = dev_get_parent(pdev);
67 struct dsa_priv *priv = dev_get_uclass_priv(dev);
68 struct udevice *master = dsa_get_master(dev);
69 struct dsa_ops *ops = dsa_get_ops(dev);
70 int err;
71
72 if (ops->port_enable) {
73 struct dsa_port_pdata *port_pdata;
74
75 port_pdata = dev_get_parent_plat(pdev);
76 err = ops->port_enable(dev, port_pdata->index,
77 port_pdata->phy);
78 if (err)
79 return err;
80
81 err = ops->port_enable(dev, priv->cpu_port,
82 priv->cpu_port_fixed_phy);
83 if (err)
84 return err;
85 }
86
87 return eth_get_ops(master)->start(master);
88 }
89
90 /* Stop the desired port, the CPU port and the master Eth interface */
dsa_port_stop(struct udevice * pdev)91 static void dsa_port_stop(struct udevice *pdev)
92 {
93 struct udevice *dev = dev_get_parent(pdev);
94 struct dsa_priv *priv = dev_get_uclass_priv(dev);
95 struct udevice *master = dsa_get_master(dev);
96 struct dsa_ops *ops = dsa_get_ops(dev);
97
98 if (ops->port_disable) {
99 struct dsa_port_pdata *port_pdata;
100
101 port_pdata = dev_get_parent_plat(pdev);
102 ops->port_disable(dev, port_pdata->index, port_pdata->phy);
103 ops->port_disable(dev, priv->cpu_port, NULL);
104 }
105
106 eth_get_ops(master)->stop(master);
107 }
108
109 /*
110 * Insert a DSA tag and call master Ethernet send on the resulting packet
111 * We copy the frame to a stack buffer where we have reserved headroom and
112 * tailroom space. Headroom and tailroom are set to 0.
113 */
dsa_port_send(struct udevice * pdev,void * packet,int length)114 static int dsa_port_send(struct udevice *pdev, void *packet, int length)
115 {
116 struct udevice *dev = dev_get_parent(pdev);
117 struct dsa_priv *priv = dev_get_uclass_priv(dev);
118 int head = priv->headroom, tail = priv->tailroom;
119 struct udevice *master = dsa_get_master(dev);
120 struct dsa_ops *ops = dsa_get_ops(dev);
121 uchar dsa_packet_tmp[PKTSIZE_ALIGN];
122 struct dsa_port_pdata *port_pdata;
123 int err;
124
125 if (length + head + tail > PKTSIZE_ALIGN)
126 return -EINVAL;
127
128 memset(dsa_packet_tmp, 0, head);
129 memset(dsa_packet_tmp + head + length, 0, tail);
130 memcpy(dsa_packet_tmp + head, packet, length);
131 length += head + tail;
132 /* copy back to preserve original buffer alignment */
133 memcpy(packet, dsa_packet_tmp, length);
134
135 port_pdata = dev_get_parent_plat(pdev);
136 err = ops->xmit(dev, port_pdata->index, packet, length);
137 if (err)
138 return err;
139
140 return eth_get_ops(master)->send(master, packet, length);
141 }
142
143 /* Receive a frame from master Ethernet, process it and pass it on */
dsa_port_recv(struct udevice * pdev,int flags,uchar ** packetp)144 static int dsa_port_recv(struct udevice *pdev, int flags, uchar **packetp)
145 {
146 struct udevice *dev = dev_get_parent(pdev);
147 struct dsa_priv *priv = dev_get_uclass_priv(dev);
148 int head = priv->headroom, tail = priv->tailroom;
149 struct udevice *master = dsa_get_master(dev);
150 struct dsa_ops *ops = dsa_get_ops(dev);
151 struct dsa_port_pdata *port_pdata;
152 int length, port_index, err;
153
154 length = eth_get_ops(master)->recv(master, flags, packetp);
155 if (length <= 0)
156 return length;
157
158 /*
159 * If we receive frames from a different port or frames that DSA driver
160 * doesn't like we discard them here.
161 * In case of discard we return with no frame and expect to be called
162 * again instead of looping here, so upper layer can deal with timeouts.
163 */
164 port_pdata = dev_get_parent_plat(pdev);
165 err = ops->rcv(dev, &port_index, *packetp, length);
166 if (err || port_index != port_pdata->index || (length <= head + tail)) {
167 if (eth_get_ops(master)->free_pkt)
168 eth_get_ops(master)->free_pkt(master, *packetp, length);
169 return -EAGAIN;
170 }
171
172 /*
173 * We move the pointer over headroom here to avoid a copy. If free_pkt
174 * gets called we move the pointer back before calling master free_pkt.
175 */
176 *packetp += head;
177
178 return length - head - tail;
179 }
180
dsa_port_free_pkt(struct udevice * pdev,uchar * packet,int length)181 static int dsa_port_free_pkt(struct udevice *pdev, uchar *packet, int length)
182 {
183 struct udevice *dev = dev_get_parent(pdev);
184 struct udevice *master = dsa_get_master(dev);
185 struct dsa_priv *priv;
186
187 priv = dev_get_uclass_priv(dev);
188 if (eth_get_ops(master)->free_pkt) {
189 /* return the original pointer and length to master Eth */
190 packet -= priv->headroom;
191 length += priv->headroom - priv->tailroom;
192
193 return eth_get_ops(master)->free_pkt(master, packet, length);
194 }
195
196 return 0;
197 }
198
dsa_port_of_to_pdata(struct udevice * pdev)199 static int dsa_port_of_to_pdata(struct udevice *pdev)
200 {
201 struct dsa_port_pdata *port_pdata;
202 struct dsa_pdata *dsa_pdata;
203 struct eth_pdata *eth_pdata;
204 struct udevice *dev;
205 const char *label;
206 u32 index;
207 int err;
208
209 if (!pdev)
210 return -ENODEV;
211
212 err = ofnode_read_u32(dev_ofnode(pdev), "reg", &index);
213 if (err)
214 return err;
215
216 dev = dev_get_parent(pdev);
217 dsa_pdata = dev_get_uclass_plat(dev);
218
219 port_pdata = dev_get_parent_plat(pdev);
220 port_pdata->index = index;
221
222 label = ofnode_read_string(dev_ofnode(pdev), "label");
223 if (label)
224 strncpy(port_pdata->name, label, DSA_PORT_NAME_LENGTH);
225
226 eth_pdata = dev_get_plat(pdev);
227 eth_pdata->priv_pdata = port_pdata;
228
229 dev_dbg(pdev, "port %d node %s\n", port_pdata->index,
230 ofnode_get_name(dev_ofnode(pdev)));
231
232 return 0;
233 }
234
235 static const struct eth_ops dsa_port_ops = {
236 .start = dsa_port_start,
237 .send = dsa_port_send,
238 .recv = dsa_port_recv,
239 .stop = dsa_port_stop,
240 .free_pkt = dsa_port_free_pkt,
241 };
242
dsa_port_probe(struct udevice * pdev)243 static int dsa_port_probe(struct udevice *pdev)
244 {
245 struct udevice *dev = dev_get_parent(pdev);
246 struct eth_pdata *eth_pdata, *master_pdata;
247 unsigned char env_enetaddr[ARP_HLEN];
248 struct dsa_port_pdata *port_pdata;
249 struct dsa_priv *dsa_priv;
250 struct udevice *master;
251 int ret;
252
253 port_pdata = dev_get_parent_plat(pdev);
254 dsa_priv = dev_get_uclass_priv(dev);
255
256 port_pdata->phy = dm_eth_phy_connect(pdev);
257 if (!port_pdata->phy)
258 return -ENODEV;
259
260 master = dsa_get_master(dev);
261 if (!master)
262 return -ENODEV;
263
264 /*
265 * Probe the master device. We depend on the master device for proper
266 * operation and we also need it for MAC inheritance below.
267 *
268 * TODO: we assume the master device is always there and doesn't get
269 * removed during runtime.
270 */
271 ret = device_probe(master);
272 if (ret)
273 return ret;
274
275 /*
276 * Inherit port's hwaddr from the DSA master, unless the port already
277 * has a unique MAC address specified in the environment.
278 */
279 eth_env_get_enetaddr_by_index("eth", dev_seq(pdev), env_enetaddr);
280 if (!is_zero_ethaddr(env_enetaddr))
281 return 0;
282
283 master_pdata = dev_get_plat(master);
284 eth_pdata = dev_get_plat(pdev);
285 memcpy(eth_pdata->enetaddr, master_pdata->enetaddr, ARP_HLEN);
286 eth_env_set_enetaddr_by_index("eth", dev_seq(pdev),
287 master_pdata->enetaddr);
288
289 return 0;
290 }
291
dsa_port_remove(struct udevice * pdev)292 static int dsa_port_remove(struct udevice *pdev)
293 {
294 struct udevice *dev = dev_get_parent(pdev);
295 struct dsa_port_pdata *port_pdata;
296 struct dsa_priv *dsa_priv;
297
298 port_pdata = dev_get_parent_plat(pdev);
299 dsa_priv = dev_get_uclass_priv(dev);
300
301 port_pdata->phy = NULL;
302
303 return 0;
304 }
305
306 U_BOOT_DRIVER(dsa_port) = {
307 .name = DSA_PORT_CHILD_DRV_NAME,
308 .id = UCLASS_ETH,
309 .ops = &dsa_port_ops,
310 .probe = dsa_port_probe,
311 .remove = dsa_port_remove,
312 .of_to_plat = dsa_port_of_to_pdata,
313 .plat_auto = sizeof(struct eth_pdata),
314 };
315
316 /*
317 * This function mostly deals with pulling information out of the device tree
318 * into the pdata structure.
319 * It goes through the list of switch ports, registers an eth device for each
320 * front panel port and identifies the cpu port connected to master eth device.
321 * TODO: support cascaded switches
322 */
dsa_post_bind(struct udevice * dev)323 static int dsa_post_bind(struct udevice *dev)
324 {
325 struct dsa_pdata *pdata = dev_get_uclass_plat(dev);
326 ofnode node = dev_ofnode(dev), pnode;
327 int i, err, first_err = 0;
328
329 if (!ofnode_valid(node))
330 return -ENODEV;
331
332 pdata->master_node = ofnode_null();
333
334 node = ofnode_find_subnode(node, "ports");
335 if (!ofnode_valid(node))
336 node = ofnode_find_subnode(node, "ethernet-ports");
337 if (!ofnode_valid(node)) {
338 dev_err(dev, "ports node is missing under DSA device!\n");
339 return -EINVAL;
340 }
341
342 pdata->num_ports = ofnode_get_child_count(node);
343 if (pdata->num_ports <= 0 || pdata->num_ports > DSA_MAX_PORTS) {
344 dev_err(dev, "invalid number of ports (%d)\n",
345 pdata->num_ports);
346 return -EINVAL;
347 }
348
349 /* look for the CPU port */
350 ofnode_for_each_subnode(pnode, node) {
351 u32 ethernet;
352
353 if (ofnode_read_u32(pnode, "ethernet", ðernet))
354 continue;
355
356 pdata->master_node = ofnode_get_by_phandle(ethernet);
357 pdata->cpu_port_node = pnode;
358 break;
359 }
360
361 if (!ofnode_valid(pdata->master_node)) {
362 dev_err(dev, "master eth node missing!\n");
363 return -EINVAL;
364 }
365
366 if (ofnode_read_u32(pnode, "reg", &pdata->cpu_port)) {
367 dev_err(dev, "CPU port node not valid!\n");
368 return -EINVAL;
369 }
370
371 dev_dbg(dev, "master node %s on port %d\n",
372 ofnode_get_name(pdata->master_node), pdata->cpu_port);
373
374 for (i = 0; i < pdata->num_ports; i++) {
375 char name[DSA_PORT_NAME_LENGTH];
376 struct udevice *pdev;
377
378 /*
379 * If this is the CPU port don't register it as an ETH device,
380 * we skip it on purpose since I/O to/from it from the CPU
381 * isn't useful.
382 */
383 if (i == pdata->cpu_port)
384 continue;
385
386 /*
387 * Set up default port names. If present, DT port labels
388 * will override the default port names.
389 */
390 snprintf(name, DSA_PORT_NAME_LENGTH, "%s@%d", dev->name, i);
391
392 ofnode_for_each_subnode(pnode, node) {
393 u32 reg;
394
395 if (ofnode_read_u32(pnode, "reg", ®))
396 continue;
397
398 if (reg == i)
399 break;
400 }
401
402 /*
403 * skip registration if port id not found or if the port
404 * is explicitly disabled in DT
405 */
406 if (!ofnode_valid(pnode) || !ofnode_is_available(pnode))
407 continue;
408
409 err = device_bind_driver_to_node(dev, DSA_PORT_CHILD_DRV_NAME,
410 name, pnode, &pdev);
411 if (pdev) {
412 struct dsa_port_pdata *port_pdata;
413
414 port_pdata = dev_get_parent_plat(pdev);
415 strncpy(port_pdata->name, name, DSA_PORT_NAME_LENGTH);
416 pdev->name = port_pdata->name;
417 }
418
419 /* try to bind all ports but keep 1st error */
420 if (err && !first_err)
421 first_err = err;
422 }
423
424 if (first_err)
425 return first_err;
426
427 dev_dbg(dev, "DSA ports successfully bound\n");
428
429 return 0;
430 }
431
432 /**
433 * Initialize the uclass per device internal state structure (priv).
434 * TODO: pick up references to other switch devices here, if we're cascaded.
435 */
dsa_pre_probe(struct udevice * dev)436 static int dsa_pre_probe(struct udevice *dev)
437 {
438 struct dsa_pdata *pdata = dev_get_uclass_plat(dev);
439 struct dsa_priv *priv = dev_get_uclass_priv(dev);
440
441 priv->num_ports = pdata->num_ports;
442 priv->cpu_port = pdata->cpu_port;
443 priv->cpu_port_fixed_phy = fixed_phy_create(pdata->cpu_port_node);
444 if (!priv->cpu_port_fixed_phy) {
445 dev_err(dev, "Failed to register fixed-link for CPU port\n");
446 return -ENODEV;
447 }
448
449 uclass_find_device_by_ofnode(UCLASS_ETH, pdata->master_node,
450 &priv->master_dev);
451 return 0;
452 }
453
454 UCLASS_DRIVER(dsa) = {
455 .id = UCLASS_DSA,
456 .name = "dsa",
457 .post_bind = dsa_post_bind,
458 .pre_probe = dsa_pre_probe,
459 .per_device_auto = sizeof(struct dsa_priv),
460 .per_device_plat_auto = sizeof(struct dsa_pdata),
461 .per_child_plat_auto = sizeof(struct dsa_port_pdata),
462 .flags = DM_UC_FLAG_SEQ_ALIAS,
463 };
464