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