dsa-uclass.c 13 KB

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