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