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