dsa2.c 16 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832
  1. /*
  2. * net/dsa/dsa2.c - Hardware switch handling, binding version 2
  3. * Copyright (c) 2008-2009 Marvell Semiconductor
  4. * Copyright (c) 2013 Florian Fainelli <florian@openwrt.org>
  5. * Copyright (c) 2016 Andrew Lunn <andrew@lunn.ch>
  6. *
  7. * This program is free software; you can redistribute it and/or modify
  8. * it under the terms of the GNU General Public License as published by
  9. * the Free Software Foundation; either version 2 of the License, or
  10. * (at your option) any later version.
  11. */
  12. #include <linux/device.h>
  13. #include <linux/err.h>
  14. #include <linux/list.h>
  15. #include <linux/netdevice.h>
  16. #include <linux/slab.h>
  17. #include <linux/rtnetlink.h>
  18. #include <linux/of.h>
  19. #include <linux/of_net.h>
  20. #include "dsa_priv.h"
  21. static LIST_HEAD(dsa_tree_list);
  22. static DEFINE_MUTEX(dsa2_mutex);
  23. static const struct devlink_ops dsa_devlink_ops = {
  24. };
  25. static struct dsa_switch_tree *dsa_tree_find(int index)
  26. {
  27. struct dsa_switch_tree *dst;
  28. list_for_each_entry(dst, &dsa_tree_list, list)
  29. if (dst->index == index)
  30. return dst;
  31. return NULL;
  32. }
  33. static struct dsa_switch_tree *dsa_tree_alloc(int index)
  34. {
  35. struct dsa_switch_tree *dst;
  36. dst = kzalloc(sizeof(*dst), GFP_KERNEL);
  37. if (!dst)
  38. return NULL;
  39. dst->index = index;
  40. INIT_LIST_HEAD(&dst->list);
  41. list_add_tail(&dst->list, &dsa_tree_list);
  42. kref_init(&dst->refcount);
  43. return dst;
  44. }
  45. static void dsa_tree_free(struct dsa_switch_tree *dst)
  46. {
  47. list_del(&dst->list);
  48. kfree(dst);
  49. }
  50. static struct dsa_switch_tree *dsa_tree_get(struct dsa_switch_tree *dst)
  51. {
  52. if (dst)
  53. kref_get(&dst->refcount);
  54. return dst;
  55. }
  56. static struct dsa_switch_tree *dsa_tree_touch(int index)
  57. {
  58. struct dsa_switch_tree *dst;
  59. dst = dsa_tree_find(index);
  60. if (dst)
  61. return dsa_tree_get(dst);
  62. else
  63. return dsa_tree_alloc(index);
  64. }
  65. static void dsa_tree_release(struct kref *ref)
  66. {
  67. struct dsa_switch_tree *dst;
  68. dst = container_of(ref, struct dsa_switch_tree, refcount);
  69. dsa_tree_free(dst);
  70. }
  71. static void dsa_tree_put(struct dsa_switch_tree *dst)
  72. {
  73. if (dst)
  74. kref_put(&dst->refcount, dsa_tree_release);
  75. }
  76. static bool dsa_port_is_dsa(struct dsa_port *port)
  77. {
  78. return port->type == DSA_PORT_TYPE_DSA;
  79. }
  80. static bool dsa_port_is_cpu(struct dsa_port *port)
  81. {
  82. return port->type == DSA_PORT_TYPE_CPU;
  83. }
  84. static bool dsa_port_is_user(struct dsa_port *dp)
  85. {
  86. return dp->type == DSA_PORT_TYPE_USER;
  87. }
  88. static struct dsa_port *dsa_tree_find_port_by_node(struct dsa_switch_tree *dst,
  89. struct device_node *dn)
  90. {
  91. struct dsa_switch *ds;
  92. struct dsa_port *dp;
  93. int device, port;
  94. for (device = 0; device < DSA_MAX_SWITCHES; device++) {
  95. ds = dst->ds[device];
  96. if (!ds)
  97. continue;
  98. for (port = 0; port < ds->num_ports; port++) {
  99. dp = &ds->ports[port];
  100. if (dp->dn == dn)
  101. return dp;
  102. }
  103. }
  104. return NULL;
  105. }
  106. static bool dsa_port_setup_routing_table(struct dsa_port *dp)
  107. {
  108. struct dsa_switch *ds = dp->ds;
  109. struct dsa_switch_tree *dst = ds->dst;
  110. struct device_node *dn = dp->dn;
  111. struct of_phandle_iterator it;
  112. struct dsa_port *link_dp;
  113. int err;
  114. of_for_each_phandle(&it, err, dn, "link", NULL, 0) {
  115. link_dp = dsa_tree_find_port_by_node(dst, it.node);
  116. if (!link_dp) {
  117. of_node_put(it.node);
  118. return false;
  119. }
  120. ds->rtable[link_dp->ds->index] = dp->index;
  121. }
  122. return true;
  123. }
  124. static bool dsa_switch_setup_routing_table(struct dsa_switch *ds)
  125. {
  126. bool complete = true;
  127. struct dsa_port *dp;
  128. int i;
  129. for (i = 0; i < DSA_MAX_SWITCHES; i++)
  130. ds->rtable[i] = DSA_RTABLE_NONE;
  131. for (i = 0; i < ds->num_ports; i++) {
  132. dp = &ds->ports[i];
  133. if (dsa_port_is_dsa(dp)) {
  134. complete = dsa_port_setup_routing_table(dp);
  135. if (!complete)
  136. break;
  137. }
  138. }
  139. return complete;
  140. }
  141. static bool dsa_tree_setup_routing_table(struct dsa_switch_tree *dst)
  142. {
  143. struct dsa_switch *ds;
  144. bool complete = true;
  145. int device;
  146. for (device = 0; device < DSA_MAX_SWITCHES; device++) {
  147. ds = dst->ds[device];
  148. if (!ds)
  149. continue;
  150. complete = dsa_switch_setup_routing_table(ds);
  151. if (!complete)
  152. break;
  153. }
  154. return complete;
  155. }
  156. static struct dsa_port *dsa_tree_find_first_cpu(struct dsa_switch_tree *dst)
  157. {
  158. struct dsa_switch *ds;
  159. struct dsa_port *dp;
  160. int device, port;
  161. for (device = 0; device < DSA_MAX_SWITCHES; device++) {
  162. ds = dst->ds[device];
  163. if (!ds)
  164. continue;
  165. for (port = 0; port < ds->num_ports; port++) {
  166. dp = &ds->ports[port];
  167. if (dsa_port_is_cpu(dp))
  168. return dp;
  169. }
  170. }
  171. return NULL;
  172. }
  173. static int dsa_tree_setup_default_cpu(struct dsa_switch_tree *dst)
  174. {
  175. struct dsa_switch *ds;
  176. struct dsa_port *dp;
  177. int device, port;
  178. /* DSA currently only supports a single CPU port */
  179. dst->cpu_dp = dsa_tree_find_first_cpu(dst);
  180. if (!dst->cpu_dp) {
  181. pr_warn("Tree has no master device\n");
  182. return -EINVAL;
  183. }
  184. /* Assign the default CPU port to all ports of the fabric */
  185. for (device = 0; device < DSA_MAX_SWITCHES; device++) {
  186. ds = dst->ds[device];
  187. if (!ds)
  188. continue;
  189. for (port = 0; port < ds->num_ports; port++) {
  190. dp = &ds->ports[port];
  191. if (dsa_port_is_user(dp) || dsa_port_is_dsa(dp))
  192. dp->cpu_dp = dst->cpu_dp;
  193. }
  194. }
  195. return 0;
  196. }
  197. static void dsa_tree_teardown_default_cpu(struct dsa_switch_tree *dst)
  198. {
  199. /* DSA currently only supports a single CPU port */
  200. dst->cpu_dp = NULL;
  201. }
  202. static int dsa_port_setup(struct dsa_port *dp)
  203. {
  204. struct dsa_switch *ds = dp->ds;
  205. int err = 0;
  206. memset(&dp->devlink_port, 0, sizeof(dp->devlink_port));
  207. dp->mac = of_get_mac_address(dp->dn);
  208. if (dp->type != DSA_PORT_TYPE_UNUSED)
  209. err = devlink_port_register(ds->devlink, &dp->devlink_port,
  210. dp->index);
  211. if (err)
  212. return err;
  213. switch (dp->type) {
  214. case DSA_PORT_TYPE_UNUSED:
  215. break;
  216. case DSA_PORT_TYPE_CPU:
  217. /* dp->index is used now as port_number. However
  218. * CPU ports should have separate numbering
  219. * independent from front panel port numbers.
  220. */
  221. devlink_port_attrs_set(&dp->devlink_port,
  222. DEVLINK_PORT_FLAVOUR_CPU,
  223. dp->index, false, 0);
  224. err = dsa_port_link_register_of(dp);
  225. if (err) {
  226. dev_err(ds->dev, "failed to setup link for port %d.%d\n",
  227. ds->index, dp->index);
  228. return err;
  229. }
  230. break;
  231. case DSA_PORT_TYPE_DSA:
  232. /* dp->index is used now as port_number. However
  233. * DSA ports should have separate numbering
  234. * independent from front panel port numbers.
  235. */
  236. devlink_port_attrs_set(&dp->devlink_port,
  237. DEVLINK_PORT_FLAVOUR_DSA,
  238. dp->index, false, 0);
  239. err = dsa_port_link_register_of(dp);
  240. if (err) {
  241. dev_err(ds->dev, "failed to setup link for port %d.%d\n",
  242. ds->index, dp->index);
  243. return err;
  244. }
  245. break;
  246. case DSA_PORT_TYPE_USER:
  247. devlink_port_attrs_set(&dp->devlink_port,
  248. DEVLINK_PORT_FLAVOUR_PHYSICAL,
  249. dp->index, false, 0);
  250. err = dsa_slave_create(dp);
  251. if (err)
  252. dev_err(ds->dev, "failed to create slave for port %d.%d\n",
  253. ds->index, dp->index);
  254. else
  255. devlink_port_type_eth_set(&dp->devlink_port, dp->slave);
  256. break;
  257. }
  258. return 0;
  259. }
  260. static void dsa_port_teardown(struct dsa_port *dp)
  261. {
  262. if (dp->type != DSA_PORT_TYPE_UNUSED)
  263. devlink_port_unregister(&dp->devlink_port);
  264. switch (dp->type) {
  265. case DSA_PORT_TYPE_UNUSED:
  266. break;
  267. case DSA_PORT_TYPE_CPU:
  268. case DSA_PORT_TYPE_DSA:
  269. dsa_port_link_unregister_of(dp);
  270. break;
  271. case DSA_PORT_TYPE_USER:
  272. if (dp->slave) {
  273. dsa_slave_destroy(dp->slave);
  274. dp->slave = NULL;
  275. }
  276. break;
  277. }
  278. }
  279. static int dsa_switch_setup(struct dsa_switch *ds)
  280. {
  281. int err;
  282. /* Initialize ds->phys_mii_mask before registering the slave MDIO bus
  283. * driver and before ops->setup() has run, since the switch drivers and
  284. * the slave MDIO bus driver rely on these values for probing PHY
  285. * devices or not
  286. */
  287. ds->phys_mii_mask |= dsa_user_ports(ds);
  288. /* Add the switch to devlink before calling setup, so that setup can
  289. * add dpipe tables
  290. */
  291. ds->devlink = devlink_alloc(&dsa_devlink_ops, 0);
  292. if (!ds->devlink)
  293. return -ENOMEM;
  294. err = devlink_register(ds->devlink, ds->dev);
  295. if (err)
  296. return err;
  297. err = ds->ops->setup(ds);
  298. if (err < 0)
  299. return err;
  300. err = dsa_switch_register_notifier(ds);
  301. if (err)
  302. return err;
  303. if (!ds->slave_mii_bus && ds->ops->phy_read) {
  304. ds->slave_mii_bus = devm_mdiobus_alloc(ds->dev);
  305. if (!ds->slave_mii_bus)
  306. return -ENOMEM;
  307. dsa_slave_mii_bus_init(ds);
  308. err = mdiobus_register(ds->slave_mii_bus);
  309. if (err < 0)
  310. return err;
  311. }
  312. return 0;
  313. }
  314. static void dsa_switch_teardown(struct dsa_switch *ds)
  315. {
  316. if (ds->slave_mii_bus && ds->ops->phy_read)
  317. mdiobus_unregister(ds->slave_mii_bus);
  318. dsa_switch_unregister_notifier(ds);
  319. if (ds->devlink) {
  320. devlink_unregister(ds->devlink);
  321. devlink_free(ds->devlink);
  322. ds->devlink = NULL;
  323. }
  324. }
  325. static int dsa_tree_setup_switches(struct dsa_switch_tree *dst)
  326. {
  327. struct dsa_switch *ds;
  328. struct dsa_port *dp;
  329. int device, port;
  330. int err;
  331. for (device = 0; device < DSA_MAX_SWITCHES; device++) {
  332. ds = dst->ds[device];
  333. if (!ds)
  334. continue;
  335. err = dsa_switch_setup(ds);
  336. if (err)
  337. continue;
  338. for (port = 0; port < ds->num_ports; port++) {
  339. dp = &ds->ports[port];
  340. err = dsa_port_setup(dp);
  341. if (err)
  342. return err;
  343. }
  344. }
  345. return 0;
  346. }
  347. static void dsa_tree_teardown_switches(struct dsa_switch_tree *dst)
  348. {
  349. struct dsa_switch *ds;
  350. struct dsa_port *dp;
  351. int device, port;
  352. for (device = 0; device < DSA_MAX_SWITCHES; device++) {
  353. ds = dst->ds[device];
  354. if (!ds)
  355. continue;
  356. for (port = 0; port < ds->num_ports; port++) {
  357. dp = &ds->ports[port];
  358. dsa_port_teardown(dp);
  359. }
  360. dsa_switch_teardown(ds);
  361. }
  362. }
  363. static int dsa_tree_setup_master(struct dsa_switch_tree *dst)
  364. {
  365. struct dsa_port *cpu_dp = dst->cpu_dp;
  366. struct net_device *master = cpu_dp->master;
  367. /* DSA currently supports a single pair of CPU port and master device */
  368. return dsa_master_setup(master, cpu_dp);
  369. }
  370. static void dsa_tree_teardown_master(struct dsa_switch_tree *dst)
  371. {
  372. struct dsa_port *cpu_dp = dst->cpu_dp;
  373. struct net_device *master = cpu_dp->master;
  374. return dsa_master_teardown(master);
  375. }
  376. static int dsa_tree_setup(struct dsa_switch_tree *dst)
  377. {
  378. bool complete;
  379. int err;
  380. if (dst->setup) {
  381. pr_err("DSA: tree %d already setup! Disjoint trees?\n",
  382. dst->index);
  383. return -EEXIST;
  384. }
  385. complete = dsa_tree_setup_routing_table(dst);
  386. if (!complete)
  387. return 0;
  388. err = dsa_tree_setup_default_cpu(dst);
  389. if (err)
  390. return err;
  391. err = dsa_tree_setup_switches(dst);
  392. if (err)
  393. return err;
  394. err = dsa_tree_setup_master(dst);
  395. if (err)
  396. return err;
  397. dst->setup = true;
  398. pr_info("DSA: tree %d setup\n", dst->index);
  399. return 0;
  400. }
  401. static void dsa_tree_teardown(struct dsa_switch_tree *dst)
  402. {
  403. if (!dst->setup)
  404. return;
  405. dsa_tree_teardown_master(dst);
  406. dsa_tree_teardown_switches(dst);
  407. dsa_tree_teardown_default_cpu(dst);
  408. pr_info("DSA: tree %d torn down\n", dst->index);
  409. dst->setup = false;
  410. }
  411. static void dsa_tree_remove_switch(struct dsa_switch_tree *dst,
  412. unsigned int index)
  413. {
  414. dsa_tree_teardown(dst);
  415. dst->ds[index] = NULL;
  416. dsa_tree_put(dst);
  417. }
  418. static int dsa_tree_add_switch(struct dsa_switch_tree *dst,
  419. struct dsa_switch *ds)
  420. {
  421. unsigned int index = ds->index;
  422. int err;
  423. if (dst->ds[index])
  424. return -EBUSY;
  425. dsa_tree_get(dst);
  426. dst->ds[index] = ds;
  427. err = dsa_tree_setup(dst);
  428. if (err)
  429. dsa_tree_remove_switch(dst, index);
  430. return err;
  431. }
  432. static int dsa_port_parse_user(struct dsa_port *dp, const char *name)
  433. {
  434. if (!name)
  435. name = "eth%d";
  436. dp->type = DSA_PORT_TYPE_USER;
  437. dp->name = name;
  438. return 0;
  439. }
  440. static int dsa_port_parse_dsa(struct dsa_port *dp)
  441. {
  442. dp->type = DSA_PORT_TYPE_DSA;
  443. return 0;
  444. }
  445. static int dsa_port_parse_cpu(struct dsa_port *dp, struct net_device *master)
  446. {
  447. struct dsa_switch *ds = dp->ds;
  448. struct dsa_switch_tree *dst = ds->dst;
  449. const struct dsa_device_ops *tag_ops;
  450. enum dsa_tag_protocol tag_protocol;
  451. tag_protocol = ds->ops->get_tag_protocol(ds, dp->index);
  452. tag_ops = dsa_resolve_tag_protocol(tag_protocol);
  453. if (IS_ERR(tag_ops)) {
  454. dev_warn(ds->dev, "No tagger for this switch\n");
  455. return PTR_ERR(tag_ops);
  456. }
  457. dp->type = DSA_PORT_TYPE_CPU;
  458. dp->rcv = tag_ops->rcv;
  459. dp->tag_ops = tag_ops;
  460. dp->master = master;
  461. dp->dst = dst;
  462. return 0;
  463. }
  464. static int dsa_port_parse_of(struct dsa_port *dp, struct device_node *dn)
  465. {
  466. struct device_node *ethernet = of_parse_phandle(dn, "ethernet", 0);
  467. const char *name = of_get_property(dn, "label", NULL);
  468. bool link = of_property_read_bool(dn, "link");
  469. dp->dn = dn;
  470. if (ethernet) {
  471. struct net_device *master;
  472. master = of_find_net_device_by_node(ethernet);
  473. if (!master)
  474. return -EPROBE_DEFER;
  475. return dsa_port_parse_cpu(dp, master);
  476. }
  477. if (link)
  478. return dsa_port_parse_dsa(dp);
  479. return dsa_port_parse_user(dp, name);
  480. }
  481. static int dsa_switch_parse_ports_of(struct dsa_switch *ds,
  482. struct device_node *dn)
  483. {
  484. struct device_node *ports, *port;
  485. struct dsa_port *dp;
  486. u32 reg;
  487. int err;
  488. ports = of_get_child_by_name(dn, "ports");
  489. if (!ports) {
  490. dev_err(ds->dev, "no ports child node found\n");
  491. return -EINVAL;
  492. }
  493. for_each_available_child_of_node(ports, port) {
  494. err = of_property_read_u32(port, "reg", &reg);
  495. if (err)
  496. return err;
  497. if (reg >= ds->num_ports)
  498. return -EINVAL;
  499. dp = &ds->ports[reg];
  500. err = dsa_port_parse_of(dp, port);
  501. if (err)
  502. return err;
  503. }
  504. return 0;
  505. }
  506. static int dsa_switch_parse_member_of(struct dsa_switch *ds,
  507. struct device_node *dn)
  508. {
  509. u32 m[2] = { 0, 0 };
  510. int sz;
  511. /* Don't error out if this optional property isn't found */
  512. sz = of_property_read_variable_u32_array(dn, "dsa,member", m, 2, 2);
  513. if (sz < 0 && sz != -EINVAL)
  514. return sz;
  515. ds->index = m[1];
  516. if (ds->index >= DSA_MAX_SWITCHES)
  517. return -EINVAL;
  518. ds->dst = dsa_tree_touch(m[0]);
  519. if (!ds->dst)
  520. return -ENOMEM;
  521. return 0;
  522. }
  523. static int dsa_switch_parse_of(struct dsa_switch *ds, struct device_node *dn)
  524. {
  525. int err;
  526. err = dsa_switch_parse_member_of(ds, dn);
  527. if (err)
  528. return err;
  529. return dsa_switch_parse_ports_of(ds, dn);
  530. }
  531. static int dsa_port_parse(struct dsa_port *dp, const char *name,
  532. struct device *dev)
  533. {
  534. if (!strcmp(name, "cpu")) {
  535. struct net_device *master;
  536. master = dsa_dev_to_net_device(dev);
  537. if (!master)
  538. return -EPROBE_DEFER;
  539. dev_put(master);
  540. return dsa_port_parse_cpu(dp, master);
  541. }
  542. if (!strcmp(name, "dsa"))
  543. return dsa_port_parse_dsa(dp);
  544. return dsa_port_parse_user(dp, name);
  545. }
  546. static int dsa_switch_parse_ports(struct dsa_switch *ds,
  547. struct dsa_chip_data *cd)
  548. {
  549. bool valid_name_found = false;
  550. struct dsa_port *dp;
  551. struct device *dev;
  552. const char *name;
  553. unsigned int i;
  554. int err;
  555. for (i = 0; i < DSA_MAX_PORTS; i++) {
  556. name = cd->port_names[i];
  557. dev = cd->netdev[i];
  558. dp = &ds->ports[i];
  559. if (!name)
  560. continue;
  561. err = dsa_port_parse(dp, name, dev);
  562. if (err)
  563. return err;
  564. valid_name_found = true;
  565. }
  566. if (!valid_name_found && i == DSA_MAX_PORTS)
  567. return -EINVAL;
  568. return 0;
  569. }
  570. static int dsa_switch_parse(struct dsa_switch *ds, struct dsa_chip_data *cd)
  571. {
  572. ds->cd = cd;
  573. /* We don't support interconnected switches nor multiple trees via
  574. * platform data, so this is the unique switch of the tree.
  575. */
  576. ds->index = 0;
  577. ds->dst = dsa_tree_touch(0);
  578. if (!ds->dst)
  579. return -ENOMEM;
  580. return dsa_switch_parse_ports(ds, cd);
  581. }
  582. static int dsa_switch_add(struct dsa_switch *ds)
  583. {
  584. struct dsa_switch_tree *dst = ds->dst;
  585. return dsa_tree_add_switch(dst, ds);
  586. }
  587. static int dsa_switch_probe(struct dsa_switch *ds)
  588. {
  589. struct dsa_chip_data *pdata = ds->dev->platform_data;
  590. struct device_node *np = ds->dev->of_node;
  591. int err;
  592. if (np)
  593. err = dsa_switch_parse_of(ds, np);
  594. else if (pdata)
  595. err = dsa_switch_parse(ds, pdata);
  596. else
  597. err = -ENODEV;
  598. if (err)
  599. return err;
  600. return dsa_switch_add(ds);
  601. }
  602. struct dsa_switch *dsa_switch_alloc(struct device *dev, size_t n)
  603. {
  604. size_t size = sizeof(struct dsa_switch) + n * sizeof(struct dsa_port);
  605. struct dsa_switch *ds;
  606. int i;
  607. ds = devm_kzalloc(dev, size, GFP_KERNEL);
  608. if (!ds)
  609. return NULL;
  610. /* We avoid allocating memory outside dsa_switch
  611. * if it is not needed.
  612. */
  613. if (n <= sizeof(ds->_bitmap) * 8) {
  614. ds->bitmap = &ds->_bitmap;
  615. } else {
  616. ds->bitmap = devm_kcalloc(dev,
  617. BITS_TO_LONGS(n),
  618. sizeof(unsigned long),
  619. GFP_KERNEL);
  620. if (unlikely(!ds->bitmap))
  621. return NULL;
  622. }
  623. ds->dev = dev;
  624. ds->num_ports = n;
  625. for (i = 0; i < ds->num_ports; ++i) {
  626. ds->ports[i].index = i;
  627. ds->ports[i].ds = ds;
  628. }
  629. return ds;
  630. }
  631. EXPORT_SYMBOL_GPL(dsa_switch_alloc);
  632. int dsa_register_switch(struct dsa_switch *ds)
  633. {
  634. int err;
  635. mutex_lock(&dsa2_mutex);
  636. err = dsa_switch_probe(ds);
  637. dsa_tree_put(ds->dst);
  638. mutex_unlock(&dsa2_mutex);
  639. return err;
  640. }
  641. EXPORT_SYMBOL_GPL(dsa_register_switch);
  642. static void dsa_switch_remove(struct dsa_switch *ds)
  643. {
  644. struct dsa_switch_tree *dst = ds->dst;
  645. unsigned int index = ds->index;
  646. dsa_tree_remove_switch(dst, index);
  647. }
  648. void dsa_unregister_switch(struct dsa_switch *ds)
  649. {
  650. mutex_lock(&dsa2_mutex);
  651. dsa_switch_remove(ds);
  652. mutex_unlock(&dsa2_mutex);
  653. }
  654. EXPORT_SYMBOL_GPL(dsa_unregister_switch);