aboutsummaryrefslogtreecommitdiffstats
path: root/drivers/s390/net/qeth_sys.c
diff options
context:
space:
mode:
Diffstat (limited to 'drivers/s390/net/qeth_sys.c')
-rw-r--r--drivers/s390/net/qeth_sys.c1788
1 files changed, 1788 insertions, 0 deletions
diff --git a/drivers/s390/net/qeth_sys.c b/drivers/s390/net/qeth_sys.c
new file mode 100644
index 000000000000..240348398211
--- /dev/null
+++ b/drivers/s390/net/qeth_sys.c
@@ -0,0 +1,1788 @@
1/*
2 *
3 * linux/drivers/s390/net/qeth_sys.c ($Revision: 1.51 $)
4 *
5 * Linux on zSeries OSA Express and HiperSockets support
6 * This file contains code related to sysfs.
7 *
8 * Copyright 2000,2003 IBM Corporation
9 *
10 * Author(s): Thomas Spatzier <tspat@de.ibm.com>
11 * Frank Pavlic <pavlic@de.ibm.com>
12 *
13 */
14#include <linux/list.h>
15#include <linux/rwsem.h>
16
17#include <asm/ebcdic.h>
18
19#include "qeth.h"
20#include "qeth_mpc.h"
21#include "qeth_fs.h"
22
23const char *VERSION_QETH_SYS_C = "$Revision: 1.51 $";
24
25/*****************************************************************************/
26/* */
27/* /sys-fs stuff UNDER DEVELOPMENT !!! */
28/* */
29/*****************************************************************************/
30//low/high watermark
31
32static ssize_t
33qeth_dev_state_show(struct device *dev, char *buf)
34{
35 struct qeth_card *card = dev->driver_data;
36 if (!card)
37 return -EINVAL;
38
39 switch (card->state) {
40 case CARD_STATE_DOWN:
41 return sprintf(buf, "DOWN\n");
42 case CARD_STATE_HARDSETUP:
43 return sprintf(buf, "HARDSETUP\n");
44 case CARD_STATE_SOFTSETUP:
45 return sprintf(buf, "SOFTSETUP\n");
46 case CARD_STATE_UP:
47 if (card->lan_online)
48 return sprintf(buf, "UP (LAN ONLINE)\n");
49 else
50 return sprintf(buf, "UP (LAN OFFLINE)\n");
51 case CARD_STATE_RECOVER:
52 return sprintf(buf, "RECOVER\n");
53 default:
54 return sprintf(buf, "UNKNOWN\n");
55 }
56}
57
58static DEVICE_ATTR(state, 0444, qeth_dev_state_show, NULL);
59
60static ssize_t
61qeth_dev_chpid_show(struct device *dev, char *buf)
62{
63 struct qeth_card *card = dev->driver_data;
64 if (!card)
65 return -EINVAL;
66
67 return sprintf(buf, "%02X\n", card->info.chpid);
68}
69
70static DEVICE_ATTR(chpid, 0444, qeth_dev_chpid_show, NULL);
71
72static ssize_t
73qeth_dev_if_name_show(struct device *dev, char *buf)
74{
75 struct qeth_card *card = dev->driver_data;
76 if (!card)
77 return -EINVAL;
78 return sprintf(buf, "%s\n", QETH_CARD_IFNAME(card));
79}
80
81static DEVICE_ATTR(if_name, 0444, qeth_dev_if_name_show, NULL);
82
83static ssize_t
84qeth_dev_card_type_show(struct device *dev, char *buf)
85{
86 struct qeth_card *card = dev->driver_data;
87 if (!card)
88 return -EINVAL;
89
90 return sprintf(buf, "%s\n", qeth_get_cardname_short(card));
91}
92
93static DEVICE_ATTR(card_type, 0444, qeth_dev_card_type_show, NULL);
94
95static ssize_t
96qeth_dev_portno_show(struct device *dev, char *buf)
97{
98 struct qeth_card *card = dev->driver_data;
99 if (!card)
100 return -EINVAL;
101
102 return sprintf(buf, "%i\n", card->info.portno);
103}
104
105static ssize_t
106qeth_dev_portno_store(struct device *dev, const char *buf, size_t count)
107{
108 struct qeth_card *card = dev->driver_data;
109 char *tmp;
110 unsigned int portno;
111
112 if (!card)
113 return -EINVAL;
114
115 if ((card->state != CARD_STATE_DOWN) &&
116 (card->state != CARD_STATE_RECOVER))
117 return -EPERM;
118
119 portno = simple_strtoul(buf, &tmp, 16);
120 if ((portno < 0) || (portno > MAX_PORTNO)){
121 PRINT_WARN("portno 0x%X is out of range\n", portno);
122 return -EINVAL;
123 }
124
125 card->info.portno = portno;
126 return count;
127}
128
129static DEVICE_ATTR(portno, 0644, qeth_dev_portno_show, qeth_dev_portno_store);
130
131static ssize_t
132qeth_dev_portname_show(struct device *dev, char *buf)
133{
134 struct qeth_card *card = dev->driver_data;
135 char portname[9] = {0, };
136
137 if (!card)
138 return -EINVAL;
139
140 if (card->info.portname_required) {
141 memcpy(portname, card->info.portname + 1, 8);
142 EBCASC(portname, 8);
143 return sprintf(buf, "%s\n", portname);
144 } else
145 return sprintf(buf, "no portname required\n");
146}
147
148static ssize_t
149qeth_dev_portname_store(struct device *dev, const char *buf, size_t count)
150{
151 struct qeth_card *card = dev->driver_data;
152 char *tmp;
153 int i;
154
155 if (!card)
156 return -EINVAL;
157
158 if ((card->state != CARD_STATE_DOWN) &&
159 (card->state != CARD_STATE_RECOVER))
160 return -EPERM;
161
162 tmp = strsep((char **) &buf, "\n");
163 if ((strlen(tmp) > 8) || (strlen(tmp) < 2))
164 return -EINVAL;
165
166 card->info.portname[0] = strlen(tmp);
167 /* for beauty reasons */
168 for (i = 1; i < 9; i++)
169 card->info.portname[i] = ' ';
170 strcpy(card->info.portname + 1, tmp);
171 ASCEBC(card->info.portname + 1, 8);
172
173 return count;
174}
175
176static DEVICE_ATTR(portname, 0644, qeth_dev_portname_show,
177 qeth_dev_portname_store);
178
179static ssize_t
180qeth_dev_checksum_show(struct device *dev, char *buf)
181{
182 struct qeth_card *card = dev->driver_data;
183
184 if (!card)
185 return -EINVAL;
186
187 return sprintf(buf, "%s checksumming\n", qeth_get_checksum_str(card));
188}
189
190static ssize_t
191qeth_dev_checksum_store(struct device *dev, const char *buf, size_t count)
192{
193 struct qeth_card *card = dev->driver_data;
194 char *tmp;
195
196 if (!card)
197 return -EINVAL;
198
199 if ((card->state != CARD_STATE_DOWN) &&
200 (card->state != CARD_STATE_RECOVER))
201 return -EPERM;
202
203 tmp = strsep((char **) &buf, "\n");
204 if (!strcmp(tmp, "sw_checksumming"))
205 card->options.checksum_type = SW_CHECKSUMMING;
206 else if (!strcmp(tmp, "hw_checksumming"))
207 card->options.checksum_type = HW_CHECKSUMMING;
208 else if (!strcmp(tmp, "no_checksumming"))
209 card->options.checksum_type = NO_CHECKSUMMING;
210 else {
211 PRINT_WARN("Unknown checksumming type '%s'\n", tmp);
212 return -EINVAL;
213 }
214 return count;
215}
216
217static DEVICE_ATTR(checksumming, 0644, qeth_dev_checksum_show,
218 qeth_dev_checksum_store);
219
220static ssize_t
221qeth_dev_prioqing_show(struct device *dev, char *buf)
222{
223 struct qeth_card *card = dev->driver_data;
224
225 if (!card)
226 return -EINVAL;
227
228 switch (card->qdio.do_prio_queueing) {
229 case QETH_PRIO_Q_ING_PREC:
230 return sprintf(buf, "%s\n", "by precedence");
231 case QETH_PRIO_Q_ING_TOS:
232 return sprintf(buf, "%s\n", "by type of service");
233 default:
234 return sprintf(buf, "always queue %i\n",
235 card->qdio.default_out_queue);
236 }
237}
238
239static ssize_t
240qeth_dev_prioqing_store(struct device *dev, const char *buf, size_t count)
241{
242 struct qeth_card *card = dev->driver_data;
243 char *tmp;
244
245 if (!card)
246 return -EINVAL;
247
248 if ((card->state != CARD_STATE_DOWN) &&
249 (card->state != CARD_STATE_RECOVER))
250 return -EPERM;
251
252 /* check if 1920 devices are supported ,
253 * if though we have to permit priority queueing
254 */
255 if (card->qdio.no_out_queues == 1) {
256 PRINT_WARN("Priority queueing disabled due "
257 "to hardware limitations!\n");
258 card->qdio.do_prio_queueing = QETH_PRIOQ_DEFAULT;
259 return -EPERM;
260 }
261
262 tmp = strsep((char **) &buf, "\n");
263 if (!strcmp(tmp, "prio_queueing_prec"))
264 card->qdio.do_prio_queueing = QETH_PRIO_Q_ING_PREC;
265 else if (!strcmp(tmp, "prio_queueing_tos"))
266 card->qdio.do_prio_queueing = QETH_PRIO_Q_ING_TOS;
267 else if (!strcmp(tmp, "no_prio_queueing:0")) {
268 card->qdio.do_prio_queueing = QETH_NO_PRIO_QUEUEING;
269 card->qdio.default_out_queue = 0;
270 } else if (!strcmp(tmp, "no_prio_queueing:1")) {
271 card->qdio.do_prio_queueing = QETH_NO_PRIO_QUEUEING;
272 card->qdio.default_out_queue = 1;
273 } else if (!strcmp(tmp, "no_prio_queueing:2")) {
274 card->qdio.do_prio_queueing = QETH_NO_PRIO_QUEUEING;
275 card->qdio.default_out_queue = 2;
276 } else if (!strcmp(tmp, "no_prio_queueing:3")) {
277 card->qdio.do_prio_queueing = QETH_NO_PRIO_QUEUEING;
278 card->qdio.default_out_queue = 3;
279 } else if (!strcmp(tmp, "no_prio_queueing")) {
280 card->qdio.do_prio_queueing = QETH_NO_PRIO_QUEUEING;
281 card->qdio.default_out_queue = QETH_DEFAULT_QUEUE;
282 } else {
283 PRINT_WARN("Unknown queueing type '%s'\n", tmp);
284 return -EINVAL;
285 }
286 return count;
287}
288
289static DEVICE_ATTR(priority_queueing, 0644, qeth_dev_prioqing_show,
290 qeth_dev_prioqing_store);
291
292static ssize_t
293qeth_dev_bufcnt_show(struct device *dev, char *buf)
294{
295 struct qeth_card *card = dev->driver_data;
296
297 if (!card)
298 return -EINVAL;
299
300 return sprintf(buf, "%i\n", card->qdio.in_buf_pool.buf_count);
301}
302
303static ssize_t
304qeth_dev_bufcnt_store(struct device *dev, const char *buf, size_t count)
305{
306 struct qeth_card *card = dev->driver_data;
307 char *tmp;
308 int cnt, old_cnt;
309 int rc;
310
311 if (!card)
312 return -EINVAL;
313
314 if ((card->state != CARD_STATE_DOWN) &&
315 (card->state != CARD_STATE_RECOVER))
316 return -EPERM;
317
318 old_cnt = card->qdio.in_buf_pool.buf_count;
319 cnt = simple_strtoul(buf, &tmp, 10);
320 cnt = (cnt < QETH_IN_BUF_COUNT_MIN) ? QETH_IN_BUF_COUNT_MIN :
321 ((cnt > QETH_IN_BUF_COUNT_MAX) ? QETH_IN_BUF_COUNT_MAX : cnt);
322 if (old_cnt != cnt) {
323 if ((rc = qeth_realloc_buffer_pool(card, cnt)))
324 PRINT_WARN("Error (%d) while setting "
325 "buffer count.\n", rc);
326 }
327 return count;
328}
329
330static DEVICE_ATTR(buffer_count, 0644, qeth_dev_bufcnt_show,
331 qeth_dev_bufcnt_store);
332
333static inline ssize_t
334qeth_dev_route_show(struct qeth_card *card, struct qeth_routing_info *route,
335 char *buf)
336{
337 switch (route->type) {
338 case PRIMARY_ROUTER:
339 return sprintf(buf, "%s\n", "primary router");
340 case SECONDARY_ROUTER:
341 return sprintf(buf, "%s\n", "secondary router");
342 case MULTICAST_ROUTER:
343 if (card->info.broadcast_capable == QETH_BROADCAST_WITHOUT_ECHO)
344 return sprintf(buf, "%s\n", "multicast router+");
345 else
346 return sprintf(buf, "%s\n", "multicast router");
347 case PRIMARY_CONNECTOR:
348 if (card->info.broadcast_capable == QETH_BROADCAST_WITHOUT_ECHO)
349 return sprintf(buf, "%s\n", "primary connector+");
350 else
351 return sprintf(buf, "%s\n", "primary connector");
352 case SECONDARY_CONNECTOR:
353 if (card->info.broadcast_capable == QETH_BROADCAST_WITHOUT_ECHO)
354 return sprintf(buf, "%s\n", "secondary connector+");
355 else
356 return sprintf(buf, "%s\n", "secondary connector");
357 default:
358 return sprintf(buf, "%s\n", "no");
359 }
360}
361
362static ssize_t
363qeth_dev_route4_show(struct device *dev, char *buf)
364{
365 struct qeth_card *card = dev->driver_data;
366
367 if (!card)
368 return -EINVAL;
369
370 return qeth_dev_route_show(card, &card->options.route4, buf);
371}
372
373static inline ssize_t
374qeth_dev_route_store(struct qeth_card *card, struct qeth_routing_info *route,
375 enum qeth_prot_versions prot, const char *buf, size_t count)
376{
377 enum qeth_routing_types old_route_type = route->type;
378 char *tmp;
379 int rc;
380
381 tmp = strsep((char **) &buf, "\n");
382
383 if (!strcmp(tmp, "no_router")){
384 route->type = NO_ROUTER;
385 } else if (!strcmp(tmp, "primary_connector")) {
386 route->type = PRIMARY_CONNECTOR;
387 } else if (!strcmp(tmp, "secondary_connector")) {
388 route->type = SECONDARY_CONNECTOR;
389 } else if (!strcmp(tmp, "multicast_router")) {
390 route->type = MULTICAST_ROUTER;
391 } else if (!strcmp(tmp, "primary_router")) {
392 route->type = PRIMARY_ROUTER;
393 } else if (!strcmp(tmp, "secondary_router")) {
394 route->type = SECONDARY_ROUTER;
395 } else if (!strcmp(tmp, "multicast_router")) {
396 route->type = MULTICAST_ROUTER;
397 } else {
398 PRINT_WARN("Invalid routing type '%s'.\n", tmp);
399 return -EINVAL;
400 }
401 if (((card->state == CARD_STATE_SOFTSETUP) ||
402 (card->state == CARD_STATE_UP)) &&
403 (old_route_type != route->type)){
404 if (prot == QETH_PROT_IPV4)
405 rc = qeth_setrouting_v4(card);
406 else if (prot == QETH_PROT_IPV6)
407 rc = qeth_setrouting_v6(card);
408 }
409 return count;
410}
411
412static ssize_t
413qeth_dev_route4_store(struct device *dev, const char *buf, size_t count)
414{
415 struct qeth_card *card = dev->driver_data;
416
417 if (!card)
418 return -EINVAL;
419
420 return qeth_dev_route_store(card, &card->options.route4,
421 QETH_PROT_IPV4, buf, count);
422}
423
424static DEVICE_ATTR(route4, 0644, qeth_dev_route4_show, qeth_dev_route4_store);
425
426#ifdef CONFIG_QETH_IPV6
427static ssize_t
428qeth_dev_route6_show(struct device *dev, char *buf)
429{
430 struct qeth_card *card = dev->driver_data;
431
432 if (!card)
433 return -EINVAL;
434
435 if (!qeth_is_supported(card, IPA_IPV6))
436 return sprintf(buf, "%s\n", "n/a");
437
438 return qeth_dev_route_show(card, &card->options.route6, buf);
439}
440
441static ssize_t
442qeth_dev_route6_store(struct device *dev, const char *buf, size_t count)
443{
444 struct qeth_card *card = dev->driver_data;
445
446 if (!card)
447 return -EINVAL;
448
449 if (!qeth_is_supported(card, IPA_IPV6)){
450 PRINT_WARN("IPv6 not supported for interface %s.\n"
451 "Routing status no changed.\n",
452 QETH_CARD_IFNAME(card));
453 return -ENOTSUPP;
454 }
455
456 return qeth_dev_route_store(card, &card->options.route6,
457 QETH_PROT_IPV6, buf, count);
458}
459
460static DEVICE_ATTR(route6, 0644, qeth_dev_route6_show, qeth_dev_route6_store);
461#endif
462
463static ssize_t
464qeth_dev_add_hhlen_show(struct device *dev, char *buf)
465{
466 struct qeth_card *card = dev->driver_data;
467
468 if (!card)
469 return -EINVAL;
470
471 return sprintf(buf, "%i\n", card->options.add_hhlen);
472}
473
474static ssize_t
475qeth_dev_add_hhlen_store(struct device *dev, const char *buf, size_t count)
476{
477 struct qeth_card *card = dev->driver_data;
478 char *tmp;
479 int i;
480
481 if (!card)
482 return -EINVAL;
483
484 if ((card->state != CARD_STATE_DOWN) &&
485 (card->state != CARD_STATE_RECOVER))
486 return -EPERM;
487
488 i = simple_strtoul(buf, &tmp, 10);
489 if ((i < 0) || (i > MAX_ADD_HHLEN)) {
490 PRINT_WARN("add_hhlen out of range\n");
491 return -EINVAL;
492 }
493 card->options.add_hhlen = i;
494
495 return count;
496}
497
498static DEVICE_ATTR(add_hhlen, 0644, qeth_dev_add_hhlen_show,
499 qeth_dev_add_hhlen_store);
500
501static ssize_t
502qeth_dev_fake_ll_show(struct device *dev, char *buf)
503{
504 struct qeth_card *card = dev->driver_data;
505
506 if (!card)
507 return -EINVAL;
508
509 return sprintf(buf, "%i\n", card->options.fake_ll? 1:0);
510}
511
512static ssize_t
513qeth_dev_fake_ll_store(struct device *dev, const char *buf, size_t count)
514{
515 struct qeth_card *card = dev->driver_data;
516 char *tmp;
517 int i;
518
519 if (!card)
520 return -EINVAL;
521
522 if ((card->state != CARD_STATE_DOWN) &&
523 (card->state != CARD_STATE_RECOVER))
524 return -EPERM;
525
526 i = simple_strtoul(buf, &tmp, 16);
527 if ((i != 0) && (i != 1)) {
528 PRINT_WARN("fake_ll: write 0 or 1 to this file!\n");
529 return -EINVAL;
530 }
531 card->options.fake_ll = i;
532 return count;
533}
534
535static DEVICE_ATTR(fake_ll, 0644, qeth_dev_fake_ll_show,
536 qeth_dev_fake_ll_store);
537
538static ssize_t
539qeth_dev_fake_broadcast_show(struct device *dev, char *buf)
540{
541 struct qeth_card *card = dev->driver_data;
542
543 if (!card)
544 return -EINVAL;
545
546 return sprintf(buf, "%i\n", card->options.fake_broadcast? 1:0);
547}
548
549static ssize_t
550qeth_dev_fake_broadcast_store(struct device *dev, const char *buf, size_t count)
551{
552 struct qeth_card *card = dev->driver_data;
553 char *tmp;
554 int i;
555
556 if (!card)
557 return -EINVAL;
558
559 if ((card->state != CARD_STATE_DOWN) &&
560 (card->state != CARD_STATE_RECOVER))
561 return -EPERM;
562
563 i = simple_strtoul(buf, &tmp, 16);
564 if ((i == 0) || (i == 1))
565 card->options.fake_broadcast = i;
566 else {
567 PRINT_WARN("fake_broadcast: write 0 or 1 to this file!\n");
568 return -EINVAL;
569 }
570 return count;
571}
572
573static DEVICE_ATTR(fake_broadcast, 0644, qeth_dev_fake_broadcast_show,
574 qeth_dev_fake_broadcast_store);
575
576static ssize_t
577qeth_dev_recover_store(struct device *dev, const char *buf, size_t count)
578{
579 struct qeth_card *card = dev->driver_data;
580 char *tmp;
581 int i;
582
583 if (!card)
584 return -EINVAL;
585
586 if (card->state != CARD_STATE_UP)
587 return -EPERM;
588
589 i = simple_strtoul(buf, &tmp, 16);
590 if (i == 1)
591 qeth_schedule_recovery(card);
592
593 return count;
594}
595
596static DEVICE_ATTR(recover, 0200, NULL, qeth_dev_recover_store);
597
598static ssize_t
599qeth_dev_broadcast_mode_show(struct device *dev, char *buf)
600{
601 struct qeth_card *card = dev->driver_data;
602
603 if (!card)
604 return -EINVAL;
605
606 if (!((card->info.link_type == QETH_LINK_TYPE_HSTR) ||
607 (card->info.link_type == QETH_LINK_TYPE_LANE_TR)))
608 return sprintf(buf, "n/a\n");
609
610 return sprintf(buf, "%s\n", (card->options.broadcast_mode ==
611 QETH_TR_BROADCAST_ALLRINGS)?
612 "all rings":"local");
613}
614
615static ssize_t
616qeth_dev_broadcast_mode_store(struct device *dev, const char *buf, size_t count)
617{
618 struct qeth_card *card = dev->driver_data;
619 char *tmp;
620
621 if (!card)
622 return -EINVAL;
623
624 if ((card->state != CARD_STATE_DOWN) &&
625 (card->state != CARD_STATE_RECOVER))
626 return -EPERM;
627
628 if (!((card->info.link_type == QETH_LINK_TYPE_HSTR) ||
629 (card->info.link_type == QETH_LINK_TYPE_LANE_TR))){
630 PRINT_WARN("Device is not a tokenring device!\n");
631 return -EINVAL;
632 }
633
634 tmp = strsep((char **) &buf, "\n");
635
636 if (!strcmp(tmp, "local")){
637 card->options.broadcast_mode = QETH_TR_BROADCAST_LOCAL;
638 return count;
639 } else if (!strcmp(tmp, "all_rings")) {
640 card->options.broadcast_mode = QETH_TR_BROADCAST_ALLRINGS;
641 return count;
642 } else {
643 PRINT_WARN("broadcast_mode: invalid mode %s!\n",
644 tmp);
645 return -EINVAL;
646 }
647 return count;
648}
649
650static DEVICE_ATTR(broadcast_mode, 0644, qeth_dev_broadcast_mode_show,
651 qeth_dev_broadcast_mode_store);
652
653static ssize_t
654qeth_dev_canonical_macaddr_show(struct device *dev, char *buf)
655{
656 struct qeth_card *card = dev->driver_data;
657
658 if (!card)
659 return -EINVAL;
660
661 if (!((card->info.link_type == QETH_LINK_TYPE_HSTR) ||
662 (card->info.link_type == QETH_LINK_TYPE_LANE_TR)))
663 return sprintf(buf, "n/a\n");
664
665 return sprintf(buf, "%i\n", (card->options.macaddr_mode ==
666 QETH_TR_MACADDR_CANONICAL)? 1:0);
667}
668
669static ssize_t
670qeth_dev_canonical_macaddr_store(struct device *dev, const char *buf,
671 size_t count)
672{
673 struct qeth_card *card = dev->driver_data;
674 char *tmp;
675 int i;
676
677 if (!card)
678 return -EINVAL;
679
680 if ((card->state != CARD_STATE_DOWN) &&
681 (card->state != CARD_STATE_RECOVER))
682 return -EPERM;
683
684 if (!((card->info.link_type == QETH_LINK_TYPE_HSTR) ||
685 (card->info.link_type == QETH_LINK_TYPE_LANE_TR))){
686 PRINT_WARN("Device is not a tokenring device!\n");
687 return -EINVAL;
688 }
689
690 i = simple_strtoul(buf, &tmp, 16);
691 if ((i == 0) || (i == 1))
692 card->options.macaddr_mode = i?
693 QETH_TR_MACADDR_CANONICAL :
694 QETH_TR_MACADDR_NONCANONICAL;
695 else {
696 PRINT_WARN("canonical_macaddr: write 0 or 1 to this file!\n");
697 return -EINVAL;
698 }
699 return count;
700}
701
702static DEVICE_ATTR(canonical_macaddr, 0644, qeth_dev_canonical_macaddr_show,
703 qeth_dev_canonical_macaddr_store);
704
705static ssize_t
706qeth_dev_layer2_show(struct device *dev, char *buf)
707{
708 struct qeth_card *card = dev->driver_data;
709
710 if (!card)
711 return -EINVAL;
712
713 return sprintf(buf, "%i\n", card->options.layer2 ? 1:0);
714}
715
716static ssize_t
717qeth_dev_layer2_store(struct device *dev, const char *buf, size_t count)
718{
719 struct qeth_card *card = dev->driver_data;
720 char *tmp;
721 int i;
722
723 if (!card)
724 return -EINVAL;
725
726 if (((card->state != CARD_STATE_DOWN) &&
727 (card->state != CARD_STATE_RECOVER)) ||
728 (card->info.type != QETH_CARD_TYPE_OSAE))
729 return -EPERM;
730
731 i = simple_strtoul(buf, &tmp, 16);
732 if ((i == 0) || (i == 1))
733 card->options.layer2 = i;
734 else {
735 PRINT_WARN("layer2: write 0 or 1 to this file!\n");
736 return -EINVAL;
737 }
738 return count;
739}
740
741static DEVICE_ATTR(layer2, 0644, qeth_dev_layer2_show,
742 qeth_dev_layer2_store);
743
744static ssize_t
745qeth_dev_large_send_show(struct device *dev, char *buf)
746{
747 struct qeth_card *card = dev->driver_data;
748
749 if (!card)
750 return -EINVAL;
751
752 switch (card->options.large_send) {
753 case QETH_LARGE_SEND_NO:
754 return sprintf(buf, "%s\n", "no");
755 case QETH_LARGE_SEND_EDDP:
756 return sprintf(buf, "%s\n", "EDDP");
757 case QETH_LARGE_SEND_TSO:
758 return sprintf(buf, "%s\n", "TSO");
759 default:
760 return sprintf(buf, "%s\n", "N/A");
761 }
762}
763
764static ssize_t
765qeth_dev_large_send_store(struct device *dev, const char *buf, size_t count)
766{
767 struct qeth_card *card = dev->driver_data;
768 enum qeth_large_send_types type;
769 int rc = 0;
770 char *tmp;
771
772 if (!card)
773 return -EINVAL;
774
775 tmp = strsep((char **) &buf, "\n");
776
777 if (!strcmp(tmp, "no")){
778 type = QETH_LARGE_SEND_NO;
779 } else if (!strcmp(tmp, "EDDP")) {
780 type = QETH_LARGE_SEND_EDDP;
781 } else if (!strcmp(tmp, "TSO")) {
782 type = QETH_LARGE_SEND_TSO;
783 } else {
784 PRINT_WARN("large_send: invalid mode %s!\n", tmp);
785 return -EINVAL;
786 }
787 if (card->options.large_send == type)
788 return count;
789 card->options.large_send = type;
790 if ((rc = qeth_set_large_send(card)))
791 return rc;
792
793 return count;
794}
795
796static DEVICE_ATTR(large_send, 0644, qeth_dev_large_send_show,
797 qeth_dev_large_send_store);
798
799static ssize_t
800qeth_dev_blkt_show(char *buf, struct qeth_card *card, int value )
801{
802
803 if (!card)
804 return -EINVAL;
805
806 return sprintf(buf, "%i\n", value);
807}
808
809static ssize_t
810qeth_dev_blkt_store(struct qeth_card *card, const char *buf, size_t count,
811 int *value, int max_value)
812{
813 char *tmp;
814 int i;
815
816 if (!card)
817 return -EINVAL;
818
819 if ((card->state != CARD_STATE_DOWN) &&
820 (card->state != CARD_STATE_RECOVER))
821 return -EPERM;
822
823 i = simple_strtoul(buf, &tmp, 10);
824 if (i <= max_value) {
825 *value = i;
826 } else {
827 PRINT_WARN("blkt total time: write values between"
828 " 0 and %d to this file!\n", max_value);
829 return -EINVAL;
830 }
831 return count;
832}
833
834static ssize_t
835qeth_dev_blkt_total_show(struct device *dev, char *buf)
836{
837 struct qeth_card *card = dev->driver_data;
838
839 return qeth_dev_blkt_show(buf, card, card->info.blkt.time_total);
840}
841
842
843static ssize_t
844qeth_dev_blkt_total_store(struct device *dev, const char *buf, size_t count)
845{
846 struct qeth_card *card = dev->driver_data;
847
848 return qeth_dev_blkt_store(card, buf, count,
849 &card->info.blkt.time_total,1000);
850}
851
852
853
854static DEVICE_ATTR(total, 0644, qeth_dev_blkt_total_show,
855 qeth_dev_blkt_total_store);
856
857static ssize_t
858qeth_dev_blkt_inter_show(struct device *dev, char *buf)
859{
860 struct qeth_card *card = dev->driver_data;
861
862 return qeth_dev_blkt_show(buf, card, card->info.blkt.inter_packet);
863}
864
865
866static ssize_t
867qeth_dev_blkt_inter_store(struct device *dev, const char *buf, size_t count)
868{
869 struct qeth_card *card = dev->driver_data;
870
871 return qeth_dev_blkt_store(card, buf, count,
872 &card->info.blkt.inter_packet,100);
873}
874
875static DEVICE_ATTR(inter, 0644, qeth_dev_blkt_inter_show,
876 qeth_dev_blkt_inter_store);
877
878static ssize_t
879qeth_dev_blkt_inter_jumbo_show(struct device *dev, char *buf)
880{
881 struct qeth_card *card = dev->driver_data;
882
883 return qeth_dev_blkt_show(buf, card,
884 card->info.blkt.inter_packet_jumbo);
885}
886
887
888static ssize_t
889qeth_dev_blkt_inter_jumbo_store(struct device *dev, const char *buf, size_t count)
890{
891 struct qeth_card *card = dev->driver_data;
892
893 return qeth_dev_blkt_store(card, buf, count,
894 &card->info.blkt.inter_packet_jumbo,100);
895}
896
897static DEVICE_ATTR(inter_jumbo, 0644, qeth_dev_blkt_inter_jumbo_show,
898 qeth_dev_blkt_inter_jumbo_store);
899
900static struct device_attribute * qeth_blkt_device_attrs[] = {
901 &dev_attr_total,
902 &dev_attr_inter,
903 &dev_attr_inter_jumbo,
904 NULL,
905};
906
907static struct attribute_group qeth_device_blkt_group = {
908 .name = "blkt",
909 .attrs = (struct attribute **)qeth_blkt_device_attrs,
910};
911
912static struct device_attribute * qeth_device_attrs[] = {
913 &dev_attr_state,
914 &dev_attr_chpid,
915 &dev_attr_if_name,
916 &dev_attr_card_type,
917 &dev_attr_portno,
918 &dev_attr_portname,
919 &dev_attr_checksumming,
920 &dev_attr_priority_queueing,
921 &dev_attr_buffer_count,
922 &dev_attr_route4,
923#ifdef CONFIG_QETH_IPV6
924 &dev_attr_route6,
925#endif
926 &dev_attr_add_hhlen,
927 &dev_attr_fake_ll,
928 &dev_attr_fake_broadcast,
929 &dev_attr_recover,
930 &dev_attr_broadcast_mode,
931 &dev_attr_canonical_macaddr,
932 &dev_attr_layer2,
933 &dev_attr_large_send,
934 NULL,
935};
936
937static struct attribute_group qeth_device_attr_group = {
938 .attrs = (struct attribute **)qeth_device_attrs,
939};
940
941
942#define QETH_DEVICE_ATTR(_id,_name,_mode,_show,_store) \
943struct device_attribute dev_attr_##_id = { \
944 .attr = {.name=__stringify(_name), .mode=_mode, .owner=THIS_MODULE },\
945 .show = _show, \
946 .store = _store, \
947};
948
949int
950qeth_check_layer2(struct qeth_card *card)
951{
952 if (card->options.layer2)
953 return -EPERM;
954 return 0;
955}
956
957
958static ssize_t
959qeth_dev_ipato_enable_show(struct device *dev, char *buf)
960{
961 struct qeth_card *card = dev->driver_data;
962
963 if (!card)
964 return -EINVAL;
965
966 if (qeth_check_layer2(card))
967 return -EPERM;
968 return sprintf(buf, "%i\n", card->ipato.enabled? 1:0);
969}
970
971static ssize_t
972qeth_dev_ipato_enable_store(struct device *dev, const char *buf, size_t count)
973{
974 struct qeth_card *card = dev->driver_data;
975 char *tmp;
976
977 if (!card)
978 return -EINVAL;
979
980 if ((card->state != CARD_STATE_DOWN) &&
981 (card->state != CARD_STATE_RECOVER))
982 return -EPERM;
983
984 if (qeth_check_layer2(card))
985 return -EPERM;
986
987 tmp = strsep((char **) &buf, "\n");
988 if (!strcmp(tmp, "toggle")){
989 card->ipato.enabled = (card->ipato.enabled)? 0 : 1;
990 } else if (!strcmp(tmp, "1")){
991 card->ipato.enabled = 1;
992 } else if (!strcmp(tmp, "0")){
993 card->ipato.enabled = 0;
994 } else {
995 PRINT_WARN("ipato_enable: write 0, 1 or 'toggle' to "
996 "this file\n");
997 return -EINVAL;
998 }
999 return count;
1000}
1001
1002static QETH_DEVICE_ATTR(ipato_enable, enable, 0644,
1003 qeth_dev_ipato_enable_show,
1004 qeth_dev_ipato_enable_store);
1005
1006static ssize_t
1007qeth_dev_ipato_invert4_show(struct device *dev, char *buf)
1008{
1009 struct qeth_card *card = dev->driver_data;
1010
1011 if (!card)
1012 return -EINVAL;
1013
1014 if (qeth_check_layer2(card))
1015 return -EPERM;
1016
1017 return sprintf(buf, "%i\n", card->ipato.invert4? 1:0);
1018}
1019
1020static ssize_t
1021qeth_dev_ipato_invert4_store(struct device *dev, const char *buf, size_t count)
1022{
1023 struct qeth_card *card = dev->driver_data;
1024 char *tmp;
1025
1026 if (!card)
1027 return -EINVAL;
1028
1029 if (qeth_check_layer2(card))
1030 return -EPERM;
1031
1032 tmp = strsep((char **) &buf, "\n");
1033 if (!strcmp(tmp, "toggle")){
1034 card->ipato.invert4 = (card->ipato.invert4)? 0 : 1;
1035 } else if (!strcmp(tmp, "1")){
1036 card->ipato.invert4 = 1;
1037 } else if (!strcmp(tmp, "0")){
1038 card->ipato.invert4 = 0;
1039 } else {
1040 PRINT_WARN("ipato_invert4: write 0, 1 or 'toggle' to "
1041 "this file\n");
1042 return -EINVAL;
1043 }
1044 return count;
1045}
1046
1047static QETH_DEVICE_ATTR(ipato_invert4, invert4, 0644,
1048 qeth_dev_ipato_invert4_show,
1049 qeth_dev_ipato_invert4_store);
1050
1051static inline ssize_t
1052qeth_dev_ipato_add_show(char *buf, struct qeth_card *card,
1053 enum qeth_prot_versions proto)
1054{
1055 struct qeth_ipato_entry *ipatoe;
1056 unsigned long flags;
1057 char addr_str[40];
1058 int entry_len; /* length of 1 entry string, differs between v4 and v6 */
1059 int i = 0;
1060
1061 if (qeth_check_layer2(card))
1062 return -EPERM;
1063
1064 entry_len = (proto == QETH_PROT_IPV4)? 12 : 40;
1065 /* add strlen for "/<mask>\n" */
1066 entry_len += (proto == QETH_PROT_IPV4)? 5 : 6;
1067 spin_lock_irqsave(&card->ip_lock, flags);
1068 list_for_each_entry(ipatoe, &card->ipato.entries, entry){
1069 if (ipatoe->proto != proto)
1070 continue;
1071 /* String must not be longer than PAGE_SIZE. So we check if
1072 * string length gets near PAGE_SIZE. Then we can savely display
1073 * the next IPv6 address (worst case, compared to IPv4) */
1074 if ((PAGE_SIZE - i) <= entry_len)
1075 break;
1076 qeth_ipaddr_to_string(proto, ipatoe->addr, addr_str);
1077 i += snprintf(buf + i, PAGE_SIZE - i,
1078 "%s/%i\n", addr_str, ipatoe->mask_bits);
1079 }
1080 spin_unlock_irqrestore(&card->ip_lock, flags);
1081 i += snprintf(buf + i, PAGE_SIZE - i, "\n");
1082
1083 return i;
1084}
1085
1086static ssize_t
1087qeth_dev_ipato_add4_show(struct device *dev, char *buf)
1088{
1089 struct qeth_card *card = dev->driver_data;
1090
1091 if (!card)
1092 return -EINVAL;
1093
1094 return qeth_dev_ipato_add_show(buf, card, QETH_PROT_IPV4);
1095}
1096
1097static inline int
1098qeth_parse_ipatoe(const char* buf, enum qeth_prot_versions proto,
1099 u8 *addr, int *mask_bits)
1100{
1101 const char *start, *end;
1102 char *tmp;
1103 char buffer[49] = {0, };
1104
1105 start = buf;
1106 /* get address string */
1107 end = strchr(start, '/');
1108 if (!end){
1109 PRINT_WARN("Invalid format for ipato_addx/delx. "
1110 "Use <ip addr>/<mask bits>\n");
1111 return -EINVAL;
1112 }
1113 strncpy(buffer, start, end - start);
1114 if (qeth_string_to_ipaddr(buffer, proto, addr)){
1115 PRINT_WARN("Invalid IP address format!\n");
1116 return -EINVAL;
1117 }
1118 start = end + 1;
1119 *mask_bits = simple_strtoul(start, &tmp, 10);
1120
1121 return 0;
1122}
1123
1124static inline ssize_t
1125qeth_dev_ipato_add_store(const char *buf, size_t count,
1126 struct qeth_card *card, enum qeth_prot_versions proto)
1127{
1128 struct qeth_ipato_entry *ipatoe;
1129 u8 addr[16];
1130 int mask_bits;
1131 int rc;
1132
1133 if (qeth_check_layer2(card))
1134 return -EPERM;
1135 if ((rc = qeth_parse_ipatoe(buf, proto, addr, &mask_bits)))
1136 return rc;
1137
1138 if (!(ipatoe = kmalloc(sizeof(struct qeth_ipato_entry), GFP_KERNEL))){
1139 PRINT_WARN("No memory to allocate ipato entry\n");
1140 return -ENOMEM;
1141 }
1142 memset(ipatoe, 0, sizeof(struct qeth_ipato_entry));
1143 ipatoe->proto = proto;
1144 memcpy(ipatoe->addr, addr, (proto == QETH_PROT_IPV4)? 4:16);
1145 ipatoe->mask_bits = mask_bits;
1146
1147 if ((rc = qeth_add_ipato_entry(card, ipatoe))){
1148 kfree(ipatoe);
1149 return rc;
1150 }
1151
1152 return count;
1153}
1154
1155static ssize_t
1156qeth_dev_ipato_add4_store(struct device *dev, const char *buf, size_t count)
1157{
1158 struct qeth_card *card = dev->driver_data;
1159
1160 if (!card)
1161 return -EINVAL;
1162
1163 return qeth_dev_ipato_add_store(buf, count, card, QETH_PROT_IPV4);
1164}
1165
1166static QETH_DEVICE_ATTR(ipato_add4, add4, 0644,
1167 qeth_dev_ipato_add4_show,
1168 qeth_dev_ipato_add4_store);
1169
1170static inline ssize_t
1171qeth_dev_ipato_del_store(const char *buf, size_t count,
1172 struct qeth_card *card, enum qeth_prot_versions proto)
1173{
1174 u8 addr[16];
1175 int mask_bits;
1176 int rc;
1177
1178 if (qeth_check_layer2(card))
1179 return -EPERM;
1180 if ((rc = qeth_parse_ipatoe(buf, proto, addr, &mask_bits)))
1181 return rc;
1182
1183 qeth_del_ipato_entry(card, proto, addr, mask_bits);
1184
1185 return count;
1186}
1187
1188static ssize_t
1189qeth_dev_ipato_del4_store(struct device *dev, const char *buf, size_t count)
1190{
1191 struct qeth_card *card = dev->driver_data;
1192
1193 if (!card)
1194 return -EINVAL;
1195
1196 return qeth_dev_ipato_del_store(buf, count, card, QETH_PROT_IPV4);
1197}
1198
1199static QETH_DEVICE_ATTR(ipato_del4, del4, 0200, NULL,
1200 qeth_dev_ipato_del4_store);
1201
1202#ifdef CONFIG_QETH_IPV6
1203static ssize_t
1204qeth_dev_ipato_invert6_show(struct device *dev, char *buf)
1205{
1206 struct qeth_card *card = dev->driver_data;
1207
1208 if (!card)
1209 return -EINVAL;
1210
1211 if (qeth_check_layer2(card))
1212 return -EPERM;
1213
1214 return sprintf(buf, "%i\n", card->ipato.invert6? 1:0);
1215}
1216
1217static ssize_t
1218qeth_dev_ipato_invert6_store(struct device *dev, const char *buf, size_t count)
1219{
1220 struct qeth_card *card = dev->driver_data;
1221 char *tmp;
1222
1223 if (!card)
1224 return -EINVAL;
1225
1226 if (qeth_check_layer2(card))
1227 return -EPERM;
1228
1229 tmp = strsep((char **) &buf, "\n");
1230 if (!strcmp(tmp, "toggle")){
1231 card->ipato.invert6 = (card->ipato.invert6)? 0 : 1;
1232 } else if (!strcmp(tmp, "1")){
1233 card->ipato.invert6 = 1;
1234 } else if (!strcmp(tmp, "0")){
1235 card->ipato.invert6 = 0;
1236 } else {
1237 PRINT_WARN("ipato_invert6: write 0, 1 or 'toggle' to "
1238 "this file\n");
1239 return -EINVAL;
1240 }
1241 return count;
1242}
1243
1244static QETH_DEVICE_ATTR(ipato_invert6, invert6, 0644,
1245 qeth_dev_ipato_invert6_show,
1246 qeth_dev_ipato_invert6_store);
1247
1248
1249static ssize_t
1250qeth_dev_ipato_add6_show(struct device *dev, char *buf)
1251{
1252 struct qeth_card *card = dev->driver_data;
1253
1254 if (!card)
1255 return -EINVAL;
1256
1257 return qeth_dev_ipato_add_show(buf, card, QETH_PROT_IPV6);
1258}
1259
1260static ssize_t
1261qeth_dev_ipato_add6_store(struct device *dev, const char *buf, size_t count)
1262{
1263 struct qeth_card *card = dev->driver_data;
1264
1265 if (!card)
1266 return -EINVAL;
1267
1268 return qeth_dev_ipato_add_store(buf, count, card, QETH_PROT_IPV6);
1269}
1270
1271static QETH_DEVICE_ATTR(ipato_add6, add6, 0644,
1272 qeth_dev_ipato_add6_show,
1273 qeth_dev_ipato_add6_store);
1274
1275static ssize_t
1276qeth_dev_ipato_del6_store(struct device *dev, const char *buf, size_t count)
1277{
1278 struct qeth_card *card = dev->driver_data;
1279
1280 if (!card)
1281 return -EINVAL;
1282
1283 return qeth_dev_ipato_del_store(buf, count, card, QETH_PROT_IPV6);
1284}
1285
1286static QETH_DEVICE_ATTR(ipato_del6, del6, 0200, NULL,
1287 qeth_dev_ipato_del6_store);
1288#endif /* CONFIG_QETH_IPV6 */
1289
1290static struct device_attribute * qeth_ipato_device_attrs[] = {
1291 &dev_attr_ipato_enable,
1292 &dev_attr_ipato_invert4,
1293 &dev_attr_ipato_add4,
1294 &dev_attr_ipato_del4,
1295#ifdef CONFIG_QETH_IPV6
1296 &dev_attr_ipato_invert6,
1297 &dev_attr_ipato_add6,
1298 &dev_attr_ipato_del6,
1299#endif
1300 NULL,
1301};
1302
1303static struct attribute_group qeth_device_ipato_group = {
1304 .name = "ipa_takeover",
1305 .attrs = (struct attribute **)qeth_ipato_device_attrs,
1306};
1307
1308static inline ssize_t
1309qeth_dev_vipa_add_show(char *buf, struct qeth_card *card,
1310 enum qeth_prot_versions proto)
1311{
1312 struct qeth_ipaddr *ipaddr;
1313 char addr_str[40];
1314 int entry_len; /* length of 1 entry string, differs between v4 and v6 */
1315 unsigned long flags;
1316 int i = 0;
1317
1318 if (qeth_check_layer2(card))
1319 return -EPERM;
1320
1321 entry_len = (proto == QETH_PROT_IPV4)? 12 : 40;
1322 entry_len += 2; /* \n + terminator */
1323 spin_lock_irqsave(&card->ip_lock, flags);
1324 list_for_each_entry(ipaddr, &card->ip_list, entry){
1325 if (ipaddr->proto != proto)
1326 continue;
1327 if (ipaddr->type != QETH_IP_TYPE_VIPA)
1328 continue;
1329 /* String must not be longer than PAGE_SIZE. So we check if
1330 * string length gets near PAGE_SIZE. Then we can savely display
1331 * the next IPv6 address (worst case, compared to IPv4) */
1332 if ((PAGE_SIZE - i) <= entry_len)
1333 break;
1334 qeth_ipaddr_to_string(proto, (const u8 *)&ipaddr->u, addr_str);
1335 i += snprintf(buf + i, PAGE_SIZE - i, "%s\n", addr_str);
1336 }
1337 spin_unlock_irqrestore(&card->ip_lock, flags);
1338 i += snprintf(buf + i, PAGE_SIZE - i, "\n");
1339
1340 return i;
1341}
1342
1343static ssize_t
1344qeth_dev_vipa_add4_show(struct device *dev, char *buf)
1345{
1346 struct qeth_card *card = dev->driver_data;
1347
1348 if (!card)
1349 return -EINVAL;
1350
1351 return qeth_dev_vipa_add_show(buf, card, QETH_PROT_IPV4);
1352}
1353
1354static inline int
1355qeth_parse_vipae(const char* buf, enum qeth_prot_versions proto,
1356 u8 *addr)
1357{
1358 if (qeth_string_to_ipaddr(buf, proto, addr)){
1359 PRINT_WARN("Invalid IP address format!\n");
1360 return -EINVAL;
1361 }
1362 return 0;
1363}
1364
1365static inline ssize_t
1366qeth_dev_vipa_add_store(const char *buf, size_t count,
1367 struct qeth_card *card, enum qeth_prot_versions proto)
1368{
1369 u8 addr[16] = {0, };
1370 int rc;
1371
1372 if (qeth_check_layer2(card))
1373 return -EPERM;
1374 if ((rc = qeth_parse_vipae(buf, proto, addr)))
1375 return rc;
1376
1377 if ((rc = qeth_add_vipa(card, proto, addr)))
1378 return rc;
1379
1380 return count;
1381}
1382
1383static ssize_t
1384qeth_dev_vipa_add4_store(struct device *dev, const char *buf, size_t count)
1385{
1386 struct qeth_card *card = dev->driver_data;
1387
1388 if (!card)
1389 return -EINVAL;
1390
1391 return qeth_dev_vipa_add_store(buf, count, card, QETH_PROT_IPV4);
1392}
1393
1394static QETH_DEVICE_ATTR(vipa_add4, add4, 0644,
1395 qeth_dev_vipa_add4_show,
1396 qeth_dev_vipa_add4_store);
1397
1398static inline ssize_t
1399qeth_dev_vipa_del_store(const char *buf, size_t count,
1400 struct qeth_card *card, enum qeth_prot_versions proto)
1401{
1402 u8 addr[16];
1403 int rc;
1404
1405 if (qeth_check_layer2(card))
1406 return -EPERM;
1407 if ((rc = qeth_parse_vipae(buf, proto, addr)))
1408 return rc;
1409
1410 qeth_del_vipa(card, proto, addr);
1411
1412 return count;
1413}
1414
1415static ssize_t
1416qeth_dev_vipa_del4_store(struct device *dev, const char *buf, size_t count)
1417{
1418 struct qeth_card *card = dev->driver_data;
1419
1420 if (!card)
1421 return -EINVAL;
1422
1423 return qeth_dev_vipa_del_store(buf, count, card, QETH_PROT_IPV4);
1424}
1425
1426static QETH_DEVICE_ATTR(vipa_del4, del4, 0200, NULL,
1427 qeth_dev_vipa_del4_store);
1428
1429#ifdef CONFIG_QETH_IPV6
1430static ssize_t
1431qeth_dev_vipa_add6_show(struct device *dev, char *buf)
1432{
1433 struct qeth_card *card = dev->driver_data;
1434
1435 if (!card)
1436 return -EINVAL;
1437
1438 return qeth_dev_vipa_add_show(buf, card, QETH_PROT_IPV6);
1439}
1440
1441static ssize_t
1442qeth_dev_vipa_add6_store(struct device *dev, const char *buf, size_t count)
1443{
1444 struct qeth_card *card = dev->driver_data;
1445
1446 if (!card)
1447 return -EINVAL;
1448
1449 return qeth_dev_vipa_add_store(buf, count, card, QETH_PROT_IPV6);
1450}
1451
1452static QETH_DEVICE_ATTR(vipa_add6, add6, 0644,
1453 qeth_dev_vipa_add6_show,
1454 qeth_dev_vipa_add6_store);
1455
1456static ssize_t
1457qeth_dev_vipa_del6_store(struct device *dev, const char *buf, size_t count)
1458{
1459 struct qeth_card *card = dev->driver_data;
1460
1461 if (!card)
1462 return -EINVAL;
1463
1464 if (qeth_check_layer2(card))
1465 return -EPERM;
1466
1467 return qeth_dev_vipa_del_store(buf, count, card, QETH_PROT_IPV6);
1468}
1469
1470static QETH_DEVICE_ATTR(vipa_del6, del6, 0200, NULL,
1471 qeth_dev_vipa_del6_store);
1472#endif /* CONFIG_QETH_IPV6 */
1473
1474static struct device_attribute * qeth_vipa_device_attrs[] = {
1475 &dev_attr_vipa_add4,
1476 &dev_attr_vipa_del4,
1477#ifdef CONFIG_QETH_IPV6
1478 &dev_attr_vipa_add6,
1479 &dev_attr_vipa_del6,
1480#endif
1481 NULL,
1482};
1483
1484static struct attribute_group qeth_device_vipa_group = {
1485 .name = "vipa",
1486 .attrs = (struct attribute **)qeth_vipa_device_attrs,
1487};
1488
1489static inline ssize_t
1490qeth_dev_rxip_add_show(char *buf, struct qeth_card *card,
1491 enum qeth_prot_versions proto)
1492{
1493 struct qeth_ipaddr *ipaddr;
1494 char addr_str[40];
1495 int entry_len; /* length of 1 entry string, differs between v4 and v6 */
1496 unsigned long flags;
1497 int i = 0;
1498
1499 if (qeth_check_layer2(card))
1500 return -EPERM;
1501
1502 entry_len = (proto == QETH_PROT_IPV4)? 12 : 40;
1503 entry_len += 2; /* \n + terminator */
1504 spin_lock_irqsave(&card->ip_lock, flags);
1505 list_for_each_entry(ipaddr, &card->ip_list, entry){
1506 if (ipaddr->proto != proto)
1507 continue;
1508 if (ipaddr->type != QETH_IP_TYPE_RXIP)
1509 continue;
1510 /* String must not be longer than PAGE_SIZE. So we check if
1511 * string length gets near PAGE_SIZE. Then we can savely display
1512 * the next IPv6 address (worst case, compared to IPv4) */
1513 if ((PAGE_SIZE - i) <= entry_len)
1514 break;
1515 qeth_ipaddr_to_string(proto, (const u8 *)&ipaddr->u, addr_str);
1516 i += snprintf(buf + i, PAGE_SIZE - i, "%s\n", addr_str);
1517 }
1518 spin_unlock_irqrestore(&card->ip_lock, flags);
1519 i += snprintf(buf + i, PAGE_SIZE - i, "\n");
1520
1521 return i;
1522}
1523
1524static ssize_t
1525qeth_dev_rxip_add4_show(struct device *dev, char *buf)
1526{
1527 struct qeth_card *card = dev->driver_data;
1528
1529 if (!card)
1530 return -EINVAL;
1531
1532 return qeth_dev_rxip_add_show(buf, card, QETH_PROT_IPV4);
1533}
1534
1535static inline int
1536qeth_parse_rxipe(const char* buf, enum qeth_prot_versions proto,
1537 u8 *addr)
1538{
1539 if (qeth_string_to_ipaddr(buf, proto, addr)){
1540 PRINT_WARN("Invalid IP address format!\n");
1541 return -EINVAL;
1542 }
1543 return 0;
1544}
1545
1546static inline ssize_t
1547qeth_dev_rxip_add_store(const char *buf, size_t count,
1548 struct qeth_card *card, enum qeth_prot_versions proto)
1549{
1550 u8 addr[16] = {0, };
1551 int rc;
1552
1553 if (qeth_check_layer2(card))
1554 return -EPERM;
1555 if ((rc = qeth_parse_rxipe(buf, proto, addr)))
1556 return rc;
1557
1558 if ((rc = qeth_add_rxip(card, proto, addr)))
1559 return rc;
1560
1561 return count;
1562}
1563
1564static ssize_t
1565qeth_dev_rxip_add4_store(struct device *dev, const char *buf, size_t count)
1566{
1567 struct qeth_card *card = dev->driver_data;
1568
1569 if (!card)
1570 return -EINVAL;
1571
1572 return qeth_dev_rxip_add_store(buf, count, card, QETH_PROT_IPV4);
1573}
1574
1575static QETH_DEVICE_ATTR(rxip_add4, add4, 0644,
1576 qeth_dev_rxip_add4_show,
1577 qeth_dev_rxip_add4_store);
1578
1579static inline ssize_t
1580qeth_dev_rxip_del_store(const char *buf, size_t count,
1581 struct qeth_card *card, enum qeth_prot_versions proto)
1582{
1583 u8 addr[16];
1584 int rc;
1585
1586 if (qeth_check_layer2(card))
1587 return -EPERM;
1588 if ((rc = qeth_parse_rxipe(buf, proto, addr)))
1589 return rc;
1590
1591 qeth_del_rxip(card, proto, addr);
1592
1593 return count;
1594}
1595
1596static ssize_t
1597qeth_dev_rxip_del4_store(struct device *dev, const char *buf, size_t count)
1598{
1599 struct qeth_card *card = dev->driver_data;
1600
1601 if (!card)
1602 return -EINVAL;
1603
1604 return qeth_dev_rxip_del_store(buf, count, card, QETH_PROT_IPV4);
1605}
1606
1607static QETH_DEVICE_ATTR(rxip_del4, del4, 0200, NULL,
1608 qeth_dev_rxip_del4_store);
1609
1610#ifdef CONFIG_QETH_IPV6
1611static ssize_t
1612qeth_dev_rxip_add6_show(struct device *dev, char *buf)
1613{
1614 struct qeth_card *card = dev->driver_data;
1615
1616 if (!card)
1617 return -EINVAL;
1618
1619 return qeth_dev_rxip_add_show(buf, card, QETH_PROT_IPV6);
1620}
1621
1622static ssize_t
1623qeth_dev_rxip_add6_store(struct device *dev, const char *buf, size_t count)
1624{
1625 struct qeth_card *card = dev->driver_data;
1626
1627 if (!card)
1628 return -EINVAL;
1629
1630 return qeth_dev_rxip_add_store(buf, count, card, QETH_PROT_IPV6);
1631}
1632
1633static QETH_DEVICE_ATTR(rxip_add6, add6, 0644,
1634 qeth_dev_rxip_add6_show,
1635 qeth_dev_rxip_add6_store);
1636
1637static ssize_t
1638qeth_dev_rxip_del6_store(struct device *dev, const char *buf, size_t count)
1639{
1640 struct qeth_card *card = dev->driver_data;
1641
1642 if (!card)
1643 return -EINVAL;
1644
1645 return qeth_dev_rxip_del_store(buf, count, card, QETH_PROT_IPV6);
1646}
1647
1648static QETH_DEVICE_ATTR(rxip_del6, del6, 0200, NULL,
1649 qeth_dev_rxip_del6_store);
1650#endif /* CONFIG_QETH_IPV6 */
1651
1652static struct device_attribute * qeth_rxip_device_attrs[] = {
1653 &dev_attr_rxip_add4,
1654 &dev_attr_rxip_del4,
1655#ifdef CONFIG_QETH_IPV6
1656 &dev_attr_rxip_add6,
1657 &dev_attr_rxip_del6,
1658#endif
1659 NULL,
1660};
1661
1662static struct attribute_group qeth_device_rxip_group = {
1663 .name = "rxip",
1664 .attrs = (struct attribute **)qeth_rxip_device_attrs,
1665};
1666
1667int
1668qeth_create_device_attributes(struct device *dev)
1669{
1670 int ret;
1671
1672 if ((ret = sysfs_create_group(&dev->kobj, &qeth_device_attr_group)))
1673 return ret;
1674 if ((ret = sysfs_create_group(&dev->kobj, &qeth_device_ipato_group))){
1675 sysfs_remove_group(&dev->kobj, &qeth_device_attr_group);
1676 return ret;
1677 }
1678 if ((ret = sysfs_create_group(&dev->kobj, &qeth_device_vipa_group))){
1679 sysfs_remove_group(&dev->kobj, &qeth_device_attr_group);
1680 sysfs_remove_group(&dev->kobj, &qeth_device_ipato_group);
1681 return ret;
1682 }
1683 if ((ret = sysfs_create_group(&dev->kobj, &qeth_device_rxip_group))){
1684 sysfs_remove_group(&dev->kobj, &qeth_device_attr_group);
1685 sysfs_remove_group(&dev->kobj, &qeth_device_ipato_group);
1686 sysfs_remove_group(&dev->kobj, &qeth_device_vipa_group);
1687 }
1688 if ((ret = sysfs_create_group(&dev->kobj, &qeth_device_blkt_group)))
1689 return ret;
1690
1691 return ret;
1692}
1693
1694void
1695qeth_remove_device_attributes(struct device *dev)
1696{
1697 sysfs_remove_group(&dev->kobj, &qeth_device_attr_group);
1698 sysfs_remove_group(&dev->kobj, &qeth_device_ipato_group);
1699 sysfs_remove_group(&dev->kobj, &qeth_device_vipa_group);
1700 sysfs_remove_group(&dev->kobj, &qeth_device_rxip_group);
1701 sysfs_remove_group(&dev->kobj, &qeth_device_blkt_group);
1702}
1703
1704/**********************/
1705/* DRIVER ATTRIBUTES */
1706/**********************/
1707static ssize_t
1708qeth_driver_group_store(struct device_driver *ddrv, const char *buf,
1709 size_t count)
1710{
1711 const char *start, *end;
1712 char bus_ids[3][BUS_ID_SIZE], *argv[3];
1713 int i;
1714 int err;
1715
1716 start = buf;
1717 for (i = 0; i < 3; i++) {
1718 static const char delim[] = { ',', ',', '\n' };
1719 int len;
1720
1721 if (!(end = strchr(start, delim[i])))
1722 return -EINVAL;
1723 len = min_t(ptrdiff_t, BUS_ID_SIZE, end - start);
1724 strncpy(bus_ids[i], start, len);
1725 bus_ids[i][len] = '\0';
1726 start = end + 1;
1727 argv[i] = bus_ids[i];
1728 }
1729 err = ccwgroup_create(qeth_root_dev, qeth_ccwgroup_driver.driver_id,
1730 &qeth_ccw_driver, 3, argv);
1731 if (err)
1732 return err;
1733 else
1734 return count;
1735}
1736
1737
1738static DRIVER_ATTR(group, 0200, 0, qeth_driver_group_store);
1739
1740static ssize_t
1741qeth_driver_notifier_register_store(struct device_driver *ddrv, const char *buf,
1742 size_t count)
1743{
1744 int rc;
1745 int signum;
1746 char *tmp, *tmp2;
1747
1748 tmp = strsep((char **) &buf, "\n");
1749 if (!strncmp(tmp, "unregister", 10)){
1750 if ((rc = qeth_notifier_unregister(current)))
1751 return rc;
1752 return count;
1753 }
1754
1755 signum = simple_strtoul(tmp, &tmp2, 10);
1756 if ((signum < 0) || (signum > 32)){
1757 PRINT_WARN("Signal number %d is out of range\n", signum);
1758 return -EINVAL;
1759 }
1760 if ((rc = qeth_notifier_register(current, signum)))
1761 return rc;
1762
1763 return count;
1764}
1765
1766static DRIVER_ATTR(notifier_register, 0200, 0,
1767 qeth_driver_notifier_register_store);
1768
1769int
1770qeth_create_driver_attributes(void)
1771{
1772 int rc;
1773
1774 if ((rc = driver_create_file(&qeth_ccwgroup_driver.driver,
1775 &driver_attr_group)))
1776 return rc;
1777 return driver_create_file(&qeth_ccwgroup_driver.driver,
1778 &driver_attr_notifier_register);
1779}
1780
1781void
1782qeth_remove_driver_attributes(void)
1783{
1784 driver_remove_file(&qeth_ccwgroup_driver.driver,
1785 &driver_attr_group);
1786 driver_remove_file(&qeth_ccwgroup_driver.driver,
1787 &driver_attr_notifier_register);
1788}
generated by cgit v1.2.2 (git 2.25.0) at 2024-12-26 06:39:05 -0500