slave.c 55 KB

1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889909192939495969798991001011021031041051061071081091101111121131141151161171181191201211221231241251261271281291301311321331341351361371381391401411421431441451461471481491501511521531541551561571581591601611621631641651661671681691701711721731741751761771781791801811821831841851861871881891901911921931941951961971981992002012022032042052062072082092102112122132142152162172182192202212222232242252262272282292302312322332342352362372382392402412422432442452462472482492502512522532542552562572582592602612622632642652662672682692702712722732742752762772782792802812822832842852862872882892902912922932942952962972982993003013023033043053063073083093103113123133143153163173183193203213223233243253263273283293303313323333343353363373383393403413423433443453463473483493503513523533543553563573583593603613623633643653663673683693703713723733743753763773783793803813823833843853863873883893903913923933943953963973983994004014024034044054064074084094104114124134144154164174184194204214224234244254264274284294304314324334344354364374384394404414424434444454464474484494504514524534544554564574584594604614624634644654664674684694704714724734744754764774784794804814824834844854864874884894904914924934944954964974984995005015025035045055065075085095105115125135145155165175185195205215225235245255265275285295305315325335345355365375385395405415425435445455465475485495505515525535545555565575585595605615625635645655665675685695705715725735745755765775785795805815825835845855865875885895905915925935945955965975985996006016026036046056066076086096106116126136146156166176186196206216226236246256266276286296306316326336346356366376386396406416426436446456466476486496506516526536546556566576586596606616626636646656666676686696706716726736746756766776786796806816826836846856866876886896906916926936946956966976986997007017027037047057067077087097107117127137147157167177187197207217227237247257267277287297307317327337347357367377387397407417427437447457467477487497507517527537547557567577587597607617627637647657667677687697707717727737747757767777787797807817827837847857867877887897907917927937947957967977987998008018028038048058068078088098108118128138148158168178188198208218228238248258268278288298308318328338348358368378388398408418428438448458468478488498508518528538548558568578588598608618628638648658668678688698708718728738748758768778788798808818828838848858868878888898908918928938948958968978988999009019029039049059069079089099109119129139149159169179189199209219229239249259269279289299309319329339349359369379389399409419429439449459469479489499509519529539549559569579589599609619629639649659669679689699709719729739749759769779789799809819829839849859869879889899909919929939949959969979989991000100110021003100410051006100710081009101010111012101310141015101610171018101910201021102210231024102510261027102810291030103110321033103410351036103710381039104010411042104310441045104610471048104910501051105210531054105510561057105810591060106110621063106410651066106710681069107010711072107310741075107610771078107910801081108210831084108510861087108810891090109110921093109410951096109710981099110011011102110311041105110611071108110911101111111211131114111511161117111811191120112111221123112411251126112711281129113011311132113311341135113611371138113911401141114211431144114511461147114811491150115111521153115411551156115711581159116011611162116311641165116611671168116911701171117211731174117511761177117811791180118111821183118411851186118711881189119011911192119311941195119611971198119912001201120212031204120512061207120812091210121112121213121412151216121712181219122012211222122312241225122612271228122912301231123212331234123512361237123812391240124112421243124412451246124712481249125012511252125312541255125612571258125912601261126212631264126512661267126812691270127112721273127412751276127712781279128012811282128312841285128612871288128912901291129212931294129512961297129812991300130113021303130413051306130713081309131013111312131313141315131613171318131913201321132213231324132513261327132813291330133113321333133413351336133713381339134013411342134313441345134613471348134913501351135213531354135513561357135813591360136113621363136413651366136713681369137013711372137313741375137613771378137913801381138213831384138513861387138813891390139113921393139413951396139713981399140014011402140314041405140614071408140914101411141214131414141514161417141814191420142114221423142414251426142714281429143014311432143314341435143614371438143914401441144214431444144514461447144814491450145114521453145414551456145714581459146014611462146314641465146614671468146914701471147214731474147514761477147814791480148114821483148414851486148714881489149014911492149314941495149614971498149915001501150215031504150515061507150815091510151115121513151415151516151715181519152015211522152315241525152615271528152915301531153215331534153515361537153815391540154115421543154415451546154715481549155015511552155315541555155615571558155915601561156215631564156515661567156815691570157115721573157415751576157715781579158015811582158315841585158615871588158915901591159215931594159515961597159815991600160116021603160416051606160716081609161016111612161316141615161616171618161916201621162216231624162516261627162816291630163116321633163416351636163716381639164016411642164316441645164616471648164916501651165216531654165516561657165816591660166116621663166416651666166716681669167016711672167316741675167616771678167916801681168216831684168516861687168816891690169116921693169416951696169716981699170017011702170317041705170617071708170917101711171217131714171517161717171817191720172117221723172417251726172717281729173017311732173317341735173617371738173917401741174217431744174517461747174817491750175117521753175417551756175717581759176017611762176317641765176617671768176917701771177217731774177517761777177817791780178117821783178417851786178717881789179017911792179317941795179617971798179918001801180218031804180518061807180818091810181118121813181418151816181718181819182018211822182318241825182618271828182918301831183218331834183518361837183818391840184118421843184418451846184718481849185018511852185318541855185618571858185918601861186218631864186518661867186818691870187118721873187418751876187718781879188018811882188318841885188618871888188918901891189218931894189518961897189818991900190119021903190419051906190719081909191019111912191319141915191619171918191919201921192219231924192519261927192819291930193119321933193419351936193719381939194019411942194319441945194619471948194919501951195219531954195519561957195819591960196119621963196419651966196719681969197019711972197319741975197619771978197919801981198219831984198519861987198819891990199119921993199419951996199719981999200020012002200320042005200620072008200920102011201220132014201520162017201820192020202120222023202420252026202720282029203020312032203320342035203620372038203920402041204220432044204520462047204820492050205120522053205420552056205720582059206020612062206320642065206620672068206920702071207220732074207520762077207820792080208120822083208420852086208720882089209020912092209320942095209620972098209921002101210221032104210521062107210821092110211121122113211421152116211721182119212021212122212321242125212621272128212921302131213221332134213521362137213821392140214121422143214421452146214721482149215021512152215321542155215621572158215921602161216221632164216521662167216821692170217121722173217421752176217721782179218021812182218321842185218621872188218921902191219221932194219521962197219821992200220122022203220422052206220722082209221022112212221322142215221622172218221922202221222222232224222522262227222822292230223122322233223422352236223722382239224022412242224322442245224622472248224922502251
  1. // SPDX-License-Identifier: GPL-2.0-or-later
  2. /*
  3. * net/dsa/slave.c - Slave device handling
  4. * Copyright (c) 2008-2009 Marvell Semiconductor
  5. */
  6. #include <linux/list.h>
  7. #include <linux/etherdevice.h>
  8. #include <linux/netdevice.h>
  9. #include <linux/phy.h>
  10. #include <linux/phy_fixed.h>
  11. #include <linux/phylink.h>
  12. #include <linux/of_net.h>
  13. #include <linux/of_mdio.h>
  14. #include <linux/mdio.h>
  15. #include <net/rtnetlink.h>
  16. #include <net/pkt_cls.h>
  17. #include <net/tc_act/tc_mirred.h>
  18. #include <linux/if_bridge.h>
  19. #include <linux/netpoll.h>
  20. #include <linux/ptp_classify.h>
  21. #include "dsa_priv.h"
  22. /* slave mii_bus handling ***************************************************/
  23. static int dsa_slave_phy_read(struct mii_bus *bus, int addr, int reg)
  24. {
  25. struct dsa_switch *ds = bus->priv;
  26. if (ds->phys_mii_mask & (1 << addr))
  27. return ds->ops->phy_read(ds, addr, reg);
  28. return 0xffff;
  29. }
  30. static int dsa_slave_phy_write(struct mii_bus *bus, int addr, int reg, u16 val)
  31. {
  32. struct dsa_switch *ds = bus->priv;
  33. if (ds->phys_mii_mask & (1 << addr))
  34. return ds->ops->phy_write(ds, addr, reg, val);
  35. return 0;
  36. }
  37. void dsa_slave_mii_bus_init(struct dsa_switch *ds)
  38. {
  39. ds->slave_mii_bus->priv = (void *)ds;
  40. ds->slave_mii_bus->name = "dsa slave smi";
  41. ds->slave_mii_bus->read = dsa_slave_phy_read;
  42. ds->slave_mii_bus->write = dsa_slave_phy_write;
  43. snprintf(ds->slave_mii_bus->id, MII_BUS_ID_SIZE, "dsa-%d.%d",
  44. ds->dst->index, ds->index);
  45. ds->slave_mii_bus->parent = ds->dev;
  46. ds->slave_mii_bus->phy_mask = ~ds->phys_mii_mask;
  47. }
  48. /* slave device handling ****************************************************/
  49. static int dsa_slave_get_iflink(const struct net_device *dev)
  50. {
  51. return dsa_slave_to_master(dev)->ifindex;
  52. }
  53. static int dsa_slave_open(struct net_device *dev)
  54. {
  55. struct net_device *master = dsa_slave_to_master(dev);
  56. struct dsa_port *dp = dsa_slave_to_port(dev);
  57. int err;
  58. if (!(master->flags & IFF_UP))
  59. return -ENETDOWN;
  60. if (!ether_addr_equal(dev->dev_addr, master->dev_addr)) {
  61. err = dev_uc_add(master, dev->dev_addr);
  62. if (err < 0)
  63. goto out;
  64. }
  65. if (dev->flags & IFF_ALLMULTI) {
  66. err = dev_set_allmulti(master, 1);
  67. if (err < 0)
  68. goto del_unicast;
  69. }
  70. if (dev->flags & IFF_PROMISC) {
  71. err = dev_set_promiscuity(master, 1);
  72. if (err < 0)
  73. goto clear_allmulti;
  74. }
  75. err = dsa_port_enable_rt(dp, dev->phydev);
  76. if (err)
  77. goto clear_promisc;
  78. return 0;
  79. clear_promisc:
  80. if (dev->flags & IFF_PROMISC)
  81. dev_set_promiscuity(master, -1);
  82. clear_allmulti:
  83. if (dev->flags & IFF_ALLMULTI)
  84. dev_set_allmulti(master, -1);
  85. del_unicast:
  86. if (!ether_addr_equal(dev->dev_addr, master->dev_addr))
  87. dev_uc_del(master, dev->dev_addr);
  88. out:
  89. return err;
  90. }
  91. static int dsa_slave_close(struct net_device *dev)
  92. {
  93. struct net_device *master = dsa_slave_to_master(dev);
  94. struct dsa_port *dp = dsa_slave_to_port(dev);
  95. dsa_port_disable_rt(dp);
  96. dev_mc_unsync(master, dev);
  97. dev_uc_unsync(master, dev);
  98. if (dev->flags & IFF_ALLMULTI)
  99. dev_set_allmulti(master, -1);
  100. if (dev->flags & IFF_PROMISC)
  101. dev_set_promiscuity(master, -1);
  102. if (!ether_addr_equal(dev->dev_addr, master->dev_addr))
  103. dev_uc_del(master, dev->dev_addr);
  104. return 0;
  105. }
  106. static void dsa_slave_change_rx_flags(struct net_device *dev, int change)
  107. {
  108. struct net_device *master = dsa_slave_to_master(dev);
  109. if (dev->flags & IFF_UP) {
  110. if (change & IFF_ALLMULTI)
  111. dev_set_allmulti(master,
  112. dev->flags & IFF_ALLMULTI ? 1 : -1);
  113. if (change & IFF_PROMISC)
  114. dev_set_promiscuity(master,
  115. dev->flags & IFF_PROMISC ? 1 : -1);
  116. }
  117. }
  118. static void dsa_slave_set_rx_mode(struct net_device *dev)
  119. {
  120. struct net_device *master = dsa_slave_to_master(dev);
  121. dev_mc_sync(master, dev);
  122. dev_uc_sync(master, dev);
  123. }
  124. static int dsa_slave_set_mac_address(struct net_device *dev, void *a)
  125. {
  126. struct net_device *master = dsa_slave_to_master(dev);
  127. struct sockaddr *addr = a;
  128. int err;
  129. if (!is_valid_ether_addr(addr->sa_data))
  130. return -EADDRNOTAVAIL;
  131. if (!(dev->flags & IFF_UP))
  132. goto out;
  133. if (!ether_addr_equal(addr->sa_data, master->dev_addr)) {
  134. err = dev_uc_add(master, addr->sa_data);
  135. if (err < 0)
  136. return err;
  137. }
  138. if (!ether_addr_equal(dev->dev_addr, master->dev_addr))
  139. dev_uc_del(master, dev->dev_addr);
  140. out:
  141. ether_addr_copy(dev->dev_addr, addr->sa_data);
  142. return 0;
  143. }
  144. struct dsa_slave_dump_ctx {
  145. struct net_device *dev;
  146. struct sk_buff *skb;
  147. struct netlink_callback *cb;
  148. int idx;
  149. };
  150. static int
  151. dsa_slave_port_fdb_do_dump(const unsigned char *addr, u16 vid,
  152. bool is_static, void *data)
  153. {
  154. struct dsa_slave_dump_ctx *dump = data;
  155. u32 portid = NETLINK_CB(dump->cb->skb).portid;
  156. u32 seq = dump->cb->nlh->nlmsg_seq;
  157. struct nlmsghdr *nlh;
  158. struct ndmsg *ndm;
  159. if (dump->idx < dump->cb->args[2])
  160. goto skip;
  161. nlh = nlmsg_put(dump->skb, portid, seq, RTM_NEWNEIGH,
  162. sizeof(*ndm), NLM_F_MULTI);
  163. if (!nlh)
  164. return -EMSGSIZE;
  165. ndm = nlmsg_data(nlh);
  166. ndm->ndm_family = AF_BRIDGE;
  167. ndm->ndm_pad1 = 0;
  168. ndm->ndm_pad2 = 0;
  169. ndm->ndm_flags = NTF_SELF;
  170. ndm->ndm_type = 0;
  171. ndm->ndm_ifindex = dump->dev->ifindex;
  172. ndm->ndm_state = is_static ? NUD_NOARP : NUD_REACHABLE;
  173. if (nla_put(dump->skb, NDA_LLADDR, ETH_ALEN, addr))
  174. goto nla_put_failure;
  175. if (vid && nla_put_u16(dump->skb, NDA_VLAN, vid))
  176. goto nla_put_failure;
  177. nlmsg_end(dump->skb, nlh);
  178. skip:
  179. dump->idx++;
  180. return 0;
  181. nla_put_failure:
  182. nlmsg_cancel(dump->skb, nlh);
  183. return -EMSGSIZE;
  184. }
  185. static int
  186. dsa_slave_fdb_dump(struct sk_buff *skb, struct netlink_callback *cb,
  187. struct net_device *dev, struct net_device *filter_dev,
  188. int *idx)
  189. {
  190. struct dsa_port *dp = dsa_slave_to_port(dev);
  191. struct dsa_slave_dump_ctx dump = {
  192. .dev = dev,
  193. .skb = skb,
  194. .cb = cb,
  195. .idx = *idx,
  196. };
  197. int err;
  198. err = dsa_port_fdb_dump(dp, dsa_slave_port_fdb_do_dump, &dump);
  199. *idx = dump.idx;
  200. return err;
  201. }
  202. static int dsa_slave_ioctl(struct net_device *dev, struct ifreq *ifr, int cmd)
  203. {
  204. struct dsa_slave_priv *p = netdev_priv(dev);
  205. struct dsa_switch *ds = p->dp->ds;
  206. int port = p->dp->index;
  207. /* Pass through to switch driver if it supports timestamping */
  208. switch (cmd) {
  209. case SIOCGHWTSTAMP:
  210. if (ds->ops->port_hwtstamp_get)
  211. return ds->ops->port_hwtstamp_get(ds, port, ifr);
  212. break;
  213. case SIOCSHWTSTAMP:
  214. if (ds->ops->port_hwtstamp_set)
  215. return ds->ops->port_hwtstamp_set(ds, port, ifr);
  216. break;
  217. }
  218. return phylink_mii_ioctl(p->dp->pl, ifr, cmd);
  219. }
  220. static int dsa_slave_port_attr_set(struct net_device *dev,
  221. const struct switchdev_attr *attr,
  222. struct switchdev_trans *trans)
  223. {
  224. struct dsa_port *dp = dsa_slave_to_port(dev);
  225. int ret;
  226. switch (attr->id) {
  227. case SWITCHDEV_ATTR_ID_PORT_STP_STATE:
  228. ret = dsa_port_set_state(dp, attr->u.stp_state, trans);
  229. break;
  230. case SWITCHDEV_ATTR_ID_BRIDGE_VLAN_FILTERING:
  231. ret = dsa_port_vlan_filtering(dp, attr->u.vlan_filtering,
  232. trans);
  233. break;
  234. case SWITCHDEV_ATTR_ID_BRIDGE_AGEING_TIME:
  235. ret = dsa_port_ageing_time(dp, attr->u.ageing_time, trans);
  236. break;
  237. case SWITCHDEV_ATTR_ID_PORT_PRE_BRIDGE_FLAGS:
  238. ret = dsa_port_pre_bridge_flags(dp, attr->u.brport_flags,
  239. trans);
  240. break;
  241. case SWITCHDEV_ATTR_ID_PORT_BRIDGE_FLAGS:
  242. ret = dsa_port_bridge_flags(dp, attr->u.brport_flags, trans);
  243. break;
  244. case SWITCHDEV_ATTR_ID_BRIDGE_MROUTER:
  245. ret = dsa_port_mrouter(dp->cpu_dp, attr->u.mrouter, trans);
  246. break;
  247. default:
  248. ret = -EOPNOTSUPP;
  249. break;
  250. }
  251. return ret;
  252. }
  253. /* Must be called under rcu_read_lock() */
  254. static int
  255. dsa_slave_vlan_check_for_8021q_uppers(struct net_device *slave,
  256. const struct switchdev_obj_port_vlan *vlan)
  257. {
  258. struct net_device *upper_dev;
  259. struct list_head *iter;
  260. netdev_for_each_upper_dev_rcu(slave, upper_dev, iter) {
  261. u16 vid;
  262. if (!is_vlan_dev(upper_dev))
  263. continue;
  264. vid = vlan_dev_vlan_id(upper_dev);
  265. if (vid >= vlan->vid_begin && vid <= vlan->vid_end)
  266. return -EBUSY;
  267. }
  268. return 0;
  269. }
  270. static int dsa_slave_vlan_add(struct net_device *dev,
  271. const struct switchdev_obj *obj,
  272. struct switchdev_trans *trans)
  273. {
  274. struct net_device *master = dsa_slave_to_master(dev);
  275. struct dsa_port *dp = dsa_slave_to_port(dev);
  276. struct switchdev_obj_port_vlan vlan;
  277. int vid, err;
  278. if (obj->orig_dev != dev)
  279. return -EOPNOTSUPP;
  280. if (dsa_port_skip_vlan_configuration(dp))
  281. return 0;
  282. vlan = *SWITCHDEV_OBJ_PORT_VLAN(obj);
  283. /* Deny adding a bridge VLAN when there is already an 802.1Q upper with
  284. * the same VID.
  285. */
  286. if (trans->ph_prepare && br_vlan_enabled(dp->bridge_dev)) {
  287. rcu_read_lock();
  288. err = dsa_slave_vlan_check_for_8021q_uppers(dev, &vlan);
  289. rcu_read_unlock();
  290. if (err)
  291. return err;
  292. }
  293. err = dsa_port_vlan_add(dp, &vlan, trans);
  294. if (err)
  295. return err;
  296. /* We need the dedicated CPU port to be a member of the VLAN as well.
  297. * Even though drivers often handle CPU membership in special ways,
  298. * it doesn't make sense to program a PVID, so clear this flag.
  299. */
  300. vlan.flags &= ~BRIDGE_VLAN_INFO_PVID;
  301. err = dsa_port_vlan_add(dp->cpu_dp, &vlan, trans);
  302. if (err)
  303. return err;
  304. for (vid = vlan.vid_begin; vid <= vlan.vid_end; vid++) {
  305. err = vlan_vid_add(master, htons(ETH_P_8021Q), vid);
  306. if (err)
  307. return err;
  308. }
  309. return 0;
  310. }
  311. static int dsa_slave_port_obj_add(struct net_device *dev,
  312. const struct switchdev_obj *obj,
  313. struct switchdev_trans *trans,
  314. struct netlink_ext_ack *extack)
  315. {
  316. struct dsa_port *dp = dsa_slave_to_port(dev);
  317. int err;
  318. /* For the prepare phase, ensure the full set of changes is feasable in
  319. * one go in order to signal a failure properly. If an operation is not
  320. * supported, return -EOPNOTSUPP.
  321. */
  322. switch (obj->id) {
  323. case SWITCHDEV_OBJ_ID_PORT_MDB:
  324. if (obj->orig_dev != dev)
  325. return -EOPNOTSUPP;
  326. err = dsa_port_mdb_add(dp, SWITCHDEV_OBJ_PORT_MDB(obj), trans);
  327. break;
  328. case SWITCHDEV_OBJ_ID_HOST_MDB:
  329. /* DSA can directly translate this to a normal MDB add,
  330. * but on the CPU port.
  331. */
  332. err = dsa_port_mdb_add(dp->cpu_dp, SWITCHDEV_OBJ_PORT_MDB(obj),
  333. trans);
  334. break;
  335. case SWITCHDEV_OBJ_ID_PORT_VLAN:
  336. err = dsa_slave_vlan_add(dev, obj, trans);
  337. break;
  338. default:
  339. err = -EOPNOTSUPP;
  340. break;
  341. }
  342. return err;
  343. }
  344. static int dsa_slave_vlan_del(struct net_device *dev,
  345. const struct switchdev_obj *obj)
  346. {
  347. struct net_device *master = dsa_slave_to_master(dev);
  348. struct dsa_port *dp = dsa_slave_to_port(dev);
  349. struct switchdev_obj_port_vlan *vlan;
  350. int vid, err;
  351. if (obj->orig_dev != dev)
  352. return -EOPNOTSUPP;
  353. if (dsa_port_skip_vlan_configuration(dp))
  354. return 0;
  355. vlan = SWITCHDEV_OBJ_PORT_VLAN(obj);
  356. /* Do not deprogram the CPU port as it may be shared with other user
  357. * ports which can be members of this VLAN as well.
  358. */
  359. err = dsa_port_vlan_del(dp, vlan);
  360. if (err)
  361. return err;
  362. for (vid = vlan->vid_begin; vid <= vlan->vid_end; vid++)
  363. vlan_vid_del(master, htons(ETH_P_8021Q), vid);
  364. return 0;
  365. }
  366. static int dsa_slave_port_obj_del(struct net_device *dev,
  367. const struct switchdev_obj *obj)
  368. {
  369. struct dsa_port *dp = dsa_slave_to_port(dev);
  370. int err;
  371. switch (obj->id) {
  372. case SWITCHDEV_OBJ_ID_PORT_MDB:
  373. if (obj->orig_dev != dev)
  374. return -EOPNOTSUPP;
  375. err = dsa_port_mdb_del(dp, SWITCHDEV_OBJ_PORT_MDB(obj));
  376. break;
  377. case SWITCHDEV_OBJ_ID_HOST_MDB:
  378. /* DSA can directly translate this to a normal MDB add,
  379. * but on the CPU port.
  380. */
  381. err = dsa_port_mdb_del(dp->cpu_dp, SWITCHDEV_OBJ_PORT_MDB(obj));
  382. break;
  383. case SWITCHDEV_OBJ_ID_PORT_VLAN:
  384. err = dsa_slave_vlan_del(dev, obj);
  385. break;
  386. default:
  387. err = -EOPNOTSUPP;
  388. break;
  389. }
  390. return err;
  391. }
  392. static int dsa_slave_get_port_parent_id(struct net_device *dev,
  393. struct netdev_phys_item_id *ppid)
  394. {
  395. struct dsa_port *dp = dsa_slave_to_port(dev);
  396. struct dsa_switch *ds = dp->ds;
  397. struct dsa_switch_tree *dst = ds->dst;
  398. /* For non-legacy ports, devlink is used and it takes
  399. * care of the name generation. This ndo implementation
  400. * should be removed with legacy support.
  401. */
  402. if (dp->ds->devlink)
  403. return -EOPNOTSUPP;
  404. ppid->id_len = sizeof(dst->index);
  405. memcpy(&ppid->id, &dst->index, ppid->id_len);
  406. return 0;
  407. }
  408. static inline netdev_tx_t dsa_slave_netpoll_send_skb(struct net_device *dev,
  409. struct sk_buff *skb)
  410. {
  411. #ifdef CONFIG_NET_POLL_CONTROLLER
  412. struct dsa_slave_priv *p = netdev_priv(dev);
  413. return netpoll_send_skb(p->netpoll, skb);
  414. #else
  415. BUG();
  416. return NETDEV_TX_OK;
  417. #endif
  418. }
  419. static void dsa_skb_tx_timestamp(struct dsa_slave_priv *p,
  420. struct sk_buff *skb)
  421. {
  422. struct dsa_switch *ds = p->dp->ds;
  423. struct sk_buff *clone;
  424. unsigned int type;
  425. type = ptp_classify_raw(skb);
  426. if (type == PTP_CLASS_NONE)
  427. return;
  428. if (!ds->ops->port_txtstamp)
  429. return;
  430. clone = skb_clone_sk(skb);
  431. if (!clone)
  432. return;
  433. DSA_SKB_CB(skb)->clone = clone;
  434. if (ds->ops->port_txtstamp(ds, p->dp->index, clone, type))
  435. return;
  436. kfree_skb(clone);
  437. }
  438. netdev_tx_t dsa_enqueue_skb(struct sk_buff *skb, struct net_device *dev)
  439. {
  440. /* SKB for netpoll still need to be mangled with the protocol-specific
  441. * tag to be successfully transmitted
  442. */
  443. if (unlikely(netpoll_tx_running(dev)))
  444. return dsa_slave_netpoll_send_skb(dev, skb);
  445. /* Queue the SKB for transmission on the parent interface, but
  446. * do not modify its EtherType
  447. */
  448. skb->dev = dsa_slave_to_master(dev);
  449. dev_queue_xmit(skb);
  450. return NETDEV_TX_OK;
  451. }
  452. EXPORT_SYMBOL_GPL(dsa_enqueue_skb);
  453. static int dsa_realloc_skb(struct sk_buff *skb, struct net_device *dev)
  454. {
  455. int needed_headroom = dev->needed_headroom;
  456. int needed_tailroom = dev->needed_tailroom;
  457. /* For tail taggers, we need to pad short frames ourselves, to ensure
  458. * that the tail tag does not fail at its role of being at the end of
  459. * the packet, once the master interface pads the frame. Account for
  460. * that pad length here, and pad later.
  461. */
  462. if (unlikely(needed_tailroom && skb->len < ETH_ZLEN))
  463. needed_tailroom += ETH_ZLEN - skb->len;
  464. /* skb_headroom() returns unsigned int... */
  465. needed_headroom = max_t(int, needed_headroom - skb_headroom(skb), 0);
  466. needed_tailroom = max_t(int, needed_tailroom - skb_tailroom(skb), 0);
  467. if (likely(!needed_headroom && !needed_tailroom && !skb_cloned(skb)))
  468. /* No reallocation needed, yay! */
  469. return 0;
  470. return pskb_expand_head(skb, needed_headroom, needed_tailroom,
  471. GFP_ATOMIC);
  472. }
  473. static netdev_tx_t dsa_slave_xmit(struct sk_buff *skb, struct net_device *dev)
  474. {
  475. struct dsa_slave_priv *p = netdev_priv(dev);
  476. struct pcpu_sw_netstats *s;
  477. struct sk_buff *nskb;
  478. s = this_cpu_ptr(p->stats64);
  479. u64_stats_update_begin(&s->syncp);
  480. s->tx_packets++;
  481. s->tx_bytes += skb->len;
  482. u64_stats_update_end(&s->syncp);
  483. DSA_SKB_CB(skb)->clone = NULL;
  484. /* Identify PTP protocol packets, clone them, and pass them to the
  485. * switch driver
  486. */
  487. dsa_skb_tx_timestamp(p, skb);
  488. if (dsa_realloc_skb(skb, dev)) {
  489. dev_kfree_skb_any(skb);
  490. return NETDEV_TX_OK;
  491. }
  492. /* needed_tailroom should still be 'warm' in the cache line from
  493. * dsa_realloc_skb(), which has also ensured that padding is safe.
  494. */
  495. if (dev->needed_tailroom)
  496. eth_skb_pad(skb);
  497. /* Transmit function may have to reallocate the original SKB,
  498. * in which case it must have freed it. Only free it here on error.
  499. */
  500. nskb = p->xmit(skb, dev);
  501. if (!nskb) {
  502. kfree_skb(skb);
  503. return NETDEV_TX_OK;
  504. }
  505. return dsa_enqueue_skb(nskb, dev);
  506. }
  507. /* ethtool operations *******************************************************/
  508. static void dsa_slave_get_drvinfo(struct net_device *dev,
  509. struct ethtool_drvinfo *drvinfo)
  510. {
  511. strlcpy(drvinfo->driver, "dsa", sizeof(drvinfo->driver));
  512. strlcpy(drvinfo->fw_version, "N/A", sizeof(drvinfo->fw_version));
  513. strlcpy(drvinfo->bus_info, "platform", sizeof(drvinfo->bus_info));
  514. }
  515. static int dsa_slave_get_regs_len(struct net_device *dev)
  516. {
  517. struct dsa_port *dp = dsa_slave_to_port(dev);
  518. struct dsa_switch *ds = dp->ds;
  519. if (ds->ops->get_regs_len)
  520. return ds->ops->get_regs_len(ds, dp->index);
  521. return -EOPNOTSUPP;
  522. }
  523. static void
  524. dsa_slave_get_regs(struct net_device *dev, struct ethtool_regs *regs, void *_p)
  525. {
  526. struct dsa_port *dp = dsa_slave_to_port(dev);
  527. struct dsa_switch *ds = dp->ds;
  528. if (ds->ops->get_regs)
  529. ds->ops->get_regs(ds, dp->index, regs, _p);
  530. }
  531. static int dsa_slave_nway_reset(struct net_device *dev)
  532. {
  533. struct dsa_port *dp = dsa_slave_to_port(dev);
  534. return phylink_ethtool_nway_reset(dp->pl);
  535. }
  536. static int dsa_slave_get_eeprom_len(struct net_device *dev)
  537. {
  538. struct dsa_port *dp = dsa_slave_to_port(dev);
  539. struct dsa_switch *ds = dp->ds;
  540. if (ds->cd && ds->cd->eeprom_len)
  541. return ds->cd->eeprom_len;
  542. if (ds->ops->get_eeprom_len)
  543. return ds->ops->get_eeprom_len(ds);
  544. return 0;
  545. }
  546. static int dsa_slave_get_eeprom(struct net_device *dev,
  547. struct ethtool_eeprom *eeprom, u8 *data)
  548. {
  549. struct dsa_port *dp = dsa_slave_to_port(dev);
  550. struct dsa_switch *ds = dp->ds;
  551. if (ds->ops->get_eeprom)
  552. return ds->ops->get_eeprom(ds, eeprom, data);
  553. return -EOPNOTSUPP;
  554. }
  555. static int dsa_slave_set_eeprom(struct net_device *dev,
  556. struct ethtool_eeprom *eeprom, u8 *data)
  557. {
  558. struct dsa_port *dp = dsa_slave_to_port(dev);
  559. struct dsa_switch *ds = dp->ds;
  560. if (ds->ops->set_eeprom)
  561. return ds->ops->set_eeprom(ds, eeprom, data);
  562. return -EOPNOTSUPP;
  563. }
  564. static void dsa_slave_get_strings(struct net_device *dev,
  565. uint32_t stringset, uint8_t *data)
  566. {
  567. struct dsa_port *dp = dsa_slave_to_port(dev);
  568. struct dsa_switch *ds = dp->ds;
  569. if (stringset == ETH_SS_STATS) {
  570. int len = ETH_GSTRING_LEN;
  571. strncpy(data, "tx_packets", len);
  572. strncpy(data + len, "tx_bytes", len);
  573. strncpy(data + 2 * len, "rx_packets", len);
  574. strncpy(data + 3 * len, "rx_bytes", len);
  575. if (ds->ops->get_strings)
  576. ds->ops->get_strings(ds, dp->index, stringset,
  577. data + 4 * len);
  578. }
  579. }
  580. static void dsa_slave_get_ethtool_stats(struct net_device *dev,
  581. struct ethtool_stats *stats,
  582. uint64_t *data)
  583. {
  584. struct dsa_port *dp = dsa_slave_to_port(dev);
  585. struct dsa_slave_priv *p = netdev_priv(dev);
  586. struct dsa_switch *ds = dp->ds;
  587. struct pcpu_sw_netstats *s;
  588. unsigned int start;
  589. int i;
  590. for_each_possible_cpu(i) {
  591. u64 tx_packets, tx_bytes, rx_packets, rx_bytes;
  592. s = per_cpu_ptr(p->stats64, i);
  593. do {
  594. start = u64_stats_fetch_begin_irq(&s->syncp);
  595. tx_packets = s->tx_packets;
  596. tx_bytes = s->tx_bytes;
  597. rx_packets = s->rx_packets;
  598. rx_bytes = s->rx_bytes;
  599. } while (u64_stats_fetch_retry_irq(&s->syncp, start));
  600. data[0] += tx_packets;
  601. data[1] += tx_bytes;
  602. data[2] += rx_packets;
  603. data[3] += rx_bytes;
  604. }
  605. if (ds->ops->get_ethtool_stats)
  606. ds->ops->get_ethtool_stats(ds, dp->index, data + 4);
  607. }
  608. static int dsa_slave_get_sset_count(struct net_device *dev, int sset)
  609. {
  610. struct dsa_port *dp = dsa_slave_to_port(dev);
  611. struct dsa_switch *ds = dp->ds;
  612. if (sset == ETH_SS_STATS) {
  613. int count = 0;
  614. if (ds->ops->get_sset_count) {
  615. count = ds->ops->get_sset_count(ds, dp->index, sset);
  616. if (count < 0)
  617. return count;
  618. }
  619. return count + 4;
  620. }
  621. return -EOPNOTSUPP;
  622. }
  623. static void dsa_slave_get_wol(struct net_device *dev, struct ethtool_wolinfo *w)
  624. {
  625. struct dsa_port *dp = dsa_slave_to_port(dev);
  626. struct dsa_switch *ds = dp->ds;
  627. phylink_ethtool_get_wol(dp->pl, w);
  628. if (ds->ops->get_wol)
  629. ds->ops->get_wol(ds, dp->index, w);
  630. }
  631. static int dsa_slave_set_wol(struct net_device *dev, struct ethtool_wolinfo *w)
  632. {
  633. struct dsa_port *dp = dsa_slave_to_port(dev);
  634. struct dsa_switch *ds = dp->ds;
  635. int ret = -EOPNOTSUPP;
  636. phylink_ethtool_set_wol(dp->pl, w);
  637. if (ds->ops->set_wol)
  638. ret = ds->ops->set_wol(ds, dp->index, w);
  639. return ret;
  640. }
  641. static int dsa_slave_set_eee(struct net_device *dev, struct ethtool_eee *e)
  642. {
  643. struct dsa_port *dp = dsa_slave_to_port(dev);
  644. struct dsa_switch *ds = dp->ds;
  645. int ret;
  646. /* Port's PHY and MAC both need to be EEE capable */
  647. if (!dev->phydev || !dp->pl)
  648. return -ENODEV;
  649. if (!ds->ops->set_mac_eee)
  650. return -EOPNOTSUPP;
  651. ret = ds->ops->set_mac_eee(ds, dp->index, e);
  652. if (ret)
  653. return ret;
  654. return phylink_ethtool_set_eee(dp->pl, e);
  655. }
  656. static int dsa_slave_get_eee(struct net_device *dev, struct ethtool_eee *e)
  657. {
  658. struct dsa_port *dp = dsa_slave_to_port(dev);
  659. struct dsa_switch *ds = dp->ds;
  660. int ret;
  661. /* Port's PHY and MAC both need to be EEE capable */
  662. if (!dev->phydev || !dp->pl)
  663. return -ENODEV;
  664. if (!ds->ops->get_mac_eee)
  665. return -EOPNOTSUPP;
  666. ret = ds->ops->get_mac_eee(ds, dp->index, e);
  667. if (ret)
  668. return ret;
  669. return phylink_ethtool_get_eee(dp->pl, e);
  670. }
  671. static int dsa_slave_get_link_ksettings(struct net_device *dev,
  672. struct ethtool_link_ksettings *cmd)
  673. {
  674. struct dsa_port *dp = dsa_slave_to_port(dev);
  675. return phylink_ethtool_ksettings_get(dp->pl, cmd);
  676. }
  677. static int dsa_slave_set_link_ksettings(struct net_device *dev,
  678. const struct ethtool_link_ksettings *cmd)
  679. {
  680. struct dsa_port *dp = dsa_slave_to_port(dev);
  681. return phylink_ethtool_ksettings_set(dp->pl, cmd);
  682. }
  683. static void dsa_slave_get_pauseparam(struct net_device *dev,
  684. struct ethtool_pauseparam *pause)
  685. {
  686. struct dsa_port *dp = dsa_slave_to_port(dev);
  687. phylink_ethtool_get_pauseparam(dp->pl, pause);
  688. }
  689. static int dsa_slave_set_pauseparam(struct net_device *dev,
  690. struct ethtool_pauseparam *pause)
  691. {
  692. struct dsa_port *dp = dsa_slave_to_port(dev);
  693. return phylink_ethtool_set_pauseparam(dp->pl, pause);
  694. }
  695. #ifdef CONFIG_NET_POLL_CONTROLLER
  696. static int dsa_slave_netpoll_setup(struct net_device *dev,
  697. struct netpoll_info *ni)
  698. {
  699. struct net_device *master = dsa_slave_to_master(dev);
  700. struct dsa_slave_priv *p = netdev_priv(dev);
  701. struct netpoll *netpoll;
  702. int err = 0;
  703. netpoll = kzalloc(sizeof(*netpoll), GFP_KERNEL);
  704. if (!netpoll)
  705. return -ENOMEM;
  706. err = __netpoll_setup(netpoll, master);
  707. if (err) {
  708. kfree(netpoll);
  709. goto out;
  710. }
  711. p->netpoll = netpoll;
  712. out:
  713. return err;
  714. }
  715. static void dsa_slave_netpoll_cleanup(struct net_device *dev)
  716. {
  717. struct dsa_slave_priv *p = netdev_priv(dev);
  718. struct netpoll *netpoll = p->netpoll;
  719. if (!netpoll)
  720. return;
  721. p->netpoll = NULL;
  722. __netpoll_free(netpoll);
  723. }
  724. static void dsa_slave_poll_controller(struct net_device *dev)
  725. {
  726. }
  727. #endif
  728. static int dsa_slave_get_phys_port_name(struct net_device *dev,
  729. char *name, size_t len)
  730. {
  731. struct dsa_port *dp = dsa_slave_to_port(dev);
  732. /* For non-legacy ports, devlink is used and it takes
  733. * care of the name generation. This ndo implementation
  734. * should be removed with legacy support.
  735. */
  736. if (dp->ds->devlink)
  737. return -EOPNOTSUPP;
  738. if (snprintf(name, len, "p%d", dp->index) >= len)
  739. return -EINVAL;
  740. return 0;
  741. }
  742. static struct dsa_mall_tc_entry *
  743. dsa_slave_mall_tc_entry_find(struct net_device *dev, unsigned long cookie)
  744. {
  745. struct dsa_slave_priv *p = netdev_priv(dev);
  746. struct dsa_mall_tc_entry *mall_tc_entry;
  747. list_for_each_entry(mall_tc_entry, &p->mall_tc_list, list)
  748. if (mall_tc_entry->cookie == cookie)
  749. return mall_tc_entry;
  750. return NULL;
  751. }
  752. static int
  753. dsa_slave_add_cls_matchall_mirred(struct net_device *dev,
  754. struct tc_cls_matchall_offload *cls,
  755. bool ingress)
  756. {
  757. struct dsa_port *dp = dsa_slave_to_port(dev);
  758. struct dsa_slave_priv *p = netdev_priv(dev);
  759. struct dsa_mall_mirror_tc_entry *mirror;
  760. struct dsa_mall_tc_entry *mall_tc_entry;
  761. struct dsa_switch *ds = dp->ds;
  762. struct flow_action_entry *act;
  763. struct dsa_port *to_dp;
  764. int err;
  765. if (!ds->ops->port_mirror_add)
  766. return -EOPNOTSUPP;
  767. if (!flow_action_basic_hw_stats_check(&cls->rule->action,
  768. cls->common.extack))
  769. return -EOPNOTSUPP;
  770. act = &cls->rule->action.entries[0];
  771. if (!act->dev)
  772. return -EINVAL;
  773. if (!dsa_slave_dev_check(act->dev))
  774. return -EOPNOTSUPP;
  775. mall_tc_entry = kzalloc(sizeof(*mall_tc_entry), GFP_KERNEL);
  776. if (!mall_tc_entry)
  777. return -ENOMEM;
  778. mall_tc_entry->cookie = cls->cookie;
  779. mall_tc_entry->type = DSA_PORT_MALL_MIRROR;
  780. mirror = &mall_tc_entry->mirror;
  781. to_dp = dsa_slave_to_port(act->dev);
  782. mirror->to_local_port = to_dp->index;
  783. mirror->ingress = ingress;
  784. err = ds->ops->port_mirror_add(ds, dp->index, mirror, ingress);
  785. if (err) {
  786. kfree(mall_tc_entry);
  787. return err;
  788. }
  789. list_add_tail(&mall_tc_entry->list, &p->mall_tc_list);
  790. return err;
  791. }
  792. static int
  793. dsa_slave_add_cls_matchall_police(struct net_device *dev,
  794. struct tc_cls_matchall_offload *cls,
  795. bool ingress)
  796. {
  797. struct netlink_ext_ack *extack = cls->common.extack;
  798. struct dsa_port *dp = dsa_slave_to_port(dev);
  799. struct dsa_slave_priv *p = netdev_priv(dev);
  800. struct dsa_mall_policer_tc_entry *policer;
  801. struct dsa_mall_tc_entry *mall_tc_entry;
  802. struct dsa_switch *ds = dp->ds;
  803. struct flow_action_entry *act;
  804. int err;
  805. if (!ds->ops->port_policer_add) {
  806. NL_SET_ERR_MSG_MOD(extack,
  807. "Policing offload not implemented");
  808. return -EOPNOTSUPP;
  809. }
  810. if (!ingress) {
  811. NL_SET_ERR_MSG_MOD(extack,
  812. "Only supported on ingress qdisc");
  813. return -EOPNOTSUPP;
  814. }
  815. if (!flow_action_basic_hw_stats_check(&cls->rule->action,
  816. cls->common.extack))
  817. return -EOPNOTSUPP;
  818. list_for_each_entry(mall_tc_entry, &p->mall_tc_list, list) {
  819. if (mall_tc_entry->type == DSA_PORT_MALL_POLICER) {
  820. NL_SET_ERR_MSG_MOD(extack,
  821. "Only one port policer allowed");
  822. return -EEXIST;
  823. }
  824. }
  825. act = &cls->rule->action.entries[0];
  826. mall_tc_entry = kzalloc(sizeof(*mall_tc_entry), GFP_KERNEL);
  827. if (!mall_tc_entry)
  828. return -ENOMEM;
  829. mall_tc_entry->cookie = cls->cookie;
  830. mall_tc_entry->type = DSA_PORT_MALL_POLICER;
  831. policer = &mall_tc_entry->policer;
  832. policer->rate_bytes_per_sec = act->police.rate_bytes_ps;
  833. policer->burst = act->police.burst;
  834. err = ds->ops->port_policer_add(ds, dp->index, policer);
  835. if (err) {
  836. kfree(mall_tc_entry);
  837. return err;
  838. }
  839. list_add_tail(&mall_tc_entry->list, &p->mall_tc_list);
  840. return err;
  841. }
  842. static int dsa_slave_add_cls_matchall(struct net_device *dev,
  843. struct tc_cls_matchall_offload *cls,
  844. bool ingress)
  845. {
  846. int err = -EOPNOTSUPP;
  847. if (cls->common.protocol == htons(ETH_P_ALL) &&
  848. flow_offload_has_one_action(&cls->rule->action) &&
  849. cls->rule->action.entries[0].id == FLOW_ACTION_MIRRED)
  850. err = dsa_slave_add_cls_matchall_mirred(dev, cls, ingress);
  851. else if (flow_offload_has_one_action(&cls->rule->action) &&
  852. cls->rule->action.entries[0].id == FLOW_ACTION_POLICE)
  853. err = dsa_slave_add_cls_matchall_police(dev, cls, ingress);
  854. return err;
  855. }
  856. static void dsa_slave_del_cls_matchall(struct net_device *dev,
  857. struct tc_cls_matchall_offload *cls)
  858. {
  859. struct dsa_port *dp = dsa_slave_to_port(dev);
  860. struct dsa_mall_tc_entry *mall_tc_entry;
  861. struct dsa_switch *ds = dp->ds;
  862. mall_tc_entry = dsa_slave_mall_tc_entry_find(dev, cls->cookie);
  863. if (!mall_tc_entry)
  864. return;
  865. list_del(&mall_tc_entry->list);
  866. switch (mall_tc_entry->type) {
  867. case DSA_PORT_MALL_MIRROR:
  868. if (ds->ops->port_mirror_del)
  869. ds->ops->port_mirror_del(ds, dp->index,
  870. &mall_tc_entry->mirror);
  871. break;
  872. case DSA_PORT_MALL_POLICER:
  873. if (ds->ops->port_policer_del)
  874. ds->ops->port_policer_del(ds, dp->index);
  875. break;
  876. default:
  877. WARN_ON(1);
  878. }
  879. kfree(mall_tc_entry);
  880. }
  881. static int dsa_slave_setup_tc_cls_matchall(struct net_device *dev,
  882. struct tc_cls_matchall_offload *cls,
  883. bool ingress)
  884. {
  885. if (cls->common.chain_index)
  886. return -EOPNOTSUPP;
  887. switch (cls->command) {
  888. case TC_CLSMATCHALL_REPLACE:
  889. return dsa_slave_add_cls_matchall(dev, cls, ingress);
  890. case TC_CLSMATCHALL_DESTROY:
  891. dsa_slave_del_cls_matchall(dev, cls);
  892. return 0;
  893. default:
  894. return -EOPNOTSUPP;
  895. }
  896. }
  897. static int dsa_slave_add_cls_flower(struct net_device *dev,
  898. struct flow_cls_offload *cls,
  899. bool ingress)
  900. {
  901. struct dsa_port *dp = dsa_slave_to_port(dev);
  902. struct dsa_switch *ds = dp->ds;
  903. int port = dp->index;
  904. if (!ds->ops->cls_flower_add)
  905. return -EOPNOTSUPP;
  906. return ds->ops->cls_flower_add(ds, port, cls, ingress);
  907. }
  908. static int dsa_slave_del_cls_flower(struct net_device *dev,
  909. struct flow_cls_offload *cls,
  910. bool ingress)
  911. {
  912. struct dsa_port *dp = dsa_slave_to_port(dev);
  913. struct dsa_switch *ds = dp->ds;
  914. int port = dp->index;
  915. if (!ds->ops->cls_flower_del)
  916. return -EOPNOTSUPP;
  917. return ds->ops->cls_flower_del(ds, port, cls, ingress);
  918. }
  919. static int dsa_slave_stats_cls_flower(struct net_device *dev,
  920. struct flow_cls_offload *cls,
  921. bool ingress)
  922. {
  923. struct dsa_port *dp = dsa_slave_to_port(dev);
  924. struct dsa_switch *ds = dp->ds;
  925. int port = dp->index;
  926. if (!ds->ops->cls_flower_stats)
  927. return -EOPNOTSUPP;
  928. return ds->ops->cls_flower_stats(ds, port, cls, ingress);
  929. }
  930. static int dsa_slave_setup_tc_cls_flower(struct net_device *dev,
  931. struct flow_cls_offload *cls,
  932. bool ingress)
  933. {
  934. switch (cls->command) {
  935. case FLOW_CLS_REPLACE:
  936. return dsa_slave_add_cls_flower(dev, cls, ingress);
  937. case FLOW_CLS_DESTROY:
  938. return dsa_slave_del_cls_flower(dev, cls, ingress);
  939. case FLOW_CLS_STATS:
  940. return dsa_slave_stats_cls_flower(dev, cls, ingress);
  941. default:
  942. return -EOPNOTSUPP;
  943. }
  944. }
  945. static int dsa_slave_setup_tc_block_cb(enum tc_setup_type type, void *type_data,
  946. void *cb_priv, bool ingress)
  947. {
  948. struct net_device *dev = cb_priv;
  949. if (!tc_can_offload(dev))
  950. return -EOPNOTSUPP;
  951. switch (type) {
  952. case TC_SETUP_CLSMATCHALL:
  953. return dsa_slave_setup_tc_cls_matchall(dev, type_data, ingress);
  954. case TC_SETUP_CLSFLOWER:
  955. return dsa_slave_setup_tc_cls_flower(dev, type_data, ingress);
  956. default:
  957. return -EOPNOTSUPP;
  958. }
  959. }
  960. static int dsa_slave_setup_tc_block_cb_ig(enum tc_setup_type type,
  961. void *type_data, void *cb_priv)
  962. {
  963. return dsa_slave_setup_tc_block_cb(type, type_data, cb_priv, true);
  964. }
  965. static int dsa_slave_setup_tc_block_cb_eg(enum tc_setup_type type,
  966. void *type_data, void *cb_priv)
  967. {
  968. return dsa_slave_setup_tc_block_cb(type, type_data, cb_priv, false);
  969. }
  970. static LIST_HEAD(dsa_slave_block_cb_list);
  971. static int dsa_slave_setup_tc_block(struct net_device *dev,
  972. struct flow_block_offload *f)
  973. {
  974. struct flow_block_cb *block_cb;
  975. flow_setup_cb_t *cb;
  976. if (f->binder_type == FLOW_BLOCK_BINDER_TYPE_CLSACT_INGRESS)
  977. cb = dsa_slave_setup_tc_block_cb_ig;
  978. else if (f->binder_type == FLOW_BLOCK_BINDER_TYPE_CLSACT_EGRESS)
  979. cb = dsa_slave_setup_tc_block_cb_eg;
  980. else
  981. return -EOPNOTSUPP;
  982. f->driver_block_list = &dsa_slave_block_cb_list;
  983. switch (f->command) {
  984. case FLOW_BLOCK_BIND:
  985. if (flow_block_cb_is_busy(cb, dev, &dsa_slave_block_cb_list))
  986. return -EBUSY;
  987. block_cb = flow_block_cb_alloc(cb, dev, dev, NULL);
  988. if (IS_ERR(block_cb))
  989. return PTR_ERR(block_cb);
  990. flow_block_cb_add(block_cb, f);
  991. list_add_tail(&block_cb->driver_list, &dsa_slave_block_cb_list);
  992. return 0;
  993. case FLOW_BLOCK_UNBIND:
  994. block_cb = flow_block_cb_lookup(f->block, cb, dev);
  995. if (!block_cb)
  996. return -ENOENT;
  997. flow_block_cb_remove(block_cb, f);
  998. list_del(&block_cb->driver_list);
  999. return 0;
  1000. default:
  1001. return -EOPNOTSUPP;
  1002. }
  1003. }
  1004. static int dsa_slave_setup_tc(struct net_device *dev, enum tc_setup_type type,
  1005. void *type_data)
  1006. {
  1007. struct dsa_port *dp = dsa_slave_to_port(dev);
  1008. struct dsa_switch *ds = dp->ds;
  1009. if (type == TC_SETUP_BLOCK)
  1010. return dsa_slave_setup_tc_block(dev, type_data);
  1011. if (!ds->ops->port_setup_tc)
  1012. return -EOPNOTSUPP;
  1013. return ds->ops->port_setup_tc(ds, dp->index, type, type_data);
  1014. }
  1015. static void dsa_slave_get_stats64(struct net_device *dev,
  1016. struct rtnl_link_stats64 *stats)
  1017. {
  1018. struct dsa_slave_priv *p = netdev_priv(dev);
  1019. netdev_stats_to_stats64(stats, &dev->stats);
  1020. dev_fetch_sw_netstats(stats, p->stats64);
  1021. }
  1022. static int dsa_slave_get_rxnfc(struct net_device *dev,
  1023. struct ethtool_rxnfc *nfc, u32 *rule_locs)
  1024. {
  1025. struct dsa_port *dp = dsa_slave_to_port(dev);
  1026. struct dsa_switch *ds = dp->ds;
  1027. if (!ds->ops->get_rxnfc)
  1028. return -EOPNOTSUPP;
  1029. return ds->ops->get_rxnfc(ds, dp->index, nfc, rule_locs);
  1030. }
  1031. static int dsa_slave_set_rxnfc(struct net_device *dev,
  1032. struct ethtool_rxnfc *nfc)
  1033. {
  1034. struct dsa_port *dp = dsa_slave_to_port(dev);
  1035. struct dsa_switch *ds = dp->ds;
  1036. if (!ds->ops->set_rxnfc)
  1037. return -EOPNOTSUPP;
  1038. return ds->ops->set_rxnfc(ds, dp->index, nfc);
  1039. }
  1040. static int dsa_slave_get_ts_info(struct net_device *dev,
  1041. struct ethtool_ts_info *ts)
  1042. {
  1043. struct dsa_slave_priv *p = netdev_priv(dev);
  1044. struct dsa_switch *ds = p->dp->ds;
  1045. if (!ds->ops->get_ts_info)
  1046. return -EOPNOTSUPP;
  1047. return ds->ops->get_ts_info(ds, p->dp->index, ts);
  1048. }
  1049. static int dsa_slave_vlan_rx_add_vid(struct net_device *dev, __be16 proto,
  1050. u16 vid)
  1051. {
  1052. struct net_device *master = dsa_slave_to_master(dev);
  1053. struct dsa_port *dp = dsa_slave_to_port(dev);
  1054. struct switchdev_obj_port_vlan vlan = {
  1055. .obj.id = SWITCHDEV_OBJ_ID_PORT_VLAN,
  1056. .vid_begin = vid,
  1057. .vid_end = vid,
  1058. /* This API only allows programming tagged, non-PVID VIDs */
  1059. .flags = 0,
  1060. };
  1061. struct switchdev_trans trans;
  1062. int ret;
  1063. /* User port... */
  1064. trans.ph_prepare = true;
  1065. ret = dsa_port_vlan_add(dp, &vlan, &trans);
  1066. if (ret)
  1067. return ret;
  1068. trans.ph_prepare = false;
  1069. ret = dsa_port_vlan_add(dp, &vlan, &trans);
  1070. if (ret)
  1071. return ret;
  1072. /* And CPU port... */
  1073. trans.ph_prepare = true;
  1074. ret = dsa_port_vlan_add(dp->cpu_dp, &vlan, &trans);
  1075. if (ret)
  1076. return ret;
  1077. trans.ph_prepare = false;
  1078. ret = dsa_port_vlan_add(dp->cpu_dp, &vlan, &trans);
  1079. if (ret)
  1080. return ret;
  1081. return vlan_vid_add(master, proto, vid);
  1082. }
  1083. static int dsa_slave_vlan_rx_kill_vid(struct net_device *dev, __be16 proto,
  1084. u16 vid)
  1085. {
  1086. struct net_device *master = dsa_slave_to_master(dev);
  1087. struct dsa_port *dp = dsa_slave_to_port(dev);
  1088. struct switchdev_obj_port_vlan vlan = {
  1089. .vid_begin = vid,
  1090. .vid_end = vid,
  1091. /* This API only allows programming tagged, non-PVID VIDs */
  1092. .flags = 0,
  1093. };
  1094. int err;
  1095. /* Do not deprogram the CPU port as it may be shared with other user
  1096. * ports which can be members of this VLAN as well.
  1097. */
  1098. err = dsa_port_vlan_del(dp, &vlan);
  1099. if (err)
  1100. return err;
  1101. vlan_vid_del(master, proto, vid);
  1102. return 0;
  1103. }
  1104. struct dsa_hw_port {
  1105. struct list_head list;
  1106. struct net_device *dev;
  1107. int old_mtu;
  1108. };
  1109. static int dsa_hw_port_list_set_mtu(struct list_head *hw_port_list, int mtu)
  1110. {
  1111. const struct dsa_hw_port *p;
  1112. int err;
  1113. list_for_each_entry(p, hw_port_list, list) {
  1114. if (p->dev->mtu == mtu)
  1115. continue;
  1116. err = dev_set_mtu(p->dev, mtu);
  1117. if (err)
  1118. goto rollback;
  1119. }
  1120. return 0;
  1121. rollback:
  1122. list_for_each_entry_continue_reverse(p, hw_port_list, list) {
  1123. if (p->dev->mtu == p->old_mtu)
  1124. continue;
  1125. if (dev_set_mtu(p->dev, p->old_mtu))
  1126. netdev_err(p->dev, "Failed to restore MTU\n");
  1127. }
  1128. return err;
  1129. }
  1130. static void dsa_hw_port_list_free(struct list_head *hw_port_list)
  1131. {
  1132. struct dsa_hw_port *p, *n;
  1133. list_for_each_entry_safe(p, n, hw_port_list, list)
  1134. kfree(p);
  1135. }
  1136. /* Make the hardware datapath to/from @dev limited to a common MTU */
  1137. static void dsa_bridge_mtu_normalization(struct dsa_port *dp)
  1138. {
  1139. struct list_head hw_port_list;
  1140. struct dsa_switch_tree *dst;
  1141. int min_mtu = ETH_MAX_MTU;
  1142. struct dsa_port *other_dp;
  1143. int err;
  1144. if (!dp->ds->mtu_enforcement_ingress)
  1145. return;
  1146. if (!dp->bridge_dev)
  1147. return;
  1148. INIT_LIST_HEAD(&hw_port_list);
  1149. /* Populate the list of ports that are part of the same bridge
  1150. * as the newly added/modified port
  1151. */
  1152. list_for_each_entry(dst, &dsa_tree_list, list) {
  1153. list_for_each_entry(other_dp, &dst->ports, list) {
  1154. struct dsa_hw_port *hw_port;
  1155. struct net_device *slave;
  1156. if (other_dp->type != DSA_PORT_TYPE_USER)
  1157. continue;
  1158. if (other_dp->bridge_dev != dp->bridge_dev)
  1159. continue;
  1160. if (!other_dp->ds->mtu_enforcement_ingress)
  1161. continue;
  1162. slave = other_dp->slave;
  1163. if (min_mtu > slave->mtu)
  1164. min_mtu = slave->mtu;
  1165. hw_port = kzalloc(sizeof(*hw_port), GFP_KERNEL);
  1166. if (!hw_port)
  1167. goto out;
  1168. hw_port->dev = slave;
  1169. hw_port->old_mtu = slave->mtu;
  1170. list_add(&hw_port->list, &hw_port_list);
  1171. }
  1172. }
  1173. /* Attempt to configure the entire hardware bridge to the newly added
  1174. * interface's MTU first, regardless of whether the intention of the
  1175. * user was to raise or lower it.
  1176. */
  1177. err = dsa_hw_port_list_set_mtu(&hw_port_list, dp->slave->mtu);
  1178. if (!err)
  1179. goto out;
  1180. /* Clearly that didn't work out so well, so just set the minimum MTU on
  1181. * all hardware bridge ports now. If this fails too, then all ports will
  1182. * still have their old MTU rolled back anyway.
  1183. */
  1184. dsa_hw_port_list_set_mtu(&hw_port_list, min_mtu);
  1185. out:
  1186. dsa_hw_port_list_free(&hw_port_list);
  1187. }
  1188. static int dsa_slave_change_mtu(struct net_device *dev, int new_mtu)
  1189. {
  1190. struct net_device *master = dsa_slave_to_master(dev);
  1191. struct dsa_port *dp = dsa_slave_to_port(dev);
  1192. struct dsa_slave_priv *p = netdev_priv(dev);
  1193. struct dsa_switch *ds = p->dp->ds;
  1194. struct dsa_port *cpu_dp;
  1195. int port = p->dp->index;
  1196. int largest_mtu = 0;
  1197. int new_master_mtu;
  1198. int old_master_mtu;
  1199. int mtu_limit;
  1200. int cpu_mtu;
  1201. int err, i;
  1202. if (!ds->ops->port_change_mtu)
  1203. return -EOPNOTSUPP;
  1204. for (i = 0; i < ds->num_ports; i++) {
  1205. int slave_mtu;
  1206. if (!dsa_is_user_port(ds, i))
  1207. continue;
  1208. /* During probe, this function will be called for each slave
  1209. * device, while not all of them have been allocated. That's
  1210. * ok, it doesn't change what the maximum is, so ignore it.
  1211. */
  1212. if (!dsa_to_port(ds, i)->slave)
  1213. continue;
  1214. /* Pretend that we already applied the setting, which we
  1215. * actually haven't (still haven't done all integrity checks)
  1216. */
  1217. if (i == port)
  1218. slave_mtu = new_mtu;
  1219. else
  1220. slave_mtu = dsa_to_port(ds, i)->slave->mtu;
  1221. if (largest_mtu < slave_mtu)
  1222. largest_mtu = slave_mtu;
  1223. }
  1224. cpu_dp = dsa_to_port(ds, port)->cpu_dp;
  1225. mtu_limit = min_t(int, master->max_mtu, dev->max_mtu);
  1226. old_master_mtu = master->mtu;
  1227. new_master_mtu = largest_mtu + cpu_dp->tag_ops->overhead;
  1228. if (new_master_mtu > mtu_limit)
  1229. return -ERANGE;
  1230. /* If the master MTU isn't over limit, there's no need to check the CPU
  1231. * MTU, since that surely isn't either.
  1232. */
  1233. cpu_mtu = largest_mtu;
  1234. /* Start applying stuff */
  1235. if (new_master_mtu != old_master_mtu) {
  1236. err = dev_set_mtu(master, new_master_mtu);
  1237. if (err < 0)
  1238. goto out_master_failed;
  1239. /* We only need to propagate the MTU of the CPU port to
  1240. * upstream switches.
  1241. */
  1242. err = dsa_port_mtu_change(cpu_dp, cpu_mtu, true);
  1243. if (err)
  1244. goto out_cpu_failed;
  1245. }
  1246. err = dsa_port_mtu_change(dp, new_mtu, false);
  1247. if (err)
  1248. goto out_port_failed;
  1249. dev->mtu = new_mtu;
  1250. dsa_bridge_mtu_normalization(dp);
  1251. return 0;
  1252. out_port_failed:
  1253. if (new_master_mtu != old_master_mtu)
  1254. dsa_port_mtu_change(cpu_dp, old_master_mtu -
  1255. cpu_dp->tag_ops->overhead,
  1256. true);
  1257. out_cpu_failed:
  1258. if (new_master_mtu != old_master_mtu)
  1259. dev_set_mtu(master, old_master_mtu);
  1260. out_master_failed:
  1261. return err;
  1262. }
  1263. static const struct ethtool_ops dsa_slave_ethtool_ops = {
  1264. .get_drvinfo = dsa_slave_get_drvinfo,
  1265. .get_regs_len = dsa_slave_get_regs_len,
  1266. .get_regs = dsa_slave_get_regs,
  1267. .nway_reset = dsa_slave_nway_reset,
  1268. .get_link = ethtool_op_get_link,
  1269. .get_eeprom_len = dsa_slave_get_eeprom_len,
  1270. .get_eeprom = dsa_slave_get_eeprom,
  1271. .set_eeprom = dsa_slave_set_eeprom,
  1272. .get_strings = dsa_slave_get_strings,
  1273. .get_ethtool_stats = dsa_slave_get_ethtool_stats,
  1274. .get_sset_count = dsa_slave_get_sset_count,
  1275. .set_wol = dsa_slave_set_wol,
  1276. .get_wol = dsa_slave_get_wol,
  1277. .set_eee = dsa_slave_set_eee,
  1278. .get_eee = dsa_slave_get_eee,
  1279. .get_link_ksettings = dsa_slave_get_link_ksettings,
  1280. .set_link_ksettings = dsa_slave_set_link_ksettings,
  1281. .get_pauseparam = dsa_slave_get_pauseparam,
  1282. .set_pauseparam = dsa_slave_set_pauseparam,
  1283. .get_rxnfc = dsa_slave_get_rxnfc,
  1284. .set_rxnfc = dsa_slave_set_rxnfc,
  1285. .get_ts_info = dsa_slave_get_ts_info,
  1286. };
  1287. /* legacy way, bypassing the bridge *****************************************/
  1288. int dsa_legacy_fdb_add(struct ndmsg *ndm, struct nlattr *tb[],
  1289. struct net_device *dev,
  1290. const unsigned char *addr, u16 vid,
  1291. u16 flags,
  1292. struct netlink_ext_ack *extack)
  1293. {
  1294. struct dsa_port *dp = dsa_slave_to_port(dev);
  1295. return dsa_port_fdb_add(dp, addr, vid);
  1296. }
  1297. int dsa_legacy_fdb_del(struct ndmsg *ndm, struct nlattr *tb[],
  1298. struct net_device *dev,
  1299. const unsigned char *addr, u16 vid)
  1300. {
  1301. struct dsa_port *dp = dsa_slave_to_port(dev);
  1302. return dsa_port_fdb_del(dp, addr, vid);
  1303. }
  1304. static struct devlink_port *dsa_slave_get_devlink_port(struct net_device *dev)
  1305. {
  1306. struct dsa_port *dp = dsa_slave_to_port(dev);
  1307. return dp->ds->devlink ? &dp->devlink_port : NULL;
  1308. }
  1309. static const struct net_device_ops dsa_slave_netdev_ops = {
  1310. .ndo_open = dsa_slave_open,
  1311. .ndo_stop = dsa_slave_close,
  1312. .ndo_start_xmit = dsa_slave_xmit,
  1313. .ndo_change_rx_flags = dsa_slave_change_rx_flags,
  1314. .ndo_set_rx_mode = dsa_slave_set_rx_mode,
  1315. .ndo_set_mac_address = dsa_slave_set_mac_address,
  1316. .ndo_fdb_add = dsa_legacy_fdb_add,
  1317. .ndo_fdb_del = dsa_legacy_fdb_del,
  1318. .ndo_fdb_dump = dsa_slave_fdb_dump,
  1319. .ndo_do_ioctl = dsa_slave_ioctl,
  1320. .ndo_get_iflink = dsa_slave_get_iflink,
  1321. #ifdef CONFIG_NET_POLL_CONTROLLER
  1322. .ndo_netpoll_setup = dsa_slave_netpoll_setup,
  1323. .ndo_netpoll_cleanup = dsa_slave_netpoll_cleanup,
  1324. .ndo_poll_controller = dsa_slave_poll_controller,
  1325. #endif
  1326. .ndo_get_phys_port_name = dsa_slave_get_phys_port_name,
  1327. .ndo_setup_tc = dsa_slave_setup_tc,
  1328. .ndo_get_stats64 = dsa_slave_get_stats64,
  1329. .ndo_get_port_parent_id = dsa_slave_get_port_parent_id,
  1330. .ndo_vlan_rx_add_vid = dsa_slave_vlan_rx_add_vid,
  1331. .ndo_vlan_rx_kill_vid = dsa_slave_vlan_rx_kill_vid,
  1332. .ndo_get_devlink_port = dsa_slave_get_devlink_port,
  1333. .ndo_change_mtu = dsa_slave_change_mtu,
  1334. };
  1335. static struct device_type dsa_type = {
  1336. .name = "dsa",
  1337. };
  1338. void dsa_port_phylink_mac_change(struct dsa_switch *ds, int port, bool up)
  1339. {
  1340. const struct dsa_port *dp = dsa_to_port(ds, port);
  1341. if (dp->pl)
  1342. phylink_mac_change(dp->pl, up);
  1343. }
  1344. EXPORT_SYMBOL_GPL(dsa_port_phylink_mac_change);
  1345. static void dsa_slave_phylink_fixed_state(struct phylink_config *config,
  1346. struct phylink_link_state *state)
  1347. {
  1348. struct dsa_port *dp = container_of(config, struct dsa_port, pl_config);
  1349. struct dsa_switch *ds = dp->ds;
  1350. /* No need to check that this operation is valid, the callback would
  1351. * not be called if it was not.
  1352. */
  1353. ds->ops->phylink_fixed_state(ds, dp->index, state);
  1354. }
  1355. /* slave device setup *******************************************************/
  1356. static int dsa_slave_phy_connect(struct net_device *slave_dev, int addr)
  1357. {
  1358. struct dsa_port *dp = dsa_slave_to_port(slave_dev);
  1359. struct dsa_switch *ds = dp->ds;
  1360. slave_dev->phydev = mdiobus_get_phy(ds->slave_mii_bus, addr);
  1361. if (!slave_dev->phydev) {
  1362. netdev_err(slave_dev, "no phy at %d\n", addr);
  1363. return -ENODEV;
  1364. }
  1365. return phylink_connect_phy(dp->pl, slave_dev->phydev);
  1366. }
  1367. static int dsa_slave_phy_setup(struct net_device *slave_dev)
  1368. {
  1369. struct dsa_port *dp = dsa_slave_to_port(slave_dev);
  1370. struct device_node *port_dn = dp->dn;
  1371. struct dsa_switch *ds = dp->ds;
  1372. phy_interface_t mode;
  1373. u32 phy_flags = 0;
  1374. int ret;
  1375. ret = of_get_phy_mode(port_dn, &mode);
  1376. if (ret)
  1377. mode = PHY_INTERFACE_MODE_NA;
  1378. dp->pl_config.dev = &slave_dev->dev;
  1379. dp->pl_config.type = PHYLINK_NETDEV;
  1380. /* The get_fixed_state callback takes precedence over polling the
  1381. * link GPIO in PHYLINK (see phylink_get_fixed_state). Only set
  1382. * this if the switch provides such a callback.
  1383. */
  1384. if (ds->ops->phylink_fixed_state) {
  1385. dp->pl_config.get_fixed_state = dsa_slave_phylink_fixed_state;
  1386. dp->pl_config.poll_fixed_state = true;
  1387. }
  1388. dp->pl = phylink_create(&dp->pl_config, of_fwnode_handle(port_dn), mode,
  1389. &dsa_port_phylink_mac_ops);
  1390. if (IS_ERR(dp->pl)) {
  1391. netdev_err(slave_dev,
  1392. "error creating PHYLINK: %ld\n", PTR_ERR(dp->pl));
  1393. return PTR_ERR(dp->pl);
  1394. }
  1395. if (ds->ops->get_phy_flags)
  1396. phy_flags = ds->ops->get_phy_flags(ds, dp->index);
  1397. ret = phylink_of_phy_connect(dp->pl, port_dn, phy_flags);
  1398. if (ret == -ENODEV && ds->slave_mii_bus) {
  1399. /* We could not connect to a designated PHY or SFP, so try to
  1400. * use the switch internal MDIO bus instead
  1401. */
  1402. ret = dsa_slave_phy_connect(slave_dev, dp->index);
  1403. }
  1404. if (ret) {
  1405. netdev_err(slave_dev, "failed to connect to PHY: %pe\n",
  1406. ERR_PTR(ret));
  1407. phylink_destroy(dp->pl);
  1408. }
  1409. return ret;
  1410. }
  1411. static struct lock_class_key dsa_slave_netdev_xmit_lock_key;
  1412. static void dsa_slave_set_lockdep_class_one(struct net_device *dev,
  1413. struct netdev_queue *txq,
  1414. void *_unused)
  1415. {
  1416. lockdep_set_class(&txq->_xmit_lock,
  1417. &dsa_slave_netdev_xmit_lock_key);
  1418. }
  1419. int dsa_slave_suspend(struct net_device *slave_dev)
  1420. {
  1421. struct dsa_port *dp = dsa_slave_to_port(slave_dev);
  1422. if (!netif_running(slave_dev))
  1423. return 0;
  1424. netif_device_detach(slave_dev);
  1425. rtnl_lock();
  1426. phylink_stop(dp->pl);
  1427. rtnl_unlock();
  1428. return 0;
  1429. }
  1430. int dsa_slave_resume(struct net_device *slave_dev)
  1431. {
  1432. struct dsa_port *dp = dsa_slave_to_port(slave_dev);
  1433. if (!netif_running(slave_dev))
  1434. return 0;
  1435. netif_device_attach(slave_dev);
  1436. rtnl_lock();
  1437. phylink_start(dp->pl);
  1438. rtnl_unlock();
  1439. return 0;
  1440. }
  1441. static void dsa_slave_notify(struct net_device *dev, unsigned long val)
  1442. {
  1443. struct net_device *master = dsa_slave_to_master(dev);
  1444. struct dsa_port *dp = dsa_slave_to_port(dev);
  1445. struct dsa_notifier_register_info rinfo = {
  1446. .switch_number = dp->ds->index,
  1447. .port_number = dp->index,
  1448. .master = master,
  1449. .info.dev = dev,
  1450. };
  1451. call_dsa_notifiers(val, dev, &rinfo.info);
  1452. }
  1453. int dsa_slave_create(struct dsa_port *port)
  1454. {
  1455. const struct dsa_port *cpu_dp = port->cpu_dp;
  1456. struct net_device *master = cpu_dp->master;
  1457. struct dsa_switch *ds = port->ds;
  1458. const char *name = port->name;
  1459. struct net_device *slave_dev;
  1460. struct dsa_slave_priv *p;
  1461. int ret;
  1462. if (!ds->num_tx_queues)
  1463. ds->num_tx_queues = 1;
  1464. slave_dev = alloc_netdev_mqs(sizeof(struct dsa_slave_priv), name,
  1465. NET_NAME_UNKNOWN, ether_setup,
  1466. ds->num_tx_queues, 1);
  1467. if (slave_dev == NULL)
  1468. return -ENOMEM;
  1469. slave_dev->features = master->vlan_features | NETIF_F_HW_TC;
  1470. if (ds->ops->port_vlan_add && ds->ops->port_vlan_del)
  1471. slave_dev->features |= NETIF_F_HW_VLAN_CTAG_FILTER;
  1472. slave_dev->hw_features |= NETIF_F_HW_TC;
  1473. slave_dev->features |= NETIF_F_LLTX;
  1474. slave_dev->ethtool_ops = &dsa_slave_ethtool_ops;
  1475. if (!IS_ERR_OR_NULL(port->mac))
  1476. ether_addr_copy(slave_dev->dev_addr, port->mac);
  1477. else
  1478. eth_hw_addr_inherit(slave_dev, master);
  1479. slave_dev->priv_flags |= IFF_NO_QUEUE;
  1480. slave_dev->netdev_ops = &dsa_slave_netdev_ops;
  1481. if (ds->ops->port_max_mtu)
  1482. slave_dev->max_mtu = ds->ops->port_max_mtu(ds, port->index);
  1483. if (cpu_dp->tag_ops->tail_tag)
  1484. slave_dev->needed_tailroom = cpu_dp->tag_ops->overhead;
  1485. else
  1486. slave_dev->needed_headroom = cpu_dp->tag_ops->overhead;
  1487. /* Try to save one extra realloc later in the TX path (in the master)
  1488. * by also inheriting the master's needed headroom and tailroom.
  1489. * The 8021q driver also does this.
  1490. */
  1491. slave_dev->needed_headroom += master->needed_headroom;
  1492. slave_dev->needed_tailroom += master->needed_tailroom;
  1493. SET_NETDEV_DEVTYPE(slave_dev, &dsa_type);
  1494. netdev_for_each_tx_queue(slave_dev, dsa_slave_set_lockdep_class_one,
  1495. NULL);
  1496. SET_NETDEV_DEV(slave_dev, port->ds->dev);
  1497. slave_dev->dev.of_node = port->dn;
  1498. slave_dev->vlan_features = master->vlan_features;
  1499. p = netdev_priv(slave_dev);
  1500. p->stats64 = netdev_alloc_pcpu_stats(struct pcpu_sw_netstats);
  1501. if (!p->stats64) {
  1502. free_netdev(slave_dev);
  1503. return -ENOMEM;
  1504. }
  1505. ret = gro_cells_init(&p->gcells, slave_dev);
  1506. if (ret)
  1507. goto out_free;
  1508. p->dp = port;
  1509. INIT_LIST_HEAD(&p->mall_tc_list);
  1510. p->xmit = cpu_dp->tag_ops->xmit;
  1511. port->slave = slave_dev;
  1512. rtnl_lock();
  1513. ret = dsa_slave_change_mtu(slave_dev, ETH_DATA_LEN);
  1514. rtnl_unlock();
  1515. if (ret && ret != -EOPNOTSUPP)
  1516. dev_warn(ds->dev, "nonfatal error %d setting MTU on port %d\n",
  1517. ret, port->index);
  1518. netif_carrier_off(slave_dev);
  1519. ret = dsa_slave_phy_setup(slave_dev);
  1520. if (ret) {
  1521. netdev_err(slave_dev,
  1522. "error %d setting up PHY for tree %d, switch %d, port %d\n",
  1523. ret, ds->dst->index, ds->index, port->index);
  1524. goto out_gcells;
  1525. }
  1526. dsa_slave_notify(slave_dev, DSA_PORT_REGISTER);
  1527. rtnl_lock();
  1528. ret = register_netdevice(slave_dev);
  1529. if (ret) {
  1530. netdev_err(master, "error %d registering interface %s\n",
  1531. ret, slave_dev->name);
  1532. rtnl_unlock();
  1533. goto out_phy;
  1534. }
  1535. ret = netdev_upper_dev_link(master, slave_dev, NULL);
  1536. rtnl_unlock();
  1537. if (ret)
  1538. goto out_unregister;
  1539. return 0;
  1540. out_unregister:
  1541. unregister_netdev(slave_dev);
  1542. out_phy:
  1543. rtnl_lock();
  1544. phylink_disconnect_phy(p->dp->pl);
  1545. rtnl_unlock();
  1546. phylink_destroy(p->dp->pl);
  1547. out_gcells:
  1548. gro_cells_destroy(&p->gcells);
  1549. out_free:
  1550. free_percpu(p->stats64);
  1551. free_netdev(slave_dev);
  1552. port->slave = NULL;
  1553. return ret;
  1554. }
  1555. void dsa_slave_destroy(struct net_device *slave_dev)
  1556. {
  1557. struct net_device *master = dsa_slave_to_master(slave_dev);
  1558. struct dsa_port *dp = dsa_slave_to_port(slave_dev);
  1559. struct dsa_slave_priv *p = netdev_priv(slave_dev);
  1560. netif_carrier_off(slave_dev);
  1561. rtnl_lock();
  1562. netdev_upper_dev_unlink(master, slave_dev);
  1563. unregister_netdevice(slave_dev);
  1564. phylink_disconnect_phy(dp->pl);
  1565. rtnl_unlock();
  1566. dsa_slave_notify(slave_dev, DSA_PORT_UNREGISTER);
  1567. phylink_destroy(dp->pl);
  1568. gro_cells_destroy(&p->gcells);
  1569. free_percpu(p->stats64);
  1570. free_netdev(slave_dev);
  1571. }
  1572. bool dsa_slave_dev_check(const struct net_device *dev)
  1573. {
  1574. return dev->netdev_ops == &dsa_slave_netdev_ops;
  1575. }
  1576. static int dsa_slave_changeupper(struct net_device *dev,
  1577. struct netdev_notifier_changeupper_info *info)
  1578. {
  1579. struct dsa_port *dp = dsa_slave_to_port(dev);
  1580. int err = NOTIFY_DONE;
  1581. if (netif_is_bridge_master(info->upper_dev)) {
  1582. if (info->linking) {
  1583. err = dsa_port_bridge_join(dp, info->upper_dev);
  1584. if (!err)
  1585. dsa_bridge_mtu_normalization(dp);
  1586. err = notifier_from_errno(err);
  1587. } else {
  1588. dsa_port_bridge_leave(dp, info->upper_dev);
  1589. err = NOTIFY_OK;
  1590. }
  1591. }
  1592. return err;
  1593. }
  1594. static int
  1595. dsa_prevent_bridging_8021q_upper(struct net_device *dev,
  1596. struct netdev_notifier_changeupper_info *info)
  1597. {
  1598. struct netlink_ext_ack *ext_ack;
  1599. struct net_device *slave;
  1600. struct dsa_port *dp;
  1601. ext_ack = netdev_notifier_info_to_extack(&info->info);
  1602. if (!is_vlan_dev(dev))
  1603. return NOTIFY_DONE;
  1604. slave = vlan_dev_real_dev(dev);
  1605. if (!dsa_slave_dev_check(slave))
  1606. return NOTIFY_DONE;
  1607. dp = dsa_slave_to_port(slave);
  1608. if (!dp->bridge_dev)
  1609. return NOTIFY_DONE;
  1610. /* Deny enslaving a VLAN device into a VLAN-aware bridge */
  1611. if (br_vlan_enabled(dp->bridge_dev) &&
  1612. netif_is_bridge_master(info->upper_dev) && info->linking) {
  1613. NL_SET_ERR_MSG_MOD(ext_ack,
  1614. "Cannot enslave VLAN device into VLAN aware bridge");
  1615. return notifier_from_errno(-EINVAL);
  1616. }
  1617. return NOTIFY_DONE;
  1618. }
  1619. static int
  1620. dsa_slave_check_8021q_upper(struct net_device *dev,
  1621. struct netdev_notifier_changeupper_info *info)
  1622. {
  1623. struct dsa_port *dp = dsa_slave_to_port(dev);
  1624. struct net_device *br = dp->bridge_dev;
  1625. struct bridge_vlan_info br_info;
  1626. struct netlink_ext_ack *extack;
  1627. int err = NOTIFY_DONE;
  1628. u16 vid;
  1629. if (!br || !br_vlan_enabled(br))
  1630. return NOTIFY_DONE;
  1631. extack = netdev_notifier_info_to_extack(&info->info);
  1632. vid = vlan_dev_vlan_id(info->upper_dev);
  1633. /* br_vlan_get_info() returns -EINVAL or -ENOENT if the
  1634. * device, respectively the VID is not found, returning
  1635. * 0 means success, which is a failure for us here.
  1636. */
  1637. err = br_vlan_get_info(br, vid, &br_info);
  1638. if (err == 0) {
  1639. NL_SET_ERR_MSG_MOD(extack,
  1640. "This VLAN is already configured by the bridge");
  1641. return notifier_from_errno(-EBUSY);
  1642. }
  1643. return NOTIFY_DONE;
  1644. }
  1645. static int dsa_slave_netdevice_event(struct notifier_block *nb,
  1646. unsigned long event, void *ptr)
  1647. {
  1648. struct net_device *dev = netdev_notifier_info_to_dev(ptr);
  1649. switch (event) {
  1650. case NETDEV_PRECHANGEUPPER: {
  1651. struct netdev_notifier_changeupper_info *info = ptr;
  1652. if (!dsa_slave_dev_check(dev))
  1653. return dsa_prevent_bridging_8021q_upper(dev, ptr);
  1654. if (is_vlan_dev(info->upper_dev))
  1655. return dsa_slave_check_8021q_upper(dev, ptr);
  1656. break;
  1657. }
  1658. case NETDEV_CHANGEUPPER:
  1659. if (!dsa_slave_dev_check(dev))
  1660. return NOTIFY_DONE;
  1661. return dsa_slave_changeupper(dev, ptr);
  1662. }
  1663. return NOTIFY_DONE;
  1664. }
  1665. struct dsa_switchdev_event_work {
  1666. struct work_struct work;
  1667. struct switchdev_notifier_fdb_info fdb_info;
  1668. struct net_device *dev;
  1669. unsigned long event;
  1670. };
  1671. static void dsa_slave_switchdev_event_work(struct work_struct *work)
  1672. {
  1673. struct dsa_switchdev_event_work *switchdev_work =
  1674. container_of(work, struct dsa_switchdev_event_work, work);
  1675. struct net_device *dev = switchdev_work->dev;
  1676. struct switchdev_notifier_fdb_info *fdb_info;
  1677. struct dsa_port *dp = dsa_slave_to_port(dev);
  1678. int err;
  1679. rtnl_lock();
  1680. switch (switchdev_work->event) {
  1681. case SWITCHDEV_FDB_ADD_TO_DEVICE:
  1682. fdb_info = &switchdev_work->fdb_info;
  1683. if (!fdb_info->added_by_user)
  1684. break;
  1685. err = dsa_port_fdb_add(dp, fdb_info->addr, fdb_info->vid);
  1686. if (err) {
  1687. netdev_dbg(dev, "fdb add failed err=%d\n", err);
  1688. break;
  1689. }
  1690. fdb_info->offloaded = true;
  1691. call_switchdev_notifiers(SWITCHDEV_FDB_OFFLOADED, dev,
  1692. &fdb_info->info, NULL);
  1693. break;
  1694. case SWITCHDEV_FDB_DEL_TO_DEVICE:
  1695. fdb_info = &switchdev_work->fdb_info;
  1696. if (!fdb_info->added_by_user)
  1697. break;
  1698. err = dsa_port_fdb_del(dp, fdb_info->addr, fdb_info->vid);
  1699. if (err) {
  1700. netdev_dbg(dev, "fdb del failed err=%d\n", err);
  1701. dev_close(dev);
  1702. }
  1703. break;
  1704. }
  1705. rtnl_unlock();
  1706. kfree(switchdev_work->fdb_info.addr);
  1707. kfree(switchdev_work);
  1708. dev_put(dev);
  1709. }
  1710. static int
  1711. dsa_slave_switchdev_fdb_work_init(struct dsa_switchdev_event_work *
  1712. switchdev_work,
  1713. const struct switchdev_notifier_fdb_info *
  1714. fdb_info)
  1715. {
  1716. memcpy(&switchdev_work->fdb_info, fdb_info,
  1717. sizeof(switchdev_work->fdb_info));
  1718. switchdev_work->fdb_info.addr = kzalloc(ETH_ALEN, GFP_ATOMIC);
  1719. if (!switchdev_work->fdb_info.addr)
  1720. return -ENOMEM;
  1721. ether_addr_copy((u8 *)switchdev_work->fdb_info.addr,
  1722. fdb_info->addr);
  1723. return 0;
  1724. }
  1725. /* Called under rcu_read_lock() */
  1726. static int dsa_slave_switchdev_event(struct notifier_block *unused,
  1727. unsigned long event, void *ptr)
  1728. {
  1729. struct net_device *dev = switchdev_notifier_info_to_dev(ptr);
  1730. struct dsa_switchdev_event_work *switchdev_work;
  1731. int err;
  1732. if (event == SWITCHDEV_PORT_ATTR_SET) {
  1733. err = switchdev_handle_port_attr_set(dev, ptr,
  1734. dsa_slave_dev_check,
  1735. dsa_slave_port_attr_set);
  1736. return notifier_from_errno(err);
  1737. }
  1738. if (!dsa_slave_dev_check(dev))
  1739. return NOTIFY_DONE;
  1740. switchdev_work = kzalloc(sizeof(*switchdev_work), GFP_ATOMIC);
  1741. if (!switchdev_work)
  1742. return NOTIFY_BAD;
  1743. INIT_WORK(&switchdev_work->work,
  1744. dsa_slave_switchdev_event_work);
  1745. switchdev_work->dev = dev;
  1746. switchdev_work->event = event;
  1747. switch (event) {
  1748. case SWITCHDEV_FDB_ADD_TO_DEVICE:
  1749. case SWITCHDEV_FDB_DEL_TO_DEVICE:
  1750. if (dsa_slave_switchdev_fdb_work_init(switchdev_work, ptr))
  1751. goto err_fdb_work_init;
  1752. dev_hold(dev);
  1753. break;
  1754. default:
  1755. kfree(switchdev_work);
  1756. return NOTIFY_DONE;
  1757. }
  1758. dsa_schedule_work(&switchdev_work->work);
  1759. return NOTIFY_OK;
  1760. err_fdb_work_init:
  1761. kfree(switchdev_work);
  1762. return NOTIFY_BAD;
  1763. }
  1764. static int dsa_slave_switchdev_blocking_event(struct notifier_block *unused,
  1765. unsigned long event, void *ptr)
  1766. {
  1767. struct net_device *dev = switchdev_notifier_info_to_dev(ptr);
  1768. int err;
  1769. switch (event) {
  1770. case SWITCHDEV_PORT_OBJ_ADD:
  1771. err = switchdev_handle_port_obj_add(dev, ptr,
  1772. dsa_slave_dev_check,
  1773. dsa_slave_port_obj_add);
  1774. return notifier_from_errno(err);
  1775. case SWITCHDEV_PORT_OBJ_DEL:
  1776. err = switchdev_handle_port_obj_del(dev, ptr,
  1777. dsa_slave_dev_check,
  1778. dsa_slave_port_obj_del);
  1779. return notifier_from_errno(err);
  1780. case SWITCHDEV_PORT_ATTR_SET:
  1781. err = switchdev_handle_port_attr_set(dev, ptr,
  1782. dsa_slave_dev_check,
  1783. dsa_slave_port_attr_set);
  1784. return notifier_from_errno(err);
  1785. }
  1786. return NOTIFY_DONE;
  1787. }
  1788. static struct notifier_block dsa_slave_nb __read_mostly = {
  1789. .notifier_call = dsa_slave_netdevice_event,
  1790. };
  1791. static struct notifier_block dsa_slave_switchdev_notifier = {
  1792. .notifier_call = dsa_slave_switchdev_event,
  1793. };
  1794. static struct notifier_block dsa_slave_switchdev_blocking_notifier = {
  1795. .notifier_call = dsa_slave_switchdev_blocking_event,
  1796. };
  1797. int dsa_slave_register_notifier(void)
  1798. {
  1799. struct notifier_block *nb;
  1800. int err;
  1801. err = register_netdevice_notifier(&dsa_slave_nb);
  1802. if (err)
  1803. return err;
  1804. err = register_switchdev_notifier(&dsa_slave_switchdev_notifier);
  1805. if (err)
  1806. goto err_switchdev_nb;
  1807. nb = &dsa_slave_switchdev_blocking_notifier;
  1808. err = register_switchdev_blocking_notifier(nb);
  1809. if (err)
  1810. goto err_switchdev_blocking_nb;
  1811. return 0;
  1812. err_switchdev_blocking_nb:
  1813. unregister_switchdev_notifier(&dsa_slave_switchdev_notifier);
  1814. err_switchdev_nb:
  1815. unregister_netdevice_notifier(&dsa_slave_nb);
  1816. return err;
  1817. }
  1818. void dsa_slave_unregister_notifier(void)
  1819. {
  1820. struct notifier_block *nb;
  1821. int err;
  1822. nb = &dsa_slave_switchdev_blocking_notifier;
  1823. err = unregister_switchdev_blocking_notifier(nb);
  1824. if (err)
  1825. pr_err("DSA: failed to unregister switchdev blocking notifier (%d)\n", err);
  1826. err = unregister_switchdev_notifier(&dsa_slave_switchdev_notifier);
  1827. if (err)
  1828. pr_err("DSA: failed to unregister switchdev notifier (%d)\n", err);
  1829. err = unregister_netdevice_notifier(&dsa_slave_nb);
  1830. if (err)
  1831. pr_err("DSA: failed to unregister slave notifier (%d)\n", err);
  1832. }