1 // SPDX-License-Identifier: GPL-2.0-only
2 /*
3  * QLogic qlcnic NIC Driver
4  * Copyright (c) 2009-2013 QLogic Corporation
5  */
6 
7 #include <linux/slab.h>
8 #include <linux/interrupt.h>
9 #include <linux/swab.h>
10 #include <linux/dma-mapping.h>
11 #include <net/ip.h>
12 #include <linux/ipv6.h>
13 #include <linux/inetdevice.h>
14 #include <linux/sysfs.h>
15 #include <linux/aer.h>
16 #include <linux/log2.h>
17 #ifdef CONFIG_QLCNIC_HWMON
18 #include <linux/hwmon.h>
19 #include <linux/hwmon-sysfs.h>
20 #endif
21 
22 #include "qlcnic.h"
23 #include "qlcnic_hw.h"
24 
qlcnicvf_config_bridged_mode(struct qlcnic_adapter * adapter,u32 enable)25 int qlcnicvf_config_bridged_mode(struct qlcnic_adapter *adapter, u32 enable)
26 {
27 	return -EOPNOTSUPP;
28 }
29 
qlcnicvf_config_led(struct qlcnic_adapter * adapter,u32 state,u32 rate)30 int qlcnicvf_config_led(struct qlcnic_adapter *adapter, u32 state, u32 rate)
31 {
32 	return -EOPNOTSUPP;
33 }
34 
qlcnic_store_bridged_mode(struct device * dev,struct device_attribute * attr,const char * buf,size_t len)35 static ssize_t qlcnic_store_bridged_mode(struct device *dev,
36 					 struct device_attribute *attr,
37 					 const char *buf, size_t len)
38 {
39 	struct qlcnic_adapter *adapter = dev_get_drvdata(dev);
40 	unsigned long new;
41 	int ret = -EINVAL;
42 
43 	if (!(adapter->ahw->capabilities & QLCNIC_FW_CAPABILITY_BDG))
44 		goto err_out;
45 
46 	if (!test_bit(__QLCNIC_DEV_UP, &adapter->state))
47 		goto err_out;
48 
49 	if (kstrtoul(buf, 2, &new))
50 		goto err_out;
51 
52 	if (!qlcnic_config_bridged_mode(adapter, !!new))
53 		ret = len;
54 
55 err_out:
56 	return ret;
57 }
58 
qlcnic_show_bridged_mode(struct device * dev,struct device_attribute * attr,char * buf)59 static ssize_t qlcnic_show_bridged_mode(struct device *dev,
60 					struct device_attribute *attr,
61 					char *buf)
62 {
63 	struct qlcnic_adapter *adapter = dev_get_drvdata(dev);
64 	int bridged_mode = 0;
65 
66 	if (adapter->ahw->capabilities & QLCNIC_FW_CAPABILITY_BDG)
67 		bridged_mode = !!(adapter->flags & QLCNIC_BRIDGE_ENABLED);
68 
69 	return sprintf(buf, "%d\n", bridged_mode);
70 }
71 
qlcnic_store_diag_mode(struct device * dev,struct device_attribute * attr,const char * buf,size_t len)72 static ssize_t qlcnic_store_diag_mode(struct device *dev,
73 				      struct device_attribute *attr,
74 				      const char *buf, size_t len)
75 {
76 	struct qlcnic_adapter *adapter = dev_get_drvdata(dev);
77 	unsigned long new;
78 
79 	if (kstrtoul(buf, 2, &new))
80 		return -EINVAL;
81 
82 	if (!!new != !!(adapter->flags & QLCNIC_DIAG_ENABLED))
83 		adapter->flags ^= QLCNIC_DIAG_ENABLED;
84 
85 	return len;
86 }
87 
qlcnic_show_diag_mode(struct device * dev,struct device_attribute * attr,char * buf)88 static ssize_t qlcnic_show_diag_mode(struct device *dev,
89 				     struct device_attribute *attr, char *buf)
90 {
91 	struct qlcnic_adapter *adapter = dev_get_drvdata(dev);
92 	return sprintf(buf, "%d\n", !!(adapter->flags & QLCNIC_DIAG_ENABLED));
93 }
94 
qlcnic_validate_beacon(struct qlcnic_adapter * adapter,u16 beacon,u8 * state,u8 * rate)95 static int qlcnic_validate_beacon(struct qlcnic_adapter *adapter, u16 beacon,
96 				  u8 *state, u8 *rate)
97 {
98 	*rate = LSB(beacon);
99 	*state = MSB(beacon);
100 
101 	QLCDB(adapter, DRV, "rate %x state %x\n", *rate, *state);
102 
103 	if (!*state) {
104 		*rate = __QLCNIC_MAX_LED_RATE;
105 		return 0;
106 	} else if (*state > __QLCNIC_MAX_LED_STATE) {
107 		return -EINVAL;
108 	}
109 
110 	if ((!*rate) || (*rate > __QLCNIC_MAX_LED_RATE))
111 		return -EINVAL;
112 
113 	return 0;
114 }
115 
qlcnic_83xx_store_beacon(struct qlcnic_adapter * adapter,const char * buf,size_t len)116 static int qlcnic_83xx_store_beacon(struct qlcnic_adapter *adapter,
117 				    const char *buf, size_t len)
118 {
119 	struct qlcnic_hardware_context *ahw = adapter->ahw;
120 	unsigned long h_beacon;
121 	int err;
122 
123 	if (test_bit(__QLCNIC_RESETTING, &adapter->state))
124 		return -EIO;
125 
126 	if (kstrtoul(buf, 2, &h_beacon))
127 		return -EINVAL;
128 
129 	qlcnic_get_beacon_state(adapter);
130 
131 	if (ahw->beacon_state == h_beacon)
132 		return len;
133 
134 	rtnl_lock();
135 	if (!ahw->beacon_state) {
136 		if (test_and_set_bit(__QLCNIC_LED_ENABLE, &adapter->state)) {
137 			rtnl_unlock();
138 			return -EBUSY;
139 		}
140 	}
141 
142 	if (h_beacon)
143 		err = qlcnic_83xx_config_led(adapter, 1, h_beacon);
144 	else
145 		err = qlcnic_83xx_config_led(adapter, 0, !h_beacon);
146 	if (!err)
147 		ahw->beacon_state = h_beacon;
148 
149 	if (!ahw->beacon_state)
150 		clear_bit(__QLCNIC_LED_ENABLE, &adapter->state);
151 
152 	rtnl_unlock();
153 	return len;
154 }
155 
qlcnic_82xx_store_beacon(struct qlcnic_adapter * adapter,const char * buf,size_t len)156 static int qlcnic_82xx_store_beacon(struct qlcnic_adapter *adapter,
157 				    const char *buf, size_t len)
158 {
159 	struct qlcnic_hardware_context *ahw = adapter->ahw;
160 	int err, drv_sds_rings = adapter->drv_sds_rings;
161 	u16 beacon;
162 	u8 b_state, b_rate;
163 
164 	if (len != sizeof(u16))
165 		return -EINVAL;
166 
167 	memcpy(&beacon, buf, sizeof(u16));
168 	err = qlcnic_validate_beacon(adapter, beacon, &b_state, &b_rate);
169 	if (err)
170 		return err;
171 
172 	qlcnic_get_beacon_state(adapter);
173 
174 	if (ahw->beacon_state == b_state)
175 		return len;
176 
177 	rtnl_lock();
178 	if (!ahw->beacon_state) {
179 		if (test_and_set_bit(__QLCNIC_LED_ENABLE, &adapter->state)) {
180 			rtnl_unlock();
181 			return -EBUSY;
182 		}
183 	}
184 
185 	if (test_bit(__QLCNIC_RESETTING, &adapter->state)) {
186 		err = -EIO;
187 		goto out;
188 	}
189 
190 	if (!test_bit(__QLCNIC_DEV_UP, &adapter->state)) {
191 		err = qlcnic_diag_alloc_res(adapter->netdev, QLCNIC_LED_TEST);
192 		if (err)
193 			goto out;
194 		set_bit(__QLCNIC_DIAG_RES_ALLOC, &adapter->state);
195 	}
196 
197 	err = qlcnic_config_led(adapter, b_state, b_rate);
198 	if (!err) {
199 		err = len;
200 		ahw->beacon_state = b_state;
201 	}
202 
203 	if (test_and_clear_bit(__QLCNIC_DIAG_RES_ALLOC, &adapter->state))
204 		qlcnic_diag_free_res(adapter->netdev, drv_sds_rings);
205 
206 out:
207 	if (!ahw->beacon_state)
208 		clear_bit(__QLCNIC_LED_ENABLE, &adapter->state);
209 	rtnl_unlock();
210 
211 	return err;
212 }
213 
qlcnic_store_beacon(struct device * dev,struct device_attribute * attr,const char * buf,size_t len)214 static ssize_t qlcnic_store_beacon(struct device *dev,
215 				   struct device_attribute *attr,
216 				   const char *buf, size_t len)
217 {
218 	struct qlcnic_adapter *adapter = dev_get_drvdata(dev);
219 	int err = 0;
220 
221 	if (adapter->ahw->op_mode == QLCNIC_NON_PRIV_FUNC) {
222 		dev_warn(dev,
223 			 "LED test not supported in non privileged mode\n");
224 		return -EOPNOTSUPP;
225 	}
226 
227 	if (qlcnic_82xx_check(adapter))
228 		err = qlcnic_82xx_store_beacon(adapter, buf, len);
229 	else if (qlcnic_83xx_check(adapter))
230 		err = qlcnic_83xx_store_beacon(adapter, buf, len);
231 	else
232 		return -EIO;
233 
234 	return err;
235 }
236 
qlcnic_show_beacon(struct device * dev,struct device_attribute * attr,char * buf)237 static ssize_t qlcnic_show_beacon(struct device *dev,
238 				  struct device_attribute *attr, char *buf)
239 {
240 	struct qlcnic_adapter *adapter = dev_get_drvdata(dev);
241 
242 	return sprintf(buf, "%d\n", adapter->ahw->beacon_state);
243 }
244 
qlcnic_sysfs_validate_crb(struct qlcnic_adapter * adapter,loff_t offset,size_t size)245 static int qlcnic_sysfs_validate_crb(struct qlcnic_adapter *adapter,
246 				     loff_t offset, size_t size)
247 {
248 	size_t crb_size = 4;
249 
250 	if (!(adapter->flags & QLCNIC_DIAG_ENABLED))
251 		return -EIO;
252 
253 	if (offset < QLCNIC_PCI_CRBSPACE) {
254 		if (ADDR_IN_RANGE(offset, QLCNIC_PCI_CAMQM,
255 				  QLCNIC_PCI_CAMQM_END))
256 			crb_size = 8;
257 		else
258 			return -EINVAL;
259 	}
260 
261 	if ((size != crb_size) || (offset & (crb_size-1)))
262 		return  -EINVAL;
263 
264 	return 0;
265 }
266 
qlcnic_sysfs_read_crb(struct file * filp,struct kobject * kobj,struct bin_attribute * attr,char * buf,loff_t offset,size_t size)267 static ssize_t qlcnic_sysfs_read_crb(struct file *filp, struct kobject *kobj,
268 				     struct bin_attribute *attr, char *buf,
269 				     loff_t offset, size_t size)
270 {
271 	struct device *dev = kobj_to_dev(kobj);
272 	struct qlcnic_adapter *adapter = dev_get_drvdata(dev);
273 	int ret;
274 
275 	ret = qlcnic_sysfs_validate_crb(adapter, offset, size);
276 	if (ret != 0)
277 		return ret;
278 	qlcnic_read_crb(adapter, buf, offset, size);
279 	qlcnic_swap32_buffer((u32 *)buf, size / sizeof(u32));
280 
281 	return size;
282 }
283 
qlcnic_sysfs_write_crb(struct file * filp,struct kobject * kobj,struct bin_attribute * attr,char * buf,loff_t offset,size_t size)284 static ssize_t qlcnic_sysfs_write_crb(struct file *filp, struct kobject *kobj,
285 				      struct bin_attribute *attr, char *buf,
286 				      loff_t offset, size_t size)
287 {
288 	struct device *dev = kobj_to_dev(kobj);
289 	struct qlcnic_adapter *adapter = dev_get_drvdata(dev);
290 	int ret;
291 
292 	ret = qlcnic_sysfs_validate_crb(adapter, offset, size);
293 	if (ret != 0)
294 		return ret;
295 
296 	qlcnic_swap32_buffer((u32 *)buf, size / sizeof(u32));
297 	qlcnic_write_crb(adapter, buf, offset, size);
298 	return size;
299 }
300 
qlcnic_sysfs_validate_mem(struct qlcnic_adapter * adapter,loff_t offset,size_t size)301 static int qlcnic_sysfs_validate_mem(struct qlcnic_adapter *adapter,
302 				     loff_t offset, size_t size)
303 {
304 	if (!(adapter->flags & QLCNIC_DIAG_ENABLED))
305 		return -EIO;
306 
307 	if ((size != 8) || (offset & 0x7))
308 		return  -EIO;
309 
310 	return 0;
311 }
312 
qlcnic_sysfs_read_mem(struct file * filp,struct kobject * kobj,struct bin_attribute * attr,char * buf,loff_t offset,size_t size)313 static ssize_t qlcnic_sysfs_read_mem(struct file *filp, struct kobject *kobj,
314 				     struct bin_attribute *attr, char *buf,
315 				     loff_t offset, size_t size)
316 {
317 	struct device *dev = kobj_to_dev(kobj);
318 	struct qlcnic_adapter *adapter = dev_get_drvdata(dev);
319 	u64 data;
320 	int ret;
321 
322 	ret = qlcnic_sysfs_validate_mem(adapter, offset, size);
323 	if (ret != 0)
324 		return ret;
325 
326 	if (qlcnic_pci_mem_read_2M(adapter, offset, &data))
327 		return -EIO;
328 
329 	memcpy(buf, &data, size);
330 	qlcnic_swap32_buffer((u32 *)buf, size / sizeof(u32));
331 
332 	return size;
333 }
334 
qlcnic_sysfs_write_mem(struct file * filp,struct kobject * kobj,struct bin_attribute * attr,char * buf,loff_t offset,size_t size)335 static ssize_t qlcnic_sysfs_write_mem(struct file *filp, struct kobject *kobj,
336 				      struct bin_attribute *attr, char *buf,
337 				      loff_t offset, size_t size)
338 {
339 	struct device *dev = kobj_to_dev(kobj);
340 	struct qlcnic_adapter *adapter = dev_get_drvdata(dev);
341 	u64 data;
342 	int ret;
343 
344 	ret = qlcnic_sysfs_validate_mem(adapter, offset, size);
345 	if (ret != 0)
346 		return ret;
347 
348 	qlcnic_swap32_buffer((u32 *)buf, size / sizeof(u32));
349 	memcpy(&data, buf, size);
350 
351 	if (qlcnic_pci_mem_write_2M(adapter, offset, data))
352 		return -EIO;
353 
354 	return size;
355 }
356 
qlcnic_is_valid_nic_func(struct qlcnic_adapter * adapter,u8 pci_func)357 int qlcnic_is_valid_nic_func(struct qlcnic_adapter *adapter, u8 pci_func)
358 {
359 	int i;
360 
361 	for (i = 0; i < adapter->ahw->total_nic_func; i++) {
362 		if (adapter->npars[i].pci_func == pci_func)
363 			return i;
364 	}
365 
366 	dev_err(&adapter->pdev->dev, "%s: Invalid nic function\n", __func__);
367 	return -EINVAL;
368 }
369 
validate_pm_config(struct qlcnic_adapter * adapter,struct qlcnic_pm_func_cfg * pm_cfg,int count)370 static int validate_pm_config(struct qlcnic_adapter *adapter,
371 			      struct qlcnic_pm_func_cfg *pm_cfg, int count)
372 {
373 	u8 src_pci_func, s_esw_id, d_esw_id;
374 	u8 dest_pci_func;
375 	int i, src_index, dest_index;
376 
377 	for (i = 0; i < count; i++) {
378 		src_pci_func = pm_cfg[i].pci_func;
379 		dest_pci_func = pm_cfg[i].dest_npar;
380 		src_index = qlcnic_is_valid_nic_func(adapter, src_pci_func);
381 		if (src_index < 0)
382 			return -EINVAL;
383 
384 		dest_index = qlcnic_is_valid_nic_func(adapter, dest_pci_func);
385 		if (dest_index < 0)
386 			return -EINVAL;
387 
388 		s_esw_id = adapter->npars[src_index].phy_port;
389 		d_esw_id = adapter->npars[dest_index].phy_port;
390 
391 		if (s_esw_id != d_esw_id)
392 			return -EINVAL;
393 	}
394 
395 	return 0;
396 }
397 
qlcnic_sysfs_write_pm_config(struct file * filp,struct kobject * kobj,struct bin_attribute * attr,char * buf,loff_t offset,size_t size)398 static ssize_t qlcnic_sysfs_write_pm_config(struct file *filp,
399 					    struct kobject *kobj,
400 					    struct bin_attribute *attr,
401 					    char *buf, loff_t offset,
402 					    size_t size)
403 {
404 	struct device *dev = kobj_to_dev(kobj);
405 	struct qlcnic_adapter *adapter = dev_get_drvdata(dev);
406 	struct qlcnic_pm_func_cfg *pm_cfg;
407 	u32 id, action, pci_func;
408 	int count, rem, i, ret, index;
409 
410 	count	= size / sizeof(struct qlcnic_pm_func_cfg);
411 	rem	= size % sizeof(struct qlcnic_pm_func_cfg);
412 	if (rem)
413 		return -EINVAL;
414 
415 	qlcnic_swap32_buffer((u32 *)buf, size / sizeof(u32));
416 	pm_cfg = (struct qlcnic_pm_func_cfg *)buf;
417 	ret = validate_pm_config(adapter, pm_cfg, count);
418 
419 	if (ret)
420 		return ret;
421 	for (i = 0; i < count; i++) {
422 		pci_func = pm_cfg[i].pci_func;
423 		action = !!pm_cfg[i].action;
424 		index = qlcnic_is_valid_nic_func(adapter, pci_func);
425 		if (index < 0)
426 			return -EINVAL;
427 
428 		id = adapter->npars[index].phy_port;
429 		ret = qlcnic_config_port_mirroring(adapter, id,
430 						   action, pci_func);
431 		if (ret)
432 			return ret;
433 	}
434 
435 	for (i = 0; i < count; i++) {
436 		pci_func = pm_cfg[i].pci_func;
437 		index = qlcnic_is_valid_nic_func(adapter, pci_func);
438 		if (index < 0)
439 			return -EINVAL;
440 		id = adapter->npars[index].phy_port;
441 		adapter->npars[index].enable_pm = !!pm_cfg[i].action;
442 		adapter->npars[index].dest_npar = id;
443 	}
444 
445 	return size;
446 }
447 
qlcnic_sysfs_read_pm_config(struct file * filp,struct kobject * kobj,struct bin_attribute * attr,char * buf,loff_t offset,size_t size)448 static ssize_t qlcnic_sysfs_read_pm_config(struct file *filp,
449 					   struct kobject *kobj,
450 					   struct bin_attribute *attr,
451 					   char *buf, loff_t offset,
452 					   size_t size)
453 {
454 	struct device *dev = kobj_to_dev(kobj);
455 	struct qlcnic_adapter *adapter = dev_get_drvdata(dev);
456 	struct qlcnic_pm_func_cfg *pm_cfg;
457 	u8 pci_func;
458 	u32 count;
459 	int i;
460 
461 	memset(buf, 0, size);
462 	pm_cfg = (struct qlcnic_pm_func_cfg *)buf;
463 	count = size / sizeof(struct qlcnic_pm_func_cfg);
464 	for (i = 0; i < adapter->ahw->total_nic_func; i++) {
465 		pci_func = adapter->npars[i].pci_func;
466 		if (pci_func >= count) {
467 			dev_dbg(dev, "%s: Total nic functions[%d], App sent function count[%d]\n",
468 				__func__, adapter->ahw->total_nic_func, count);
469 			continue;
470 		}
471 		if (!adapter->npars[i].eswitch_status)
472 			continue;
473 
474 		pm_cfg[pci_func].action = adapter->npars[i].enable_pm;
475 		pm_cfg[pci_func].dest_npar = 0;
476 		pm_cfg[pci_func].pci_func = i;
477 	}
478 	qlcnic_swap32_buffer((u32 *)buf, size / sizeof(u32));
479 	return size;
480 }
481 
validate_esw_config(struct qlcnic_adapter * adapter,struct qlcnic_esw_func_cfg * esw_cfg,int count)482 static int validate_esw_config(struct qlcnic_adapter *adapter,
483 			       struct qlcnic_esw_func_cfg *esw_cfg, int count)
484 {
485 	struct qlcnic_hardware_context *ahw = adapter->ahw;
486 	int i, ret;
487 	u32 op_mode;
488 	u8 pci_func;
489 
490 	if (qlcnic_82xx_check(adapter))
491 		op_mode = readl(ahw->pci_base0 + QLCNIC_DRV_OP_MODE);
492 	else
493 		op_mode = QLCRDX(ahw, QLC_83XX_DRV_OP_MODE);
494 
495 	for (i = 0; i < count; i++) {
496 		pci_func = esw_cfg[i].pci_func;
497 		if (pci_func >= ahw->max_vnic_func)
498 			return -EINVAL;
499 
500 		if (adapter->ahw->op_mode == QLCNIC_MGMT_FUNC)
501 			if (qlcnic_is_valid_nic_func(adapter, pci_func) < 0)
502 				return -EINVAL;
503 
504 		switch (esw_cfg[i].op_mode) {
505 		case QLCNIC_PORT_DEFAULTS:
506 			if (qlcnic_82xx_check(adapter)) {
507 				ret = QLC_DEV_GET_DRV(op_mode, pci_func);
508 			} else {
509 				ret = QLC_83XX_GET_FUNC_PRIVILEGE(op_mode,
510 								  pci_func);
511 				esw_cfg[i].offload_flags = 0;
512 			}
513 
514 			if (ret != QLCNIC_NON_PRIV_FUNC) {
515 				if (esw_cfg[i].mac_anti_spoof != 0)
516 					return -EINVAL;
517 				if (esw_cfg[i].mac_override != 1)
518 					return -EINVAL;
519 				if (esw_cfg[i].promisc_mode != 1)
520 					return -EINVAL;
521 			}
522 			break;
523 		case QLCNIC_ADD_VLAN:
524 			if (!IS_VALID_VLAN(esw_cfg[i].vlan_id))
525 				return -EINVAL;
526 			if (!esw_cfg[i].op_type)
527 				return -EINVAL;
528 			break;
529 		case QLCNIC_DEL_VLAN:
530 			if (!esw_cfg[i].op_type)
531 				return -EINVAL;
532 			break;
533 		default:
534 			return -EINVAL;
535 		}
536 	}
537 
538 	return 0;
539 }
540 
qlcnic_sysfs_write_esw_config(struct file * file,struct kobject * kobj,struct bin_attribute * attr,char * buf,loff_t offset,size_t size)541 static ssize_t qlcnic_sysfs_write_esw_config(struct file *file,
542 					     struct kobject *kobj,
543 					     struct bin_attribute *attr,
544 					     char *buf, loff_t offset,
545 					     size_t size)
546 {
547 	struct device *dev = kobj_to_dev(kobj);
548 	struct qlcnic_adapter *adapter = dev_get_drvdata(dev);
549 	struct qlcnic_esw_func_cfg *esw_cfg;
550 	struct qlcnic_npar_info *npar;
551 	int count, rem, i, ret;
552 	int index;
553 	u8 op_mode = 0, pci_func;
554 
555 	count	= size / sizeof(struct qlcnic_esw_func_cfg);
556 	rem	= size % sizeof(struct qlcnic_esw_func_cfg);
557 	if (rem)
558 		return -EINVAL;
559 
560 	qlcnic_swap32_buffer((u32 *)buf, size / sizeof(u32));
561 	esw_cfg = (struct qlcnic_esw_func_cfg *)buf;
562 	ret = validate_esw_config(adapter, esw_cfg, count);
563 	if (ret)
564 		return ret;
565 
566 	for (i = 0; i < count; i++) {
567 		if (adapter->ahw->op_mode == QLCNIC_MGMT_FUNC)
568 			if (qlcnic_config_switch_port(adapter, &esw_cfg[i]))
569 				return -EINVAL;
570 
571 		if (adapter->ahw->pci_func != esw_cfg[i].pci_func)
572 			continue;
573 
574 		op_mode = esw_cfg[i].op_mode;
575 		qlcnic_get_eswitch_port_config(adapter, &esw_cfg[i]);
576 		esw_cfg[i].op_mode = op_mode;
577 		esw_cfg[i].pci_func = adapter->ahw->pci_func;
578 
579 		switch (esw_cfg[i].op_mode) {
580 		case QLCNIC_PORT_DEFAULTS:
581 			qlcnic_set_eswitch_port_features(adapter, &esw_cfg[i]);
582 			rtnl_lock();
583 			qlcnic_set_netdev_features(adapter, &esw_cfg[i]);
584 			rtnl_unlock();
585 			break;
586 		case QLCNIC_ADD_VLAN:
587 			qlcnic_set_vlan_config(adapter, &esw_cfg[i]);
588 			break;
589 		case QLCNIC_DEL_VLAN:
590 			esw_cfg[i].vlan_id = 0;
591 			qlcnic_set_vlan_config(adapter, &esw_cfg[i]);
592 			break;
593 		}
594 	}
595 
596 	if (adapter->ahw->op_mode != QLCNIC_MGMT_FUNC)
597 		goto out;
598 
599 	for (i = 0; i < count; i++) {
600 		pci_func = esw_cfg[i].pci_func;
601 		index = qlcnic_is_valid_nic_func(adapter, pci_func);
602 		if (index < 0)
603 			return -EINVAL;
604 		npar = &adapter->npars[index];
605 		switch (esw_cfg[i].op_mode) {
606 		case QLCNIC_PORT_DEFAULTS:
607 			npar->promisc_mode = esw_cfg[i].promisc_mode;
608 			npar->mac_override = esw_cfg[i].mac_override;
609 			npar->offload_flags = esw_cfg[i].offload_flags;
610 			npar->mac_anti_spoof = esw_cfg[i].mac_anti_spoof;
611 			npar->discard_tagged = esw_cfg[i].discard_tagged;
612 			break;
613 		case QLCNIC_ADD_VLAN:
614 			npar->pvid = esw_cfg[i].vlan_id;
615 			break;
616 		case QLCNIC_DEL_VLAN:
617 			npar->pvid = 0;
618 			break;
619 		}
620 	}
621 out:
622 	return size;
623 }
624 
qlcnic_sysfs_read_esw_config(struct file * file,struct kobject * kobj,struct bin_attribute * attr,char * buf,loff_t offset,size_t size)625 static ssize_t qlcnic_sysfs_read_esw_config(struct file *file,
626 					    struct kobject *kobj,
627 					    struct bin_attribute *attr,
628 					    char *buf, loff_t offset,
629 					    size_t size)
630 {
631 	struct device *dev = kobj_to_dev(kobj);
632 	struct qlcnic_adapter *adapter = dev_get_drvdata(dev);
633 	struct qlcnic_esw_func_cfg *esw_cfg;
634 	u8 pci_func;
635 	u32 count;
636 	int i;
637 
638 	memset(buf, 0, size);
639 	esw_cfg = (struct qlcnic_esw_func_cfg *)buf;
640 	count = size / sizeof(struct qlcnic_esw_func_cfg);
641 	for (i = 0; i < adapter->ahw->total_nic_func; i++) {
642 		pci_func = adapter->npars[i].pci_func;
643 		if (pci_func >= count) {
644 			dev_dbg(dev, "%s: Total nic functions[%d], App sent function count[%d]\n",
645 				__func__, adapter->ahw->total_nic_func, count);
646 			continue;
647 		}
648 		if (!adapter->npars[i].eswitch_status)
649 			continue;
650 
651 		esw_cfg[pci_func].pci_func = pci_func;
652 		if (qlcnic_get_eswitch_port_config(adapter, &esw_cfg[pci_func]))
653 			return -EINVAL;
654 	}
655 	qlcnic_swap32_buffer((u32 *)buf, size / sizeof(u32));
656 	return size;
657 }
658 
validate_npar_config(struct qlcnic_adapter * adapter,struct qlcnic_npar_func_cfg * np_cfg,int count)659 static int validate_npar_config(struct qlcnic_adapter *adapter,
660 				struct qlcnic_npar_func_cfg *np_cfg,
661 				int count)
662 {
663 	u8 pci_func, i;
664 
665 	for (i = 0; i < count; i++) {
666 		pci_func = np_cfg[i].pci_func;
667 		if (qlcnic_is_valid_nic_func(adapter, pci_func) < 0)
668 			return -EINVAL;
669 
670 		if (!IS_VALID_BW(np_cfg[i].min_bw) ||
671 		    !IS_VALID_BW(np_cfg[i].max_bw))
672 			return -EINVAL;
673 	}
674 	return 0;
675 }
676 
qlcnic_sysfs_write_npar_config(struct file * file,struct kobject * kobj,struct bin_attribute * attr,char * buf,loff_t offset,size_t size)677 static ssize_t qlcnic_sysfs_write_npar_config(struct file *file,
678 					      struct kobject *kobj,
679 					      struct bin_attribute *attr,
680 					      char *buf, loff_t offset,
681 					      size_t size)
682 {
683 	struct device *dev = kobj_to_dev(kobj);
684 	struct qlcnic_adapter *adapter = dev_get_drvdata(dev);
685 	struct qlcnic_info nic_info;
686 	struct qlcnic_npar_func_cfg *np_cfg;
687 	int i, count, rem, ret, index;
688 	u8 pci_func;
689 
690 	count	= size / sizeof(struct qlcnic_npar_func_cfg);
691 	rem	= size % sizeof(struct qlcnic_npar_func_cfg);
692 	if (rem)
693 		return -EINVAL;
694 
695 	qlcnic_swap32_buffer((u32 *)buf, size / sizeof(u32));
696 	np_cfg = (struct qlcnic_npar_func_cfg *)buf;
697 	ret = validate_npar_config(adapter, np_cfg, count);
698 	if (ret)
699 		return ret;
700 
701 	for (i = 0; i < count; i++) {
702 		pci_func = np_cfg[i].pci_func;
703 
704 		memset(&nic_info, 0, sizeof(struct qlcnic_info));
705 		ret = qlcnic_get_nic_info(adapter, &nic_info, pci_func);
706 		if (ret)
707 			return ret;
708 		nic_info.pci_func = pci_func;
709 		nic_info.min_tx_bw = np_cfg[i].min_bw;
710 		nic_info.max_tx_bw = np_cfg[i].max_bw;
711 		ret = qlcnic_set_nic_info(adapter, &nic_info);
712 		if (ret)
713 			return ret;
714 		index = qlcnic_is_valid_nic_func(adapter, pci_func);
715 		if (index < 0)
716 			return -EINVAL;
717 		adapter->npars[index].min_bw = nic_info.min_tx_bw;
718 		adapter->npars[index].max_bw = nic_info.max_tx_bw;
719 	}
720 
721 	return size;
722 }
723 
qlcnic_sysfs_read_npar_config(struct file * file,struct kobject * kobj,struct bin_attribute * attr,char * buf,loff_t offset,size_t size)724 static ssize_t qlcnic_sysfs_read_npar_config(struct file *file,
725 					     struct kobject *kobj,
726 					     struct bin_attribute *attr,
727 					     char *buf, loff_t offset,
728 					     size_t size)
729 {
730 	struct device *dev = kobj_to_dev(kobj);
731 	struct qlcnic_adapter *adapter = dev_get_drvdata(dev);
732 	struct qlcnic_npar_func_cfg *np_cfg;
733 	struct qlcnic_info nic_info;
734 	u8 pci_func;
735 	int i, ret;
736 	u32 count;
737 
738 	memset(&nic_info, 0, sizeof(struct qlcnic_info));
739 	memset(buf, 0, size);
740 	np_cfg = (struct qlcnic_npar_func_cfg *)buf;
741 
742 	count = size / sizeof(struct qlcnic_npar_func_cfg);
743 	for (i = 0; i < adapter->ahw->total_nic_func; i++) {
744 		if (adapter->npars[i].pci_func >= count) {
745 			dev_dbg(dev, "%s: Total nic functions[%d], App sent function count[%d]\n",
746 				__func__, adapter->ahw->total_nic_func, count);
747 			continue;
748 		}
749 		if (!adapter->npars[i].eswitch_status)
750 			continue;
751 		pci_func = adapter->npars[i].pci_func;
752 		if (qlcnic_is_valid_nic_func(adapter, pci_func) < 0)
753 			continue;
754 		ret = qlcnic_get_nic_info(adapter, &nic_info, pci_func);
755 		if (ret)
756 			return ret;
757 
758 		np_cfg[pci_func].pci_func = pci_func;
759 		np_cfg[pci_func].op_mode = (u8)nic_info.op_mode;
760 		np_cfg[pci_func].port_num = nic_info.phys_port;
761 		np_cfg[pci_func].fw_capab = nic_info.capabilities;
762 		np_cfg[pci_func].min_bw = nic_info.min_tx_bw;
763 		np_cfg[pci_func].max_bw = nic_info.max_tx_bw;
764 		np_cfg[pci_func].max_tx_queues = nic_info.max_tx_ques;
765 		np_cfg[pci_func].max_rx_queues = nic_info.max_rx_ques;
766 	}
767 	qlcnic_swap32_buffer((u32 *)buf, size / sizeof(u32));
768 	return size;
769 }
770 
qlcnic_sysfs_get_port_stats(struct file * file,struct kobject * kobj,struct bin_attribute * attr,char * buf,loff_t offset,size_t size)771 static ssize_t qlcnic_sysfs_get_port_stats(struct file *file,
772 					   struct kobject *kobj,
773 					   struct bin_attribute *attr,
774 					   char *buf, loff_t offset,
775 					   size_t size)
776 {
777 	struct device *dev = kobj_to_dev(kobj);
778 	struct qlcnic_adapter *adapter = dev_get_drvdata(dev);
779 	struct qlcnic_esw_statistics port_stats;
780 	int ret;
781 
782 	if (qlcnic_83xx_check(adapter))
783 		return -EOPNOTSUPP;
784 
785 	if (size != sizeof(struct qlcnic_esw_statistics))
786 		return -EINVAL;
787 
788 	if (offset >= adapter->ahw->max_vnic_func)
789 		return -EINVAL;
790 
791 	memset(&port_stats, 0, size);
792 	ret = qlcnic_get_port_stats(adapter, offset, QLCNIC_QUERY_RX_COUNTER,
793 				    &port_stats.rx);
794 	if (ret)
795 		return ret;
796 
797 	ret = qlcnic_get_port_stats(adapter, offset, QLCNIC_QUERY_TX_COUNTER,
798 				    &port_stats.tx);
799 	if (ret)
800 		return ret;
801 
802 	memcpy(buf, &port_stats, size);
803 	return size;
804 }
805 
qlcnic_sysfs_get_esw_stats(struct file * file,struct kobject * kobj,struct bin_attribute * attr,char * buf,loff_t offset,size_t size)806 static ssize_t qlcnic_sysfs_get_esw_stats(struct file *file,
807 					  struct kobject *kobj,
808 					  struct bin_attribute *attr,
809 					  char *buf, loff_t offset,
810 					  size_t size)
811 {
812 	struct device *dev = kobj_to_dev(kobj);
813 	struct qlcnic_adapter *adapter = dev_get_drvdata(dev);
814 	struct qlcnic_esw_statistics esw_stats;
815 	int ret;
816 
817 	if (qlcnic_83xx_check(adapter))
818 		return -EOPNOTSUPP;
819 
820 	if (size != sizeof(struct qlcnic_esw_statistics))
821 		return -EINVAL;
822 
823 	if (offset >= QLCNIC_NIU_MAX_XG_PORTS)
824 		return -EINVAL;
825 
826 	memset(&esw_stats, 0, size);
827 	ret = qlcnic_get_eswitch_stats(adapter, offset, QLCNIC_QUERY_RX_COUNTER,
828 				       &esw_stats.rx);
829 	if (ret)
830 		return ret;
831 
832 	ret = qlcnic_get_eswitch_stats(adapter, offset, QLCNIC_QUERY_TX_COUNTER,
833 				       &esw_stats.tx);
834 	if (ret)
835 		return ret;
836 
837 	memcpy(buf, &esw_stats, size);
838 	return size;
839 }
840 
qlcnic_sysfs_clear_esw_stats(struct file * file,struct kobject * kobj,struct bin_attribute * attr,char * buf,loff_t offset,size_t size)841 static ssize_t qlcnic_sysfs_clear_esw_stats(struct file *file,
842 					    struct kobject *kobj,
843 					    struct bin_attribute *attr,
844 					    char *buf, loff_t offset,
845 					    size_t size)
846 {
847 	struct device *dev = kobj_to_dev(kobj);
848 	struct qlcnic_adapter *adapter = dev_get_drvdata(dev);
849 	int ret;
850 
851 	if (qlcnic_83xx_check(adapter))
852 		return -EOPNOTSUPP;
853 
854 	if (offset >= QLCNIC_NIU_MAX_XG_PORTS)
855 		return -EINVAL;
856 
857 	ret = qlcnic_clear_esw_stats(adapter, QLCNIC_STATS_ESWITCH, offset,
858 				     QLCNIC_QUERY_RX_COUNTER);
859 	if (ret)
860 		return ret;
861 
862 	ret = qlcnic_clear_esw_stats(adapter, QLCNIC_STATS_ESWITCH, offset,
863 				     QLCNIC_QUERY_TX_COUNTER);
864 	if (ret)
865 		return ret;
866 
867 	return size;
868 }
869 
qlcnic_sysfs_clear_port_stats(struct file * file,struct kobject * kobj,struct bin_attribute * attr,char * buf,loff_t offset,size_t size)870 static ssize_t qlcnic_sysfs_clear_port_stats(struct file *file,
871 					     struct kobject *kobj,
872 					     struct bin_attribute *attr,
873 					     char *buf, loff_t offset,
874 					     size_t size)
875 {
876 
877 	struct device *dev = kobj_to_dev(kobj);
878 	struct qlcnic_adapter *adapter = dev_get_drvdata(dev);
879 	int ret;
880 
881 	if (qlcnic_83xx_check(adapter))
882 		return -EOPNOTSUPP;
883 
884 	if (offset >= adapter->ahw->max_vnic_func)
885 		return -EINVAL;
886 
887 	ret = qlcnic_clear_esw_stats(adapter, QLCNIC_STATS_PORT, offset,
888 				     QLCNIC_QUERY_RX_COUNTER);
889 	if (ret)
890 		return ret;
891 
892 	ret = qlcnic_clear_esw_stats(adapter, QLCNIC_STATS_PORT, offset,
893 				     QLCNIC_QUERY_TX_COUNTER);
894 	if (ret)
895 		return ret;
896 
897 	return size;
898 }
899 
qlcnic_sysfs_read_pci_config(struct file * file,struct kobject * kobj,struct bin_attribute * attr,char * buf,loff_t offset,size_t size)900 static ssize_t qlcnic_sysfs_read_pci_config(struct file *file,
901 					    struct kobject *kobj,
902 					    struct bin_attribute *attr,
903 					    char *buf, loff_t offset,
904 					    size_t size)
905 {
906 	struct device *dev = kobj_to_dev(kobj);
907 	struct qlcnic_adapter *adapter = dev_get_drvdata(dev);
908 	struct qlcnic_pci_func_cfg *pci_cfg;
909 	struct qlcnic_pci_info *pci_info;
910 	int i, ret;
911 	u32 count;
912 
913 	pci_info = kcalloc(size, sizeof(*pci_info), GFP_KERNEL);
914 	if (!pci_info)
915 		return -ENOMEM;
916 
917 	ret = qlcnic_get_pci_info(adapter, pci_info);
918 	if (ret) {
919 		kfree(pci_info);
920 		return ret;
921 	}
922 
923 	pci_cfg = (struct qlcnic_pci_func_cfg *)buf;
924 	count = size / sizeof(struct qlcnic_pci_func_cfg);
925 	qlcnic_swap32_buffer((u32 *)pci_info, size / sizeof(u32));
926 	for (i = 0; i < count; i++) {
927 		pci_cfg[i].pci_func = pci_info[i].id;
928 		pci_cfg[i].func_type = pci_info[i].type;
929 		pci_cfg[i].func_state = 0;
930 		pci_cfg[i].port_num = pci_info[i].default_port;
931 		pci_cfg[i].min_bw = pci_info[i].tx_min_bw;
932 		pci_cfg[i].max_bw = pci_info[i].tx_max_bw;
933 		memcpy(&pci_cfg[i].def_mac_addr, &pci_info[i].mac, ETH_ALEN);
934 	}
935 
936 	kfree(pci_info);
937 	return size;
938 }
939 
qlcnic_83xx_sysfs_flash_read_handler(struct file * filp,struct kobject * kobj,struct bin_attribute * attr,char * buf,loff_t offset,size_t size)940 static ssize_t qlcnic_83xx_sysfs_flash_read_handler(struct file *filp,
941 						    struct kobject *kobj,
942 						    struct bin_attribute *attr,
943 						    char *buf, loff_t offset,
944 						    size_t size)
945 {
946 	unsigned char *p_read_buf;
947 	int  ret, count;
948 	struct device *dev = kobj_to_dev(kobj);
949 	struct qlcnic_adapter *adapter = dev_get_drvdata(dev);
950 
951 	if (!size)
952 		return -EINVAL;
953 
954 	count = size / sizeof(u32);
955 
956 	if (size % sizeof(u32))
957 		count++;
958 
959 	p_read_buf = kcalloc(size, sizeof(unsigned char), GFP_KERNEL);
960 	if (!p_read_buf)
961 		return -ENOMEM;
962 	if (qlcnic_83xx_lock_flash(adapter) != 0) {
963 		kfree(p_read_buf);
964 		return -EIO;
965 	}
966 
967 	ret = qlcnic_83xx_lockless_flash_read32(adapter, offset, p_read_buf,
968 						count);
969 
970 	if (ret) {
971 		qlcnic_83xx_unlock_flash(adapter);
972 		kfree(p_read_buf);
973 		return ret;
974 	}
975 
976 	qlcnic_83xx_unlock_flash(adapter);
977 	qlcnic_swap32_buffer((u32 *)p_read_buf, count);
978 	memcpy(buf, p_read_buf, size);
979 	kfree(p_read_buf);
980 
981 	return size;
982 }
983 
qlcnic_83xx_sysfs_flash_bulk_write(struct qlcnic_adapter * adapter,char * buf,loff_t offset,size_t size)984 static int qlcnic_83xx_sysfs_flash_bulk_write(struct qlcnic_adapter *adapter,
985 					      char *buf, loff_t offset,
986 					      size_t size)
987 {
988 	int  i, ret, count;
989 	unsigned char *p_cache, *p_src;
990 
991 	p_cache = kcalloc(size, sizeof(unsigned char), GFP_KERNEL);
992 	if (!p_cache)
993 		return -ENOMEM;
994 
995 	count = size / sizeof(u32);
996 	qlcnic_swap32_buffer((u32 *)buf, count);
997 	memcpy(p_cache, buf, size);
998 	p_src = p_cache;
999 
1000 	if (qlcnic_83xx_lock_flash(adapter) != 0) {
1001 		kfree(p_cache);
1002 		return -EIO;
1003 	}
1004 
1005 	if (adapter->ahw->fdt.mfg_id == adapter->flash_mfg_id) {
1006 		ret = qlcnic_83xx_enable_flash_write(adapter);
1007 		if (ret) {
1008 			kfree(p_cache);
1009 			qlcnic_83xx_unlock_flash(adapter);
1010 			return -EIO;
1011 		}
1012 	}
1013 
1014 	for (i = 0; i < count / QLC_83XX_FLASH_WRITE_MAX; i++) {
1015 		ret = qlcnic_83xx_flash_bulk_write(adapter, offset,
1016 						   (u32 *)p_src,
1017 						   QLC_83XX_FLASH_WRITE_MAX);
1018 
1019 		if (ret) {
1020 			if (adapter->ahw->fdt.mfg_id == adapter->flash_mfg_id) {
1021 				ret = qlcnic_83xx_disable_flash_write(adapter);
1022 				if (ret) {
1023 					kfree(p_cache);
1024 					qlcnic_83xx_unlock_flash(adapter);
1025 					return -EIO;
1026 				}
1027 			}
1028 
1029 			kfree(p_cache);
1030 			qlcnic_83xx_unlock_flash(adapter);
1031 			return -EIO;
1032 		}
1033 
1034 		p_src = p_src + sizeof(u32)*QLC_83XX_FLASH_WRITE_MAX;
1035 		offset = offset + sizeof(u32)*QLC_83XX_FLASH_WRITE_MAX;
1036 	}
1037 
1038 	if (adapter->ahw->fdt.mfg_id == adapter->flash_mfg_id) {
1039 		ret = qlcnic_83xx_disable_flash_write(adapter);
1040 		if (ret) {
1041 			kfree(p_cache);
1042 			qlcnic_83xx_unlock_flash(adapter);
1043 			return -EIO;
1044 		}
1045 	}
1046 
1047 	kfree(p_cache);
1048 	qlcnic_83xx_unlock_flash(adapter);
1049 
1050 	return 0;
1051 }
1052 
qlcnic_83xx_sysfs_flash_write(struct qlcnic_adapter * adapter,char * buf,loff_t offset,size_t size)1053 static int qlcnic_83xx_sysfs_flash_write(struct qlcnic_adapter *adapter,
1054 					 char *buf, loff_t offset, size_t size)
1055 {
1056 	int  i, ret, count;
1057 	unsigned char *p_cache, *p_src;
1058 
1059 	p_cache = kcalloc(size, sizeof(unsigned char), GFP_KERNEL);
1060 	if (!p_cache)
1061 		return -ENOMEM;
1062 
1063 	qlcnic_swap32_buffer((u32 *)buf, size / sizeof(u32));
1064 	memcpy(p_cache, buf, size);
1065 	p_src = p_cache;
1066 	count = size / sizeof(u32);
1067 
1068 	if (qlcnic_83xx_lock_flash(adapter) != 0) {
1069 		kfree(p_cache);
1070 		return -EIO;
1071 	}
1072 
1073 	if (adapter->ahw->fdt.mfg_id == adapter->flash_mfg_id) {
1074 		ret = qlcnic_83xx_enable_flash_write(adapter);
1075 		if (ret) {
1076 			kfree(p_cache);
1077 			qlcnic_83xx_unlock_flash(adapter);
1078 			return -EIO;
1079 		}
1080 	}
1081 
1082 	for (i = 0; i < count; i++) {
1083 		ret = qlcnic_83xx_flash_write32(adapter, offset, (u32 *)p_src);
1084 		if (ret) {
1085 			if (adapter->ahw->fdt.mfg_id == adapter->flash_mfg_id) {
1086 				ret = qlcnic_83xx_disable_flash_write(adapter);
1087 				if (ret) {
1088 					kfree(p_cache);
1089 					qlcnic_83xx_unlock_flash(adapter);
1090 					return -EIO;
1091 				}
1092 			}
1093 			kfree(p_cache);
1094 			qlcnic_83xx_unlock_flash(adapter);
1095 			return -EIO;
1096 		}
1097 
1098 		p_src = p_src + sizeof(u32);
1099 		offset = offset + sizeof(u32);
1100 	}
1101 
1102 	if (adapter->ahw->fdt.mfg_id == adapter->flash_mfg_id) {
1103 		ret = qlcnic_83xx_disable_flash_write(adapter);
1104 		if (ret) {
1105 			kfree(p_cache);
1106 			qlcnic_83xx_unlock_flash(adapter);
1107 			return -EIO;
1108 		}
1109 	}
1110 
1111 	kfree(p_cache);
1112 	qlcnic_83xx_unlock_flash(adapter);
1113 
1114 	return 0;
1115 }
1116 
qlcnic_83xx_sysfs_flash_write_handler(struct file * filp,struct kobject * kobj,struct bin_attribute * attr,char * buf,loff_t offset,size_t size)1117 static ssize_t qlcnic_83xx_sysfs_flash_write_handler(struct file *filp,
1118 						     struct kobject *kobj,
1119 						     struct bin_attribute *attr,
1120 						     char *buf, loff_t offset,
1121 						     size_t size)
1122 {
1123 	int  ret;
1124 	static int flash_mode;
1125 	unsigned long data;
1126 	struct device *dev = kobj_to_dev(kobj);
1127 	struct qlcnic_adapter *adapter = dev_get_drvdata(dev);
1128 
1129 	ret = kstrtoul(buf, 16, &data);
1130 	if (ret)
1131 		return ret;
1132 
1133 	switch (data) {
1134 	case QLC_83XX_FLASH_SECTOR_ERASE_CMD:
1135 		flash_mode = QLC_83XX_ERASE_MODE;
1136 		ret = qlcnic_83xx_erase_flash_sector(adapter, offset);
1137 		if (ret) {
1138 			dev_err(&adapter->pdev->dev,
1139 				"%s failed at %d\n", __func__, __LINE__);
1140 			return -EIO;
1141 		}
1142 		break;
1143 
1144 	case QLC_83XX_FLASH_BULK_WRITE_CMD:
1145 		flash_mode = QLC_83XX_BULK_WRITE_MODE;
1146 		break;
1147 
1148 	case QLC_83XX_FLASH_WRITE_CMD:
1149 		flash_mode = QLC_83XX_WRITE_MODE;
1150 		break;
1151 	default:
1152 		if (flash_mode == QLC_83XX_BULK_WRITE_MODE) {
1153 			ret = qlcnic_83xx_sysfs_flash_bulk_write(adapter, buf,
1154 								 offset, size);
1155 			if (ret) {
1156 				dev_err(&adapter->pdev->dev,
1157 					"%s failed at %d\n",
1158 					__func__, __LINE__);
1159 				return -EIO;
1160 			}
1161 		}
1162 
1163 		if (flash_mode == QLC_83XX_WRITE_MODE) {
1164 			ret = qlcnic_83xx_sysfs_flash_write(adapter, buf,
1165 							    offset, size);
1166 			if (ret) {
1167 				dev_err(&adapter->pdev->dev,
1168 					"%s failed at %d\n", __func__,
1169 					__LINE__);
1170 				return -EIO;
1171 			}
1172 		}
1173 	}
1174 
1175 	return size;
1176 }
1177 
1178 static const struct device_attribute dev_attr_bridged_mode = {
1179 	.attr = { .name = "bridged_mode", .mode = 0644 },
1180 	.show = qlcnic_show_bridged_mode,
1181 	.store = qlcnic_store_bridged_mode,
1182 };
1183 
1184 static const struct device_attribute dev_attr_diag_mode = {
1185 	.attr = { .name = "diag_mode", .mode = 0644 },
1186 	.show = qlcnic_show_diag_mode,
1187 	.store = qlcnic_store_diag_mode,
1188 };
1189 
1190 static const struct device_attribute dev_attr_beacon = {
1191 	.attr = { .name = "beacon", .mode = 0644 },
1192 	.show = qlcnic_show_beacon,
1193 	.store = qlcnic_store_beacon,
1194 };
1195 
1196 static const struct bin_attribute bin_attr_crb = {
1197 	.attr = { .name = "crb", .mode = 0644 },
1198 	.size = 0,
1199 	.read = qlcnic_sysfs_read_crb,
1200 	.write = qlcnic_sysfs_write_crb,
1201 };
1202 
1203 static const struct bin_attribute bin_attr_mem = {
1204 	.attr = { .name = "mem", .mode = 0644 },
1205 	.size = 0,
1206 	.read = qlcnic_sysfs_read_mem,
1207 	.write = qlcnic_sysfs_write_mem,
1208 };
1209 
1210 static const struct bin_attribute bin_attr_npar_config = {
1211 	.attr = { .name = "npar_config", .mode = 0644 },
1212 	.size = 0,
1213 	.read = qlcnic_sysfs_read_npar_config,
1214 	.write = qlcnic_sysfs_write_npar_config,
1215 };
1216 
1217 static const struct bin_attribute bin_attr_pci_config = {
1218 	.attr = { .name = "pci_config", .mode = 0644 },
1219 	.size = 0,
1220 	.read = qlcnic_sysfs_read_pci_config,
1221 	.write = NULL,
1222 };
1223 
1224 static const struct bin_attribute bin_attr_port_stats = {
1225 	.attr = { .name = "port_stats", .mode = 0644 },
1226 	.size = 0,
1227 	.read = qlcnic_sysfs_get_port_stats,
1228 	.write = qlcnic_sysfs_clear_port_stats,
1229 };
1230 
1231 static const struct bin_attribute bin_attr_esw_stats = {
1232 	.attr = { .name = "esw_stats", .mode = 0644 },
1233 	.size = 0,
1234 	.read = qlcnic_sysfs_get_esw_stats,
1235 	.write = qlcnic_sysfs_clear_esw_stats,
1236 };
1237 
1238 static const struct bin_attribute bin_attr_esw_config = {
1239 	.attr = { .name = "esw_config", .mode = 0644 },
1240 	.size = 0,
1241 	.read = qlcnic_sysfs_read_esw_config,
1242 	.write = qlcnic_sysfs_write_esw_config,
1243 };
1244 
1245 static const struct bin_attribute bin_attr_pm_config = {
1246 	.attr = { .name = "pm_config", .mode = 0644 },
1247 	.size = 0,
1248 	.read = qlcnic_sysfs_read_pm_config,
1249 	.write = qlcnic_sysfs_write_pm_config,
1250 };
1251 
1252 static const struct bin_attribute bin_attr_flash = {
1253 	.attr = { .name = "flash", .mode = 0644 },
1254 	.size = 0,
1255 	.read = qlcnic_83xx_sysfs_flash_read_handler,
1256 	.write = qlcnic_83xx_sysfs_flash_write_handler,
1257 };
1258 
1259 #ifdef CONFIG_QLCNIC_HWMON
1260 
qlcnic_hwmon_show_temp(struct device * dev,struct device_attribute * dev_attr,char * buf)1261 static ssize_t qlcnic_hwmon_show_temp(struct device *dev,
1262 				      struct device_attribute *dev_attr,
1263 				      char *buf)
1264 {
1265 	struct qlcnic_adapter *adapter = dev_get_drvdata(dev);
1266 	unsigned int temperature = 0, value = 0;
1267 
1268 	if (qlcnic_83xx_check(adapter))
1269 		value = QLCRDX(adapter->ahw, QLC_83XX_ASIC_TEMP);
1270 	else if (qlcnic_82xx_check(adapter))
1271 		value = QLC_SHARED_REG_RD32(adapter, QLCNIC_ASIC_TEMP);
1272 
1273 	temperature = qlcnic_get_temp_val(value);
1274 	/* display millidegree celcius */
1275 	temperature *= 1000;
1276 	return sprintf(buf, "%u\n", temperature);
1277 }
1278 
1279 /* hwmon-sysfs attributes */
1280 static SENSOR_DEVICE_ATTR(temp1_input, 0444,
1281 			  qlcnic_hwmon_show_temp, NULL, 1);
1282 
1283 static struct attribute *qlcnic_hwmon_attrs[] = {
1284 	&sensor_dev_attr_temp1_input.dev_attr.attr,
1285 	NULL
1286 };
1287 
1288 ATTRIBUTE_GROUPS(qlcnic_hwmon);
1289 
qlcnic_register_hwmon_dev(struct qlcnic_adapter * adapter)1290 void qlcnic_register_hwmon_dev(struct qlcnic_adapter *adapter)
1291 {
1292 	struct device *dev = &adapter->pdev->dev;
1293 	struct device *hwmon_dev;
1294 
1295 	/* Skip hwmon registration for a VF device */
1296 	if (qlcnic_sriov_vf_check(adapter)) {
1297 		adapter->ahw->hwmon_dev = NULL;
1298 		return;
1299 	}
1300 	hwmon_dev = hwmon_device_register_with_groups(dev, qlcnic_driver_name,
1301 						      adapter,
1302 						      qlcnic_hwmon_groups);
1303 	if (IS_ERR(hwmon_dev)) {
1304 		dev_err(dev, "Cannot register with hwmon, err=%ld\n",
1305 			PTR_ERR(hwmon_dev));
1306 		hwmon_dev = NULL;
1307 	}
1308 	adapter->ahw->hwmon_dev = hwmon_dev;
1309 }
1310 
qlcnic_unregister_hwmon_dev(struct qlcnic_adapter * adapter)1311 void qlcnic_unregister_hwmon_dev(struct qlcnic_adapter *adapter)
1312 {
1313 	struct device *hwmon_dev = adapter->ahw->hwmon_dev;
1314 	if (hwmon_dev) {
1315 		hwmon_device_unregister(hwmon_dev);
1316 		adapter->ahw->hwmon_dev = NULL;
1317 	}
1318 }
1319 #endif
1320 
qlcnic_create_sysfs_entries(struct qlcnic_adapter * adapter)1321 void qlcnic_create_sysfs_entries(struct qlcnic_adapter *adapter)
1322 {
1323 	struct device *dev = &adapter->pdev->dev;
1324 
1325 	if (adapter->ahw->capabilities & QLCNIC_FW_CAPABILITY_BDG)
1326 		if (device_create_file(dev, &dev_attr_bridged_mode))
1327 			dev_warn(dev,
1328 				 "failed to create bridged_mode sysfs entry\n");
1329 }
1330 
qlcnic_remove_sysfs_entries(struct qlcnic_adapter * adapter)1331 void qlcnic_remove_sysfs_entries(struct qlcnic_adapter *adapter)
1332 {
1333 	struct device *dev = &adapter->pdev->dev;
1334 
1335 	if (adapter->ahw->capabilities & QLCNIC_FW_CAPABILITY_BDG)
1336 		device_remove_file(dev, &dev_attr_bridged_mode);
1337 }
1338 
qlcnic_create_diag_entries(struct qlcnic_adapter * adapter)1339 static void qlcnic_create_diag_entries(struct qlcnic_adapter *adapter)
1340 {
1341 	struct device *dev = &adapter->pdev->dev;
1342 
1343 	if (device_create_bin_file(dev, &bin_attr_port_stats))
1344 		dev_info(dev, "failed to create port stats sysfs entry");
1345 
1346 	if (adapter->ahw->op_mode == QLCNIC_NON_PRIV_FUNC)
1347 		return;
1348 	if (device_create_file(dev, &dev_attr_diag_mode))
1349 		dev_info(dev, "failed to create diag_mode sysfs entry\n");
1350 	if (device_create_bin_file(dev, &bin_attr_crb))
1351 		dev_info(dev, "failed to create crb sysfs entry\n");
1352 	if (device_create_bin_file(dev, &bin_attr_mem))
1353 		dev_info(dev, "failed to create mem sysfs entry\n");
1354 
1355 	if (test_bit(__QLCNIC_MAINTENANCE_MODE, &adapter->state))
1356 		return;
1357 
1358 	if (device_create_bin_file(dev, &bin_attr_pci_config))
1359 		dev_info(dev, "failed to create pci config sysfs entry");
1360 
1361 	if (device_create_file(dev, &dev_attr_beacon))
1362 		dev_info(dev, "failed to create beacon sysfs entry");
1363 
1364 	if (!(adapter->flags & QLCNIC_ESWITCH_ENABLED))
1365 		return;
1366 	if (device_create_bin_file(dev, &bin_attr_esw_config))
1367 		dev_info(dev, "failed to create esw config sysfs entry");
1368 	if (adapter->ahw->op_mode != QLCNIC_MGMT_FUNC)
1369 		return;
1370 	if (device_create_bin_file(dev, &bin_attr_npar_config))
1371 		dev_info(dev, "failed to create npar config sysfs entry");
1372 	if (device_create_bin_file(dev, &bin_attr_pm_config))
1373 		dev_info(dev, "failed to create pm config sysfs entry");
1374 	if (device_create_bin_file(dev, &bin_attr_esw_stats))
1375 		dev_info(dev, "failed to create eswitch stats sysfs entry");
1376 }
1377 
qlcnic_remove_diag_entries(struct qlcnic_adapter * adapter)1378 static void qlcnic_remove_diag_entries(struct qlcnic_adapter *adapter)
1379 {
1380 	struct device *dev = &adapter->pdev->dev;
1381 
1382 	device_remove_bin_file(dev, &bin_attr_port_stats);
1383 
1384 	if (adapter->ahw->op_mode == QLCNIC_NON_PRIV_FUNC)
1385 		return;
1386 	device_remove_file(dev, &dev_attr_diag_mode);
1387 	device_remove_bin_file(dev, &bin_attr_crb);
1388 	device_remove_bin_file(dev, &bin_attr_mem);
1389 
1390 	if (test_bit(__QLCNIC_MAINTENANCE_MODE, &adapter->state))
1391 		return;
1392 
1393 	device_remove_bin_file(dev, &bin_attr_pci_config);
1394 	device_remove_file(dev, &dev_attr_beacon);
1395 	if (!(adapter->flags & QLCNIC_ESWITCH_ENABLED))
1396 		return;
1397 	device_remove_bin_file(dev, &bin_attr_esw_config);
1398 	if (adapter->ahw->op_mode != QLCNIC_MGMT_FUNC)
1399 		return;
1400 	device_remove_bin_file(dev, &bin_attr_npar_config);
1401 	device_remove_bin_file(dev, &bin_attr_pm_config);
1402 	device_remove_bin_file(dev, &bin_attr_esw_stats);
1403 }
1404 
qlcnic_82xx_add_sysfs(struct qlcnic_adapter * adapter)1405 void qlcnic_82xx_add_sysfs(struct qlcnic_adapter *adapter)
1406 {
1407 	qlcnic_create_diag_entries(adapter);
1408 }
1409 
qlcnic_82xx_remove_sysfs(struct qlcnic_adapter * adapter)1410 void qlcnic_82xx_remove_sysfs(struct qlcnic_adapter *adapter)
1411 {
1412 	qlcnic_remove_diag_entries(adapter);
1413 }
1414 
qlcnic_83xx_add_sysfs(struct qlcnic_adapter * adapter)1415 void qlcnic_83xx_add_sysfs(struct qlcnic_adapter *adapter)
1416 {
1417 	struct device *dev = &adapter->pdev->dev;
1418 
1419 	qlcnic_create_diag_entries(adapter);
1420 
1421 	if (sysfs_create_bin_file(&dev->kobj, &bin_attr_flash))
1422 		dev_info(dev, "failed to create flash sysfs entry\n");
1423 }
1424 
qlcnic_83xx_remove_sysfs(struct qlcnic_adapter * adapter)1425 void qlcnic_83xx_remove_sysfs(struct qlcnic_adapter *adapter)
1426 {
1427 	struct device *dev = &adapter->pdev->dev;
1428 
1429 	qlcnic_remove_diag_entries(adapter);
1430 	sysfs_remove_bin_file(&dev->kobj, &bin_attr_flash);
1431 }
1432