1 // SPDX-License-Identifier: GPL-2.0
2 /*
3  *    Copyright IBM Corp. 2007
4  *    Author(s): Utz Bacher <utz.bacher@de.ibm.com>,
5  *		 Frank Pavlic <fpavlic@de.ibm.com>,
6  *		 Thomas Spatzier <tspat@de.ibm.com>,
7  *		 Frank Blaschka <frank.blaschka@de.ibm.com>
8  */
9 
10 #define KMSG_COMPONENT "qeth"
11 #define pr_fmt(fmt) KMSG_COMPONENT ": " fmt
12 
13 #include <linux/list.h>
14 #include <linux/rwsem.h>
15 #include <asm/ebcdic.h>
16 
17 #include "qeth_core.h"
18 
qeth_dev_state_show(struct device * dev,struct device_attribute * attr,char * buf)19 static ssize_t qeth_dev_state_show(struct device *dev,
20 				struct device_attribute *attr, char *buf)
21 {
22 	struct qeth_card *card = dev_get_drvdata(dev);
23 	if (!card)
24 		return -EINVAL;
25 
26 	switch (card->state) {
27 	case CARD_STATE_DOWN:
28 		return sprintf(buf, "DOWN\n");
29 	case CARD_STATE_HARDSETUP:
30 		return sprintf(buf, "HARDSETUP\n");
31 	case CARD_STATE_SOFTSETUP:
32 		return sprintf(buf, "SOFTSETUP\n");
33 	case CARD_STATE_UP:
34 		if (card->lan_online)
35 		return sprintf(buf, "UP (LAN ONLINE)\n");
36 		else
37 			return sprintf(buf, "UP (LAN OFFLINE)\n");
38 	case CARD_STATE_RECOVER:
39 		return sprintf(buf, "RECOVER\n");
40 	default:
41 		return sprintf(buf, "UNKNOWN\n");
42 	}
43 }
44 
45 static DEVICE_ATTR(state, 0444, qeth_dev_state_show, NULL);
46 
qeth_dev_chpid_show(struct device * dev,struct device_attribute * attr,char * buf)47 static ssize_t qeth_dev_chpid_show(struct device *dev,
48 				struct device_attribute *attr, char *buf)
49 {
50 	struct qeth_card *card = dev_get_drvdata(dev);
51 	if (!card)
52 		return -EINVAL;
53 
54 	return sprintf(buf, "%02X\n", card->info.chpid);
55 }
56 
57 static DEVICE_ATTR(chpid, 0444, qeth_dev_chpid_show, NULL);
58 
qeth_dev_if_name_show(struct device * dev,struct device_attribute * attr,char * buf)59 static ssize_t qeth_dev_if_name_show(struct device *dev,
60 				struct device_attribute *attr, char *buf)
61 {
62 	struct qeth_card *card = dev_get_drvdata(dev);
63 	if (!card)
64 		return -EINVAL;
65 	return sprintf(buf, "%s\n", QETH_CARD_IFNAME(card));
66 }
67 
68 static DEVICE_ATTR(if_name, 0444, qeth_dev_if_name_show, NULL);
69 
qeth_dev_card_type_show(struct device * dev,struct device_attribute * attr,char * buf)70 static ssize_t qeth_dev_card_type_show(struct device *dev,
71 				struct device_attribute *attr, char *buf)
72 {
73 	struct qeth_card *card = dev_get_drvdata(dev);
74 	if (!card)
75 		return -EINVAL;
76 
77 	return sprintf(buf, "%s\n", qeth_get_cardname_short(card));
78 }
79 
80 static DEVICE_ATTR(card_type, 0444, qeth_dev_card_type_show, NULL);
81 
qeth_get_bufsize_str(struct qeth_card * card)82 static const char *qeth_get_bufsize_str(struct qeth_card *card)
83 {
84 	if (card->qdio.in_buf_size == 16384)
85 		return "16k";
86 	else if (card->qdio.in_buf_size == 24576)
87 		return "24k";
88 	else if (card->qdio.in_buf_size == 32768)
89 		return "32k";
90 	else if (card->qdio.in_buf_size == 40960)
91 		return "40k";
92 	else
93 		return "64k";
94 }
95 
qeth_dev_inbuf_size_show(struct device * dev,struct device_attribute * attr,char * buf)96 static ssize_t qeth_dev_inbuf_size_show(struct device *dev,
97 				struct device_attribute *attr, char *buf)
98 {
99 	struct qeth_card *card = dev_get_drvdata(dev);
100 	if (!card)
101 		return -EINVAL;
102 
103 	return sprintf(buf, "%s\n", qeth_get_bufsize_str(card));
104 }
105 
106 static DEVICE_ATTR(inbuf_size, 0444, qeth_dev_inbuf_size_show, NULL);
107 
qeth_dev_portno_show(struct device * dev,struct device_attribute * attr,char * buf)108 static ssize_t qeth_dev_portno_show(struct device *dev,
109 			struct device_attribute *attr, char *buf)
110 {
111 	struct qeth_card *card = dev_get_drvdata(dev);
112 	if (!card)
113 		return -EINVAL;
114 
115 	return sprintf(buf, "%i\n", card->dev->dev_port);
116 }
117 
qeth_dev_portno_store(struct device * dev,struct device_attribute * attr,const char * buf,size_t count)118 static ssize_t qeth_dev_portno_store(struct device *dev,
119 		struct device_attribute *attr, const char *buf, size_t count)
120 {
121 	struct qeth_card *card = dev_get_drvdata(dev);
122 	char *tmp;
123 	unsigned int portno, limit;
124 	int rc = 0;
125 
126 	if (!card)
127 		return -EINVAL;
128 
129 	mutex_lock(&card->conf_mutex);
130 	if ((card->state != CARD_STATE_DOWN) &&
131 	    (card->state != CARD_STATE_RECOVER)) {
132 		rc = -EPERM;
133 		goto out;
134 	}
135 
136 	portno = simple_strtoul(buf, &tmp, 16);
137 	if (portno > QETH_MAX_PORTNO) {
138 		rc = -EINVAL;
139 		goto out;
140 	}
141 	limit = (card->ssqd.pcnt ? card->ssqd.pcnt - 1 : card->ssqd.pcnt);
142 	if (portno > limit) {
143 		rc = -EINVAL;
144 		goto out;
145 	}
146 	card->dev->dev_port = portno;
147 out:
148 	mutex_unlock(&card->conf_mutex);
149 	return rc ? rc : count;
150 }
151 
152 static DEVICE_ATTR(portno, 0644, qeth_dev_portno_show, qeth_dev_portno_store);
153 
qeth_dev_portname_show(struct device * dev,struct device_attribute * attr,char * buf)154 static ssize_t qeth_dev_portname_show(struct device *dev,
155 				struct device_attribute *attr, char *buf)
156 {
157 	return sprintf(buf, "no portname required\n");
158 }
159 
qeth_dev_portname_store(struct device * dev,struct device_attribute * attr,const char * buf,size_t count)160 static ssize_t qeth_dev_portname_store(struct device *dev,
161 		struct device_attribute *attr, const char *buf, size_t count)
162 {
163 	struct qeth_card *card = dev_get_drvdata(dev);
164 
165 	dev_warn_once(&card->gdev->dev,
166 		      "portname is deprecated and is ignored\n");
167 	return count;
168 }
169 
170 static DEVICE_ATTR(portname, 0644, qeth_dev_portname_show,
171 		qeth_dev_portname_store);
172 
qeth_dev_prioqing_show(struct device * dev,struct device_attribute * attr,char * buf)173 static ssize_t qeth_dev_prioqing_show(struct device *dev,
174 				struct device_attribute *attr, char *buf)
175 {
176 	struct qeth_card *card = dev_get_drvdata(dev);
177 
178 	if (!card)
179 		return -EINVAL;
180 
181 	switch (card->qdio.do_prio_queueing) {
182 	case QETH_PRIO_Q_ING_PREC:
183 		return sprintf(buf, "%s\n", "by precedence");
184 	case QETH_PRIO_Q_ING_TOS:
185 		return sprintf(buf, "%s\n", "by type of service");
186 	case QETH_PRIO_Q_ING_SKB:
187 		return sprintf(buf, "%s\n", "by skb-priority");
188 	case QETH_PRIO_Q_ING_VLAN:
189 		return sprintf(buf, "%s\n", "by VLAN headers");
190 	default:
191 		return sprintf(buf, "always queue %i\n",
192 			       card->qdio.default_out_queue);
193 	}
194 }
195 
qeth_dev_prioqing_store(struct device * dev,struct device_attribute * attr,const char * buf,size_t count)196 static ssize_t qeth_dev_prioqing_store(struct device *dev,
197 		struct device_attribute *attr, const char *buf, size_t count)
198 {
199 	struct qeth_card *card = dev_get_drvdata(dev);
200 	int rc = 0;
201 
202 	if (!card)
203 		return -EINVAL;
204 
205 	mutex_lock(&card->conf_mutex);
206 	if ((card->state != CARD_STATE_DOWN) &&
207 	    (card->state != CARD_STATE_RECOVER)) {
208 		rc = -EPERM;
209 		goto out;
210 	}
211 
212 	/* check if 1920 devices are supported ,
213 	 * if though we have to permit priority queueing
214 	 */
215 	if (card->qdio.no_out_queues == 1) {
216 		card->qdio.do_prio_queueing = QETH_PRIOQ_DEFAULT;
217 		rc = -EPERM;
218 		goto out;
219 	}
220 
221 	if (sysfs_streq(buf, "prio_queueing_prec")) {
222 		card->qdio.do_prio_queueing = QETH_PRIO_Q_ING_PREC;
223 		card->qdio.default_out_queue = QETH_DEFAULT_QUEUE;
224 	} else if (sysfs_streq(buf, "prio_queueing_skb")) {
225 		card->qdio.do_prio_queueing = QETH_PRIO_Q_ING_SKB;
226 		card->qdio.default_out_queue = QETH_DEFAULT_QUEUE;
227 	} else if (sysfs_streq(buf, "prio_queueing_tos")) {
228 		card->qdio.do_prio_queueing = QETH_PRIO_Q_ING_TOS;
229 		card->qdio.default_out_queue = QETH_DEFAULT_QUEUE;
230 	} else if (sysfs_streq(buf, "prio_queueing_vlan")) {
231 		if (!card->options.layer2) {
232 			rc = -ENOTSUPP;
233 			goto out;
234 		}
235 		card->qdio.do_prio_queueing = QETH_PRIO_Q_ING_VLAN;
236 		card->qdio.default_out_queue = QETH_DEFAULT_QUEUE;
237 	} else if (sysfs_streq(buf, "no_prio_queueing:0")) {
238 		card->qdio.do_prio_queueing = QETH_NO_PRIO_QUEUEING;
239 		card->qdio.default_out_queue = 0;
240 	} else if (sysfs_streq(buf, "no_prio_queueing:1")) {
241 		card->qdio.do_prio_queueing = QETH_NO_PRIO_QUEUEING;
242 		card->qdio.default_out_queue = 1;
243 	} else if (sysfs_streq(buf, "no_prio_queueing:2")) {
244 		card->qdio.do_prio_queueing = QETH_NO_PRIO_QUEUEING;
245 		card->qdio.default_out_queue = 2;
246 	} else if (sysfs_streq(buf, "no_prio_queueing:3")) {
247 		if (card->info.type == QETH_CARD_TYPE_IQD) {
248 			rc = -EPERM;
249 			goto out;
250 		}
251 		card->qdio.do_prio_queueing = QETH_NO_PRIO_QUEUEING;
252 		card->qdio.default_out_queue = 3;
253 	} else if (sysfs_streq(buf, "no_prio_queueing")) {
254 		card->qdio.do_prio_queueing = QETH_NO_PRIO_QUEUEING;
255 		card->qdio.default_out_queue = QETH_DEFAULT_QUEUE;
256 	} else
257 		rc = -EINVAL;
258 out:
259 	mutex_unlock(&card->conf_mutex);
260 	return rc ? rc : count;
261 }
262 
263 static DEVICE_ATTR(priority_queueing, 0644, qeth_dev_prioqing_show,
264 		qeth_dev_prioqing_store);
265 
qeth_dev_bufcnt_show(struct device * dev,struct device_attribute * attr,char * buf)266 static ssize_t qeth_dev_bufcnt_show(struct device *dev,
267 				struct device_attribute *attr, char *buf)
268 {
269 	struct qeth_card *card = dev_get_drvdata(dev);
270 
271 	if (!card)
272 		return -EINVAL;
273 
274 	return sprintf(buf, "%i\n", card->qdio.in_buf_pool.buf_count);
275 }
276 
qeth_dev_bufcnt_store(struct device * dev,struct device_attribute * attr,const char * buf,size_t count)277 static ssize_t qeth_dev_bufcnt_store(struct device *dev,
278 		struct device_attribute *attr, const char *buf, size_t count)
279 {
280 	struct qeth_card *card = dev_get_drvdata(dev);
281 	char *tmp;
282 	int cnt, old_cnt;
283 	int rc = 0;
284 
285 	if (!card)
286 		return -EINVAL;
287 
288 	mutex_lock(&card->conf_mutex);
289 	if ((card->state != CARD_STATE_DOWN) &&
290 	    (card->state != CARD_STATE_RECOVER)) {
291 		rc = -EPERM;
292 		goto out;
293 	}
294 
295 	old_cnt = card->qdio.in_buf_pool.buf_count;
296 	cnt = simple_strtoul(buf, &tmp, 10);
297 	cnt = (cnt < QETH_IN_BUF_COUNT_MIN) ? QETH_IN_BUF_COUNT_MIN :
298 		((cnt > QETH_IN_BUF_COUNT_MAX) ? QETH_IN_BUF_COUNT_MAX : cnt);
299 	if (old_cnt != cnt) {
300 		rc = qeth_realloc_buffer_pool(card, cnt);
301 	}
302 out:
303 	mutex_unlock(&card->conf_mutex);
304 	return rc ? rc : count;
305 }
306 
307 static DEVICE_ATTR(buffer_count, 0644, qeth_dev_bufcnt_show,
308 		qeth_dev_bufcnt_store);
309 
qeth_dev_recover_store(struct device * dev,struct device_attribute * attr,const char * buf,size_t count)310 static ssize_t qeth_dev_recover_store(struct device *dev,
311 		struct device_attribute *attr, const char *buf, size_t count)
312 {
313 	struct qeth_card *card = dev_get_drvdata(dev);
314 	char *tmp;
315 	int i;
316 
317 	if (!card)
318 		return -EINVAL;
319 
320 	if (card->state != CARD_STATE_UP)
321 		return -EPERM;
322 
323 	i = simple_strtoul(buf, &tmp, 16);
324 	if (i == 1)
325 		qeth_schedule_recovery(card);
326 
327 	return count;
328 }
329 
330 static DEVICE_ATTR(recover, 0200, NULL, qeth_dev_recover_store);
331 
qeth_dev_performance_stats_show(struct device * dev,struct device_attribute * attr,char * buf)332 static ssize_t qeth_dev_performance_stats_show(struct device *dev,
333 				struct device_attribute *attr, char *buf)
334 {
335 	struct qeth_card *card = dev_get_drvdata(dev);
336 
337 	if (!card)
338 		return -EINVAL;
339 
340 	return sprintf(buf, "%i\n", card->options.performance_stats ? 1:0);
341 }
342 
qeth_dev_performance_stats_store(struct device * dev,struct device_attribute * attr,const char * buf,size_t count)343 static ssize_t qeth_dev_performance_stats_store(struct device *dev,
344 		struct device_attribute *attr, const char *buf, size_t count)
345 {
346 	struct qeth_card *card = dev_get_drvdata(dev);
347 	char *tmp;
348 	int i, rc = 0;
349 
350 	if (!card)
351 		return -EINVAL;
352 
353 	mutex_lock(&card->conf_mutex);
354 	i = simple_strtoul(buf, &tmp, 16);
355 	if ((i == 0) || (i == 1)) {
356 		if (i == card->options.performance_stats)
357 			goto out;
358 		card->options.performance_stats = i;
359 		if (i == 0)
360 			memset(&card->perf_stats, 0,
361 				sizeof(struct qeth_perf_stats));
362 		card->perf_stats.initial_rx_packets = card->stats.rx_packets;
363 		card->perf_stats.initial_tx_packets = card->stats.tx_packets;
364 	} else
365 		rc = -EINVAL;
366 out:
367 	mutex_unlock(&card->conf_mutex);
368 	return rc ? rc : count;
369 }
370 
371 static DEVICE_ATTR(performance_stats, 0644, qeth_dev_performance_stats_show,
372 		   qeth_dev_performance_stats_store);
373 
qeth_dev_layer2_show(struct device * dev,struct device_attribute * attr,char * buf)374 static ssize_t qeth_dev_layer2_show(struct device *dev,
375 		struct device_attribute *attr, char *buf)
376 {
377 	struct qeth_card *card = dev_get_drvdata(dev);
378 
379 	if (!card)
380 		return -EINVAL;
381 
382 	return sprintf(buf, "%i\n", card->options.layer2);
383 }
384 
qeth_dev_layer2_store(struct device * dev,struct device_attribute * attr,const char * buf,size_t count)385 static ssize_t qeth_dev_layer2_store(struct device *dev,
386 		struct device_attribute *attr, const char *buf, size_t count)
387 {
388 	struct qeth_card *card = dev_get_drvdata(dev);
389 	struct net_device *ndev;
390 	char *tmp;
391 	int i, rc = 0;
392 	enum qeth_discipline_id newdis;
393 
394 	if (!card)
395 		return -EINVAL;
396 
397 	mutex_lock(&card->discipline_mutex);
398 	if (card->state != CARD_STATE_DOWN) {
399 		rc = -EPERM;
400 		goto out;
401 	}
402 
403 	i = simple_strtoul(buf, &tmp, 16);
404 	switch (i) {
405 	case 0:
406 		newdis = QETH_DISCIPLINE_LAYER3;
407 		break;
408 	case 1:
409 		newdis = QETH_DISCIPLINE_LAYER2;
410 		break;
411 	default:
412 		rc = -EINVAL;
413 		goto out;
414 	}
415 
416 	if (card->options.layer2 == newdis)
417 		goto out;
418 	if (card->info.layer_enforced) {
419 		/* fixed layer, can't switch */
420 		rc = -EOPNOTSUPP;
421 		goto out;
422 	}
423 
424 	card->info.mac_bits = 0;
425 	if (card->discipline) {
426 		/* start with a new, pristine netdevice: */
427 		ndev = qeth_clone_netdev(card->dev);
428 		if (!ndev) {
429 			rc = -ENOMEM;
430 			goto out;
431 		}
432 
433 		card->discipline->remove(card->gdev);
434 		qeth_core_free_discipline(card);
435 		card->options.layer2 = -1;
436 
437 		free_netdev(card->dev);
438 		card->dev = ndev;
439 	}
440 
441 	rc = qeth_core_load_discipline(card, newdis);
442 	if (rc)
443 		goto out;
444 
445 	rc = card->discipline->setup(card->gdev);
446 	if (rc)
447 		qeth_core_free_discipline(card);
448 out:
449 	mutex_unlock(&card->discipline_mutex);
450 	return rc ? rc : count;
451 }
452 
453 static DEVICE_ATTR(layer2, 0644, qeth_dev_layer2_show,
454 		   qeth_dev_layer2_store);
455 
456 #define ATTR_QETH_ISOLATION_NONE	("none")
457 #define ATTR_QETH_ISOLATION_FWD		("forward")
458 #define ATTR_QETH_ISOLATION_DROP	("drop")
459 
qeth_dev_isolation_show(struct device * dev,struct device_attribute * attr,char * buf)460 static ssize_t qeth_dev_isolation_show(struct device *dev,
461 				struct device_attribute *attr, char *buf)
462 {
463 	struct qeth_card *card = dev_get_drvdata(dev);
464 
465 	if (!card)
466 		return -EINVAL;
467 
468 	switch (card->options.isolation) {
469 	case ISOLATION_MODE_NONE:
470 		return snprintf(buf, 6, "%s\n", ATTR_QETH_ISOLATION_NONE);
471 	case ISOLATION_MODE_FWD:
472 		return snprintf(buf, 9, "%s\n", ATTR_QETH_ISOLATION_FWD);
473 	case ISOLATION_MODE_DROP:
474 		return snprintf(buf, 6, "%s\n", ATTR_QETH_ISOLATION_DROP);
475 	default:
476 		return snprintf(buf, 5, "%s\n", "N/A");
477 	}
478 }
479 
qeth_dev_isolation_store(struct device * dev,struct device_attribute * attr,const char * buf,size_t count)480 static ssize_t qeth_dev_isolation_store(struct device *dev,
481 		struct device_attribute *attr, const char *buf, size_t count)
482 {
483 	struct qeth_card *card = dev_get_drvdata(dev);
484 	enum qeth_ipa_isolation_modes isolation;
485 	int rc = 0;
486 
487 	if (!card)
488 		return -EINVAL;
489 
490 	mutex_lock(&card->conf_mutex);
491 	if (card->info.type != QETH_CARD_TYPE_OSD &&
492 	    card->info.type != QETH_CARD_TYPE_OSX) {
493 		rc = -EOPNOTSUPP;
494 		dev_err(&card->gdev->dev, "Adapter does not "
495 			"support QDIO data connection isolation\n");
496 		goto out;
497 	}
498 
499 	/* parse input into isolation mode */
500 	if (sysfs_streq(buf, ATTR_QETH_ISOLATION_NONE)) {
501 		isolation = ISOLATION_MODE_NONE;
502 	} else if (sysfs_streq(buf, ATTR_QETH_ISOLATION_FWD)) {
503 		isolation = ISOLATION_MODE_FWD;
504 	} else if (sysfs_streq(buf, ATTR_QETH_ISOLATION_DROP)) {
505 		isolation = ISOLATION_MODE_DROP;
506 	} else {
507 		rc = -EINVAL;
508 		goto out;
509 	}
510 	rc = count;
511 
512 	/* defer IP assist if device is offline (until discipline->set_online)*/
513 	card->options.prev_isolation = card->options.isolation;
514 	card->options.isolation = isolation;
515 	if (qeth_card_hw_is_reachable(card)) {
516 		int ipa_rc = qeth_set_access_ctrl_online(card, 1);
517 		if (ipa_rc != 0)
518 			rc = ipa_rc;
519 	}
520 out:
521 	mutex_unlock(&card->conf_mutex);
522 	return rc;
523 }
524 
525 static DEVICE_ATTR(isolation, 0644, qeth_dev_isolation_show,
526 			qeth_dev_isolation_store);
527 
qeth_dev_switch_attrs_show(struct device * dev,struct device_attribute * attr,char * buf)528 static ssize_t qeth_dev_switch_attrs_show(struct device *dev,
529 				struct device_attribute *attr, char *buf)
530 {
531 	struct qeth_card *card = dev_get_drvdata(dev);
532 	struct qeth_switch_info sw_info;
533 	int	rc = 0;
534 
535 	if (!card)
536 		return -EINVAL;
537 
538 	if (!qeth_card_hw_is_reachable(card))
539 		return sprintf(buf, "n/a\n");
540 
541 	rc = qeth_query_switch_attributes(card, &sw_info);
542 	if (rc)
543 		return rc;
544 
545 	if (!sw_info.capabilities)
546 		rc = sprintf(buf, "unknown");
547 
548 	if (sw_info.capabilities & QETH_SWITCH_FORW_802_1)
549 		rc = sprintf(buf, (sw_info.settings & QETH_SWITCH_FORW_802_1 ?
550 							"[802.1]" : "802.1"));
551 	if (sw_info.capabilities & QETH_SWITCH_FORW_REFL_RELAY)
552 		rc += sprintf(buf + rc,
553 			(sw_info.settings & QETH_SWITCH_FORW_REFL_RELAY ?
554 							" [rr]" : " rr"));
555 	rc += sprintf(buf + rc, "\n");
556 
557 	return rc;
558 }
559 
560 static DEVICE_ATTR(switch_attrs, 0444,
561 		   qeth_dev_switch_attrs_show, NULL);
562 
qeth_hw_trap_show(struct device * dev,struct device_attribute * attr,char * buf)563 static ssize_t qeth_hw_trap_show(struct device *dev,
564 				struct device_attribute *attr, char *buf)
565 {
566 	struct qeth_card *card = dev_get_drvdata(dev);
567 
568 	if (!card)
569 		return -EINVAL;
570 	if (card->info.hwtrap)
571 		return snprintf(buf, 5, "arm\n");
572 	else
573 		return snprintf(buf, 8, "disarm\n");
574 }
575 
qeth_hw_trap_store(struct device * dev,struct device_attribute * attr,const char * buf,size_t count)576 static ssize_t qeth_hw_trap_store(struct device *dev,
577 		struct device_attribute *attr, const char *buf, size_t count)
578 {
579 	struct qeth_card *card = dev_get_drvdata(dev);
580 	int rc = 0;
581 	int state = 0;
582 
583 	if (!card)
584 		return -EINVAL;
585 
586 	mutex_lock(&card->conf_mutex);
587 	if (qeth_card_hw_is_reachable(card))
588 		state = 1;
589 
590 	if (sysfs_streq(buf, "arm") && !card->info.hwtrap) {
591 		if (state) {
592 			if (qeth_is_diagass_supported(card,
593 			    QETH_DIAGS_CMD_TRAP)) {
594 				rc = qeth_hw_trap(card, QETH_DIAGS_TRAP_ARM);
595 				if (!rc)
596 					card->info.hwtrap = 1;
597 			} else
598 				rc = -EINVAL;
599 		} else
600 			card->info.hwtrap = 1;
601 	} else if (sysfs_streq(buf, "disarm") && card->info.hwtrap) {
602 		if (state) {
603 			rc = qeth_hw_trap(card, QETH_DIAGS_TRAP_DISARM);
604 			if (!rc)
605 				card->info.hwtrap = 0;
606 		} else
607 			card->info.hwtrap = 0;
608 	} else if (sysfs_streq(buf, "trap") && state && card->info.hwtrap)
609 		rc = qeth_hw_trap(card, QETH_DIAGS_TRAP_CAPTURE);
610 	else
611 		rc = -EINVAL;
612 
613 	mutex_unlock(&card->conf_mutex);
614 	return rc ? rc : count;
615 }
616 
617 static DEVICE_ATTR(hw_trap, 0644, qeth_hw_trap_show,
618 		   qeth_hw_trap_store);
619 
qeth_dev_blkt_show(char * buf,struct qeth_card * card,int value)620 static ssize_t qeth_dev_blkt_show(char *buf, struct qeth_card *card, int value)
621 {
622 
623 	if (!card)
624 		return -EINVAL;
625 
626 	return sprintf(buf, "%i\n", value);
627 }
628 
qeth_dev_blkt_store(struct qeth_card * card,const char * buf,size_t count,int * value,int max_value)629 static ssize_t qeth_dev_blkt_store(struct qeth_card *card,
630 		const char *buf, size_t count, int *value, int max_value)
631 {
632 	char *tmp;
633 	int i, rc = 0;
634 
635 	if (!card)
636 		return -EINVAL;
637 
638 	mutex_lock(&card->conf_mutex);
639 	if ((card->state != CARD_STATE_DOWN) &&
640 	    (card->state != CARD_STATE_RECOVER)) {
641 		rc = -EPERM;
642 		goto out;
643 	}
644 	i = simple_strtoul(buf, &tmp, 10);
645 	if (i <= max_value)
646 		*value = i;
647 	else
648 		rc = -EINVAL;
649 out:
650 	mutex_unlock(&card->conf_mutex);
651 	return rc ? rc : count;
652 }
653 
qeth_dev_blkt_total_show(struct device * dev,struct device_attribute * attr,char * buf)654 static ssize_t qeth_dev_blkt_total_show(struct device *dev,
655 				struct device_attribute *attr, char *buf)
656 {
657 	struct qeth_card *card = dev_get_drvdata(dev);
658 
659 	return qeth_dev_blkt_show(buf, card, card->info.blkt.time_total);
660 }
661 
qeth_dev_blkt_total_store(struct device * dev,struct device_attribute * attr,const char * buf,size_t count)662 static ssize_t qeth_dev_blkt_total_store(struct device *dev,
663 		struct device_attribute *attr, const char *buf, size_t count)
664 {
665 	struct qeth_card *card = dev_get_drvdata(dev);
666 
667 	return qeth_dev_blkt_store(card, buf, count,
668 				   &card->info.blkt.time_total, 5000);
669 }
670 
671 
672 
673 static DEVICE_ATTR(total, 0644, qeth_dev_blkt_total_show,
674 		   qeth_dev_blkt_total_store);
675 
qeth_dev_blkt_inter_show(struct device * dev,struct device_attribute * attr,char * buf)676 static ssize_t qeth_dev_blkt_inter_show(struct device *dev,
677 				struct device_attribute *attr, char *buf)
678 {
679 	struct qeth_card *card = dev_get_drvdata(dev);
680 
681 	return qeth_dev_blkt_show(buf, card, card->info.blkt.inter_packet);
682 }
683 
qeth_dev_blkt_inter_store(struct device * dev,struct device_attribute * attr,const char * buf,size_t count)684 static ssize_t qeth_dev_blkt_inter_store(struct device *dev,
685 		struct device_attribute *attr, const char *buf, size_t count)
686 {
687 	struct qeth_card *card = dev_get_drvdata(dev);
688 
689 	return qeth_dev_blkt_store(card, buf, count,
690 				   &card->info.blkt.inter_packet, 1000);
691 }
692 
693 static DEVICE_ATTR(inter, 0644, qeth_dev_blkt_inter_show,
694 		   qeth_dev_blkt_inter_store);
695 
qeth_dev_blkt_inter_jumbo_show(struct device * dev,struct device_attribute * attr,char * buf)696 static ssize_t qeth_dev_blkt_inter_jumbo_show(struct device *dev,
697 				struct device_attribute *attr, char *buf)
698 {
699 	struct qeth_card *card = dev_get_drvdata(dev);
700 
701 	return qeth_dev_blkt_show(buf, card,
702 				  card->info.blkt.inter_packet_jumbo);
703 }
704 
qeth_dev_blkt_inter_jumbo_store(struct device * dev,struct device_attribute * attr,const char * buf,size_t count)705 static ssize_t qeth_dev_blkt_inter_jumbo_store(struct device *dev,
706 		struct device_attribute *attr, const char *buf, size_t count)
707 {
708 	struct qeth_card *card = dev_get_drvdata(dev);
709 
710 	return qeth_dev_blkt_store(card, buf, count,
711 				   &card->info.blkt.inter_packet_jumbo, 1000);
712 }
713 
714 static DEVICE_ATTR(inter_jumbo, 0644, qeth_dev_blkt_inter_jumbo_show,
715 		   qeth_dev_blkt_inter_jumbo_store);
716 
717 static struct attribute *qeth_blkt_device_attrs[] = {
718 	&dev_attr_total.attr,
719 	&dev_attr_inter.attr,
720 	&dev_attr_inter_jumbo.attr,
721 	NULL,
722 };
723 const struct attribute_group qeth_device_blkt_group = {
724 	.name = "blkt",
725 	.attrs = qeth_blkt_device_attrs,
726 };
727 EXPORT_SYMBOL_GPL(qeth_device_blkt_group);
728 
729 static struct attribute *qeth_device_attrs[] = {
730 	&dev_attr_state.attr,
731 	&dev_attr_chpid.attr,
732 	&dev_attr_if_name.attr,
733 	&dev_attr_card_type.attr,
734 	&dev_attr_inbuf_size.attr,
735 	&dev_attr_portno.attr,
736 	&dev_attr_portname.attr,
737 	&dev_attr_priority_queueing.attr,
738 	&dev_attr_buffer_count.attr,
739 	&dev_attr_recover.attr,
740 	&dev_attr_performance_stats.attr,
741 	&dev_attr_layer2.attr,
742 	&dev_attr_isolation.attr,
743 	&dev_attr_hw_trap.attr,
744 	&dev_attr_switch_attrs.attr,
745 	NULL,
746 };
747 const struct attribute_group qeth_device_attr_group = {
748 	.attrs = qeth_device_attrs,
749 };
750 EXPORT_SYMBOL_GPL(qeth_device_attr_group);
751 
752 const struct attribute_group *qeth_generic_attr_groups[] = {
753 	&qeth_device_attr_group,
754 	&qeth_device_blkt_group,
755 	NULL,
756 };
757 
758 static struct attribute *qeth_osn_device_attrs[] = {
759 	&dev_attr_state.attr,
760 	&dev_attr_chpid.attr,
761 	&dev_attr_if_name.attr,
762 	&dev_attr_card_type.attr,
763 	&dev_attr_buffer_count.attr,
764 	&dev_attr_recover.attr,
765 	NULL,
766 };
767 static struct attribute_group qeth_osn_device_attr_group = {
768 	.attrs = qeth_osn_device_attrs,
769 };
770 const struct attribute_group *qeth_osn_attr_groups[] = {
771 	&qeth_osn_device_attr_group,
772 	NULL,
773 };
774