dsa2.c 20 KB

1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889909192939495969798991001011021031041051061071081091101111121131141151161171181191201211221231241251261271281291301311321331341351361371381391401411421431441451461471481491501511521531541551561571581591601611621631641651661671681691701711721731741751761771781791801811821831841851861871881891901911921931941951961971981992002012022032042052062072082092102112122132142152162172182192202212222232242252262272282292302312322332342352362372382392402412422432442452462472482492502512522532542552562572582592602612622632642652662672682692702712722732742752762772782792802812822832842852862872882892902912922932942952962972982993003013023033043053063073083093103113123133143153163173183193203213223233243253263273283293303313323333343353363373383393403413423433443453463473483493503513523533543553563573583593603613623633643653663673683693703713723733743753763773783793803813823833843853863873883893903913923933943953963973983994004014024034044054064074084094104114124134144154164174184194204214224234244254264274284294304314324334344354364374384394404414424434444454464474484494504514524534544554564574584594604614624634644654664674684694704714724734744754764774784794804814824834844854864874884894904914924934944954964974984995005015025035045055065075085095105115125135145155165175185195205215225235245255265275285295305315325335345355365375385395405415425435445455465475485495505515525535545555565575585595605615625635645655665675685695705715725735745755765775785795805815825835845855865875885895905915925935945955965975985996006016026036046056066076086096106116126136146156166176186196206216226236246256266276286296306316326336346356366376386396406416426436446456466476486496506516526536546556566576586596606616626636646656666676686696706716726736746756766776786796806816826836846856866876886896906916926936946956966976986997007017027037047057067077087097107117127137147157167177187197207217227237247257267277287297307317327337347357367377387397407417427437447457467477487497507517527537547557567577587597607617627637647657667677687697707717727737747757767777787797807817827837847857867877887897907917927937947957967977987998008018028038048058068078088098108118128138148158168178188198208218228238248258268278288298308318328338348358368378388398408418428438448458468478488498508518528538548558568578588598608618628638648658668678688698708718728738748758768778788798808818828838848858868878888898908918928938948958968978988999009019029039049059069079089099109119129139149159169179189199209219229239249259269279289299309319329339349359369379389399409419429439449459469479489499509519529539549559569579589599609619629639649659669679689699709719729739749759769779789799809819829839849859869879889899909919929939949959969979989991000100110021003100410051006100710081009101010111012101310141015101610171018101910201021102210231024102510261027
  1. // SPDX-License-Identifier: GPL-2.0-or-later
  2. /*
  3. * net/dsa/dsa2.c - Hardware switch handling, binding version 2
  4. * Copyright (c) 2008-2009 Marvell Semiconductor
  5. * Copyright (c) 2013 Florian Fainelli <florian@openwrt.org>
  6. * Copyright (c) 2016 Andrew Lunn <andrew@lunn.ch>
  7. */
  8. #include <linux/device.h>
  9. #include <linux/err.h>
  10. #include <linux/list.h>
  11. #include <linux/netdevice.h>
  12. #include <linux/slab.h>
  13. #include <linux/rtnetlink.h>
  14. #include <linux/of.h>
  15. #include <linux/of_net.h>
  16. #include <net/devlink.h>
  17. #include "dsa_priv.h"
  18. static DEFINE_MUTEX(dsa2_mutex);
  19. LIST_HEAD(dsa_tree_list);
  20. struct dsa_switch *dsa_switch_find(int tree_index, int sw_index)
  21. {
  22. struct dsa_switch_tree *dst;
  23. struct dsa_port *dp;
  24. list_for_each_entry(dst, &dsa_tree_list, list) {
  25. if (dst->index != tree_index)
  26. continue;
  27. list_for_each_entry(dp, &dst->ports, list) {
  28. if (dp->ds->index != sw_index)
  29. continue;
  30. return dp->ds;
  31. }
  32. }
  33. return NULL;
  34. }
  35. EXPORT_SYMBOL_GPL(dsa_switch_find);
  36. static struct dsa_switch_tree *dsa_tree_find(int index)
  37. {
  38. struct dsa_switch_tree *dst;
  39. list_for_each_entry(dst, &dsa_tree_list, list)
  40. if (dst->index == index)
  41. return dst;
  42. return NULL;
  43. }
  44. static struct dsa_switch_tree *dsa_tree_alloc(int index)
  45. {
  46. struct dsa_switch_tree *dst;
  47. dst = kzalloc(sizeof(*dst), GFP_KERNEL);
  48. if (!dst)
  49. return NULL;
  50. dst->index = index;
  51. INIT_LIST_HEAD(&dst->rtable);
  52. INIT_LIST_HEAD(&dst->ports);
  53. INIT_LIST_HEAD(&dst->list);
  54. list_add_tail(&dst->list, &dsa_tree_list);
  55. kref_init(&dst->refcount);
  56. return dst;
  57. }
  58. static void dsa_tree_free(struct dsa_switch_tree *dst)
  59. {
  60. list_del(&dst->list);
  61. kfree(dst);
  62. }
  63. static struct dsa_switch_tree *dsa_tree_get(struct dsa_switch_tree *dst)
  64. {
  65. if (dst)
  66. kref_get(&dst->refcount);
  67. return dst;
  68. }
  69. static struct dsa_switch_tree *dsa_tree_touch(int index)
  70. {
  71. struct dsa_switch_tree *dst;
  72. dst = dsa_tree_find(index);
  73. if (dst)
  74. return dsa_tree_get(dst);
  75. else
  76. return dsa_tree_alloc(index);
  77. }
  78. static void dsa_tree_release(struct kref *ref)
  79. {
  80. struct dsa_switch_tree *dst;
  81. dst = container_of(ref, struct dsa_switch_tree, refcount);
  82. dsa_tree_free(dst);
  83. }
  84. static void dsa_tree_put(struct dsa_switch_tree *dst)
  85. {
  86. if (dst)
  87. kref_put(&dst->refcount, dsa_tree_release);
  88. }
  89. static bool dsa_port_is_dsa(struct dsa_port *port)
  90. {
  91. return port->type == DSA_PORT_TYPE_DSA;
  92. }
  93. static bool dsa_port_is_cpu(struct dsa_port *port)
  94. {
  95. return port->type == DSA_PORT_TYPE_CPU;
  96. }
  97. static bool dsa_port_is_user(struct dsa_port *dp)
  98. {
  99. return dp->type == DSA_PORT_TYPE_USER;
  100. }
  101. static struct dsa_port *dsa_tree_find_port_by_node(struct dsa_switch_tree *dst,
  102. struct device_node *dn)
  103. {
  104. struct dsa_port *dp;
  105. list_for_each_entry(dp, &dst->ports, list)
  106. if (dp->dn == dn)
  107. return dp;
  108. return NULL;
  109. }
  110. static struct dsa_link *dsa_link_touch(struct dsa_port *dp,
  111. struct dsa_port *link_dp)
  112. {
  113. struct dsa_switch *ds = dp->ds;
  114. struct dsa_switch_tree *dst;
  115. struct dsa_link *dl;
  116. dst = ds->dst;
  117. list_for_each_entry(dl, &dst->rtable, list)
  118. if (dl->dp == dp && dl->link_dp == link_dp)
  119. return dl;
  120. dl = kzalloc(sizeof(*dl), GFP_KERNEL);
  121. if (!dl)
  122. return NULL;
  123. dl->dp = dp;
  124. dl->link_dp = link_dp;
  125. INIT_LIST_HEAD(&dl->list);
  126. list_add_tail(&dl->list, &dst->rtable);
  127. return dl;
  128. }
  129. static bool dsa_port_setup_routing_table(struct dsa_port *dp)
  130. {
  131. struct dsa_switch *ds = dp->ds;
  132. struct dsa_switch_tree *dst = ds->dst;
  133. struct device_node *dn = dp->dn;
  134. struct of_phandle_iterator it;
  135. struct dsa_port *link_dp;
  136. struct dsa_link *dl;
  137. int err;
  138. of_for_each_phandle(&it, err, dn, "link", NULL, 0) {
  139. link_dp = dsa_tree_find_port_by_node(dst, it.node);
  140. if (!link_dp) {
  141. of_node_put(it.node);
  142. return false;
  143. }
  144. dl = dsa_link_touch(dp, link_dp);
  145. if (!dl) {
  146. of_node_put(it.node);
  147. return false;
  148. }
  149. }
  150. return true;
  151. }
  152. static bool dsa_tree_setup_routing_table(struct dsa_switch_tree *dst)
  153. {
  154. bool complete = true;
  155. struct dsa_port *dp;
  156. list_for_each_entry(dp, &dst->ports, list) {
  157. if (dsa_port_is_dsa(dp)) {
  158. complete = dsa_port_setup_routing_table(dp);
  159. if (!complete)
  160. break;
  161. }
  162. }
  163. return complete;
  164. }
  165. static struct dsa_port *dsa_tree_find_first_cpu(struct dsa_switch_tree *dst)
  166. {
  167. struct dsa_port *dp;
  168. list_for_each_entry(dp, &dst->ports, list)
  169. if (dsa_port_is_cpu(dp))
  170. return dp;
  171. return NULL;
  172. }
  173. static int dsa_tree_setup_default_cpu(struct dsa_switch_tree *dst)
  174. {
  175. struct dsa_port *cpu_dp, *dp;
  176. cpu_dp = dsa_tree_find_first_cpu(dst);
  177. if (!cpu_dp) {
  178. pr_err("DSA: tree %d has no CPU port\n", dst->index);
  179. return -EINVAL;
  180. }
  181. /* Assign the default CPU port to all ports of the fabric */
  182. list_for_each_entry(dp, &dst->ports, list)
  183. if (dsa_port_is_user(dp) || dsa_port_is_dsa(dp))
  184. dp->cpu_dp = cpu_dp;
  185. return 0;
  186. }
  187. static void dsa_tree_teardown_default_cpu(struct dsa_switch_tree *dst)
  188. {
  189. struct dsa_port *dp;
  190. list_for_each_entry(dp, &dst->ports, list)
  191. if (dsa_port_is_user(dp) || dsa_port_is_dsa(dp))
  192. dp->cpu_dp = NULL;
  193. }
  194. static int dsa_port_setup(struct dsa_port *dp)
  195. {
  196. struct devlink_port *dlp = &dp->devlink_port;
  197. bool dsa_port_link_registered = false;
  198. bool dsa_port_enabled = false;
  199. int err = 0;
  200. if (dp->setup)
  201. return 0;
  202. switch (dp->type) {
  203. case DSA_PORT_TYPE_UNUSED:
  204. dsa_port_disable(dp);
  205. break;
  206. case DSA_PORT_TYPE_CPU:
  207. err = dsa_port_link_register_of(dp);
  208. if (err)
  209. break;
  210. dsa_port_link_registered = true;
  211. err = dsa_port_enable(dp, NULL);
  212. if (err)
  213. break;
  214. dsa_port_enabled = true;
  215. break;
  216. case DSA_PORT_TYPE_DSA:
  217. err = dsa_port_link_register_of(dp);
  218. if (err)
  219. break;
  220. dsa_port_link_registered = true;
  221. err = dsa_port_enable(dp, NULL);
  222. if (err)
  223. break;
  224. dsa_port_enabled = true;
  225. break;
  226. case DSA_PORT_TYPE_USER:
  227. dp->mac = of_get_mac_address(dp->dn);
  228. err = dsa_slave_create(dp);
  229. if (err)
  230. break;
  231. devlink_port_type_eth_set(dlp, dp->slave);
  232. break;
  233. }
  234. if (err && dsa_port_enabled)
  235. dsa_port_disable(dp);
  236. if (err && dsa_port_link_registered)
  237. dsa_port_link_unregister_of(dp);
  238. if (err)
  239. return err;
  240. dp->setup = true;
  241. return 0;
  242. }
  243. static int dsa_port_devlink_setup(struct dsa_port *dp)
  244. {
  245. struct devlink_port *dlp = &dp->devlink_port;
  246. struct dsa_switch_tree *dst = dp->ds->dst;
  247. struct devlink_port_attrs attrs = {};
  248. struct devlink *dl = dp->ds->devlink;
  249. const unsigned char *id;
  250. unsigned char len;
  251. int err;
  252. id = (const unsigned char *)&dst->index;
  253. len = sizeof(dst->index);
  254. attrs.phys.port_number = dp->index;
  255. memcpy(attrs.switch_id.id, id, len);
  256. attrs.switch_id.id_len = len;
  257. memset(dlp, 0, sizeof(*dlp));
  258. switch (dp->type) {
  259. case DSA_PORT_TYPE_UNUSED:
  260. attrs.flavour = DEVLINK_PORT_FLAVOUR_UNUSED;
  261. break;
  262. case DSA_PORT_TYPE_CPU:
  263. attrs.flavour = DEVLINK_PORT_FLAVOUR_CPU;
  264. break;
  265. case DSA_PORT_TYPE_DSA:
  266. attrs.flavour = DEVLINK_PORT_FLAVOUR_DSA;
  267. break;
  268. case DSA_PORT_TYPE_USER:
  269. attrs.flavour = DEVLINK_PORT_FLAVOUR_PHYSICAL;
  270. break;
  271. }
  272. devlink_port_attrs_set(dlp, &attrs);
  273. err = devlink_port_register(dl, dlp, dp->index);
  274. if (!err)
  275. dp->devlink_port_setup = true;
  276. return err;
  277. }
  278. static void dsa_port_teardown(struct dsa_port *dp)
  279. {
  280. struct devlink_port *dlp = &dp->devlink_port;
  281. if (!dp->setup)
  282. return;
  283. devlink_port_type_clear(dlp);
  284. switch (dp->type) {
  285. case DSA_PORT_TYPE_UNUSED:
  286. break;
  287. case DSA_PORT_TYPE_CPU:
  288. dsa_port_disable(dp);
  289. dsa_tag_driver_put(dp->tag_ops);
  290. dsa_port_link_unregister_of(dp);
  291. break;
  292. case DSA_PORT_TYPE_DSA:
  293. dsa_port_disable(dp);
  294. dsa_port_link_unregister_of(dp);
  295. break;
  296. case DSA_PORT_TYPE_USER:
  297. if (dp->slave) {
  298. dsa_slave_destroy(dp->slave);
  299. dp->slave = NULL;
  300. }
  301. break;
  302. }
  303. dp->setup = false;
  304. }
  305. static void dsa_port_devlink_teardown(struct dsa_port *dp)
  306. {
  307. struct devlink_port *dlp = &dp->devlink_port;
  308. if (dp->devlink_port_setup)
  309. devlink_port_unregister(dlp);
  310. dp->devlink_port_setup = false;
  311. }
  312. static int dsa_devlink_info_get(struct devlink *dl,
  313. struct devlink_info_req *req,
  314. struct netlink_ext_ack *extack)
  315. {
  316. struct dsa_switch *ds = dsa_devlink_to_ds(dl);
  317. if (ds->ops->devlink_info_get)
  318. return ds->ops->devlink_info_get(ds, req, extack);
  319. return -EOPNOTSUPP;
  320. }
  321. static const struct devlink_ops dsa_devlink_ops = {
  322. .info_get = dsa_devlink_info_get,
  323. };
  324. static int dsa_switch_setup(struct dsa_switch *ds)
  325. {
  326. struct dsa_devlink_priv *dl_priv;
  327. struct dsa_port *dp;
  328. int err;
  329. if (ds->setup)
  330. return 0;
  331. /* Initialize ds->phys_mii_mask before registering the slave MDIO bus
  332. * driver and before ops->setup() has run, since the switch drivers and
  333. * the slave MDIO bus driver rely on these values for probing PHY
  334. * devices or not
  335. */
  336. ds->phys_mii_mask |= dsa_user_ports(ds);
  337. /* Add the switch to devlink before calling setup, so that setup can
  338. * add dpipe tables
  339. */
  340. ds->devlink = devlink_alloc(&dsa_devlink_ops, sizeof(*dl_priv));
  341. if (!ds->devlink)
  342. return -ENOMEM;
  343. dl_priv = devlink_priv(ds->devlink);
  344. dl_priv->ds = ds;
  345. err = devlink_register(ds->devlink, ds->dev);
  346. if (err)
  347. goto free_devlink;
  348. /* Setup devlink port instances now, so that the switch
  349. * setup() can register regions etc, against the ports
  350. */
  351. list_for_each_entry(dp, &ds->dst->ports, list) {
  352. if (dp->ds == ds) {
  353. err = dsa_port_devlink_setup(dp);
  354. if (err)
  355. goto unregister_devlink_ports;
  356. }
  357. }
  358. err = dsa_switch_register_notifier(ds);
  359. if (err)
  360. goto unregister_devlink_ports;
  361. err = ds->ops->setup(ds);
  362. if (err < 0)
  363. goto unregister_notifier;
  364. devlink_params_publish(ds->devlink);
  365. if (!ds->slave_mii_bus && ds->ops->phy_read) {
  366. ds->slave_mii_bus = mdiobus_alloc();
  367. if (!ds->slave_mii_bus) {
  368. err = -ENOMEM;
  369. goto teardown;
  370. }
  371. dsa_slave_mii_bus_init(ds);
  372. err = mdiobus_register(ds->slave_mii_bus);
  373. if (err < 0)
  374. goto free_slave_mii_bus;
  375. }
  376. ds->setup = true;
  377. return 0;
  378. free_slave_mii_bus:
  379. if (ds->slave_mii_bus && ds->ops->phy_read)
  380. mdiobus_free(ds->slave_mii_bus);
  381. teardown:
  382. if (ds->ops->teardown)
  383. ds->ops->teardown(ds);
  384. unregister_notifier:
  385. dsa_switch_unregister_notifier(ds);
  386. unregister_devlink_ports:
  387. list_for_each_entry(dp, &ds->dst->ports, list)
  388. if (dp->ds == ds)
  389. dsa_port_devlink_teardown(dp);
  390. devlink_unregister(ds->devlink);
  391. free_devlink:
  392. devlink_free(ds->devlink);
  393. ds->devlink = NULL;
  394. return err;
  395. }
  396. static void dsa_switch_teardown(struct dsa_switch *ds)
  397. {
  398. struct dsa_port *dp;
  399. if (!ds->setup)
  400. return;
  401. if (ds->slave_mii_bus && ds->ops->phy_read) {
  402. mdiobus_unregister(ds->slave_mii_bus);
  403. mdiobus_free(ds->slave_mii_bus);
  404. ds->slave_mii_bus = NULL;
  405. }
  406. dsa_switch_unregister_notifier(ds);
  407. if (ds->ops->teardown)
  408. ds->ops->teardown(ds);
  409. if (ds->devlink) {
  410. list_for_each_entry(dp, &ds->dst->ports, list)
  411. if (dp->ds == ds)
  412. dsa_port_devlink_teardown(dp);
  413. devlink_unregister(ds->devlink);
  414. devlink_free(ds->devlink);
  415. ds->devlink = NULL;
  416. }
  417. ds->setup = false;
  418. }
  419. static int dsa_tree_setup_switches(struct dsa_switch_tree *dst)
  420. {
  421. struct dsa_port *dp;
  422. int err;
  423. list_for_each_entry(dp, &dst->ports, list) {
  424. err = dsa_switch_setup(dp->ds);
  425. if (err)
  426. goto teardown;
  427. }
  428. list_for_each_entry(dp, &dst->ports, list) {
  429. err = dsa_port_setup(dp);
  430. if (err) {
  431. dsa_port_devlink_teardown(dp);
  432. dp->type = DSA_PORT_TYPE_UNUSED;
  433. err = dsa_port_devlink_setup(dp);
  434. if (err)
  435. goto teardown;
  436. continue;
  437. }
  438. }
  439. return 0;
  440. teardown:
  441. list_for_each_entry(dp, &dst->ports, list)
  442. dsa_port_teardown(dp);
  443. list_for_each_entry(dp, &dst->ports, list)
  444. dsa_switch_teardown(dp->ds);
  445. return err;
  446. }
  447. static void dsa_tree_teardown_switches(struct dsa_switch_tree *dst)
  448. {
  449. struct dsa_port *dp;
  450. list_for_each_entry(dp, &dst->ports, list)
  451. dsa_port_teardown(dp);
  452. list_for_each_entry(dp, &dst->ports, list)
  453. dsa_switch_teardown(dp->ds);
  454. }
  455. static int dsa_tree_setup_master(struct dsa_switch_tree *dst)
  456. {
  457. struct dsa_port *dp;
  458. int err;
  459. list_for_each_entry(dp, &dst->ports, list) {
  460. if (dsa_port_is_cpu(dp)) {
  461. err = dsa_master_setup(dp->master, dp);
  462. if (err)
  463. return err;
  464. }
  465. }
  466. return 0;
  467. }
  468. static void dsa_tree_teardown_master(struct dsa_switch_tree *dst)
  469. {
  470. struct dsa_port *dp;
  471. list_for_each_entry(dp, &dst->ports, list)
  472. if (dsa_port_is_cpu(dp))
  473. dsa_master_teardown(dp->master);
  474. }
  475. static int dsa_tree_setup(struct dsa_switch_tree *dst)
  476. {
  477. bool complete;
  478. int err;
  479. if (dst->setup) {
  480. pr_err("DSA: tree %d already setup! Disjoint trees?\n",
  481. dst->index);
  482. return -EEXIST;
  483. }
  484. complete = dsa_tree_setup_routing_table(dst);
  485. if (!complete)
  486. return 0;
  487. err = dsa_tree_setup_default_cpu(dst);
  488. if (err)
  489. return err;
  490. err = dsa_tree_setup_switches(dst);
  491. if (err)
  492. goto teardown_default_cpu;
  493. err = dsa_tree_setup_master(dst);
  494. if (err)
  495. goto teardown_switches;
  496. dst->setup = true;
  497. pr_info("DSA: tree %d setup\n", dst->index);
  498. return 0;
  499. teardown_switches:
  500. dsa_tree_teardown_switches(dst);
  501. teardown_default_cpu:
  502. dsa_tree_teardown_default_cpu(dst);
  503. return err;
  504. }
  505. static void dsa_tree_teardown(struct dsa_switch_tree *dst)
  506. {
  507. struct dsa_link *dl, *next;
  508. if (!dst->setup)
  509. return;
  510. dsa_tree_teardown_master(dst);
  511. dsa_tree_teardown_switches(dst);
  512. dsa_tree_teardown_default_cpu(dst);
  513. list_for_each_entry_safe(dl, next, &dst->rtable, list) {
  514. list_del(&dl->list);
  515. kfree(dl);
  516. }
  517. pr_info("DSA: tree %d torn down\n", dst->index);
  518. dst->setup = false;
  519. }
  520. static struct dsa_port *dsa_port_touch(struct dsa_switch *ds, int index)
  521. {
  522. struct dsa_switch_tree *dst = ds->dst;
  523. struct dsa_port *dp;
  524. list_for_each_entry(dp, &dst->ports, list)
  525. if (dp->ds == ds && dp->index == index)
  526. return dp;
  527. dp = kzalloc(sizeof(*dp), GFP_KERNEL);
  528. if (!dp)
  529. return NULL;
  530. dp->ds = ds;
  531. dp->index = index;
  532. INIT_LIST_HEAD(&dp->list);
  533. list_add_tail(&dp->list, &dst->ports);
  534. return dp;
  535. }
  536. static int dsa_port_parse_user(struct dsa_port *dp, const char *name)
  537. {
  538. if (!name)
  539. name = "eth%d";
  540. dp->type = DSA_PORT_TYPE_USER;
  541. dp->name = name;
  542. return 0;
  543. }
  544. static int dsa_port_parse_dsa(struct dsa_port *dp)
  545. {
  546. dp->type = DSA_PORT_TYPE_DSA;
  547. return 0;
  548. }
  549. static enum dsa_tag_protocol dsa_get_tag_protocol(struct dsa_port *dp,
  550. struct net_device *master)
  551. {
  552. enum dsa_tag_protocol tag_protocol = DSA_TAG_PROTO_NONE;
  553. struct dsa_switch *mds, *ds = dp->ds;
  554. unsigned int mdp_upstream;
  555. struct dsa_port *mdp;
  556. /* It is possible to stack DSA switches onto one another when that
  557. * happens the switch driver may want to know if its tagging protocol
  558. * is going to work in such a configuration.
  559. */
  560. if (dsa_slave_dev_check(master)) {
  561. mdp = dsa_slave_to_port(master);
  562. mds = mdp->ds;
  563. mdp_upstream = dsa_upstream_port(mds, mdp->index);
  564. tag_protocol = mds->ops->get_tag_protocol(mds, mdp_upstream,
  565. DSA_TAG_PROTO_NONE);
  566. }
  567. /* If the master device is not itself a DSA slave in a disjoint DSA
  568. * tree, then return immediately.
  569. */
  570. return ds->ops->get_tag_protocol(ds, dp->index, tag_protocol);
  571. }
  572. static int dsa_port_parse_cpu(struct dsa_port *dp, struct net_device *master)
  573. {
  574. struct dsa_switch *ds = dp->ds;
  575. struct dsa_switch_tree *dst = ds->dst;
  576. const struct dsa_device_ops *tag_ops;
  577. enum dsa_tag_protocol tag_protocol;
  578. tag_protocol = dsa_get_tag_protocol(dp, master);
  579. tag_ops = dsa_tag_driver_get(tag_protocol);
  580. if (IS_ERR(tag_ops)) {
  581. if (PTR_ERR(tag_ops) == -ENOPROTOOPT)
  582. return -EPROBE_DEFER;
  583. dev_warn(ds->dev, "No tagger for this switch\n");
  584. dp->master = NULL;
  585. return PTR_ERR(tag_ops);
  586. }
  587. dp->master = master;
  588. dp->type = DSA_PORT_TYPE_CPU;
  589. dp->filter = tag_ops->filter;
  590. dp->rcv = tag_ops->rcv;
  591. dp->tag_ops = tag_ops;
  592. dp->dst = dst;
  593. return 0;
  594. }
  595. static int dsa_port_parse_of(struct dsa_port *dp, struct device_node *dn)
  596. {
  597. struct device_node *ethernet = of_parse_phandle(dn, "ethernet", 0);
  598. const char *name = of_get_property(dn, "label", NULL);
  599. bool link = of_property_read_bool(dn, "link");
  600. dp->dn = dn;
  601. if (ethernet) {
  602. struct net_device *master;
  603. master = of_find_net_device_by_node(ethernet);
  604. of_node_put(ethernet);
  605. if (!master)
  606. return -EPROBE_DEFER;
  607. return dsa_port_parse_cpu(dp, master);
  608. }
  609. if (link)
  610. return dsa_port_parse_dsa(dp);
  611. return dsa_port_parse_user(dp, name);
  612. }
  613. static int dsa_switch_parse_ports_of(struct dsa_switch *ds,
  614. struct device_node *dn)
  615. {
  616. struct device_node *ports, *port;
  617. struct dsa_port *dp;
  618. int err = 0;
  619. u32 reg;
  620. ports = of_get_child_by_name(dn, "ports");
  621. if (!ports) {
  622. /* The second possibility is "ethernet-ports" */
  623. ports = of_get_child_by_name(dn, "ethernet-ports");
  624. if (!ports) {
  625. dev_err(ds->dev, "no ports child node found\n");
  626. return -EINVAL;
  627. }
  628. }
  629. for_each_available_child_of_node(ports, port) {
  630. err = of_property_read_u32(port, "reg", &reg);
  631. if (err)
  632. goto out_put_node;
  633. if (reg >= ds->num_ports) {
  634. err = -EINVAL;
  635. goto out_put_node;
  636. }
  637. dp = dsa_to_port(ds, reg);
  638. err = dsa_port_parse_of(dp, port);
  639. if (err)
  640. goto out_put_node;
  641. }
  642. out_put_node:
  643. of_node_put(ports);
  644. return err;
  645. }
  646. static int dsa_switch_parse_member_of(struct dsa_switch *ds,
  647. struct device_node *dn)
  648. {
  649. u32 m[2] = { 0, 0 };
  650. int sz;
  651. /* Don't error out if this optional property isn't found */
  652. sz = of_property_read_variable_u32_array(dn, "dsa,member", m, 2, 2);
  653. if (sz < 0 && sz != -EINVAL)
  654. return sz;
  655. ds->index = m[1];
  656. ds->dst = dsa_tree_touch(m[0]);
  657. if (!ds->dst)
  658. return -ENOMEM;
  659. return 0;
  660. }
  661. static int dsa_switch_touch_ports(struct dsa_switch *ds)
  662. {
  663. struct dsa_port *dp;
  664. int port;
  665. for (port = 0; port < ds->num_ports; port++) {
  666. dp = dsa_port_touch(ds, port);
  667. if (!dp)
  668. return -ENOMEM;
  669. }
  670. return 0;
  671. }
  672. static int dsa_switch_parse_of(struct dsa_switch *ds, struct device_node *dn)
  673. {
  674. int err;
  675. err = dsa_switch_parse_member_of(ds, dn);
  676. if (err)
  677. return err;
  678. err = dsa_switch_touch_ports(ds);
  679. if (err)
  680. return err;
  681. return dsa_switch_parse_ports_of(ds, dn);
  682. }
  683. static int dsa_port_parse(struct dsa_port *dp, const char *name,
  684. struct device *dev)
  685. {
  686. if (!strcmp(name, "cpu")) {
  687. struct net_device *master;
  688. master = dsa_dev_to_net_device(dev);
  689. if (!master)
  690. return -EPROBE_DEFER;
  691. dev_put(master);
  692. return dsa_port_parse_cpu(dp, master);
  693. }
  694. if (!strcmp(name, "dsa"))
  695. return dsa_port_parse_dsa(dp);
  696. return dsa_port_parse_user(dp, name);
  697. }
  698. static int dsa_switch_parse_ports(struct dsa_switch *ds,
  699. struct dsa_chip_data *cd)
  700. {
  701. bool valid_name_found = false;
  702. struct dsa_port *dp;
  703. struct device *dev;
  704. const char *name;
  705. unsigned int i;
  706. int err;
  707. for (i = 0; i < DSA_MAX_PORTS; i++) {
  708. name = cd->port_names[i];
  709. dev = cd->netdev[i];
  710. dp = dsa_to_port(ds, i);
  711. if (!name)
  712. continue;
  713. err = dsa_port_parse(dp, name, dev);
  714. if (err)
  715. return err;
  716. valid_name_found = true;
  717. }
  718. if (!valid_name_found && i == DSA_MAX_PORTS)
  719. return -EINVAL;
  720. return 0;
  721. }
  722. static int dsa_switch_parse(struct dsa_switch *ds, struct dsa_chip_data *cd)
  723. {
  724. int err;
  725. ds->cd = cd;
  726. /* We don't support interconnected switches nor multiple trees via
  727. * platform data, so this is the unique switch of the tree.
  728. */
  729. ds->index = 0;
  730. ds->dst = dsa_tree_touch(0);
  731. if (!ds->dst)
  732. return -ENOMEM;
  733. err = dsa_switch_touch_ports(ds);
  734. if (err)
  735. return err;
  736. return dsa_switch_parse_ports(ds, cd);
  737. }
  738. static void dsa_switch_release_ports(struct dsa_switch *ds)
  739. {
  740. struct dsa_switch_tree *dst = ds->dst;
  741. struct dsa_port *dp, *next;
  742. list_for_each_entry_safe(dp, next, &dst->ports, list) {
  743. if (dp->ds != ds)
  744. continue;
  745. list_del(&dp->list);
  746. kfree(dp);
  747. }
  748. }
  749. static int dsa_switch_probe(struct dsa_switch *ds)
  750. {
  751. struct dsa_switch_tree *dst;
  752. struct dsa_chip_data *pdata;
  753. struct device_node *np;
  754. int err;
  755. if (!ds->dev)
  756. return -ENODEV;
  757. pdata = ds->dev->platform_data;
  758. np = ds->dev->of_node;
  759. if (!ds->num_ports)
  760. return -EINVAL;
  761. if (np) {
  762. err = dsa_switch_parse_of(ds, np);
  763. if (err)
  764. dsa_switch_release_ports(ds);
  765. } else if (pdata) {
  766. err = dsa_switch_parse(ds, pdata);
  767. if (err)
  768. dsa_switch_release_ports(ds);
  769. } else {
  770. err = -ENODEV;
  771. }
  772. if (err)
  773. return err;
  774. dst = ds->dst;
  775. dsa_tree_get(dst);
  776. err = dsa_tree_setup(dst);
  777. if (err) {
  778. dsa_switch_release_ports(ds);
  779. dsa_tree_put(dst);
  780. }
  781. return err;
  782. }
  783. int dsa_register_switch(struct dsa_switch *ds)
  784. {
  785. int err;
  786. mutex_lock(&dsa2_mutex);
  787. err = dsa_switch_probe(ds);
  788. dsa_tree_put(ds->dst);
  789. mutex_unlock(&dsa2_mutex);
  790. return err;
  791. }
  792. EXPORT_SYMBOL_GPL(dsa_register_switch);
  793. static void dsa_switch_remove(struct dsa_switch *ds)
  794. {
  795. struct dsa_switch_tree *dst = ds->dst;
  796. dsa_tree_teardown(dst);
  797. dsa_switch_release_ports(ds);
  798. dsa_tree_put(dst);
  799. }
  800. void dsa_unregister_switch(struct dsa_switch *ds)
  801. {
  802. mutex_lock(&dsa2_mutex);
  803. dsa_switch_remove(ds);
  804. mutex_unlock(&dsa2_mutex);
  805. }
  806. EXPORT_SYMBOL_GPL(dsa_unregister_switch);