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