drivers/net/wireless/libertas/mesh.c

   1 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
   2
   3 #include <linux/delay.h>
   4 #include <linux/etherdevice.h>
   5 #include <linux/netdevice.h>
   6 #include <linux/if_ether.h>
   7 #include <linux/if_arp.h>
   8 #include <linux/kthread.h>
   9 #include <linux/kfifo.h>
  10 #include <net/cfg80211.h>
  11
  12 #include "mesh.h"
  13 #include "decl.h"
  14 #include "cmd.h"
  15
  16
  17 /***************************************************************************
  18  * Mesh sysfs support
  19  */
  20
  21 /*
  22  * Attributes exported through sysfs
  23  */
  24
  25 /**
  26  * lbs_anycast_get - Get function for sysfs attribute anycast_mask
  27  * @dev: the &struct device
  28  * @attr: device attributes
  29  * @buf: buffer where data will be returned
  30  */
  31 static ssize_t lbs_anycast_get(struct device *dev,
  32                 struct device_attribute *attr, char * buf)
  33 {
  34         struct lbs_private *priv = to_net_dev(dev)->ml_priv;
  35         struct cmd_ds_mesh_access mesh_access;
  36         int ret;
  37
  38         memset(&mesh_access, 0, sizeof(mesh_access));
  39
  40         ret = lbs_mesh_access(priv, CMD_ACT_MESH_GET_ANYCAST, &mesh_access);
  41         if (ret)
  42                 return ret;
  43
  44         return snprintf(buf, 12, "0x%X\n", le32_to_cpu(mesh_access.data[0]));
  45 }
  46
  47 /**
  48  * lbs_anycast_set - Set function for sysfs attribute anycast_mask
  49  * @dev: the &struct device
  50  * @attr: device attributes
  51  * @buf: buffer that contains new attribute value
  52  * @count: size of buffer
  53  */
  54 static ssize_t lbs_anycast_set(struct device *dev,
  55                 struct device_attribute *attr, const char * buf, size_t count)
  56 {
  57         struct lbs_private *priv = to_net_dev(dev)->ml_priv;
  58         struct cmd_ds_mesh_access mesh_access;
  59         uint32_t datum;
  60         int ret;
  61
  62         memset(&mesh_access, 0, sizeof(mesh_access));
  63         sscanf(buf, "%x", &datum);
  64         mesh_access.data[0] = cpu_to_le32(datum);
  65
  66         ret = lbs_mesh_access(priv, CMD_ACT_MESH_SET_ANYCAST, &mesh_access);
  67         if (ret)
  68                 return ret;
  69
  70         return strlen(buf);
  71 }
  72
  73 /**
  74  * lbs_prb_rsp_limit_get - Get function for sysfs attribute prb_rsp_limit
  75  * @dev: the &struct device
  76  * @attr: device attributes
  77  * @buf: buffer where data will be returned
  78  */
  79 static ssize_t lbs_prb_rsp_limit_get(struct device *dev,
  80                 struct device_attribute *attr, char *buf)
  81 {
  82         struct lbs_private *priv = to_net_dev(dev)->ml_priv;
  83         struct cmd_ds_mesh_access mesh_access;
  84         int ret;
  85         u32 retry_limit;
  86
  87         memset(&mesh_access, 0, sizeof(mesh_access));
  88         mesh_access.data[0] = cpu_to_le32(CMD_ACT_GET);
  89
  90         ret = lbs_mesh_access(priv, CMD_ACT_MESH_SET_GET_PRB_RSP_LIMIT,
  91                         &mesh_access);
  92         if (ret)
  93                 return ret;
  94
  95         retry_limit = le32_to_cpu(mesh_access.data[1]);
  96         return snprintf(buf, 10, "%d\n", retry_limit);
  97 }
  98
  99 /**
 100  * lbs_prb_rsp_limit_set - Set function for sysfs attribute prb_rsp_limit
 101  * @dev: the &struct device
 102  * @attr: device attributes
 103  * @buf: buffer that contains new attribute value
 104  * @count: size of buffer
 105  */
 106 static ssize_t lbs_prb_rsp_limit_set(struct device *dev,
 107                 struct device_attribute *attr, const char *buf, size_t count)
 108 {
 109         struct lbs_private *priv = to_net_dev(dev)->ml_priv;
 110         struct cmd_ds_mesh_access mesh_access;
 111         int ret;
 112         unsigned long retry_limit;
 113
 114         memset(&mesh_access, 0, sizeof(mesh_access));
 115         mesh_access.data[0] = cpu_to_le32(CMD_ACT_SET);
 116
 117         if (!strict_strtoul(buf, 10, &retry_limit))
 118                 return -ENOTSUPP;
 119         if (retry_limit > 15)
 120                 return -ENOTSUPP;
 121
 122         mesh_access.data[1] = cpu_to_le32(retry_limit);
 123
 124         ret = lbs_mesh_access(priv, CMD_ACT_MESH_SET_GET_PRB_RSP_LIMIT,
 125                         &mesh_access);
 126         if (ret)
 127                 return ret;
 128
 129         return strlen(buf);
 130 }
 131
 132 /**
 133  * lbs_mesh_get - Get function for sysfs attribute mesh
 134  * @dev: the &struct device
 135  * @attr: device attributes
 136  * @buf: buffer where data will be returned
 137  */
 138 static ssize_t lbs_mesh_get(struct device *dev,
 139                 struct device_attribute *attr, char * buf)
 140 {
 141         struct lbs_private *priv = to_net_dev(dev)->ml_priv;
 142         return snprintf(buf, 5, "0x%X\n", !!priv->mesh_dev);
 143 }
 144
 145 /**
 146  * lbs_mesh_set - Set function for sysfs attribute mesh
 147  * @dev: the &struct device
 148  * @attr: device attributes
 149  * @buf: buffer that contains new attribute value
 150  * @count: size of buffer
 151  */
 152 static ssize_t lbs_mesh_set(struct device *dev,
 153                 struct device_attribute *attr, const char * buf, size_t count)
 154 {
 155         struct lbs_private *priv = to_net_dev(dev)->ml_priv;
 156         int enable;
 157         int ret, action = CMD_ACT_MESH_CONFIG_STOP;
 158
 159         sscanf(buf, "%x", &enable);
 160         enable = !!enable;
 161         if (enable == !!priv->mesh_dev)
 162                 return count;
 163         if (enable)
 164                 action = CMD_ACT_MESH_CONFIG_START;
 165         ret = lbs_mesh_config(priv, action, priv->channel);
 166         if (ret)
 167                 return ret;
 168
 169         if (enable)
 170                 lbs_add_mesh(priv);
 171         else
 172                 lbs_remove_mesh(priv);
 173
 174         return count;
 175 }
 176
 177 /*
 178  * lbs_mesh attribute to be exported per ethX interface
 179  * through sysfs (/sys/class/net/ethX/lbs_mesh)
 180  */
 181 static DEVICE_ATTR(lbs_mesh, 0644, lbs_mesh_get, lbs_mesh_set);
 182
 183 /*
 184  * anycast_mask attribute to be exported per mshX interface
 185  * through sysfs (/sys/class/net/mshX/anycast_mask)
 186  */
 187 static DEVICE_ATTR(anycast_mask, 0644, lbs_anycast_get, lbs_anycast_set);
 188
 189 /*
 190  * prb_rsp_limit attribute to be exported per mshX interface
 191  * through sysfs (/sys/class/net/mshX/prb_rsp_limit)
 192  */
 193 static DEVICE_ATTR(prb_rsp_limit, 0644, lbs_prb_rsp_limit_get,
 194                 lbs_prb_rsp_limit_set);
 195
 196 static struct attribute *lbs_mesh_sysfs_entries[] = {
 197         &dev_attr_anycast_mask.attr,
 198         &dev_attr_prb_rsp_limit.attr,
 199         NULL,
 200 };
 201
 202 static struct attribute_group lbs_mesh_attr_group = {
 203         .attrs = lbs_mesh_sysfs_entries,
 204 };
 205
 206
 207
 208 /***************************************************************************
 209  * Initializing and starting, stopping mesh
 210  */
 211
 212 /*
 213  * Check mesh FW version and appropriately send the mesh start
 214  * command
 215  */
 216 int lbs_init_mesh(struct lbs_private *priv)
 217 {
 218         struct net_device *dev = priv->dev;
 219         int ret = 0;
 220
 221         lbs_deb_enter(LBS_DEB_MESH);
 222
 223         priv->mesh_connect_status = LBS_DISCONNECTED;
 224
 225         /* Determine mesh_fw_ver from fwrelease and fwcapinfo */
 226         /* 5.0.16p0 9.0.0.p0 is known to NOT support any mesh */
 227         /* 5.110.22 have mesh command with 0xa3 command id */
 228         /* 10.0.0.p0 FW brings in mesh config command with different id */
 229         /* Check FW version MSB and initialize mesh_fw_ver */
 230         if (MRVL_FW_MAJOR_REV(priv->fwrelease) == MRVL_FW_V5) {
 231                 /* Enable mesh, if supported, and work out which TLV it uses.
 232                    0x100 + 291 is an unofficial value used in 5.110.20.pXX
 233                    0x100 + 37 is the official value used in 5.110.21.pXX
 234                    but we check them in that order because 20.pXX doesn't
 235                    give an error -- it just silently fails. */
 236
 237                 /* 5.110.20.pXX firmware will fail the command if the channel
 238                    doesn't match the existing channel. But only if the TLV
 239                    is correct. If the channel is wrong, _BOTH_ versions will
 240                    give an error to 0x100+291, and allow 0x100+37 to succeed.
 241                    It's just that 5.110.20.pXX will not have done anything
 242                    useful */
 243
 244                 priv->mesh_tlv = TLV_TYPE_OLD_MESH_ID;
 245                 if (lbs_mesh_config(priv, CMD_ACT_MESH_CONFIG_START,
 246                                     priv->channel)) {
 247                         priv->mesh_tlv = TLV_TYPE_MESH_ID;
 248                         if (lbs_mesh_config(priv, CMD_ACT_MESH_CONFIG_START,
 249                                             priv->channel))
 250                                 priv->mesh_tlv = 0;
 251                 }
 252         } else
 253         if ((MRVL_FW_MAJOR_REV(priv->fwrelease) >= MRVL_FW_V10) &&
 254                 (priv->fwcapinfo & MESH_CAPINFO_ENABLE_MASK)) {
 255                 /* 10.0.0.pXX new firmwares should succeed with TLV
 256                  * 0x100+37; Do not invoke command with old TLV.
 257                  */
 258                 priv->mesh_tlv = TLV_TYPE_MESH_ID;
 259                 if (lbs_mesh_config(priv, CMD_ACT_MESH_CONFIG_START,
 260                                     priv->channel))
 261                         priv->mesh_tlv = 0;
 262         }
 263
 264
 265         if (priv->mesh_tlv) {
 266                 sprintf(priv->mesh_ssid, "mesh");
 267                 priv->mesh_ssid_len = 4;
 268
 269                 lbs_add_mesh(priv);
 270
 271                 if (device_create_file(&dev->dev, &dev_attr_lbs_mesh))
 272                         netdev_err(dev, "cannot register lbs_mesh attribute\n");
 273
 274                 ret = 1;
 275         }
 276
 277         lbs_deb_leave_args(LBS_DEB_MESH, "ret %d", ret);
 278         return ret;
 279 }
 280
 281
 282 int lbs_deinit_mesh(struct lbs_private *priv)
 283 {
 284         struct net_device *dev = priv->dev;
 285         int ret = 0;
 286
 287         lbs_deb_enter(LBS_DEB_MESH);
 288
 289         if (priv->mesh_tlv) {
 290                 device_remove_file(&dev->dev, &dev_attr_lbs_mesh);
 291                 ret = 1;
 292         }
 293
 294         lbs_deb_leave_args(LBS_DEB_MESH, "ret %d", ret);
 295         return ret;
 296 }
 297
 298
 299 /**
 300  * lbs_mesh_stop - close the mshX interface
 301  *
 302  * @dev:        A pointer to &net_device structure
 303  * returns:     0
 304  */
 305 static int lbs_mesh_stop(struct net_device *dev)
 306 {
 307         struct lbs_private *priv = dev->ml_priv;
 308
 309         lbs_deb_enter(LBS_DEB_MESH);
 310         spin_lock_irq(&priv->driver_lock);
 311
 312         priv->mesh_open = 0;
 313         priv->mesh_connect_status = LBS_DISCONNECTED;
 314
 315         netif_stop_queue(dev);
 316         netif_carrier_off(dev);
 317
 318         spin_unlock_irq(&priv->driver_lock);
 319
 320         schedule_work(&priv->mcast_work);
 321
 322         lbs_deb_leave(LBS_DEB_MESH);
 323         return 0;
 324 }
 325
 326 /**
 327  * lbs_mesh_dev_open - open the mshX interface
 328  *
 329  * @dev:        A pointer to &net_device structure
 330  * returns:     0 or -EBUSY if monitor mode active
 331  */
 332 static int lbs_mesh_dev_open(struct net_device *dev)
 333 {
 334         struct lbs_private *priv = dev->ml_priv;
 335         int ret = 0;
 336
 337         lbs_deb_enter(LBS_DEB_NET);
 338
 339         spin_lock_irq(&priv->driver_lock);
 340
 341         if (priv->wdev->iftype == NL80211_IFTYPE_MONITOR) {
 342                 ret = -EBUSY;
 343                 goto out;
 344         }
 345
 346         priv->mesh_open = 1;
 347         priv->mesh_connect_status = LBS_CONNECTED;
 348         netif_carrier_on(dev);
 349
 350         if (!priv->tx_pending_len)
 351                 netif_wake_queue(dev);
 352  out:
 353
 354         spin_unlock_irq(&priv->driver_lock);
 355         lbs_deb_leave_args(LBS_DEB_NET, "ret %d", ret);
 356         return ret;
 357 }
 358
 359 static const struct net_device_ops mesh_netdev_ops = {
 360         .ndo_open               = lbs_mesh_dev_open,
 361         .ndo_stop               = lbs_mesh_stop,
 362         .ndo_start_xmit         = lbs_hard_start_xmit,
 363         .ndo_set_mac_address    = lbs_set_mac_address,
 364         .ndo_set_multicast_list = lbs_set_multicast_list,
 365 };
 366
 367 /**
 368  * lbs_add_mesh - add mshX interface
 369  *
 370  * @priv:       A pointer to the &struct lbs_private structure
 371  * returns:     0 if successful, -X otherwise
 372  */
 373 int lbs_add_mesh(struct lbs_private *priv)
 374 {
 375         struct net_device *mesh_dev = NULL;
 376         int ret = 0;
 377
 378         lbs_deb_enter(LBS_DEB_MESH);
 379
 380         /* Allocate a virtual mesh device */
 381         mesh_dev = alloc_netdev(0, "msh%d", ether_setup);
 382         if (!mesh_dev) {
 383                 lbs_deb_mesh("init mshX device failed\n");
 384                 ret = -ENOMEM;
 385                 goto done;
 386         }
 387         mesh_dev->ml_priv = priv;
 388         priv->mesh_dev = mesh_dev;
 389
 390         mesh_dev->netdev_ops = &mesh_netdev_ops;
 391         mesh_dev->ethtool_ops = &lbs_ethtool_ops;
 392         memcpy(mesh_dev->dev_addr, priv->dev->dev_addr, ETH_ALEN);
 393
 394         SET_NETDEV_DEV(priv->mesh_dev, priv->dev->dev.parent);
 395
 396         mesh_dev->flags |= IFF_BROADCAST | IFF_MULTICAST;
 397         /* Register virtual mesh interface */
 398         ret = register_netdev(mesh_dev);
 399         if (ret) {
 400                 pr_err("cannot register mshX virtual interface\n");
 401                 goto err_free;
 402         }
 403
 404         ret = sysfs_create_group(&(mesh_dev->dev.kobj), &lbs_mesh_attr_group);
 405         if (ret)
 406                 goto err_unregister;
 407
 408         lbs_persist_config_init(mesh_dev);
 409
 410         /* Everything successful */
 411         ret = 0;
 412         goto done;
 413
 414 err_unregister:
 415         unregister_netdev(mesh_dev);
 416
 417 err_free:
 418         free_netdev(mesh_dev);
 419
 420 done:
 421         lbs_deb_leave_args(LBS_DEB_MESH, "ret %d", ret);
 422         return ret;
 423 }
 424
 425 void lbs_remove_mesh(struct lbs_private *priv)
 426 {
 427         struct net_device *mesh_dev;
 428
 429         mesh_dev = priv->mesh_dev;
 430         if (!mesh_dev)
 431                 return;
 432
 433         lbs_deb_enter(LBS_DEB_MESH);
 434         netif_stop_queue(mesh_dev);
 435         netif_carrier_off(mesh_dev);
 436         sysfs_remove_group(&(mesh_dev->dev.kobj), &lbs_mesh_attr_group);
 437         lbs_persist_config_remove(mesh_dev);
 438         unregister_netdev(mesh_dev);
 439         priv->mesh_dev = NULL;
 440         free_netdev(mesh_dev);
 441         lbs_deb_leave(LBS_DEB_MESH);
 442 }
 443
 444
 445
 446 /***************************************************************************
 447  * Sending and receiving
 448  */
 449 struct net_device *lbs_mesh_set_dev(struct lbs_private *priv,
 450         struct net_device *dev, struct rxpd *rxpd)
 451 {
 452         if (priv->mesh_dev) {
 453                 if (priv->mesh_tlv == TLV_TYPE_OLD_MESH_ID) {
 454                         if (rxpd->rx_control & RxPD_MESH_FRAME)
 455                                 dev = priv->mesh_dev;
 456                 } else if (priv->mesh_tlv == TLV_TYPE_MESH_ID) {
 457                         if (rxpd->u.bss.bss_num == MESH_IFACE_ID)
 458                                 dev = priv->mesh_dev;
 459                 }
 460         }
 461         return dev;
 462 }
 463
 464
 465 void lbs_mesh_set_txpd(struct lbs_private *priv,
 466         struct net_device *dev, struct txpd *txpd)
 467 {
 468         if (dev == priv->mesh_dev) {
 469                 if (priv->mesh_tlv == TLV_TYPE_OLD_MESH_ID)
 470                         txpd->tx_control |= cpu_to_le32(TxPD_MESH_FRAME);
 471                 else if (priv->mesh_tlv == TLV_TYPE_MESH_ID)
 472                         txpd->u.bss.bss_num = MESH_IFACE_ID;
 473         }
 474 }
 475
 476
 477 /***************************************************************************
 478  * Mesh command handling
 479  */
 480
 481 /**
 482  * lbs_mesh_bt_add_del - Add or delete Mesh Blinding Table entries
 483  *
 484  * @priv:       A pointer to &struct lbs_private structure
 485  * @add:        TRUE to add the entry, FALSE to delete it
 486  * @addr1:      Destination address to blind or unblind
 487  *
 488  * returns:     0 on success, error on failure
 489  */
 490 int lbs_mesh_bt_add_del(struct lbs_private *priv, bool add, u8 *addr1)
 491 {
 492         struct cmd_ds_bt_access cmd;
 493         int ret = 0;
 494
 495         lbs_deb_enter(LBS_DEB_CMD);
 496
 497         BUG_ON(addr1 == NULL);
 498
 499         memset(&cmd, 0, sizeof(cmd));
 500         cmd.hdr.size = cpu_to_le16(sizeof(cmd));
 501         memcpy(cmd.addr1, addr1, ETH_ALEN);
 502         if (add) {
 503                 cmd.action = cpu_to_le16(CMD_ACT_BT_ACCESS_ADD);
 504                 lbs_deb_hex(LBS_DEB_MESH, "BT_ADD: blinded MAC addr",
 505                         addr1, ETH_ALEN);
 506         } else {
 507                 cmd.action = cpu_to_le16(CMD_ACT_BT_ACCESS_DEL);
 508                 lbs_deb_hex(LBS_DEB_MESH, "BT_DEL: blinded MAC addr",
 509                         addr1, ETH_ALEN);
 510         }
 511
 512         ret = lbs_cmd_with_response(priv, CMD_BT_ACCESS, &cmd);
 513
 514         lbs_deb_leave_args(LBS_DEB_CMD, "ret %d", ret);
 515         return ret;
 516 }
 517
 518 /**
 519  * lbs_mesh_bt_reset - Reset/clear the mesh blinding table
 520  *
 521  * @priv:       A pointer to &struct lbs_private structure
 522  *
 523  * returns:     0 on success, error on failure
 524  */
 525 int lbs_mesh_bt_reset(struct lbs_private *priv)
 526 {
 527         struct cmd_ds_bt_access cmd;
 528         int ret = 0;
 529
 530         lbs_deb_enter(LBS_DEB_CMD);
 531
 532         memset(&cmd, 0, sizeof(cmd));
 533         cmd.hdr.size = cpu_to_le16(sizeof(cmd));
 534         cmd.action = cpu_to_le16(CMD_ACT_BT_ACCESS_RESET);
 535
 536         ret = lbs_cmd_with_response(priv, CMD_BT_ACCESS, &cmd);
 537
 538         lbs_deb_leave_args(LBS_DEB_CMD, "ret %d", ret);
 539         return ret;
 540 }
 541
 542 /**
 543  * lbs_mesh_bt_get_inverted - Gets the inverted status of the mesh
 544  * blinding table
 545  *
 546  * Normally the firmware "blinds" or ignores traffic from mesh nodes in the
 547  * table, but an inverted table allows *only* traffic from nodes listed in
 548  * the table.
 549  *
 550  * @priv:       A pointer to &struct lbs_private structure
 551  * @inverted:   On success, TRUE if the blinding table is inverted,
 552  *              FALSE if it is not inverted
 553  *
 554  * returns:     0 on success, error on failure
 555  */
 556 int lbs_mesh_bt_get_inverted(struct lbs_private *priv, bool *inverted)
 557 {
 558         struct cmd_ds_bt_access cmd;
 559         int ret = 0;
 560
 561         lbs_deb_enter(LBS_DEB_CMD);
 562
 563         BUG_ON(inverted == NULL);
 564
 565         memset(&cmd, 0, sizeof(cmd));
 566         cmd.hdr.size = cpu_to_le16(sizeof(cmd));
 567         cmd.action = cpu_to_le16(CMD_ACT_BT_ACCESS_GET_INVERT);
 568
 569         ret = lbs_cmd_with_response(priv, CMD_BT_ACCESS, &cmd);
 570         if (ret == 0)
 571                 *inverted = !!cmd.id;
 572
 573         lbs_deb_leave_args(LBS_DEB_CMD, "ret %d", ret);
 574         return ret;
 575 }
 576
 577 /**
 578  * lbs_mesh_bt_set_inverted - Sets the inverted status of the mesh
 579  * blinding table
 580  *
 581  * Normally the firmware "blinds" or ignores traffic from mesh nodes in the
 582  * table, but an inverted table allows *only* traffic from nodes listed in
 583  * the table.
 584  *
 585  * @priv:       A pointer to &struct lbs_private structure
 586  * @inverted:   TRUE to invert the blinding table (only traffic from
 587  *              listed nodes allowed), FALSE to return it
 588  *              to normal state (listed nodes ignored)
 589  *
 590  * returns:     0 on success, error on failure
 591  */
 592 int lbs_mesh_bt_set_inverted(struct lbs_private *priv, bool inverted)
 593 {
 594         struct cmd_ds_bt_access cmd;
 595         int ret = 0;
 596
 597         lbs_deb_enter(LBS_DEB_CMD);
 598
 599         memset(&cmd, 0, sizeof(cmd));
 600         cmd.hdr.size = cpu_to_le16(sizeof(cmd));
 601         cmd.action = cpu_to_le16(CMD_ACT_BT_ACCESS_SET_INVERT);
 602         cmd.id = cpu_to_le32(!!inverted);
 603
 604         ret = lbs_cmd_with_response(priv, CMD_BT_ACCESS, &cmd);
 605
 606         lbs_deb_leave_args(LBS_DEB_CMD, "ret %d", ret);
 607         return ret;
 608 }
 609
 610 /**
 611  * lbs_mesh_bt_get_entry - List an entry in the mesh blinding table
 612  *
 613  * @priv:       A pointer to &struct lbs_private structure
 614  * @id:         The ID of the entry to list
 615  * @addr1:      MAC address associated with the table entry
 616  *
 617  * returns:             0 on success, error on failure
 618  */
 619 int lbs_mesh_bt_get_entry(struct lbs_private *priv, u32 id, u8 *addr1)
 620 {
 621         struct cmd_ds_bt_access cmd;
 622         int ret = 0;
 623
 624         lbs_deb_enter(LBS_DEB_CMD);
 625
 626         BUG_ON(addr1 == NULL);
 627
 628         memset(&cmd, 0, sizeof(cmd));
 629         cmd.hdr.size = cpu_to_le16(sizeof(cmd));
 630         cmd.action = cpu_to_le16(CMD_ACT_BT_ACCESS_SET_INVERT);
 631         cmd.id = cpu_to_le32(id);
 632
 633         ret = lbs_cmd_with_response(priv, CMD_BT_ACCESS, &cmd);
 634         if (ret == 0)
 635                 memcpy(addr1, cmd.addr1, sizeof(cmd.addr1));
 636
 637         lbs_deb_leave_args(LBS_DEB_CMD, "ret %d", ret);
 638         return ret;
 639 }
 640
 641 /**
 642  * lbs_cmd_fwt_access - Access the mesh forwarding table
 643  *
 644  * @priv:       A pointer to &struct lbs_private structure
 645  * @cmd_action: The forwarding table action to perform
 646  * @cmd:        The pre-filled FWT_ACCESS command
 647  *
 648  * returns:     0 on success and 'cmd' will be filled with the
 649  *              firmware's response
 650  */
 651 int lbs_cmd_fwt_access(struct lbs_private *priv, u16 cmd_action,
 652                         struct cmd_ds_fwt_access *cmd)
 653 {
 654         int ret;
 655
 656         lbs_deb_enter_args(LBS_DEB_CMD, "action %d", cmd_action);
 657
 658         cmd->hdr.command = cpu_to_le16(CMD_FWT_ACCESS);
 659         cmd->hdr.size = cpu_to_le16(sizeof(struct cmd_ds_fwt_access));
 660         cmd->hdr.result = 0;
 661         cmd->action = cpu_to_le16(cmd_action);
 662
 663         ret = lbs_cmd_with_response(priv, CMD_FWT_ACCESS, cmd);
 664
 665         lbs_deb_leave_args(LBS_DEB_CMD, "ret %d", ret);
 666         return 0;
 667 }
 668
 669 int lbs_mesh_access(struct lbs_private *priv, uint16_t cmd_action,
 670                     struct cmd_ds_mesh_access *cmd)
 671 {
 672         int ret;
 673
 674         lbs_deb_enter_args(LBS_DEB_CMD, "action %d", cmd_action);
 675
 676         cmd->hdr.command = cpu_to_le16(CMD_MESH_ACCESS);
 677         cmd->hdr.size = cpu_to_le16(sizeof(*cmd));
 678         cmd->hdr.result = 0;
 679
 680         cmd->action = cpu_to_le16(cmd_action);
 681
 682         ret = lbs_cmd_with_response(priv, CMD_MESH_ACCESS, cmd);
 683
 684         lbs_deb_leave(LBS_DEB_CMD);
 685         return ret;
 686 }
 687
 688 static int __lbs_mesh_config_send(struct lbs_private *priv,
 689                                   struct cmd_ds_mesh_config *cmd,
 690                                   uint16_t action, uint16_t type)
 691 {
 692         int ret;
 693         u16 command = CMD_MESH_CONFIG_OLD;
 694
 695         lbs_deb_enter(LBS_DEB_CMD);
 696
 697         /*
 698          * Command id is 0xac for v10 FW along with mesh interface
 699          * id in bits 14-13-12.
 700          */
 701         if (priv->mesh_tlv == TLV_TYPE_MESH_ID)
 702                 command = CMD_MESH_CONFIG |
 703                           (MESH_IFACE_ID << MESH_IFACE_BIT_OFFSET);
 704
 705         cmd->hdr.command = cpu_to_le16(command);
 706         cmd->hdr.size = cpu_to_le16(sizeof(struct cmd_ds_mesh_config));
 707         cmd->hdr.result = 0;
 708
 709         cmd->type = cpu_to_le16(type);
 710         cmd->action = cpu_to_le16(action);
 711
 712         ret = lbs_cmd_with_response(priv, command, cmd);
 713
 714         lbs_deb_leave(LBS_DEB_CMD);
 715         return ret;
 716 }
 717
 718 int lbs_mesh_config_send(struct lbs_private *priv,
 719                          struct cmd_ds_mesh_config *cmd,
 720                          uint16_t action, uint16_t type)
 721 {
 722         int ret;
 723
 724         if (!(priv->fwcapinfo & FW_CAPINFO_PERSISTENT_CONFIG))
 725                 return -EOPNOTSUPP;
 726
 727         ret = __lbs_mesh_config_send(priv, cmd, action, type);
 728         return ret;
 729 }
 730
 731 /* This function is the CMD_MESH_CONFIG legacy function.  It only handles the
 732  * START and STOP actions.  The extended actions supported by CMD_MESH_CONFIG
 733  * are all handled by preparing a struct cmd_ds_mesh_config and passing it to
 734  * lbs_mesh_config_send.
 735  */
 736 int lbs_mesh_config(struct lbs_private *priv, uint16_t action, uint16_t chan)
 737 {
 738         struct cmd_ds_mesh_config cmd;
 739         struct mrvl_meshie *ie;
 740         DECLARE_SSID_BUF(ssid);
 741
 742         memset(&cmd, 0, sizeof(cmd));
 743         cmd.channel = cpu_to_le16(chan);
 744         ie = (struct mrvl_meshie *)cmd.data;
 745
 746         switch (action) {
 747         case CMD_ACT_MESH_CONFIG_START:
 748                 ie->id = WLAN_EID_GENERIC;
 749                 ie->val.oui[0] = 0x00;
 750                 ie->val.oui[1] = 0x50;
 751                 ie->val.oui[2] = 0x43;
 752                 ie->val.type = MARVELL_MESH_IE_TYPE;
 753                 ie->val.subtype = MARVELL_MESH_IE_SUBTYPE;
 754                 ie->val.version = MARVELL_MESH_IE_VERSION;
 755                 ie->val.active_protocol_id = MARVELL_MESH_PROTO_ID_HWMP;
 756                 ie->val.active_metric_id = MARVELL_MESH_METRIC_ID;
 757                 ie->val.mesh_capability = MARVELL_MESH_CAPABILITY;
 758                 ie->val.mesh_id_len = priv->mesh_ssid_len;
 759                 memcpy(ie->val.mesh_id, priv->mesh_ssid, priv->mesh_ssid_len);
 760                 ie->len = sizeof(struct mrvl_meshie_val) -
 761                         IEEE80211_MAX_SSID_LEN + priv->mesh_ssid_len;
 762                 cmd.length = cpu_to_le16(sizeof(struct mrvl_meshie_val));
 763                 break;
 764         case CMD_ACT_MESH_CONFIG_STOP:
 765                 break;
 766         default:
 767                 return -1;
 768         }
 769         lbs_deb_cmd("mesh config action %d type %x channel %d SSID %s\n",
 770                     action, priv->mesh_tlv, chan,
 771                     print_ssid(ssid, priv->mesh_ssid, priv->mesh_ssid_len));
 772
 773         return __lbs_mesh_config_send(priv, &cmd, action, priv->mesh_tlv);
 774 }
 775
 776
 777
 778 /***************************************************************************
 779  * Persistent configuration support
 780  */
 781
 782 static int mesh_get_default_parameters(struct device *dev,
 783                                        struct mrvl_mesh_defaults *defs)
 784 {
 785         struct lbs_private *priv = to_net_dev(dev)->ml_priv;
 786         struct cmd_ds_mesh_config cmd;
 787         int ret;
 788
 789         memset(&cmd, 0, sizeof(struct cmd_ds_mesh_config));
 790         ret = lbs_mesh_config_send(priv, &cmd, CMD_ACT_MESH_CONFIG_GET,
 791                                    CMD_TYPE_MESH_GET_DEFAULTS);
 792
 793         if (ret)
 794                 return -EOPNOTSUPP;
 795
 796         memcpy(defs, &cmd.data[0], sizeof(struct mrvl_mesh_defaults));
 797
 798         return 0;
 799 }
 800
 801 /**
 802  * bootflag_get - Get function for sysfs attribute bootflag
 803  * @dev: the &struct device
 804  * @attr: device attributes
 805  * @buf: buffer where data will be returned
 806  */
 807 static ssize_t bootflag_get(struct device *dev,
 808                             struct device_attribute *attr, char *buf)
 809 {
 810         struct mrvl_mesh_defaults defs;
 811         int ret;
 812
 813         ret = mesh_get_default_parameters(dev, &defs);
 814
 815         if (ret)
 816                 return ret;
 817
 818         return snprintf(buf, 12, "%d\n", le32_to_cpu(defs.bootflag));
 819 }
 820
 821 /**
 822  * bootflag_set - Set function for sysfs attribute bootflag
 823  * @dev: the &struct device
 824  * @attr: device attributes
 825  * @buf: buffer that contains new attribute value
 826  * @count: size of buffer
 827  */
 828 static ssize_t bootflag_set(struct device *dev, struct device_attribute *attr,
 829                             const char *buf, size_t count)
 830 {
 831         struct lbs_private *priv = to_net_dev(dev)->ml_priv;
 832         struct cmd_ds_mesh_config cmd;
 833         uint32_t datum;
 834         int ret;
 835
 836         memset(&cmd, 0, sizeof(cmd));
 837         ret = sscanf(buf, "%d", &datum);
 838         if ((ret != 1) || (datum > 1))
 839                 return -EINVAL;
 840
 841         *((__le32 *)&cmd.data[0]) = cpu_to_le32(!!datum);
 842         cmd.length = cpu_to_le16(sizeof(uint32_t));
 843         ret = lbs_mesh_config_send(priv, &cmd, CMD_ACT_MESH_CONFIG_SET,
 844                                    CMD_TYPE_MESH_SET_BOOTFLAG);
 845         if (ret)
 846                 return ret;
 847
 848         return strlen(buf);
 849 }
 850
 851 /**
 852  * boottime_get - Get function for sysfs attribute boottime
 853  * @dev: the &struct device
 854  * @attr: device attributes
 855  * @buf: buffer where data will be returned
 856  */
 857 static ssize_t boottime_get(struct device *dev,
 858                             struct device_attribute *attr, char *buf)
 859 {
 860         struct mrvl_mesh_defaults defs;
 861         int ret;
 862
 863         ret = mesh_get_default_parameters(dev, &defs);
 864
 865         if (ret)
 866                 return ret;
 867
 868         return snprintf(buf, 12, "%d\n", defs.boottime);
 869 }
 870
 871 /**
 872  * boottime_set - Set function for sysfs attribute boottime
 873  * @dev: the &struct device
 874  * @attr: device attributes
 875  * @buf: buffer that contains new attribute value
 876  * @count: size of buffer
 877  */
 878 static ssize_t boottime_set(struct device *dev,
 879                 struct device_attribute *attr, const char *buf, size_t count)
 880 {
 881         struct lbs_private *priv = to_net_dev(dev)->ml_priv;
 882         struct cmd_ds_mesh_config cmd;
 883         uint32_t datum;
 884         int ret;
 885
 886         memset(&cmd, 0, sizeof(cmd));
 887         ret = sscanf(buf, "%d", &datum);
 888         if ((ret != 1) || (datum > 255))
 889                 return -EINVAL;
 890
 891         /* A too small boot time will result in the device booting into
 892          * standalone (no-host) mode before the host can take control of it,
 893          * so the change will be hard to revert.  This may be a desired
 894          * feature (e.g to configure a very fast boot time for devices that
 895          * will not be attached to a host), but dangerous.  So I'm enforcing a
 896          * lower limit of 20 seconds:  remove and recompile the driver if this
 897          * does not work for you.
 898          */
 899         datum = (datum < 20) ? 20 : datum;
 900         cmd.data[0] = datum;
 901         cmd.length = cpu_to_le16(sizeof(uint8_t));
 902         ret = lbs_mesh_config_send(priv, &cmd, CMD_ACT_MESH_CONFIG_SET,
 903                                    CMD_TYPE_MESH_SET_BOOTTIME);
 904         if (ret)
 905                 return ret;
 906
 907         return strlen(buf);
 908 }
 909
 910 /**
 911  * channel_get - Get function for sysfs attribute channel
 912  * @dev: the &struct device
 913  * @attr: device attributes
 914  * @buf: buffer where data will be returned
 915  */
 916 static ssize_t channel_get(struct device *dev,
 917                            struct device_attribute *attr, char *buf)
 918 {
 919         struct mrvl_mesh_defaults defs;
 920         int ret;
 921
 922         ret = mesh_get_default_parameters(dev, &defs);
 923
 924         if (ret)
 925                 return ret;
 926
 927         return snprintf(buf, 12, "%d\n", le16_to_cpu(defs.channel));
 928 }
 929
 930 /**
 931  * channel_set - Set function for sysfs attribute channel
 932  * @dev: the &struct device
 933  * @attr: device attributes
 934  * @buf: buffer that contains new attribute value
 935  * @count: size of buffer
 936  */
 937 static ssize_t channel_set(struct device *dev, struct device_attribute *attr,
 938                            const char *buf, size_t count)
 939 {
 940         struct lbs_private *priv = to_net_dev(dev)->ml_priv;
 941         struct cmd_ds_mesh_config cmd;
 942         uint32_t datum;
 943         int ret;
 944
 945         memset(&cmd, 0, sizeof(cmd));
 946         ret = sscanf(buf, "%d", &datum);
 947         if (ret != 1 || datum < 1 || datum > 11)
 948                 return -EINVAL;
 949
 950         *((__le16 *)&cmd.data[0]) = cpu_to_le16(datum);
 951         cmd.length = cpu_to_le16(sizeof(uint16_t));
 952         ret = lbs_mesh_config_send(priv, &cmd, CMD_ACT_MESH_CONFIG_SET,
 953                                    CMD_TYPE_MESH_SET_DEF_CHANNEL);
 954         if (ret)
 955                 return ret;
 956
 957         return strlen(buf);
 958 }
 959
 960 /**
 961  * mesh_id_get - Get function for sysfs attribute mesh_id
 962  * @dev: the &struct device
 963  * @attr: device attributes
 964  * @buf: buffer where data will be returned
 965  */
 966 static ssize_t mesh_id_get(struct device *dev, struct device_attribute *attr,
 967                            char *buf)
 968 {
 969         struct mrvl_mesh_defaults defs;
 970         int ret;
 971
 972         ret = mesh_get_default_parameters(dev, &defs);
 973
 974         if (ret)
 975                 return ret;
 976
 977         if (defs.meshie.val.mesh_id_len > IEEE80211_MAX_SSID_LEN) {
 978                 dev_err(dev, "inconsistent mesh ID length\n");
 979                 defs.meshie.val.mesh_id_len = IEEE80211_MAX_SSID_LEN;
 980         }
 981
 982         memcpy(buf, defs.meshie.val.mesh_id, defs.meshie.val.mesh_id_len);
 983         buf[defs.meshie.val.mesh_id_len] = '\n';
 984         buf[defs.meshie.val.mesh_id_len + 1] = '\0';
 985
 986         return defs.meshie.val.mesh_id_len + 1;
 987 }
 988
 989 /**
 990  * mesh_id_set - Set function for sysfs attribute mesh_id
 991  * @dev: the &struct device
 992  * @attr: device attributes
 993  * @buf: buffer that contains new attribute value
 994  * @count: size of buffer
 995  */
 996 static ssize_t mesh_id_set(struct device *dev, struct device_attribute *attr,
 997                            const char *buf, size_t count)
 998 {
 999         struct cmd_ds_mesh_config cmd;
1000         struct mrvl_mesh_defaults defs;
1001         struct mrvl_meshie *ie;
1002         struct lbs_private *priv = to_net_dev(dev)->ml_priv;
1003         int len;
1004         int ret;
1005
1006         if (count < 2 || count > IEEE80211_MAX_SSID_LEN + 1)
1007                 return -EINVAL;
1008
1009         memset(&cmd, 0, sizeof(struct cmd_ds_mesh_config));
1010         ie = (struct mrvl_meshie *) &cmd.data[0];
1011
1012         /* fetch all other Information Element parameters */
1013         ret = mesh_get_default_parameters(dev, &defs);
1014
1015         cmd.length = cpu_to_le16(sizeof(struct mrvl_meshie));
1016
1017         /* transfer IE elements */
1018         memcpy(ie, &defs.meshie, sizeof(struct mrvl_meshie));
1019
1020         len = count - 1;
1021         memcpy(ie->val.mesh_id, buf, len);
1022         /* SSID len */
1023         ie->val.mesh_id_len = len;
1024         /* IE len */
1025         ie->len = sizeof(struct mrvl_meshie_val) - IEEE80211_MAX_SSID_LEN + len;
1026
1027         ret = lbs_mesh_config_send(priv, &cmd, CMD_ACT_MESH_CONFIG_SET,
1028                                    CMD_TYPE_MESH_SET_MESH_IE);
1029         if (ret)
1030                 return ret;
1031
1032         return strlen(buf);
1033 }
1034
1035 /**
1036  * protocol_id_get - Get function for sysfs attribute protocol_id
1037  * @dev: the &struct device
1038  * @attr: device attributes
1039  * @buf: buffer where data will be returned
1040  */
1041 static ssize_t protocol_id_get(struct device *dev,
1042                                struct device_attribute *attr, char *buf)
1043 {
1044         struct mrvl_mesh_defaults defs;
1045         int ret;
1046
1047         ret = mesh_get_default_parameters(dev, &defs);
1048
1049         if (ret)
1050                 return ret;
1051
1052         return snprintf(buf, 5, "%d\n", defs.meshie.val.active_protocol_id);
1053 }
1054
1055 /**
1056  * protocol_id_set - Set function for sysfs attribute protocol_id
1057  * @dev: the &struct device
1058  * @attr: device attributes
1059  * @buf: buffer that contains new attribute value
1060  * @count: size of buffer
1061  */
1062 static ssize_t protocol_id_set(struct device *dev,
1063                 struct device_attribute *attr, const char *buf, size_t count)
1064 {
1065         struct cmd_ds_mesh_config cmd;
1066         struct mrvl_mesh_defaults defs;
1067         struct mrvl_meshie *ie;
1068         struct lbs_private *priv = to_net_dev(dev)->ml_priv;
1069         uint32_t datum;
1070         int ret;
1071
1072         memset(&cmd, 0, sizeof(cmd));
1073         ret = sscanf(buf, "%d", &datum);
1074         if ((ret != 1) || (datum > 255))
1075                 return -EINVAL;
1076
1077         /* fetch all other Information Element parameters */
1078         ret = mesh_get_default_parameters(dev, &defs);
1079
1080         cmd.length = cpu_to_le16(sizeof(struct mrvl_meshie));
1081
1082         /* transfer IE elements */
1083         ie = (struct mrvl_meshie *) &cmd.data[0];
1084         memcpy(ie, &defs.meshie, sizeof(struct mrvl_meshie));
1085         /* update protocol id */
1086         ie->val.active_protocol_id = datum;
1087
1088         ret = lbs_mesh_config_send(priv, &cmd, CMD_ACT_MESH_CONFIG_SET,
1089                                    CMD_TYPE_MESH_SET_MESH_IE);
1090         if (ret)
1091                 return ret;
1092
1093         return strlen(buf);
1094 }
1095
1096 /**
1097  * metric_id_get - Get function for sysfs attribute metric_id
1098  * @dev: the &struct device
1099  * @attr: device attributes
1100  * @buf: buffer where data will be returned
1101  */
1102 static ssize_t metric_id_get(struct device *dev,
1103                 struct device_attribute *attr, char *buf)
1104 {
1105         struct mrvl_mesh_defaults defs;
1106         int ret;
1107
1108         ret = mesh_get_default_parameters(dev, &defs);
1109
1110         if (ret)
1111                 return ret;
1112
1113         return snprintf(buf, 5, "%d\n", defs.meshie.val.active_metric_id);
1114 }
1115
1116 /**
1117  * metric_id_set - Set function for sysfs attribute metric_id
1118  * @dev: the &struct device
1119  * @attr: device attributes
1120  * @buf: buffer that contains new attribute value
1121  * @count: size of buffer
1122  */
1123 static ssize_t metric_id_set(struct device *dev, struct device_attribute *attr,
1124                              const char *buf, size_t count)
1125 {
1126         struct cmd_ds_mesh_config cmd;
1127         struct mrvl_mesh_defaults defs;
1128         struct mrvl_meshie *ie;
1129         struct lbs_private *priv = to_net_dev(dev)->ml_priv;
1130         uint32_t datum;
1131         int ret;
1132
1133         memset(&cmd, 0, sizeof(cmd));
1134         ret = sscanf(buf, "%d", &datum);
1135         if ((ret != 1) || (datum > 255))
1136                 return -EINVAL;
1137
1138         /* fetch all other Information Element parameters */
1139         ret = mesh_get_default_parameters(dev, &defs);
1140
1141         cmd.length = cpu_to_le16(sizeof(struct mrvl_meshie));
1142
1143         /* transfer IE elements */
1144         ie = (struct mrvl_meshie *) &cmd.data[0];
1145         memcpy(ie, &defs.meshie, sizeof(struct mrvl_meshie));
1146         /* update metric id */
1147         ie->val.active_metric_id = datum;
1148
1149         ret = lbs_mesh_config_send(priv, &cmd, CMD_ACT_MESH_CONFIG_SET,
1150                                    CMD_TYPE_MESH_SET_MESH_IE);
1151         if (ret)
1152                 return ret;
1153
1154         return strlen(buf);
1155 }
1156
1157 /**
1158  * capability_get - Get function for sysfs attribute capability
1159  * @dev: the &struct device
1160  * @attr: device attributes
1161  * @buf: buffer where data will be returned
1162  */
1163 static ssize_t capability_get(struct device *dev,
1164                 struct device_attribute *attr, char *buf)
1165 {
1166         struct mrvl_mesh_defaults defs;
1167         int ret;
1168
1169         ret = mesh_get_default_parameters(dev, &defs);
1170
1171         if (ret)
1172                 return ret;
1173
1174         return snprintf(buf, 5, "%d\n", defs.meshie.val.mesh_capability);
1175 }
1176
1177 /**
1178  * capability_set - Set function for sysfs attribute capability
1179  * @dev: the &struct device
1180  * @attr: device attributes
1181  * @buf: buffer that contains new attribute value
1182  * @count: size of buffer
1183  */
1184 static ssize_t capability_set(struct device *dev, struct device_attribute *attr,
1185                               const char *buf, size_t count)
1186 {
1187         struct cmd_ds_mesh_config cmd;
1188         struct mrvl_mesh_defaults defs;
1189         struct mrvl_meshie *ie;
1190         struct lbs_private *priv = to_net_dev(dev)->ml_priv;
1191         uint32_t datum;
1192         int ret;
1193
1194         memset(&cmd, 0, sizeof(cmd));
1195         ret = sscanf(buf, "%d", &datum);
1196         if ((ret != 1) || (datum > 255))
1197                 return -EINVAL;
1198
1199         /* fetch all other Information Element parameters */
1200         ret = mesh_get_default_parameters(dev, &defs);
1201
1202         cmd.length = cpu_to_le16(sizeof(struct mrvl_meshie));
1203
1204         /* transfer IE elements */
1205         ie = (struct mrvl_meshie *) &cmd.data[0];
1206         memcpy(ie, &defs.meshie, sizeof(struct mrvl_meshie));
1207         /* update value */
1208         ie->val.mesh_capability = datum;
1209
1210         ret = lbs_mesh_config_send(priv, &cmd, CMD_ACT_MESH_CONFIG_SET,
1211                                    CMD_TYPE_MESH_SET_MESH_IE);
1212         if (ret)
1213                 return ret;
1214
1215         return strlen(buf);
1216 }
1217
1218
1219 static DEVICE_ATTR(bootflag, 0644, bootflag_get, bootflag_set);
1220 static DEVICE_ATTR(boottime, 0644, boottime_get, boottime_set);
1221 static DEVICE_ATTR(channel, 0644, channel_get, channel_set);
1222 static DEVICE_ATTR(mesh_id, 0644, mesh_id_get, mesh_id_set);
1223 static DEVICE_ATTR(protocol_id, 0644, protocol_id_get, protocol_id_set);
1224 static DEVICE_ATTR(metric_id, 0644, metric_id_get, metric_id_set);
1225 static DEVICE_ATTR(capability, 0644, capability_get, capability_set);
1226
1227 static struct attribute *boot_opts_attrs[] = {
1228         &dev_attr_bootflag.attr,
1229         &dev_attr_boottime.attr,
1230         &dev_attr_channel.attr,
1231         NULL
1232 };
1233
1234 static struct attribute_group boot_opts_group = {
1235         .name = "boot_options",
1236         .attrs = boot_opts_attrs,
1237 };
1238
1239 static struct attribute *mesh_ie_attrs[] = {
1240         &dev_attr_mesh_id.attr,
1241         &dev_attr_protocol_id.attr,
1242         &dev_attr_metric_id.attr,
1243         &dev_attr_capability.attr,
1244         NULL
1245 };
1246
1247 static struct attribute_group mesh_ie_group = {
1248         .name = "mesh_ie",
1249         .attrs = mesh_ie_attrs,
1250 };
1251
1252 void lbs_persist_config_init(struct net_device *dev)
1253 {
1254         int ret;
1255         ret = sysfs_create_group(&(dev->dev.kobj), &boot_opts_group);
1256         ret = sysfs_create_group(&(dev->dev.kobj), &mesh_ie_group);
1257 }
1258
1259 void lbs_persist_config_remove(struct net_device *dev)
1260 {
1261         sysfs_remove_group(&(dev->dev.kobj), &boot_opts_group);
1262         sysfs_remove_group(&(dev->dev.kobj), &mesh_ie_group);
1263 }
1264
1265
1266
1267 /***************************************************************************
1268  * Ethtool related
1269  */
1270
1271 static const char *mesh_stat_strings[] = {
1272                         "drop_duplicate_bcast",
1273                         "drop_ttl_zero",
1274                         "drop_no_fwd_route",
1275                         "drop_no_buffers",
1276                         "fwded_unicast_cnt",
1277                         "fwded_bcast_cnt",
1278                         "drop_blind_table",
1279                         "tx_failed_cnt"
1280 };
1281
1282 void lbs_mesh_ethtool_get_stats(struct net_device *dev,
1283         struct ethtool_stats *stats, uint64_t *data)
1284 {
1285         struct lbs_private *priv = dev->ml_priv;
1286         struct cmd_ds_mesh_access mesh_access;
1287         int ret;
1288
1289         lbs_deb_enter(LBS_DEB_ETHTOOL);
1290
1291         /* Get Mesh Statistics */
1292         ret = lbs_mesh_access(priv, CMD_ACT_MESH_GET_STATS, &mesh_access);
1293
1294         if (ret) {
1295                 memset(data, 0, MESH_STATS_NUM*(sizeof(uint64_t)));
1296                 return;
1297         }
1298
1299         priv->mstats.fwd_drop_rbt = le32_to_cpu(mesh_access.data[0]);
1300         priv->mstats.fwd_drop_ttl = le32_to_cpu(mesh_access.data[1]);
1301         priv->mstats.fwd_drop_noroute = le32_to_cpu(mesh_access.data[2]);
1302         priv->mstats.fwd_drop_nobuf = le32_to_cpu(mesh_access.data[3]);
1303         priv->mstats.fwd_unicast_cnt = le32_to_cpu(mesh_access.data[4]);
1304         priv->mstats.fwd_bcast_cnt = le32_to_cpu(mesh_access.data[5]);
1305         priv->mstats.drop_blind = le32_to_cpu(mesh_access.data[6]);
1306         priv->mstats.tx_failed_cnt = le32_to_cpu(mesh_access.data[7]);
1307
1308         data[0] = priv->mstats.fwd_drop_rbt;
1309         data[1] = priv->mstats.fwd_drop_ttl;
1310         data[2] = priv->mstats.fwd_drop_noroute;
1311         data[3] = priv->mstats.fwd_drop_nobuf;
1312         data[4] = priv->mstats.fwd_unicast_cnt;
1313         data[5] = priv->mstats.fwd_bcast_cnt;
1314         data[6] = priv->mstats.drop_blind;
1315         data[7] = priv->mstats.tx_failed_cnt;
1316
1317         lbs_deb_enter(LBS_DEB_ETHTOOL);
1318 }
1319
1320 int lbs_mesh_ethtool_get_sset_count(struct net_device *dev, int sset)
1321 {
1322         struct lbs_private *priv = dev->ml_priv;
1323
1324         if (sset == ETH_SS_STATS && dev == priv->mesh_dev)
1325                 return MESH_STATS_NUM;
1326
1327         return -EOPNOTSUPP;
1328 }
1329
1330 void lbs_mesh_ethtool_get_strings(struct net_device *dev,
1331         uint32_t stringset, uint8_t *s)
1332 {
1333         int i;
1334
1335         lbs_deb_enter(LBS_DEB_ETHTOOL);
1336
1337         switch (stringset) {
1338         case ETH_SS_STATS:
1339                 for (i = 0; i < MESH_STATS_NUM; i++) {
1340                         memcpy(s + i * ETH_GSTRING_LEN,
1341                                         mesh_stat_strings[i],
1342                                         ETH_GSTRING_LEN);
1343                 }
1344                 break;
1345         }
1346         lbs_deb_enter(LBS_DEB_ETHTOOL);
1347 }