1 #include <linux/delay.h>
2 #include <linux/etherdevice.h>
3 #include <linux/netdevice.h>
4 #include <linux/if_ether.h>
5 #include <linux/if_arp.h>
6 #include <linux/kthread.h>
7 #include <linux/kfifo.h>
8 #include <net/cfg80211.h>
15 /***************************************************************************
20 * Attributes exported through sysfs
24 * @brief Get function for sysfs attribute anycast_mask
26 static ssize_t lbs_anycast_get(struct device *dev,
27 struct device_attribute *attr, char * buf)
29 struct lbs_private *priv = to_net_dev(dev)->ml_priv;
30 struct cmd_ds_mesh_access mesh_access;
33 memset(&mesh_access, 0, sizeof(mesh_access));
35 ret = lbs_mesh_access(priv, CMD_ACT_MESH_GET_ANYCAST, &mesh_access);
39 return snprintf(buf, 12, "0x%X\n", le32_to_cpu(mesh_access.data[0]));
43 * @brief Set function for sysfs attribute anycast_mask
45 static ssize_t lbs_anycast_set(struct device *dev,
46 struct device_attribute *attr, const char * buf, size_t count)
48 struct lbs_private *priv = to_net_dev(dev)->ml_priv;
49 struct cmd_ds_mesh_access mesh_access;
53 memset(&mesh_access, 0, sizeof(mesh_access));
54 sscanf(buf, "%x", &datum);
55 mesh_access.data[0] = cpu_to_le32(datum);
57 ret = lbs_mesh_access(priv, CMD_ACT_MESH_SET_ANYCAST, &mesh_access);
65 * @brief Get function for sysfs attribute prb_rsp_limit
67 static ssize_t lbs_prb_rsp_limit_get(struct device *dev,
68 struct device_attribute *attr, char *buf)
70 struct lbs_private *priv = to_net_dev(dev)->ml_priv;
71 struct cmd_ds_mesh_access mesh_access;
75 memset(&mesh_access, 0, sizeof(mesh_access));
76 mesh_access.data[0] = cpu_to_le32(CMD_ACT_GET);
78 ret = lbs_mesh_access(priv, CMD_ACT_MESH_SET_GET_PRB_RSP_LIMIT,
83 retry_limit = le32_to_cpu(mesh_access.data[1]);
84 return snprintf(buf, 10, "%d\n", retry_limit);
88 * @brief Set function for sysfs attribute prb_rsp_limit
90 static ssize_t lbs_prb_rsp_limit_set(struct device *dev,
91 struct device_attribute *attr, const char *buf, size_t count)
93 struct lbs_private *priv = to_net_dev(dev)->ml_priv;
94 struct cmd_ds_mesh_access mesh_access;
96 unsigned long retry_limit;
98 memset(&mesh_access, 0, sizeof(mesh_access));
99 mesh_access.data[0] = cpu_to_le32(CMD_ACT_SET);
101 if (!strict_strtoul(buf, 10, &retry_limit))
103 if (retry_limit > 15)
106 mesh_access.data[1] = cpu_to_le32(retry_limit);
108 ret = lbs_mesh_access(priv, CMD_ACT_MESH_SET_GET_PRB_RSP_LIMIT,
117 * Get function for sysfs attribute mesh
119 static ssize_t lbs_mesh_get(struct device *dev,
120 struct device_attribute *attr, char * buf)
122 struct lbs_private *priv = to_net_dev(dev)->ml_priv;
123 return snprintf(buf, 5, "0x%X\n", !!priv->mesh_dev);
127 * Set function for sysfs attribute mesh
129 static ssize_t lbs_mesh_set(struct device *dev,
130 struct device_attribute *attr, const char * buf, size_t count)
132 struct lbs_private *priv = to_net_dev(dev)->ml_priv;
134 int ret, action = CMD_ACT_MESH_CONFIG_STOP;
136 sscanf(buf, "%x", &enable);
138 if (enable == !!priv->mesh_dev)
141 action = CMD_ACT_MESH_CONFIG_START;
142 ret = lbs_mesh_config(priv, action, priv->channel);
149 lbs_remove_mesh(priv);
155 * lbs_mesh attribute to be exported per ethX interface
156 * through sysfs (/sys/class/net/ethX/lbs_mesh)
158 static DEVICE_ATTR(lbs_mesh, 0644, lbs_mesh_get, lbs_mesh_set);
161 * anycast_mask attribute to be exported per mshX interface
162 * through sysfs (/sys/class/net/mshX/anycast_mask)
164 static DEVICE_ATTR(anycast_mask, 0644, lbs_anycast_get, lbs_anycast_set);
167 * prb_rsp_limit attribute to be exported per mshX interface
168 * through sysfs (/sys/class/net/mshX/prb_rsp_limit)
170 static DEVICE_ATTR(prb_rsp_limit, 0644, lbs_prb_rsp_limit_get,
171 lbs_prb_rsp_limit_set);
173 static struct attribute *lbs_mesh_sysfs_entries[] = {
174 &dev_attr_anycast_mask.attr,
175 &dev_attr_prb_rsp_limit.attr,
179 static struct attribute_group lbs_mesh_attr_group = {
180 .attrs = lbs_mesh_sysfs_entries,
185 /***************************************************************************
186 * Initializing and starting, stopping mesh
190 * Check mesh FW version and appropriately send the mesh start
193 int lbs_init_mesh(struct lbs_private *priv)
195 struct net_device *dev = priv->dev;
198 lbs_deb_enter(LBS_DEB_MESH);
200 priv->mesh_connect_status = LBS_DISCONNECTED;
202 /* Determine mesh_fw_ver from fwrelease and fwcapinfo */
203 /* 5.0.16p0 9.0.0.p0 is known to NOT support any mesh */
204 /* 5.110.22 have mesh command with 0xa3 command id */
205 /* 10.0.0.p0 FW brings in mesh config command with different id */
206 /* Check FW version MSB and initialize mesh_fw_ver */
207 if (MRVL_FW_MAJOR_REV(priv->fwrelease) == MRVL_FW_V5) {
208 /* Enable mesh, if supported, and work out which TLV it uses.
209 0x100 + 291 is an unofficial value used in 5.110.20.pXX
210 0x100 + 37 is the official value used in 5.110.21.pXX
211 but we check them in that order because 20.pXX doesn't
212 give an error -- it just silently fails. */
214 /* 5.110.20.pXX firmware will fail the command if the channel
215 doesn't match the existing channel. But only if the TLV
216 is correct. If the channel is wrong, _BOTH_ versions will
217 give an error to 0x100+291, and allow 0x100+37 to succeed.
218 It's just that 5.110.20.pXX will not have done anything
221 priv->mesh_tlv = TLV_TYPE_OLD_MESH_ID;
222 if (lbs_mesh_config(priv, CMD_ACT_MESH_CONFIG_START,
224 priv->mesh_tlv = TLV_TYPE_MESH_ID;
225 if (lbs_mesh_config(priv, CMD_ACT_MESH_CONFIG_START,
230 if ((MRVL_FW_MAJOR_REV(priv->fwrelease) >= MRVL_FW_V10) &&
231 (priv->fwcapinfo & MESH_CAPINFO_ENABLE_MASK)) {
232 /* 10.0.0.pXX new firmwares should succeed with TLV
233 * 0x100+37; Do not invoke command with old TLV.
235 priv->mesh_tlv = TLV_TYPE_MESH_ID;
236 if (lbs_mesh_config(priv, CMD_ACT_MESH_CONFIG_START,
242 if (priv->mesh_tlv) {
243 sprintf(priv->mesh_ssid, "mesh");
244 priv->mesh_ssid_len = 4;
248 if (device_create_file(&dev->dev, &dev_attr_lbs_mesh))
249 lbs_pr_err("cannot register lbs_mesh attribute\n");
254 lbs_deb_leave_args(LBS_DEB_MESH, "ret %d", ret);
259 int lbs_deinit_mesh(struct lbs_private *priv)
261 struct net_device *dev = priv->dev;
264 lbs_deb_enter(LBS_DEB_MESH);
266 if (priv->mesh_tlv) {
267 device_remove_file(&dev->dev, &dev_attr_lbs_mesh);
271 lbs_deb_leave_args(LBS_DEB_MESH, "ret %d", ret);
277 * @brief This function closes the mshX interface
279 * @param dev A pointer to net_device structure
282 static int lbs_mesh_stop(struct net_device *dev)
284 struct lbs_private *priv = dev->ml_priv;
286 lbs_deb_enter(LBS_DEB_MESH);
287 spin_lock_irq(&priv->driver_lock);
290 priv->mesh_connect_status = LBS_DISCONNECTED;
292 netif_stop_queue(dev);
293 netif_carrier_off(dev);
295 spin_unlock_irq(&priv->driver_lock);
297 schedule_work(&priv->mcast_work);
299 lbs_deb_leave(LBS_DEB_MESH);
304 * @brief This function opens the mshX interface
306 * @param dev A pointer to net_device structure
307 * @return 0 or -EBUSY if monitor mode active
309 static int lbs_mesh_dev_open(struct net_device *dev)
311 struct lbs_private *priv = dev->ml_priv;
314 lbs_deb_enter(LBS_DEB_NET);
316 spin_lock_irq(&priv->driver_lock);
318 if (priv->wdev->iftype == NL80211_IFTYPE_MONITOR) {
324 priv->mesh_connect_status = LBS_CONNECTED;
325 netif_carrier_on(dev);
327 if (!priv->tx_pending_len)
328 netif_wake_queue(dev);
331 spin_unlock_irq(&priv->driver_lock);
332 lbs_deb_leave_args(LBS_DEB_NET, "ret %d", ret);
336 static const struct net_device_ops mesh_netdev_ops = {
337 .ndo_open = lbs_mesh_dev_open,
338 .ndo_stop = lbs_mesh_stop,
339 .ndo_start_xmit = lbs_hard_start_xmit,
340 .ndo_set_mac_address = lbs_set_mac_address,
341 .ndo_set_multicast_list = lbs_set_multicast_list,
345 * @brief This function adds mshX interface
347 * @param priv A pointer to the struct lbs_private structure
348 * @return 0 if successful, -X otherwise
350 int lbs_add_mesh(struct lbs_private *priv)
352 struct net_device *mesh_dev = NULL;
355 lbs_deb_enter(LBS_DEB_MESH);
357 /* Allocate a virtual mesh device */
358 mesh_dev = alloc_netdev(0, "msh%d", ether_setup);
360 lbs_deb_mesh("init mshX device failed\n");
364 mesh_dev->ml_priv = priv;
365 priv->mesh_dev = mesh_dev;
367 mesh_dev->netdev_ops = &mesh_netdev_ops;
368 mesh_dev->ethtool_ops = &lbs_ethtool_ops;
369 memcpy(mesh_dev->dev_addr, priv->dev->dev_addr, ETH_ALEN);
371 SET_NETDEV_DEV(priv->mesh_dev, priv->dev->dev.parent);
373 mesh_dev->flags |= IFF_BROADCAST | IFF_MULTICAST;
374 /* Register virtual mesh interface */
375 ret = register_netdev(mesh_dev);
377 lbs_pr_err("cannot register mshX virtual interface\n");
381 ret = sysfs_create_group(&(mesh_dev->dev.kobj), &lbs_mesh_attr_group);
385 lbs_persist_config_init(mesh_dev);
387 /* Everything successful */
392 unregister_netdev(mesh_dev);
395 free_netdev(mesh_dev);
398 lbs_deb_leave_args(LBS_DEB_MESH, "ret %d", ret);
402 void lbs_remove_mesh(struct lbs_private *priv)
404 struct net_device *mesh_dev;
406 mesh_dev = priv->mesh_dev;
410 lbs_deb_enter(LBS_DEB_MESH);
411 netif_stop_queue(mesh_dev);
412 netif_carrier_off(mesh_dev);
413 sysfs_remove_group(&(mesh_dev->dev.kobj), &lbs_mesh_attr_group);
414 lbs_persist_config_remove(mesh_dev);
415 unregister_netdev(mesh_dev);
416 priv->mesh_dev = NULL;
417 free_netdev(mesh_dev);
418 lbs_deb_leave(LBS_DEB_MESH);
423 /***************************************************************************
424 * Sending and receiving
426 struct net_device *lbs_mesh_set_dev(struct lbs_private *priv,
427 struct net_device *dev, struct rxpd *rxpd)
429 if (priv->mesh_dev) {
430 if (priv->mesh_tlv == TLV_TYPE_OLD_MESH_ID) {
431 if (rxpd->rx_control & RxPD_MESH_FRAME)
432 dev = priv->mesh_dev;
433 } else if (priv->mesh_tlv == TLV_TYPE_MESH_ID) {
434 if (rxpd->u.bss.bss_num == MESH_IFACE_ID)
435 dev = priv->mesh_dev;
442 void lbs_mesh_set_txpd(struct lbs_private *priv,
443 struct net_device *dev, struct txpd *txpd)
445 if (dev == priv->mesh_dev) {
446 if (priv->mesh_tlv == TLV_TYPE_OLD_MESH_ID)
447 txpd->tx_control |= cpu_to_le32(TxPD_MESH_FRAME);
448 else if (priv->mesh_tlv == TLV_TYPE_MESH_ID)
449 txpd->u.bss.bss_num = MESH_IFACE_ID;
454 /***************************************************************************
455 * Mesh command handling
458 int lbs_cmd_bt_access(struct cmd_ds_command *cmd,
459 u16 cmd_action, void *pdata_buf)
461 struct cmd_ds_bt_access *bt_access = &cmd->params.bt;
462 lbs_deb_enter_args(LBS_DEB_CMD, "action %d", cmd_action);
464 cmd->command = cpu_to_le16(CMD_BT_ACCESS);
465 cmd->size = cpu_to_le16(sizeof(struct cmd_ds_bt_access) +
466 sizeof(struct cmd_header));
468 bt_access->action = cpu_to_le16(cmd_action);
470 switch (cmd_action) {
471 case CMD_ACT_BT_ACCESS_ADD:
472 memcpy(bt_access->addr1, pdata_buf, 2 * ETH_ALEN);
473 lbs_deb_hex(LBS_DEB_MESH, "BT_ADD: blinded MAC addr",
474 bt_access->addr1, 6);
476 case CMD_ACT_BT_ACCESS_DEL:
477 memcpy(bt_access->addr1, pdata_buf, 1 * ETH_ALEN);
478 lbs_deb_hex(LBS_DEB_MESH, "BT_DEL: blinded MAC addr",
479 bt_access->addr1, 6);
481 case CMD_ACT_BT_ACCESS_LIST:
482 bt_access->id = cpu_to_le32(*(u32 *) pdata_buf);
484 case CMD_ACT_BT_ACCESS_RESET:
486 case CMD_ACT_BT_ACCESS_SET_INVERT:
487 bt_access->id = cpu_to_le32(*(u32 *) pdata_buf);
489 case CMD_ACT_BT_ACCESS_GET_INVERT:
494 lbs_deb_leave(LBS_DEB_CMD);
498 int lbs_cmd_fwt_access(struct cmd_ds_command *cmd,
499 u16 cmd_action, void *pdata_buf)
501 struct cmd_ds_fwt_access *fwt_access = &cmd->params.fwt;
502 lbs_deb_enter_args(LBS_DEB_CMD, "action %d", cmd_action);
504 cmd->command = cpu_to_le16(CMD_FWT_ACCESS);
505 cmd->size = cpu_to_le16(sizeof(struct cmd_ds_fwt_access) +
506 sizeof(struct cmd_header));
510 memcpy(fwt_access, pdata_buf, sizeof(*fwt_access));
512 memset(fwt_access, 0, sizeof(*fwt_access));
514 fwt_access->action = cpu_to_le16(cmd_action);
516 lbs_deb_leave(LBS_DEB_CMD);
520 int lbs_mesh_access(struct lbs_private *priv, uint16_t cmd_action,
521 struct cmd_ds_mesh_access *cmd)
525 lbs_deb_enter_args(LBS_DEB_CMD, "action %d", cmd_action);
527 cmd->hdr.command = cpu_to_le16(CMD_MESH_ACCESS);
528 cmd->hdr.size = cpu_to_le16(sizeof(*cmd));
531 cmd->action = cpu_to_le16(cmd_action);
533 ret = lbs_cmd_with_response(priv, CMD_MESH_ACCESS, cmd);
535 lbs_deb_leave(LBS_DEB_CMD);
539 static int __lbs_mesh_config_send(struct lbs_private *priv,
540 struct cmd_ds_mesh_config *cmd,
541 uint16_t action, uint16_t type)
544 u16 command = CMD_MESH_CONFIG_OLD;
546 lbs_deb_enter(LBS_DEB_CMD);
549 * Command id is 0xac for v10 FW along with mesh interface
550 * id in bits 14-13-12.
552 if (priv->mesh_tlv == TLV_TYPE_MESH_ID)
553 command = CMD_MESH_CONFIG |
554 (MESH_IFACE_ID << MESH_IFACE_BIT_OFFSET);
556 cmd->hdr.command = cpu_to_le16(command);
557 cmd->hdr.size = cpu_to_le16(sizeof(struct cmd_ds_mesh_config));
560 cmd->type = cpu_to_le16(type);
561 cmd->action = cpu_to_le16(action);
563 ret = lbs_cmd_with_response(priv, command, cmd);
565 lbs_deb_leave(LBS_DEB_CMD);
569 int lbs_mesh_config_send(struct lbs_private *priv,
570 struct cmd_ds_mesh_config *cmd,
571 uint16_t action, uint16_t type)
575 if (!(priv->fwcapinfo & FW_CAPINFO_PERSISTENT_CONFIG))
578 ret = __lbs_mesh_config_send(priv, cmd, action, type);
582 /* This function is the CMD_MESH_CONFIG legacy function. It only handles the
583 * START and STOP actions. The extended actions supported by CMD_MESH_CONFIG
584 * are all handled by preparing a struct cmd_ds_mesh_config and passing it to
585 * lbs_mesh_config_send.
587 int lbs_mesh_config(struct lbs_private *priv, uint16_t action, uint16_t chan)
589 struct cmd_ds_mesh_config cmd;
590 struct mrvl_meshie *ie;
591 DECLARE_SSID_BUF(ssid);
593 memset(&cmd, 0, sizeof(cmd));
594 cmd.channel = cpu_to_le16(chan);
595 ie = (struct mrvl_meshie *)cmd.data;
598 case CMD_ACT_MESH_CONFIG_START:
599 ie->id = WLAN_EID_GENERIC;
600 ie->val.oui[0] = 0x00;
601 ie->val.oui[1] = 0x50;
602 ie->val.oui[2] = 0x43;
603 ie->val.type = MARVELL_MESH_IE_TYPE;
604 ie->val.subtype = MARVELL_MESH_IE_SUBTYPE;
605 ie->val.version = MARVELL_MESH_IE_VERSION;
606 ie->val.active_protocol_id = MARVELL_MESH_PROTO_ID_HWMP;
607 ie->val.active_metric_id = MARVELL_MESH_METRIC_ID;
608 ie->val.mesh_capability = MARVELL_MESH_CAPABILITY;
609 ie->val.mesh_id_len = priv->mesh_ssid_len;
610 memcpy(ie->val.mesh_id, priv->mesh_ssid, priv->mesh_ssid_len);
611 ie->len = sizeof(struct mrvl_meshie_val) -
612 IEEE80211_MAX_SSID_LEN + priv->mesh_ssid_len;
613 cmd.length = cpu_to_le16(sizeof(struct mrvl_meshie_val));
615 case CMD_ACT_MESH_CONFIG_STOP:
620 lbs_deb_cmd("mesh config action %d type %x channel %d SSID %s\n",
621 action, priv->mesh_tlv, chan,
622 print_ssid(ssid, priv->mesh_ssid, priv->mesh_ssid_len));
624 return __lbs_mesh_config_send(priv, &cmd, action, priv->mesh_tlv);
629 /***************************************************************************
630 * Persistent configuration support
633 static int mesh_get_default_parameters(struct device *dev,
634 struct mrvl_mesh_defaults *defs)
636 struct lbs_private *priv = to_net_dev(dev)->ml_priv;
637 struct cmd_ds_mesh_config cmd;
640 memset(&cmd, 0, sizeof(struct cmd_ds_mesh_config));
641 ret = lbs_mesh_config_send(priv, &cmd, CMD_ACT_MESH_CONFIG_GET,
642 CMD_TYPE_MESH_GET_DEFAULTS);
647 memcpy(defs, &cmd.data[0], sizeof(struct mrvl_mesh_defaults));
653 * @brief Get function for sysfs attribute bootflag
655 static ssize_t bootflag_get(struct device *dev,
656 struct device_attribute *attr, char *buf)
658 struct mrvl_mesh_defaults defs;
661 ret = mesh_get_default_parameters(dev, &defs);
666 return snprintf(buf, 12, "%d\n", le32_to_cpu(defs.bootflag));
670 * @brief Set function for sysfs attribute bootflag
672 static ssize_t bootflag_set(struct device *dev, struct device_attribute *attr,
673 const char *buf, size_t count)
675 struct lbs_private *priv = to_net_dev(dev)->ml_priv;
676 struct cmd_ds_mesh_config cmd;
680 memset(&cmd, 0, sizeof(cmd));
681 ret = sscanf(buf, "%d", &datum);
682 if ((ret != 1) || (datum > 1))
685 *((__le32 *)&cmd.data[0]) = cpu_to_le32(!!datum);
686 cmd.length = cpu_to_le16(sizeof(uint32_t));
687 ret = lbs_mesh_config_send(priv, &cmd, CMD_ACT_MESH_CONFIG_SET,
688 CMD_TYPE_MESH_SET_BOOTFLAG);
696 * @brief Get function for sysfs attribute boottime
698 static ssize_t boottime_get(struct device *dev,
699 struct device_attribute *attr, char *buf)
701 struct mrvl_mesh_defaults defs;
704 ret = mesh_get_default_parameters(dev, &defs);
709 return snprintf(buf, 12, "%d\n", defs.boottime);
713 * @brief Set function for sysfs attribute boottime
715 static ssize_t boottime_set(struct device *dev,
716 struct device_attribute *attr, const char *buf, size_t count)
718 struct lbs_private *priv = to_net_dev(dev)->ml_priv;
719 struct cmd_ds_mesh_config cmd;
723 memset(&cmd, 0, sizeof(cmd));
724 ret = sscanf(buf, "%d", &datum);
725 if ((ret != 1) || (datum > 255))
728 /* A too small boot time will result in the device booting into
729 * standalone (no-host) mode before the host can take control of it,
730 * so the change will be hard to revert. This may be a desired
731 * feature (e.g to configure a very fast boot time for devices that
732 * will not be attached to a host), but dangerous. So I'm enforcing a
733 * lower limit of 20 seconds: remove and recompile the driver if this
734 * does not work for you.
736 datum = (datum < 20) ? 20 : datum;
738 cmd.length = cpu_to_le16(sizeof(uint8_t));
739 ret = lbs_mesh_config_send(priv, &cmd, CMD_ACT_MESH_CONFIG_SET,
740 CMD_TYPE_MESH_SET_BOOTTIME);
748 * @brief Get function for sysfs attribute channel
750 static ssize_t channel_get(struct device *dev,
751 struct device_attribute *attr, char *buf)
753 struct mrvl_mesh_defaults defs;
756 ret = mesh_get_default_parameters(dev, &defs);
761 return snprintf(buf, 12, "%d\n", le16_to_cpu(defs.channel));
765 * @brief Set function for sysfs attribute channel
767 static ssize_t channel_set(struct device *dev, struct device_attribute *attr,
768 const char *buf, size_t count)
770 struct lbs_private *priv = to_net_dev(dev)->ml_priv;
771 struct cmd_ds_mesh_config cmd;
775 memset(&cmd, 0, sizeof(cmd));
776 ret = sscanf(buf, "%d", &datum);
777 if (ret != 1 || datum < 1 || datum > 11)
780 *((__le16 *)&cmd.data[0]) = cpu_to_le16(datum);
781 cmd.length = cpu_to_le16(sizeof(uint16_t));
782 ret = lbs_mesh_config_send(priv, &cmd, CMD_ACT_MESH_CONFIG_SET,
783 CMD_TYPE_MESH_SET_DEF_CHANNEL);
791 * @brief Get function for sysfs attribute mesh_id
793 static ssize_t mesh_id_get(struct device *dev, struct device_attribute *attr,
796 struct mrvl_mesh_defaults defs;
800 ret = mesh_get_default_parameters(dev, &defs);
805 if (defs.meshie.val.mesh_id_len > IEEE80211_MAX_SSID_LEN) {
806 lbs_pr_err("inconsistent mesh ID length");
807 defs.meshie.val.mesh_id_len = IEEE80211_MAX_SSID_LEN;
810 /* SSID not null terminated: reserve room for \0 + \n */
811 maxlen = defs.meshie.val.mesh_id_len + 2;
812 maxlen = (PAGE_SIZE > maxlen) ? maxlen : PAGE_SIZE;
814 defs.meshie.val.mesh_id[defs.meshie.val.mesh_id_len] = '\0';
816 return snprintf(buf, maxlen, "%s\n", defs.meshie.val.mesh_id);
820 * @brief Set function for sysfs attribute mesh_id
822 static ssize_t mesh_id_set(struct device *dev, struct device_attribute *attr,
823 const char *buf, size_t count)
825 struct cmd_ds_mesh_config cmd;
826 struct mrvl_mesh_defaults defs;
827 struct mrvl_meshie *ie;
828 struct lbs_private *priv = to_net_dev(dev)->ml_priv;
832 if (count < 2 || count > IEEE80211_MAX_SSID_LEN + 1)
835 memset(&cmd, 0, sizeof(struct cmd_ds_mesh_config));
836 ie = (struct mrvl_meshie *) &cmd.data[0];
838 /* fetch all other Information Element parameters */
839 ret = mesh_get_default_parameters(dev, &defs);
841 cmd.length = cpu_to_le16(sizeof(struct mrvl_meshie));
843 /* transfer IE elements */
844 memcpy(ie, &defs.meshie, sizeof(struct mrvl_meshie));
847 memcpy(ie->val.mesh_id, buf, len);
849 ie->val.mesh_id_len = len;
851 ie->len = sizeof(struct mrvl_meshie_val) - IEEE80211_MAX_SSID_LEN + len;
853 ret = lbs_mesh_config_send(priv, &cmd, CMD_ACT_MESH_CONFIG_SET,
854 CMD_TYPE_MESH_SET_MESH_IE);
862 * @brief Get function for sysfs attribute protocol_id
864 static ssize_t protocol_id_get(struct device *dev,
865 struct device_attribute *attr, char *buf)
867 struct mrvl_mesh_defaults defs;
870 ret = mesh_get_default_parameters(dev, &defs);
875 return snprintf(buf, 5, "%d\n", defs.meshie.val.active_protocol_id);
879 * @brief Set function for sysfs attribute protocol_id
881 static ssize_t protocol_id_set(struct device *dev,
882 struct device_attribute *attr, const char *buf, size_t count)
884 struct cmd_ds_mesh_config cmd;
885 struct mrvl_mesh_defaults defs;
886 struct mrvl_meshie *ie;
887 struct lbs_private *priv = to_net_dev(dev)->ml_priv;
891 memset(&cmd, 0, sizeof(cmd));
892 ret = sscanf(buf, "%d", &datum);
893 if ((ret != 1) || (datum > 255))
896 /* fetch all other Information Element parameters */
897 ret = mesh_get_default_parameters(dev, &defs);
899 cmd.length = cpu_to_le16(sizeof(struct mrvl_meshie));
901 /* transfer IE elements */
902 ie = (struct mrvl_meshie *) &cmd.data[0];
903 memcpy(ie, &defs.meshie, sizeof(struct mrvl_meshie));
904 /* update protocol id */
905 ie->val.active_protocol_id = datum;
907 ret = lbs_mesh_config_send(priv, &cmd, CMD_ACT_MESH_CONFIG_SET,
908 CMD_TYPE_MESH_SET_MESH_IE);
916 * @brief Get function for sysfs attribute metric_id
918 static ssize_t metric_id_get(struct device *dev,
919 struct device_attribute *attr, char *buf)
921 struct mrvl_mesh_defaults defs;
924 ret = mesh_get_default_parameters(dev, &defs);
929 return snprintf(buf, 5, "%d\n", defs.meshie.val.active_metric_id);
933 * @brief Set function for sysfs attribute metric_id
935 static ssize_t metric_id_set(struct device *dev, struct device_attribute *attr,
936 const char *buf, size_t count)
938 struct cmd_ds_mesh_config cmd;
939 struct mrvl_mesh_defaults defs;
940 struct mrvl_meshie *ie;
941 struct lbs_private *priv = to_net_dev(dev)->ml_priv;
945 memset(&cmd, 0, sizeof(cmd));
946 ret = sscanf(buf, "%d", &datum);
947 if ((ret != 1) || (datum > 255))
950 /* fetch all other Information Element parameters */
951 ret = mesh_get_default_parameters(dev, &defs);
953 cmd.length = cpu_to_le16(sizeof(struct mrvl_meshie));
955 /* transfer IE elements */
956 ie = (struct mrvl_meshie *) &cmd.data[0];
957 memcpy(ie, &defs.meshie, sizeof(struct mrvl_meshie));
958 /* update metric id */
959 ie->val.active_metric_id = datum;
961 ret = lbs_mesh_config_send(priv, &cmd, CMD_ACT_MESH_CONFIG_SET,
962 CMD_TYPE_MESH_SET_MESH_IE);
970 * @brief Get function for sysfs attribute capability
972 static ssize_t capability_get(struct device *dev,
973 struct device_attribute *attr, char *buf)
975 struct mrvl_mesh_defaults defs;
978 ret = mesh_get_default_parameters(dev, &defs);
983 return snprintf(buf, 5, "%d\n", defs.meshie.val.mesh_capability);
987 * @brief Set function for sysfs attribute capability
989 static ssize_t capability_set(struct device *dev, struct device_attribute *attr,
990 const char *buf, size_t count)
992 struct cmd_ds_mesh_config cmd;
993 struct mrvl_mesh_defaults defs;
994 struct mrvl_meshie *ie;
995 struct lbs_private *priv = to_net_dev(dev)->ml_priv;
999 memset(&cmd, 0, sizeof(cmd));
1000 ret = sscanf(buf, "%d", &datum);
1001 if ((ret != 1) || (datum > 255))
1004 /* fetch all other Information Element parameters */
1005 ret = mesh_get_default_parameters(dev, &defs);
1007 cmd.length = cpu_to_le16(sizeof(struct mrvl_meshie));
1009 /* transfer IE elements */
1010 ie = (struct mrvl_meshie *) &cmd.data[0];
1011 memcpy(ie, &defs.meshie, sizeof(struct mrvl_meshie));
1013 ie->val.mesh_capability = datum;
1015 ret = lbs_mesh_config_send(priv, &cmd, CMD_ACT_MESH_CONFIG_SET,
1016 CMD_TYPE_MESH_SET_MESH_IE);
1024 static DEVICE_ATTR(bootflag, 0644, bootflag_get, bootflag_set);
1025 static DEVICE_ATTR(boottime, 0644, boottime_get, boottime_set);
1026 static DEVICE_ATTR(channel, 0644, channel_get, channel_set);
1027 static DEVICE_ATTR(mesh_id, 0644, mesh_id_get, mesh_id_set);
1028 static DEVICE_ATTR(protocol_id, 0644, protocol_id_get, protocol_id_set);
1029 static DEVICE_ATTR(metric_id, 0644, metric_id_get, metric_id_set);
1030 static DEVICE_ATTR(capability, 0644, capability_get, capability_set);
1032 static struct attribute *boot_opts_attrs[] = {
1033 &dev_attr_bootflag.attr,
1034 &dev_attr_boottime.attr,
1035 &dev_attr_channel.attr,
1039 static struct attribute_group boot_opts_group = {
1040 .name = "boot_options",
1041 .attrs = boot_opts_attrs,
1044 static struct attribute *mesh_ie_attrs[] = {
1045 &dev_attr_mesh_id.attr,
1046 &dev_attr_protocol_id.attr,
1047 &dev_attr_metric_id.attr,
1048 &dev_attr_capability.attr,
1052 static struct attribute_group mesh_ie_group = {
1054 .attrs = mesh_ie_attrs,
1057 void lbs_persist_config_init(struct net_device *dev)
1060 ret = sysfs_create_group(&(dev->dev.kobj), &boot_opts_group);
1061 ret = sysfs_create_group(&(dev->dev.kobj), &mesh_ie_group);
1064 void lbs_persist_config_remove(struct net_device *dev)
1066 sysfs_remove_group(&(dev->dev.kobj), &boot_opts_group);
1067 sysfs_remove_group(&(dev->dev.kobj), &mesh_ie_group);
1072 /***************************************************************************
1076 static const char *mesh_stat_strings[] = {
1077 "drop_duplicate_bcast",
1079 "drop_no_fwd_route",
1081 "fwded_unicast_cnt",
1087 void lbs_mesh_ethtool_get_stats(struct net_device *dev,
1088 struct ethtool_stats *stats, uint64_t *data)
1090 struct lbs_private *priv = dev->ml_priv;
1091 struct cmd_ds_mesh_access mesh_access;
1094 lbs_deb_enter(LBS_DEB_ETHTOOL);
1096 /* Get Mesh Statistics */
1097 ret = lbs_mesh_access(priv, CMD_ACT_MESH_GET_STATS, &mesh_access);
1100 memset(data, 0, MESH_STATS_NUM*(sizeof(uint64_t)));
1104 priv->mstats.fwd_drop_rbt = le32_to_cpu(mesh_access.data[0]);
1105 priv->mstats.fwd_drop_ttl = le32_to_cpu(mesh_access.data[1]);
1106 priv->mstats.fwd_drop_noroute = le32_to_cpu(mesh_access.data[2]);
1107 priv->mstats.fwd_drop_nobuf = le32_to_cpu(mesh_access.data[3]);
1108 priv->mstats.fwd_unicast_cnt = le32_to_cpu(mesh_access.data[4]);
1109 priv->mstats.fwd_bcast_cnt = le32_to_cpu(mesh_access.data[5]);
1110 priv->mstats.drop_blind = le32_to_cpu(mesh_access.data[6]);
1111 priv->mstats.tx_failed_cnt = le32_to_cpu(mesh_access.data[7]);
1113 data[0] = priv->mstats.fwd_drop_rbt;
1114 data[1] = priv->mstats.fwd_drop_ttl;
1115 data[2] = priv->mstats.fwd_drop_noroute;
1116 data[3] = priv->mstats.fwd_drop_nobuf;
1117 data[4] = priv->mstats.fwd_unicast_cnt;
1118 data[5] = priv->mstats.fwd_bcast_cnt;
1119 data[6] = priv->mstats.drop_blind;
1120 data[7] = priv->mstats.tx_failed_cnt;
1122 lbs_deb_enter(LBS_DEB_ETHTOOL);
1125 int lbs_mesh_ethtool_get_sset_count(struct net_device *dev, int sset)
1127 struct lbs_private *priv = dev->ml_priv;
1129 if (sset == ETH_SS_STATS && dev == priv->mesh_dev)
1130 return MESH_STATS_NUM;
1135 void lbs_mesh_ethtool_get_strings(struct net_device *dev,
1136 uint32_t stringset, uint8_t *s)
1140 lbs_deb_enter(LBS_DEB_ETHTOOL);
1142 switch (stringset) {
1144 for (i = 0; i < MESH_STATS_NUM; i++) {
1145 memcpy(s + i * ETH_GSTRING_LEN,
1146 mesh_stat_strings[i],
1151 lbs_deb_enter(LBS_DEB_ETHTOOL);