2 * drivers/s390/net/qeth_l3_sys.c
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>
11 #include <linux/slab.h>
15 #define QETH_DEVICE_ATTR(_id, _name, _mode, _show, _store) \
16 struct device_attribute dev_attr_##_id = __ATTR(_name, _mode, _show, _store)
18 static const char *qeth_l3_get_checksum_str(struct qeth_card
*card
)
20 if (card
->options
.checksum_type
== SW_CHECKSUMMING
)
22 else if (card
->options
.checksum_type
== HW_CHECKSUMMING
)
28 static ssize_t
qeth_l3_dev_route_show(struct qeth_card
*card
,
29 struct qeth_routing_info
*route
, char *buf
)
31 switch (route
->type
) {
33 return sprintf(buf
, "%s\n", "primary router");
34 case SECONDARY_ROUTER
:
35 return sprintf(buf
, "%s\n", "secondary router");
36 case MULTICAST_ROUTER
:
37 if (card
->info
.broadcast_capable
== QETH_BROADCAST_WITHOUT_ECHO
)
38 return sprintf(buf
, "%s\n", "multicast router+");
40 return sprintf(buf
, "%s\n", "multicast router");
41 case PRIMARY_CONNECTOR
:
42 if (card
->info
.broadcast_capable
== QETH_BROADCAST_WITHOUT_ECHO
)
43 return sprintf(buf
, "%s\n", "primary connector+");
45 return sprintf(buf
, "%s\n", "primary connector");
46 case SECONDARY_CONNECTOR
:
47 if (card
->info
.broadcast_capable
== QETH_BROADCAST_WITHOUT_ECHO
)
48 return sprintf(buf
, "%s\n", "secondary connector+");
50 return sprintf(buf
, "%s\n", "secondary connector");
52 return sprintf(buf
, "%s\n", "no");
56 static ssize_t
qeth_l3_dev_route4_show(struct device
*dev
,
57 struct device_attribute
*attr
, char *buf
)
59 struct qeth_card
*card
= dev_get_drvdata(dev
);
64 return qeth_l3_dev_route_show(card
, &card
->options
.route4
, buf
);
67 static ssize_t
qeth_l3_dev_route_store(struct qeth_card
*card
,
68 struct qeth_routing_info
*route
, enum qeth_prot_versions prot
,
69 const char *buf
, size_t count
)
71 enum qeth_routing_types old_route_type
= route
->type
;
75 tmp
= strsep((char **) &buf
, "\n");
76 mutex_lock(&card
->conf_mutex
);
77 if (!strcmp(tmp
, "no_router")) {
78 route
->type
= NO_ROUTER
;
79 } else if (!strcmp(tmp
, "primary_connector")) {
80 route
->type
= PRIMARY_CONNECTOR
;
81 } else if (!strcmp(tmp
, "secondary_connector")) {
82 route
->type
= SECONDARY_CONNECTOR
;
83 } else if (!strcmp(tmp
, "primary_router")) {
84 route
->type
= PRIMARY_ROUTER
;
85 } else if (!strcmp(tmp
, "secondary_router")) {
86 route
->type
= SECONDARY_ROUTER
;
87 } else if (!strcmp(tmp
, "multicast_router")) {
88 route
->type
= MULTICAST_ROUTER
;
93 if (((card
->state
== CARD_STATE_SOFTSETUP
) ||
94 (card
->state
== CARD_STATE_UP
)) &&
95 (old_route_type
!= route
->type
)) {
96 if (prot
== QETH_PROT_IPV4
)
97 rc
= qeth_l3_setrouting_v4(card
);
98 else if (prot
== QETH_PROT_IPV6
)
99 rc
= qeth_l3_setrouting_v6(card
);
102 mutex_unlock(&card
->conf_mutex
);
103 return rc
? rc
: count
;
106 static ssize_t
qeth_l3_dev_route4_store(struct device
*dev
,
107 struct device_attribute
*attr
, const char *buf
, size_t count
)
109 struct qeth_card
*card
= dev_get_drvdata(dev
);
114 return qeth_l3_dev_route_store(card
, &card
->options
.route4
,
115 QETH_PROT_IPV4
, buf
, count
);
118 static DEVICE_ATTR(route4
, 0644, qeth_l3_dev_route4_show
,
119 qeth_l3_dev_route4_store
);
121 static ssize_t
qeth_l3_dev_route6_show(struct device
*dev
,
122 struct device_attribute
*attr
, char *buf
)
124 struct qeth_card
*card
= dev_get_drvdata(dev
);
129 return qeth_l3_dev_route_show(card
, &card
->options
.route6
, buf
);
132 static ssize_t
qeth_l3_dev_route6_store(struct device
*dev
,
133 struct device_attribute
*attr
, const char *buf
, size_t count
)
135 struct qeth_card
*card
= dev_get_drvdata(dev
);
140 return qeth_l3_dev_route_store(card
, &card
->options
.route6
,
141 QETH_PROT_IPV6
, buf
, count
);
144 static DEVICE_ATTR(route6
, 0644, qeth_l3_dev_route6_show
,
145 qeth_l3_dev_route6_store
);
147 static ssize_t
qeth_l3_dev_fake_broadcast_show(struct device
*dev
,
148 struct device_attribute
*attr
, char *buf
)
150 struct qeth_card
*card
= dev_get_drvdata(dev
);
155 return sprintf(buf
, "%i\n", card
->options
.fake_broadcast
? 1:0);
158 static ssize_t
qeth_l3_dev_fake_broadcast_store(struct device
*dev
,
159 struct device_attribute
*attr
, const char *buf
, size_t count
)
161 struct qeth_card
*card
= dev_get_drvdata(dev
);
168 mutex_lock(&card
->conf_mutex
);
169 if ((card
->state
!= CARD_STATE_DOWN
) &&
170 (card
->state
!= CARD_STATE_RECOVER
)) {
175 i
= simple_strtoul(buf
, &tmp
, 16);
176 if ((i
== 0) || (i
== 1))
177 card
->options
.fake_broadcast
= i
;
181 mutex_unlock(&card
->conf_mutex
);
182 return rc
? rc
: count
;
185 static DEVICE_ATTR(fake_broadcast
, 0644, qeth_l3_dev_fake_broadcast_show
,
186 qeth_l3_dev_fake_broadcast_store
);
188 static ssize_t
qeth_l3_dev_broadcast_mode_show(struct device
*dev
,
189 struct device_attribute
*attr
, char *buf
)
191 struct qeth_card
*card
= dev_get_drvdata(dev
);
196 if (!((card
->info
.link_type
== QETH_LINK_TYPE_HSTR
) ||
197 (card
->info
.link_type
== QETH_LINK_TYPE_LANE_TR
)))
198 return sprintf(buf
, "n/a\n");
200 return sprintf(buf
, "%s\n", (card
->options
.broadcast_mode
==
201 QETH_TR_BROADCAST_ALLRINGS
)?
202 "all rings":"local");
205 static ssize_t
qeth_l3_dev_broadcast_mode_store(struct device
*dev
,
206 struct device_attribute
*attr
, const char *buf
, size_t count
)
208 struct qeth_card
*card
= dev_get_drvdata(dev
);
215 mutex_lock(&card
->conf_mutex
);
216 if ((card
->state
!= CARD_STATE_DOWN
) &&
217 (card
->state
!= CARD_STATE_RECOVER
)) {
222 if (!((card
->info
.link_type
== QETH_LINK_TYPE_HSTR
) ||
223 (card
->info
.link_type
== QETH_LINK_TYPE_LANE_TR
))) {
228 tmp
= strsep((char **) &buf
, "\n");
230 if (!strcmp(tmp
, "local"))
231 card
->options
.broadcast_mode
= QETH_TR_BROADCAST_LOCAL
;
232 else if (!strcmp(tmp
, "all_rings"))
233 card
->options
.broadcast_mode
= QETH_TR_BROADCAST_ALLRINGS
;
237 mutex_unlock(&card
->conf_mutex
);
238 return rc
? rc
: count
;
241 static DEVICE_ATTR(broadcast_mode
, 0644, qeth_l3_dev_broadcast_mode_show
,
242 qeth_l3_dev_broadcast_mode_store
);
244 static ssize_t
qeth_l3_dev_canonical_macaddr_show(struct device
*dev
,
245 struct device_attribute
*attr
, char *buf
)
247 struct qeth_card
*card
= dev_get_drvdata(dev
);
252 if (!((card
->info
.link_type
== QETH_LINK_TYPE_HSTR
) ||
253 (card
->info
.link_type
== QETH_LINK_TYPE_LANE_TR
)))
254 return sprintf(buf
, "n/a\n");
256 return sprintf(buf
, "%i\n", (card
->options
.macaddr_mode
==
257 QETH_TR_MACADDR_CANONICAL
)? 1:0);
260 static ssize_t
qeth_l3_dev_canonical_macaddr_store(struct device
*dev
,
261 struct device_attribute
*attr
, const char *buf
, size_t count
)
263 struct qeth_card
*card
= dev_get_drvdata(dev
);
270 mutex_lock(&card
->conf_mutex
);
271 if ((card
->state
!= CARD_STATE_DOWN
) &&
272 (card
->state
!= CARD_STATE_RECOVER
)) {
277 if (!((card
->info
.link_type
== QETH_LINK_TYPE_HSTR
) ||
278 (card
->info
.link_type
== QETH_LINK_TYPE_LANE_TR
))) {
283 i
= simple_strtoul(buf
, &tmp
, 16);
284 if ((i
== 0) || (i
== 1))
285 card
->options
.macaddr_mode
= i
?
286 QETH_TR_MACADDR_CANONICAL
:
287 QETH_TR_MACADDR_NONCANONICAL
;
291 mutex_unlock(&card
->conf_mutex
);
292 return rc
? rc
: count
;
295 static DEVICE_ATTR(canonical_macaddr
, 0644, qeth_l3_dev_canonical_macaddr_show
,
296 qeth_l3_dev_canonical_macaddr_store
);
298 static ssize_t
qeth_l3_dev_checksum_show(struct device
*dev
,
299 struct device_attribute
*attr
, char *buf
)
301 struct qeth_card
*card
= dev_get_drvdata(dev
);
306 return sprintf(buf
, "%s checksumming\n",
307 qeth_l3_get_checksum_str(card
));
310 static ssize_t
qeth_l3_dev_checksum_store(struct device
*dev
,
311 struct device_attribute
*attr
, const char *buf
, size_t count
)
313 struct qeth_card
*card
= dev_get_drvdata(dev
);
314 enum qeth_checksum_types csum_type
;
321 mutex_lock(&card
->conf_mutex
);
322 tmp
= strsep((char **) &buf
, "\n");
323 if (!strcmp(tmp
, "sw_checksumming"))
324 csum_type
= SW_CHECKSUMMING
;
325 else if (!strcmp(tmp
, "hw_checksumming"))
326 csum_type
= HW_CHECKSUMMING
;
327 else if (!strcmp(tmp
, "no_checksumming"))
328 csum_type
= NO_CHECKSUMMING
;
334 rc
= qeth_l3_set_rx_csum(card
, csum_type
);
336 mutex_unlock(&card
->conf_mutex
);
337 return rc
? rc
: count
;
340 static DEVICE_ATTR(checksumming
, 0644, qeth_l3_dev_checksum_show
,
341 qeth_l3_dev_checksum_store
);
343 static ssize_t
qeth_l3_dev_sniffer_show(struct device
*dev
,
344 struct device_attribute
*attr
, char *buf
)
346 struct qeth_card
*card
= dev_get_drvdata(dev
);
351 return sprintf(buf
, "%i\n", card
->options
.sniffer
? 1 : 0);
354 static ssize_t
qeth_l3_dev_sniffer_store(struct device
*dev
,
355 struct device_attribute
*attr
, const char *buf
, size_t count
)
357 struct qeth_card
*card
= dev_get_drvdata(dev
);
364 if (card
->info
.type
!= QETH_CARD_TYPE_IQD
)
367 mutex_lock(&card
->conf_mutex
);
368 if ((card
->state
!= CARD_STATE_DOWN
) &&
369 (card
->state
!= CARD_STATE_RECOVER
)) {
374 rc
= strict_strtoul(buf
, 16, &i
);
381 card
->options
.sniffer
= i
;
384 qdio_get_ssqd_desc(CARD_DDEV(card
), &card
->ssqd
);
385 if (card
->ssqd
.qdioac2
& QETH_SNIFF_AVAIL
) {
386 card
->options
.sniffer
= i
;
387 if (card
->qdio
.init_pool
.buf_count
!=
388 QETH_IN_BUF_COUNT_MAX
)
389 qeth_realloc_buffer_pool(card
,
390 QETH_IN_BUF_COUNT_MAX
);
394 default: /* fall through */
398 mutex_unlock(&card
->conf_mutex
);
399 return rc
? rc
: count
;
402 static DEVICE_ATTR(sniffer
, 0644, qeth_l3_dev_sniffer_show
,
403 qeth_l3_dev_sniffer_store
);
405 static ssize_t
qeth_l3_dev_large_send_show(struct device
*dev
,
406 struct device_attribute
*attr
, char *buf
)
408 struct qeth_card
*card
= dev_get_drvdata(dev
);
413 switch (card
->options
.large_send
) {
414 case QETH_LARGE_SEND_NO
:
415 return sprintf(buf
, "%s\n", "no");
416 case QETH_LARGE_SEND_TSO
:
417 return sprintf(buf
, "%s\n", "TSO");
419 return sprintf(buf
, "%s\n", "N/A");
423 static ssize_t
qeth_l3_dev_large_send_store(struct device
*dev
,
424 struct device_attribute
*attr
, const char *buf
, size_t count
)
426 struct qeth_card
*card
= dev_get_drvdata(dev
);
427 enum qeth_large_send_types type
;
433 tmp
= strsep((char **) &buf
, "\n");
434 if (!strcmp(tmp
, "no"))
435 type
= QETH_LARGE_SEND_NO
;
436 else if (!strcmp(tmp
, "TSO"))
437 type
= QETH_LARGE_SEND_TSO
;
441 mutex_lock(&card
->conf_mutex
);
442 if (card
->options
.large_send
!= type
)
443 rc
= qeth_l3_set_large_send(card
, type
);
444 mutex_unlock(&card
->conf_mutex
);
445 return rc
? rc
: count
;
448 static DEVICE_ATTR(large_send
, 0644, qeth_l3_dev_large_send_show
,
449 qeth_l3_dev_large_send_store
);
451 static struct attribute
*qeth_l3_device_attrs
[] = {
452 &dev_attr_route4
.attr
,
453 &dev_attr_route6
.attr
,
454 &dev_attr_fake_broadcast
.attr
,
455 &dev_attr_broadcast_mode
.attr
,
456 &dev_attr_canonical_macaddr
.attr
,
457 &dev_attr_checksumming
.attr
,
458 &dev_attr_sniffer
.attr
,
459 &dev_attr_large_send
.attr
,
463 static struct attribute_group qeth_l3_device_attr_group
= {
464 .attrs
= qeth_l3_device_attrs
,
467 static ssize_t
qeth_l3_dev_ipato_enable_show(struct device
*dev
,
468 struct device_attribute
*attr
, char *buf
)
470 struct qeth_card
*card
= dev_get_drvdata(dev
);
475 return sprintf(buf
, "%i\n", card
->ipato
.enabled
? 1:0);
478 static ssize_t
qeth_l3_dev_ipato_enable_store(struct device
*dev
,
479 struct device_attribute
*attr
, const char *buf
, size_t count
)
481 struct qeth_card
*card
= dev_get_drvdata(dev
);
482 struct qeth_ipaddr
*tmpipa
, *t
;
489 mutex_lock(&card
->conf_mutex
);
490 if ((card
->state
!= CARD_STATE_DOWN
) &&
491 (card
->state
!= CARD_STATE_RECOVER
)) {
496 tmp
= strsep((char **) &buf
, "\n");
497 if (!strcmp(tmp
, "toggle")) {
498 card
->ipato
.enabled
= (card
->ipato
.enabled
)? 0 : 1;
499 } else if (!strcmp(tmp
, "1")) {
500 card
->ipato
.enabled
= 1;
501 list_for_each_entry_safe(tmpipa
, t
, card
->ip_tbd_list
, entry
) {
502 if ((tmpipa
->type
== QETH_IP_TYPE_NORMAL
) &&
503 qeth_l3_is_addr_covered_by_ipato(card
, tmpipa
))
505 QETH_IPA_SETIP_TAKEOVER_FLAG
;
508 } else if (!strcmp(tmp
, "0")) {
509 card
->ipato
.enabled
= 0;
510 list_for_each_entry_safe(tmpipa
, t
, card
->ip_tbd_list
, entry
) {
511 if (tmpipa
->set_flags
&
512 QETH_IPA_SETIP_TAKEOVER_FLAG
)
514 ~QETH_IPA_SETIP_TAKEOVER_FLAG
;
519 mutex_unlock(&card
->conf_mutex
);
520 return rc
? rc
: count
;
523 static QETH_DEVICE_ATTR(ipato_enable
, enable
, 0644,
524 qeth_l3_dev_ipato_enable_show
,
525 qeth_l3_dev_ipato_enable_store
);
527 static ssize_t
qeth_l3_dev_ipato_invert4_show(struct device
*dev
,
528 struct device_attribute
*attr
, char *buf
)
530 struct qeth_card
*card
= dev_get_drvdata(dev
);
535 return sprintf(buf
, "%i\n", card
->ipato
.invert4
? 1:0);
538 static ssize_t
qeth_l3_dev_ipato_invert4_store(struct device
*dev
,
539 struct device_attribute
*attr
,
540 const char *buf
, size_t count
)
542 struct qeth_card
*card
= dev_get_drvdata(dev
);
549 mutex_lock(&card
->conf_mutex
);
550 tmp
= strsep((char **) &buf
, "\n");
551 if (!strcmp(tmp
, "toggle")) {
552 card
->ipato
.invert4
= (card
->ipato
.invert4
)? 0 : 1;
553 } else if (!strcmp(tmp
, "1")) {
554 card
->ipato
.invert4
= 1;
555 } else if (!strcmp(tmp
, "0")) {
556 card
->ipato
.invert4
= 0;
559 mutex_unlock(&card
->conf_mutex
);
560 return rc
? rc
: count
;
563 static QETH_DEVICE_ATTR(ipato_invert4
, invert4
, 0644,
564 qeth_l3_dev_ipato_invert4_show
,
565 qeth_l3_dev_ipato_invert4_store
);
567 static ssize_t
qeth_l3_dev_ipato_add_show(char *buf
, struct qeth_card
*card
,
568 enum qeth_prot_versions proto
)
570 struct qeth_ipato_entry
*ipatoe
;
573 int entry_len
; /* length of 1 entry string, differs between v4 and v6 */
576 entry_len
= (proto
== QETH_PROT_IPV4
)? 12 : 40;
577 /* add strlen for "/<mask>\n" */
578 entry_len
+= (proto
== QETH_PROT_IPV4
)? 5 : 6;
579 spin_lock_irqsave(&card
->ip_lock
, flags
);
580 list_for_each_entry(ipatoe
, &card
->ipato
.entries
, entry
) {
581 if (ipatoe
->proto
!= proto
)
583 /* String must not be longer than PAGE_SIZE. So we check if
584 * string length gets near PAGE_SIZE. Then we can savely display
585 * the next IPv6 address (worst case, compared to IPv4) */
586 if ((PAGE_SIZE
- i
) <= entry_len
)
588 qeth_l3_ipaddr_to_string(proto
, ipatoe
->addr
, addr_str
);
589 i
+= snprintf(buf
+ i
, PAGE_SIZE
- i
,
590 "%s/%i\n", addr_str
, ipatoe
->mask_bits
);
592 spin_unlock_irqrestore(&card
->ip_lock
, flags
);
593 i
+= snprintf(buf
+ i
, PAGE_SIZE
- i
, "\n");
598 static ssize_t
qeth_l3_dev_ipato_add4_show(struct device
*dev
,
599 struct device_attribute
*attr
, char *buf
)
601 struct qeth_card
*card
= dev_get_drvdata(dev
);
606 return qeth_l3_dev_ipato_add_show(buf
, card
, QETH_PROT_IPV4
);
609 static int qeth_l3_parse_ipatoe(const char *buf
, enum qeth_prot_versions proto
,
610 u8
*addr
, int *mask_bits
)
612 const char *start
, *end
;
614 char buffer
[40] = {0, };
617 /* get address string */
618 end
= strchr(start
, '/');
619 if (!end
|| (end
- start
>= 40)) {
622 strncpy(buffer
, start
, end
- start
);
623 if (qeth_l3_string_to_ipaddr(buffer
, proto
, addr
)) {
627 *mask_bits
= simple_strtoul(start
, &tmp
, 10);
628 if (!strlen(start
) ||
630 (*mask_bits
> ((proto
== QETH_PROT_IPV4
) ? 32 : 128))) {
636 static ssize_t
qeth_l3_dev_ipato_add_store(const char *buf
, size_t count
,
637 struct qeth_card
*card
, enum qeth_prot_versions proto
)
639 struct qeth_ipato_entry
*ipatoe
;
644 mutex_lock(&card
->conf_mutex
);
645 rc
= qeth_l3_parse_ipatoe(buf
, proto
, addr
, &mask_bits
);
649 ipatoe
= kzalloc(sizeof(struct qeth_ipato_entry
), GFP_KERNEL
);
654 ipatoe
->proto
= proto
;
655 memcpy(ipatoe
->addr
, addr
, (proto
== QETH_PROT_IPV4
)? 4:16);
656 ipatoe
->mask_bits
= mask_bits
;
658 rc
= qeth_l3_add_ipato_entry(card
, ipatoe
);
662 mutex_unlock(&card
->conf_mutex
);
663 return rc
? rc
: count
;
666 static ssize_t
qeth_l3_dev_ipato_add4_store(struct device
*dev
,
667 struct device_attribute
*attr
, const char *buf
, size_t count
)
669 struct qeth_card
*card
= dev_get_drvdata(dev
);
674 return qeth_l3_dev_ipato_add_store(buf
, count
, card
, QETH_PROT_IPV4
);
677 static QETH_DEVICE_ATTR(ipato_add4
, add4
, 0644,
678 qeth_l3_dev_ipato_add4_show
,
679 qeth_l3_dev_ipato_add4_store
);
681 static ssize_t
qeth_l3_dev_ipato_del_store(const char *buf
, size_t count
,
682 struct qeth_card
*card
, enum qeth_prot_versions proto
)
688 mutex_lock(&card
->conf_mutex
);
689 rc
= qeth_l3_parse_ipatoe(buf
, proto
, addr
, &mask_bits
);
691 qeth_l3_del_ipato_entry(card
, proto
, addr
, mask_bits
);
692 mutex_unlock(&card
->conf_mutex
);
693 return rc
? rc
: count
;
696 static ssize_t
qeth_l3_dev_ipato_del4_store(struct device
*dev
,
697 struct device_attribute
*attr
, const char *buf
, size_t count
)
699 struct qeth_card
*card
= dev_get_drvdata(dev
);
704 return qeth_l3_dev_ipato_del_store(buf
, count
, card
, QETH_PROT_IPV4
);
707 static QETH_DEVICE_ATTR(ipato_del4
, del4
, 0200, NULL
,
708 qeth_l3_dev_ipato_del4_store
);
710 static ssize_t
qeth_l3_dev_ipato_invert6_show(struct device
*dev
,
711 struct device_attribute
*attr
, char *buf
)
713 struct qeth_card
*card
= dev_get_drvdata(dev
);
718 return sprintf(buf
, "%i\n", card
->ipato
.invert6
? 1:0);
721 static ssize_t
qeth_l3_dev_ipato_invert6_store(struct device
*dev
,
722 struct device_attribute
*attr
, const char *buf
, size_t count
)
724 struct qeth_card
*card
= dev_get_drvdata(dev
);
731 mutex_lock(&card
->conf_mutex
);
732 tmp
= strsep((char **) &buf
, "\n");
733 if (!strcmp(tmp
, "toggle")) {
734 card
->ipato
.invert6
= (card
->ipato
.invert6
)? 0 : 1;
735 } else if (!strcmp(tmp
, "1")) {
736 card
->ipato
.invert6
= 1;
737 } else if (!strcmp(tmp
, "0")) {
738 card
->ipato
.invert6
= 0;
741 mutex_unlock(&card
->conf_mutex
);
742 return rc
? rc
: count
;
745 static QETH_DEVICE_ATTR(ipato_invert6
, invert6
, 0644,
746 qeth_l3_dev_ipato_invert6_show
,
747 qeth_l3_dev_ipato_invert6_store
);
750 static ssize_t
qeth_l3_dev_ipato_add6_show(struct device
*dev
,
751 struct device_attribute
*attr
, char *buf
)
753 struct qeth_card
*card
= dev_get_drvdata(dev
);
758 return qeth_l3_dev_ipato_add_show(buf
, card
, QETH_PROT_IPV6
);
761 static ssize_t
qeth_l3_dev_ipato_add6_store(struct device
*dev
,
762 struct device_attribute
*attr
, const char *buf
, size_t count
)
764 struct qeth_card
*card
= dev_get_drvdata(dev
);
769 return qeth_l3_dev_ipato_add_store(buf
, count
, card
, QETH_PROT_IPV6
);
772 static QETH_DEVICE_ATTR(ipato_add6
, add6
, 0644,
773 qeth_l3_dev_ipato_add6_show
,
774 qeth_l3_dev_ipato_add6_store
);
776 static ssize_t
qeth_l3_dev_ipato_del6_store(struct device
*dev
,
777 struct device_attribute
*attr
, const char *buf
, size_t count
)
779 struct qeth_card
*card
= dev_get_drvdata(dev
);
784 return qeth_l3_dev_ipato_del_store(buf
, count
, card
, QETH_PROT_IPV6
);
787 static QETH_DEVICE_ATTR(ipato_del6
, del6
, 0200, NULL
,
788 qeth_l3_dev_ipato_del6_store
);
790 static struct attribute
*qeth_ipato_device_attrs
[] = {
791 &dev_attr_ipato_enable
.attr
,
792 &dev_attr_ipato_invert4
.attr
,
793 &dev_attr_ipato_add4
.attr
,
794 &dev_attr_ipato_del4
.attr
,
795 &dev_attr_ipato_invert6
.attr
,
796 &dev_attr_ipato_add6
.attr
,
797 &dev_attr_ipato_del6
.attr
,
801 static struct attribute_group qeth_device_ipato_group
= {
802 .name
= "ipa_takeover",
803 .attrs
= qeth_ipato_device_attrs
,
806 static ssize_t
qeth_l3_dev_vipa_add_show(char *buf
, struct qeth_card
*card
,
807 enum qeth_prot_versions proto
)
809 struct qeth_ipaddr
*ipaddr
;
811 int entry_len
; /* length of 1 entry string, differs between v4 and v6 */
815 entry_len
= (proto
== QETH_PROT_IPV4
)? 12 : 40;
816 entry_len
+= 2; /* \n + terminator */
817 spin_lock_irqsave(&card
->ip_lock
, flags
);
818 list_for_each_entry(ipaddr
, &card
->ip_list
, entry
) {
819 if (ipaddr
->proto
!= proto
)
821 if (ipaddr
->type
!= QETH_IP_TYPE_VIPA
)
823 /* String must not be longer than PAGE_SIZE. So we check if
824 * string length gets near PAGE_SIZE. Then we can savely display
825 * the next IPv6 address (worst case, compared to IPv4) */
826 if ((PAGE_SIZE
- i
) <= entry_len
)
828 qeth_l3_ipaddr_to_string(proto
, (const u8
*)&ipaddr
->u
,
830 i
+= snprintf(buf
+ i
, PAGE_SIZE
- i
, "%s\n", addr_str
);
832 spin_unlock_irqrestore(&card
->ip_lock
, flags
);
833 i
+= snprintf(buf
+ i
, PAGE_SIZE
- i
, "\n");
838 static ssize_t
qeth_l3_dev_vipa_add4_show(struct device
*dev
,
839 struct device_attribute
*attr
, char *buf
)
841 struct qeth_card
*card
= dev_get_drvdata(dev
);
846 return qeth_l3_dev_vipa_add_show(buf
, card
, QETH_PROT_IPV4
);
849 static int qeth_l3_parse_vipae(const char *buf
, enum qeth_prot_versions proto
,
852 if (qeth_l3_string_to_ipaddr(buf
, proto
, addr
)) {
858 static ssize_t
qeth_l3_dev_vipa_add_store(const char *buf
, size_t count
,
859 struct qeth_card
*card
, enum qeth_prot_versions proto
)
864 mutex_lock(&card
->conf_mutex
);
865 rc
= qeth_l3_parse_vipae(buf
, proto
, addr
);
867 rc
= qeth_l3_add_vipa(card
, proto
, addr
);
868 mutex_unlock(&card
->conf_mutex
);
869 return rc
? rc
: count
;
872 static ssize_t
qeth_l3_dev_vipa_add4_store(struct device
*dev
,
873 struct device_attribute
*attr
, const char *buf
, size_t count
)
875 struct qeth_card
*card
= dev_get_drvdata(dev
);
880 return qeth_l3_dev_vipa_add_store(buf
, count
, card
, QETH_PROT_IPV4
);
883 static QETH_DEVICE_ATTR(vipa_add4
, add4
, 0644,
884 qeth_l3_dev_vipa_add4_show
,
885 qeth_l3_dev_vipa_add4_store
);
887 static ssize_t
qeth_l3_dev_vipa_del_store(const char *buf
, size_t count
,
888 struct qeth_card
*card
, enum qeth_prot_versions proto
)
893 mutex_lock(&card
->conf_mutex
);
894 rc
= qeth_l3_parse_vipae(buf
, proto
, addr
);
896 qeth_l3_del_vipa(card
, proto
, addr
);
897 mutex_unlock(&card
->conf_mutex
);
898 return rc
? rc
: count
;
901 static ssize_t
qeth_l3_dev_vipa_del4_store(struct device
*dev
,
902 struct device_attribute
*attr
, const char *buf
, size_t count
)
904 struct qeth_card
*card
= dev_get_drvdata(dev
);
909 return qeth_l3_dev_vipa_del_store(buf
, count
, card
, QETH_PROT_IPV4
);
912 static QETH_DEVICE_ATTR(vipa_del4
, del4
, 0200, NULL
,
913 qeth_l3_dev_vipa_del4_store
);
915 static ssize_t
qeth_l3_dev_vipa_add6_show(struct device
*dev
,
916 struct device_attribute
*attr
, char *buf
)
918 struct qeth_card
*card
= dev_get_drvdata(dev
);
923 return qeth_l3_dev_vipa_add_show(buf
, card
, QETH_PROT_IPV6
);
926 static ssize_t
qeth_l3_dev_vipa_add6_store(struct device
*dev
,
927 struct device_attribute
*attr
, const char *buf
, size_t count
)
929 struct qeth_card
*card
= dev_get_drvdata(dev
);
934 return qeth_l3_dev_vipa_add_store(buf
, count
, card
, QETH_PROT_IPV6
);
937 static QETH_DEVICE_ATTR(vipa_add6
, add6
, 0644,
938 qeth_l3_dev_vipa_add6_show
,
939 qeth_l3_dev_vipa_add6_store
);
941 static ssize_t
qeth_l3_dev_vipa_del6_store(struct device
*dev
,
942 struct device_attribute
*attr
, const char *buf
, size_t count
)
944 struct qeth_card
*card
= dev_get_drvdata(dev
);
949 return qeth_l3_dev_vipa_del_store(buf
, count
, card
, QETH_PROT_IPV6
);
952 static QETH_DEVICE_ATTR(vipa_del6
, del6
, 0200, NULL
,
953 qeth_l3_dev_vipa_del6_store
);
955 static struct attribute
*qeth_vipa_device_attrs
[] = {
956 &dev_attr_vipa_add4
.attr
,
957 &dev_attr_vipa_del4
.attr
,
958 &dev_attr_vipa_add6
.attr
,
959 &dev_attr_vipa_del6
.attr
,
963 static struct attribute_group qeth_device_vipa_group
= {
965 .attrs
= qeth_vipa_device_attrs
,
968 static ssize_t
qeth_l3_dev_rxip_add_show(char *buf
, struct qeth_card
*card
,
969 enum qeth_prot_versions proto
)
971 struct qeth_ipaddr
*ipaddr
;
973 int entry_len
; /* length of 1 entry string, differs between v4 and v6 */
977 entry_len
= (proto
== QETH_PROT_IPV4
)? 12 : 40;
978 entry_len
+= 2; /* \n + terminator */
979 spin_lock_irqsave(&card
->ip_lock
, flags
);
980 list_for_each_entry(ipaddr
, &card
->ip_list
, entry
) {
981 if (ipaddr
->proto
!= proto
)
983 if (ipaddr
->type
!= QETH_IP_TYPE_RXIP
)
985 /* String must not be longer than PAGE_SIZE. So we check if
986 * string length gets near PAGE_SIZE. Then we can savely display
987 * the next IPv6 address (worst case, compared to IPv4) */
988 if ((PAGE_SIZE
- i
) <= entry_len
)
990 qeth_l3_ipaddr_to_string(proto
, (const u8
*)&ipaddr
->u
,
992 i
+= snprintf(buf
+ i
, PAGE_SIZE
- i
, "%s\n", addr_str
);
994 spin_unlock_irqrestore(&card
->ip_lock
, flags
);
995 i
+= snprintf(buf
+ i
, PAGE_SIZE
- i
, "\n");
1000 static ssize_t
qeth_l3_dev_rxip_add4_show(struct device
*dev
,
1001 struct device_attribute
*attr
, char *buf
)
1003 struct qeth_card
*card
= dev_get_drvdata(dev
);
1008 return qeth_l3_dev_rxip_add_show(buf
, card
, QETH_PROT_IPV4
);
1011 static int qeth_l3_parse_rxipe(const char *buf
, enum qeth_prot_versions proto
,
1014 if (qeth_l3_string_to_ipaddr(buf
, proto
, addr
)) {
1020 static ssize_t
qeth_l3_dev_rxip_add_store(const char *buf
, size_t count
,
1021 struct qeth_card
*card
, enum qeth_prot_versions proto
)
1023 u8 addr
[16] = {0, };
1026 mutex_lock(&card
->conf_mutex
);
1027 rc
= qeth_l3_parse_rxipe(buf
, proto
, addr
);
1029 rc
= qeth_l3_add_rxip(card
, proto
, addr
);
1030 mutex_unlock(&card
->conf_mutex
);
1031 return rc
? rc
: count
;
1034 static ssize_t
qeth_l3_dev_rxip_add4_store(struct device
*dev
,
1035 struct device_attribute
*attr
, const char *buf
, size_t count
)
1037 struct qeth_card
*card
= dev_get_drvdata(dev
);
1042 return qeth_l3_dev_rxip_add_store(buf
, count
, card
, QETH_PROT_IPV4
);
1045 static QETH_DEVICE_ATTR(rxip_add4
, add4
, 0644,
1046 qeth_l3_dev_rxip_add4_show
,
1047 qeth_l3_dev_rxip_add4_store
);
1049 static ssize_t
qeth_l3_dev_rxip_del_store(const char *buf
, size_t count
,
1050 struct qeth_card
*card
, enum qeth_prot_versions proto
)
1055 mutex_lock(&card
->conf_mutex
);
1056 rc
= qeth_l3_parse_rxipe(buf
, proto
, addr
);
1058 qeth_l3_del_rxip(card
, proto
, addr
);
1059 mutex_unlock(&card
->conf_mutex
);
1060 return rc
? rc
: count
;
1063 static ssize_t
qeth_l3_dev_rxip_del4_store(struct device
*dev
,
1064 struct device_attribute
*attr
, const char *buf
, size_t count
)
1066 struct qeth_card
*card
= dev_get_drvdata(dev
);
1071 return qeth_l3_dev_rxip_del_store(buf
, count
, card
, QETH_PROT_IPV4
);
1074 static QETH_DEVICE_ATTR(rxip_del4
, del4
, 0200, NULL
,
1075 qeth_l3_dev_rxip_del4_store
);
1077 static ssize_t
qeth_l3_dev_rxip_add6_show(struct device
*dev
,
1078 struct device_attribute
*attr
, char *buf
)
1080 struct qeth_card
*card
= dev_get_drvdata(dev
);
1085 return qeth_l3_dev_rxip_add_show(buf
, card
, QETH_PROT_IPV6
);
1088 static ssize_t
qeth_l3_dev_rxip_add6_store(struct device
*dev
,
1089 struct device_attribute
*attr
, const char *buf
, size_t count
)
1091 struct qeth_card
*card
= dev_get_drvdata(dev
);
1096 return qeth_l3_dev_rxip_add_store(buf
, count
, card
, QETH_PROT_IPV6
);
1099 static QETH_DEVICE_ATTR(rxip_add6
, add6
, 0644,
1100 qeth_l3_dev_rxip_add6_show
,
1101 qeth_l3_dev_rxip_add6_store
);
1103 static ssize_t
qeth_l3_dev_rxip_del6_store(struct device
*dev
,
1104 struct device_attribute
*attr
, const char *buf
, size_t count
)
1106 struct qeth_card
*card
= dev_get_drvdata(dev
);
1111 return qeth_l3_dev_rxip_del_store(buf
, count
, card
, QETH_PROT_IPV6
);
1114 static QETH_DEVICE_ATTR(rxip_del6
, del6
, 0200, NULL
,
1115 qeth_l3_dev_rxip_del6_store
);
1117 static struct attribute
*qeth_rxip_device_attrs
[] = {
1118 &dev_attr_rxip_add4
.attr
,
1119 &dev_attr_rxip_del4
.attr
,
1120 &dev_attr_rxip_add6
.attr
,
1121 &dev_attr_rxip_del6
.attr
,
1125 static struct attribute_group qeth_device_rxip_group
= {
1127 .attrs
= qeth_rxip_device_attrs
,
1130 int qeth_l3_create_device_attributes(struct device
*dev
)
1134 ret
= sysfs_create_group(&dev
->kobj
, &qeth_l3_device_attr_group
);
1138 ret
= sysfs_create_group(&dev
->kobj
, &qeth_device_ipato_group
);
1140 sysfs_remove_group(&dev
->kobj
, &qeth_l3_device_attr_group
);
1144 ret
= sysfs_create_group(&dev
->kobj
, &qeth_device_vipa_group
);
1146 sysfs_remove_group(&dev
->kobj
, &qeth_l3_device_attr_group
);
1147 sysfs_remove_group(&dev
->kobj
, &qeth_device_ipato_group
);
1151 ret
= sysfs_create_group(&dev
->kobj
, &qeth_device_rxip_group
);
1153 sysfs_remove_group(&dev
->kobj
, &qeth_l3_device_attr_group
);
1154 sysfs_remove_group(&dev
->kobj
, &qeth_device_ipato_group
);
1155 sysfs_remove_group(&dev
->kobj
, &qeth_device_vipa_group
);
1161 void qeth_l3_remove_device_attributes(struct device
*dev
)
1163 sysfs_remove_group(&dev
->kobj
, &qeth_l3_device_attr_group
);
1164 sysfs_remove_group(&dev
->kobj
, &qeth_device_ipato_group
);
1165 sysfs_remove_group(&dev
->kobj
, &qeth_device_vipa_group
);
1166 sysfs_remove_group(&dev
->kobj
, &qeth_device_rxip_group
);