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