1 // SPDX-License-Identifier: GPL-2.0
3 * Copyright IBM Corp. 2007
4 * Author(s): Utz Bacher <utz.bacher@de.ibm.com>,
5 * Frank Pavlic <fpavlic@de.ibm.com>,
6 * Thomas Spatzier <tspat@de.ibm.com>,
7 * Frank Blaschka <frank.blaschka@de.ibm.com>
10 #include <linux/slab.h>
11 #include <asm/ebcdic.h>
12 #include <linux/hashtable.h>
13 #include <linux/inet.h>
16 #define QETH_DEVICE_ATTR(_id, _name, _mode, _show, _store) \
17 struct device_attribute dev_attr_##_id = __ATTR(_name, _mode, _show, _store)
19 static int qeth_l3_string_to_ipaddr(const char *buf,
20 enum qeth_prot_versions proto, u8 *addr)
24 if ((proto == QETH_PROT_IPV4 && !in4_pton(buf, -1, addr, -1, &end)) ||
25 (proto == QETH_PROT_IPV6 && !in6_pton(buf, -1, addr, -1, &end)))
30 static ssize_t qeth_l3_dev_route_show(struct qeth_card *card,
31 struct qeth_routing_info *route, char *buf)
33 switch (route->type) {
35 return sprintf(buf, "%s\n", "primary router");
36 case SECONDARY_ROUTER:
37 return sprintf(buf, "%s\n", "secondary router");
38 case MULTICAST_ROUTER:
39 if (card->info.broadcast_capable == QETH_BROADCAST_WITHOUT_ECHO)
40 return sprintf(buf, "%s\n", "multicast router+");
42 return sprintf(buf, "%s\n", "multicast router");
43 case PRIMARY_CONNECTOR:
44 if (card->info.broadcast_capable == QETH_BROADCAST_WITHOUT_ECHO)
45 return sprintf(buf, "%s\n", "primary connector+");
47 return sprintf(buf, "%s\n", "primary connector");
48 case SECONDARY_CONNECTOR:
49 if (card->info.broadcast_capable == QETH_BROADCAST_WITHOUT_ECHO)
50 return sprintf(buf, "%s\n", "secondary connector+");
52 return sprintf(buf, "%s\n", "secondary connector");
54 return sprintf(buf, "%s\n", "no");
58 static ssize_t qeth_l3_dev_route4_show(struct device *dev,
59 struct device_attribute *attr, char *buf)
61 struct qeth_card *card = dev_get_drvdata(dev);
63 return qeth_l3_dev_route_show(card, &card->options.route4, buf);
66 static ssize_t qeth_l3_dev_route_store(struct qeth_card *card,
67 struct qeth_routing_info *route, enum qeth_prot_versions prot,
68 const char *buf, size_t count)
70 enum qeth_routing_types old_route_type = route->type;
73 mutex_lock(&card->conf_mutex);
74 if (sysfs_streq(buf, "no_router")) {
75 route->type = NO_ROUTER;
76 } else if (sysfs_streq(buf, "primary_connector")) {
77 route->type = PRIMARY_CONNECTOR;
78 } else if (sysfs_streq(buf, "secondary_connector")) {
79 route->type = SECONDARY_CONNECTOR;
80 } else if (sysfs_streq(buf, "primary_router")) {
81 route->type = PRIMARY_ROUTER;
82 } else if (sysfs_streq(buf, "secondary_router")) {
83 route->type = SECONDARY_ROUTER;
84 } else if (sysfs_streq(buf, "multicast_router")) {
85 route->type = MULTICAST_ROUTER;
90 if (qeth_card_hw_is_reachable(card) &&
91 (old_route_type != route->type)) {
92 if (prot == QETH_PROT_IPV4)
93 rc = qeth_l3_setrouting_v4(card);
94 else if (prot == QETH_PROT_IPV6)
95 rc = qeth_l3_setrouting_v6(card);
99 route->type = old_route_type;
100 mutex_unlock(&card->conf_mutex);
101 return rc ? rc : count;
104 static ssize_t qeth_l3_dev_route4_store(struct device *dev,
105 struct device_attribute *attr, const char *buf, size_t count)
107 struct qeth_card *card = dev_get_drvdata(dev);
109 return qeth_l3_dev_route_store(card, &card->options.route4,
110 QETH_PROT_IPV4, buf, count);
113 static DEVICE_ATTR(route4, 0644, qeth_l3_dev_route4_show,
114 qeth_l3_dev_route4_store);
116 static ssize_t qeth_l3_dev_route6_show(struct device *dev,
117 struct device_attribute *attr, char *buf)
119 struct qeth_card *card = dev_get_drvdata(dev);
121 return qeth_l3_dev_route_show(card, &card->options.route6, buf);
124 static ssize_t qeth_l3_dev_route6_store(struct device *dev,
125 struct device_attribute *attr, const char *buf, size_t count)
127 struct qeth_card *card = dev_get_drvdata(dev);
129 return qeth_l3_dev_route_store(card, &card->options.route6,
130 QETH_PROT_IPV6, buf, count);
133 static DEVICE_ATTR(route6, 0644, qeth_l3_dev_route6_show,
134 qeth_l3_dev_route6_store);
136 static ssize_t qeth_l3_dev_fake_broadcast_show(struct device *dev,
137 struct device_attribute *attr, char *buf)
139 struct qeth_card *card = dev_get_drvdata(dev);
141 return sprintf(buf, "%i\n", card->options.fake_broadcast? 1:0);
144 static ssize_t qeth_l3_dev_fake_broadcast_store(struct device *dev,
145 struct device_attribute *attr, const char *buf, size_t count)
147 struct qeth_card *card = dev_get_drvdata(dev);
151 mutex_lock(&card->conf_mutex);
152 if (card->state != CARD_STATE_DOWN) {
157 i = simple_strtoul(buf, &tmp, 16);
158 if ((i == 0) || (i == 1))
159 card->options.fake_broadcast = i;
163 mutex_unlock(&card->conf_mutex);
164 return rc ? rc : count;
167 static DEVICE_ATTR(fake_broadcast, 0644, qeth_l3_dev_fake_broadcast_show,
168 qeth_l3_dev_fake_broadcast_store);
170 static ssize_t qeth_l3_dev_sniffer_show(struct device *dev,
171 struct device_attribute *attr, char *buf)
173 struct qeth_card *card = dev_get_drvdata(dev);
175 return sprintf(buf, "%i\n", card->options.sniffer ? 1 : 0);
178 static ssize_t qeth_l3_dev_sniffer_store(struct device *dev,
179 struct device_attribute *attr, const char *buf, size_t count)
181 struct qeth_card *card = dev_get_drvdata(dev);
187 if (card->options.cq == QETH_CQ_ENABLED)
190 mutex_lock(&card->conf_mutex);
191 if (card->state != CARD_STATE_DOWN) {
196 rc = kstrtoul(buf, 16, &i);
203 card->options.sniffer = i;
206 qdio_get_ssqd_desc(CARD_DDEV(card), &card->ssqd);
207 if (card->ssqd.qdioac2 & CHSC_AC2_SNIFFER_AVAILABLE) {
208 card->options.sniffer = i;
209 if (card->qdio.init_pool.buf_count !=
210 QETH_IN_BUF_COUNT_MAX)
211 qeth_realloc_buffer_pool(card,
212 QETH_IN_BUF_COUNT_MAX);
220 mutex_unlock(&card->conf_mutex);
221 return rc ? rc : count;
224 static DEVICE_ATTR(sniffer, 0644, qeth_l3_dev_sniffer_show,
225 qeth_l3_dev_sniffer_store);
227 static ssize_t qeth_l3_dev_hsuid_show(struct device *dev,
228 struct device_attribute *attr, char *buf)
230 struct qeth_card *card = dev_get_drvdata(dev);
236 memcpy(tmp_hsuid, card->options.hsuid, sizeof(tmp_hsuid));
237 EBCASC(tmp_hsuid, 8);
238 return sprintf(buf, "%s\n", tmp_hsuid);
241 static ssize_t qeth_l3_dev_hsuid_store(struct device *dev,
242 struct device_attribute *attr, const char *buf, size_t count)
244 struct qeth_card *card = dev_get_drvdata(dev);
251 mutex_lock(&card->conf_mutex);
252 if (card->state != CARD_STATE_DOWN) {
257 if (card->options.sniffer) {
262 if (card->options.cq == QETH_CQ_NOTAVAILABLE) {
267 tmp = strsep((char **)&buf, "\n");
268 if (strlen(tmp) > 8) {
273 if (card->options.hsuid[0])
274 /* delete old ip address */
275 qeth_l3_modify_hsuid(card, false);
277 if (strlen(tmp) == 0) {
278 /* delete ip address only */
279 card->options.hsuid[0] = '\0';
280 memcpy(card->dev->perm_addr, card->options.hsuid, 9);
281 qeth_configure_cq(card, QETH_CQ_DISABLED);
285 if (qeth_configure_cq(card, QETH_CQ_ENABLED)) {
290 snprintf(card->options.hsuid, sizeof(card->options.hsuid),
292 ASCEBC(card->options.hsuid, 8);
293 memcpy(card->dev->perm_addr, card->options.hsuid, 9);
295 rc = qeth_l3_modify_hsuid(card, true);
298 mutex_unlock(&card->conf_mutex);
299 return rc ? rc : count;
302 static DEVICE_ATTR(hsuid, 0644, qeth_l3_dev_hsuid_show,
303 qeth_l3_dev_hsuid_store);
306 static struct attribute *qeth_l3_device_attrs[] = {
307 &dev_attr_route4.attr,
308 &dev_attr_route6.attr,
309 &dev_attr_fake_broadcast.attr,
310 &dev_attr_sniffer.attr,
311 &dev_attr_hsuid.attr,
315 static const struct attribute_group qeth_l3_device_attr_group = {
316 .attrs = qeth_l3_device_attrs,
319 static ssize_t qeth_l3_dev_ipato_enable_show(struct device *dev,
320 struct device_attribute *attr, char *buf)
322 struct qeth_card *card = dev_get_drvdata(dev);
324 return sprintf(buf, "%i\n", card->ipato.enabled? 1:0);
327 static ssize_t qeth_l3_dev_ipato_enable_store(struct device *dev,
328 struct device_attribute *attr, const char *buf, size_t count)
330 struct qeth_card *card = dev_get_drvdata(dev);
334 mutex_lock(&card->conf_mutex);
335 if (card->state != CARD_STATE_DOWN) {
340 if (sysfs_streq(buf, "toggle")) {
341 enable = !card->ipato.enabled;
342 } else if (kstrtobool(buf, &enable)) {
347 if (card->ipato.enabled != enable) {
348 card->ipato.enabled = enable;
349 mutex_lock(&card->ip_lock);
350 qeth_l3_update_ipato(card);
351 mutex_unlock(&card->ip_lock);
354 mutex_unlock(&card->conf_mutex);
355 return rc ? rc : count;
358 static QETH_DEVICE_ATTR(ipato_enable, enable, 0644,
359 qeth_l3_dev_ipato_enable_show,
360 qeth_l3_dev_ipato_enable_store);
362 static ssize_t qeth_l3_dev_ipato_invert4_show(struct device *dev,
363 struct device_attribute *attr, char *buf)
365 struct qeth_card *card = dev_get_drvdata(dev);
367 return sprintf(buf, "%i\n", card->ipato.invert4? 1:0);
370 static ssize_t qeth_l3_dev_ipato_invert4_store(struct device *dev,
371 struct device_attribute *attr,
372 const char *buf, size_t count)
374 struct qeth_card *card = dev_get_drvdata(dev);
378 mutex_lock(&card->conf_mutex);
379 if (sysfs_streq(buf, "toggle")) {
380 invert = !card->ipato.invert4;
381 } else if (kstrtobool(buf, &invert)) {
386 if (card->ipato.invert4 != invert) {
387 card->ipato.invert4 = invert;
388 mutex_lock(&card->ip_lock);
389 qeth_l3_update_ipato(card);
390 mutex_unlock(&card->ip_lock);
393 mutex_unlock(&card->conf_mutex);
394 return rc ? rc : count;
397 static QETH_DEVICE_ATTR(ipato_invert4, invert4, 0644,
398 qeth_l3_dev_ipato_invert4_show,
399 qeth_l3_dev_ipato_invert4_store);
401 static ssize_t qeth_l3_dev_ipato_add_show(char *buf, struct qeth_card *card,
402 enum qeth_prot_versions proto)
404 struct qeth_ipato_entry *ipatoe;
407 mutex_lock(&card->ip_lock);
408 list_for_each_entry(ipatoe, &card->ipato.entries, entry) {
412 if (ipatoe->proto != proto)
415 entry_len = qeth_l3_ipaddr_to_string(proto, ipatoe->addr,
420 /* Append /%mask to the entry: */
421 entry_len += 1 + ((proto == QETH_PROT_IPV4) ? 2 : 3);
422 /* Enough room to format %entry\n into null terminated page? */
423 if (entry_len + 1 > PAGE_SIZE - str_len - 1)
426 entry_len = scnprintf(buf, PAGE_SIZE - str_len,
427 "%s/%i\n", addr_str, ipatoe->mask_bits);
428 str_len += entry_len;
431 mutex_unlock(&card->ip_lock);
433 return str_len ? str_len : scnprintf(buf, PAGE_SIZE, "\n");
436 static ssize_t qeth_l3_dev_ipato_add4_show(struct device *dev,
437 struct device_attribute *attr, char *buf)
439 struct qeth_card *card = dev_get_drvdata(dev);
441 return qeth_l3_dev_ipato_add_show(buf, card, QETH_PROT_IPV4);
444 static int qeth_l3_parse_ipatoe(const char *buf, enum qeth_prot_versions proto,
445 u8 *addr, int *mask_bits)
447 const char *start, *end;
449 char buffer[40] = {0, };
452 /* get address string */
453 end = strchr(start, '/');
454 if (!end || (end - start >= 40)) {
457 strncpy(buffer, start, end - start);
458 if (qeth_l3_string_to_ipaddr(buffer, proto, addr)) {
462 *mask_bits = simple_strtoul(start, &tmp, 10);
463 if (!strlen(start) ||
465 (*mask_bits > ((proto == QETH_PROT_IPV4) ? 32 : 128))) {
471 static ssize_t qeth_l3_dev_ipato_add_store(const char *buf, size_t count,
472 struct qeth_card *card, enum qeth_prot_versions proto)
474 struct qeth_ipato_entry *ipatoe;
479 rc = qeth_l3_parse_ipatoe(buf, proto, addr, &mask_bits);
483 ipatoe = kzalloc(sizeof(struct qeth_ipato_entry), GFP_KERNEL);
487 ipatoe->proto = proto;
488 memcpy(ipatoe->addr, addr, (proto == QETH_PROT_IPV4)? 4:16);
489 ipatoe->mask_bits = mask_bits;
491 rc = qeth_l3_add_ipato_entry(card, ipatoe);
495 return rc ? rc : count;
498 static ssize_t qeth_l3_dev_ipato_add4_store(struct device *dev,
499 struct device_attribute *attr, const char *buf, size_t count)
501 struct qeth_card *card = dev_get_drvdata(dev);
503 return qeth_l3_dev_ipato_add_store(buf, count, card, QETH_PROT_IPV4);
506 static QETH_DEVICE_ATTR(ipato_add4, add4, 0644,
507 qeth_l3_dev_ipato_add4_show,
508 qeth_l3_dev_ipato_add4_store);
510 static ssize_t qeth_l3_dev_ipato_del_store(const char *buf, size_t count,
511 struct qeth_card *card, enum qeth_prot_versions proto)
517 rc = qeth_l3_parse_ipatoe(buf, proto, addr, &mask_bits);
519 rc = qeth_l3_del_ipato_entry(card, proto, addr, mask_bits);
520 return rc ? rc : count;
523 static ssize_t qeth_l3_dev_ipato_del4_store(struct device *dev,
524 struct device_attribute *attr, const char *buf, size_t count)
526 struct qeth_card *card = dev_get_drvdata(dev);
528 return qeth_l3_dev_ipato_del_store(buf, count, card, QETH_PROT_IPV4);
531 static QETH_DEVICE_ATTR(ipato_del4, del4, 0200, NULL,
532 qeth_l3_dev_ipato_del4_store);
534 static ssize_t qeth_l3_dev_ipato_invert6_show(struct device *dev,
535 struct device_attribute *attr, char *buf)
537 struct qeth_card *card = dev_get_drvdata(dev);
539 return sprintf(buf, "%i\n", card->ipato.invert6? 1:0);
542 static ssize_t qeth_l3_dev_ipato_invert6_store(struct device *dev,
543 struct device_attribute *attr, const char *buf, size_t count)
545 struct qeth_card *card = dev_get_drvdata(dev);
549 mutex_lock(&card->conf_mutex);
550 if (sysfs_streq(buf, "toggle")) {
551 invert = !card->ipato.invert6;
552 } else if (kstrtobool(buf, &invert)) {
557 if (card->ipato.invert6 != invert) {
558 card->ipato.invert6 = invert;
559 mutex_lock(&card->ip_lock);
560 qeth_l3_update_ipato(card);
561 mutex_unlock(&card->ip_lock);
564 mutex_unlock(&card->conf_mutex);
565 return rc ? rc : count;
568 static QETH_DEVICE_ATTR(ipato_invert6, invert6, 0644,
569 qeth_l3_dev_ipato_invert6_show,
570 qeth_l3_dev_ipato_invert6_store);
573 static ssize_t qeth_l3_dev_ipato_add6_show(struct device *dev,
574 struct device_attribute *attr, char *buf)
576 struct qeth_card *card = dev_get_drvdata(dev);
578 return qeth_l3_dev_ipato_add_show(buf, card, QETH_PROT_IPV6);
581 static ssize_t qeth_l3_dev_ipato_add6_store(struct device *dev,
582 struct device_attribute *attr, const char *buf, size_t count)
584 struct qeth_card *card = dev_get_drvdata(dev);
586 return qeth_l3_dev_ipato_add_store(buf, count, card, QETH_PROT_IPV6);
589 static QETH_DEVICE_ATTR(ipato_add6, add6, 0644,
590 qeth_l3_dev_ipato_add6_show,
591 qeth_l3_dev_ipato_add6_store);
593 static ssize_t qeth_l3_dev_ipato_del6_store(struct device *dev,
594 struct device_attribute *attr, const char *buf, size_t count)
596 struct qeth_card *card = dev_get_drvdata(dev);
598 return qeth_l3_dev_ipato_del_store(buf, count, card, QETH_PROT_IPV6);
601 static QETH_DEVICE_ATTR(ipato_del6, del6, 0200, NULL,
602 qeth_l3_dev_ipato_del6_store);
604 static struct attribute *qeth_ipato_device_attrs[] = {
605 &dev_attr_ipato_enable.attr,
606 &dev_attr_ipato_invert4.attr,
607 &dev_attr_ipato_add4.attr,
608 &dev_attr_ipato_del4.attr,
609 &dev_attr_ipato_invert6.attr,
610 &dev_attr_ipato_add6.attr,
611 &dev_attr_ipato_del6.attr,
615 static const struct attribute_group qeth_device_ipato_group = {
616 .name = "ipa_takeover",
617 .attrs = qeth_ipato_device_attrs,
620 static ssize_t qeth_l3_dev_ip_add_show(struct device *dev, char *buf,
621 enum qeth_prot_versions proto,
622 enum qeth_ip_types type)
624 struct qeth_card *card = dev_get_drvdata(dev);
625 struct qeth_ipaddr *ipaddr;
629 mutex_lock(&card->ip_lock);
630 hash_for_each(card->ip_htable, i, ipaddr, hnode) {
634 if (ipaddr->proto != proto || ipaddr->type != type)
637 entry_len = qeth_l3_ipaddr_to_string(proto, (u8 *)&ipaddr->u,
642 /* Enough room to format %addr\n into null terminated page? */
643 if (entry_len + 1 > PAGE_SIZE - str_len - 1)
646 entry_len = scnprintf(buf, PAGE_SIZE - str_len, "%s\n",
648 str_len += entry_len;
651 mutex_unlock(&card->ip_lock);
653 return str_len ? str_len : scnprintf(buf, PAGE_SIZE, "\n");
656 static ssize_t qeth_l3_dev_vipa_add4_show(struct device *dev,
657 struct device_attribute *attr,
660 return qeth_l3_dev_ip_add_show(dev, buf, QETH_PROT_IPV4,
664 static ssize_t qeth_l3_vipa_store(struct device *dev, const char *buf, bool add,
665 size_t count, enum qeth_prot_versions proto)
667 struct qeth_card *card = dev_get_drvdata(dev);
671 rc = qeth_l3_string_to_ipaddr(buf, proto, addr);
673 rc = qeth_l3_modify_rxip_vipa(card, add, addr,
674 QETH_IP_TYPE_VIPA, proto);
675 return rc ? rc : count;
678 static ssize_t qeth_l3_dev_vipa_add4_store(struct device *dev,
679 struct device_attribute *attr, const char *buf, size_t count)
681 return qeth_l3_vipa_store(dev, buf, true, count, QETH_PROT_IPV4);
684 static QETH_DEVICE_ATTR(vipa_add4, add4, 0644,
685 qeth_l3_dev_vipa_add4_show,
686 qeth_l3_dev_vipa_add4_store);
688 static ssize_t qeth_l3_dev_vipa_del4_store(struct device *dev,
689 struct device_attribute *attr, const char *buf, size_t count)
691 return qeth_l3_vipa_store(dev, buf, true, count, QETH_PROT_IPV4);
694 static QETH_DEVICE_ATTR(vipa_del4, del4, 0200, NULL,
695 qeth_l3_dev_vipa_del4_store);
697 static ssize_t qeth_l3_dev_vipa_add6_show(struct device *dev,
698 struct device_attribute *attr,
701 return qeth_l3_dev_ip_add_show(dev, buf, QETH_PROT_IPV6,
705 static ssize_t qeth_l3_dev_vipa_add6_store(struct device *dev,
706 struct device_attribute *attr, const char *buf, size_t count)
708 return qeth_l3_vipa_store(dev, buf, true, count, QETH_PROT_IPV6);
711 static QETH_DEVICE_ATTR(vipa_add6, add6, 0644,
712 qeth_l3_dev_vipa_add6_show,
713 qeth_l3_dev_vipa_add6_store);
715 static ssize_t qeth_l3_dev_vipa_del6_store(struct device *dev,
716 struct device_attribute *attr, const char *buf, size_t count)
718 return qeth_l3_vipa_store(dev, buf, false, count, QETH_PROT_IPV6);
721 static QETH_DEVICE_ATTR(vipa_del6, del6, 0200, NULL,
722 qeth_l3_dev_vipa_del6_store);
724 static struct attribute *qeth_vipa_device_attrs[] = {
725 &dev_attr_vipa_add4.attr,
726 &dev_attr_vipa_del4.attr,
727 &dev_attr_vipa_add6.attr,
728 &dev_attr_vipa_del6.attr,
732 static const struct attribute_group qeth_device_vipa_group = {
734 .attrs = qeth_vipa_device_attrs,
737 static ssize_t qeth_l3_dev_rxip_add4_show(struct device *dev,
738 struct device_attribute *attr,
741 return qeth_l3_dev_ip_add_show(dev, buf, QETH_PROT_IPV4,
745 static int qeth_l3_parse_rxipe(const char *buf, enum qeth_prot_versions proto,
749 struct in6_addr ipv6_addr;
751 if (qeth_l3_string_to_ipaddr(buf, proto, addr)) {
754 if (proto == QETH_PROT_IPV4) {
755 memcpy(&ipv4_addr, addr, sizeof(ipv4_addr));
756 if (ipv4_is_multicast(ipv4_addr)) {
757 QETH_DBF_MESSAGE(2, "multicast rxip not supported.\n");
760 } else if (proto == QETH_PROT_IPV6) {
761 memcpy(&ipv6_addr, addr, sizeof(ipv6_addr));
762 if (ipv6_addr_is_multicast(&ipv6_addr)) {
763 QETH_DBF_MESSAGE(2, "multicast rxip not supported.\n");
771 static ssize_t qeth_l3_rxip_store(struct device *dev, const char *buf, bool add,
772 size_t count, enum qeth_prot_versions proto)
774 struct qeth_card *card = dev_get_drvdata(dev);
778 rc = qeth_l3_parse_rxipe(buf, proto, addr);
780 rc = qeth_l3_modify_rxip_vipa(card, add, addr,
781 QETH_IP_TYPE_RXIP, proto);
782 return rc ? rc : count;
785 static ssize_t qeth_l3_dev_rxip_add4_store(struct device *dev,
786 struct device_attribute *attr, const char *buf, size_t count)
788 return qeth_l3_rxip_store(dev, buf, true, count, QETH_PROT_IPV4);
791 static QETH_DEVICE_ATTR(rxip_add4, add4, 0644,
792 qeth_l3_dev_rxip_add4_show,
793 qeth_l3_dev_rxip_add4_store);
795 static ssize_t qeth_l3_dev_rxip_del4_store(struct device *dev,
796 struct device_attribute *attr, const char *buf, size_t count)
798 return qeth_l3_rxip_store(dev, buf, false, count, QETH_PROT_IPV4);
801 static QETH_DEVICE_ATTR(rxip_del4, del4, 0200, NULL,
802 qeth_l3_dev_rxip_del4_store);
804 static ssize_t qeth_l3_dev_rxip_add6_show(struct device *dev,
805 struct device_attribute *attr,
808 return qeth_l3_dev_ip_add_show(dev, buf, QETH_PROT_IPV6,
812 static ssize_t qeth_l3_dev_rxip_add6_store(struct device *dev,
813 struct device_attribute *attr, const char *buf, size_t count)
815 return qeth_l3_rxip_store(dev, buf, true, count, QETH_PROT_IPV6);
818 static QETH_DEVICE_ATTR(rxip_add6, add6, 0644,
819 qeth_l3_dev_rxip_add6_show,
820 qeth_l3_dev_rxip_add6_store);
822 static ssize_t qeth_l3_dev_rxip_del6_store(struct device *dev,
823 struct device_attribute *attr, const char *buf, size_t count)
825 return qeth_l3_rxip_store(dev, buf, false, count, QETH_PROT_IPV6);
828 static QETH_DEVICE_ATTR(rxip_del6, del6, 0200, NULL,
829 qeth_l3_dev_rxip_del6_store);
831 static struct attribute *qeth_rxip_device_attrs[] = {
832 &dev_attr_rxip_add4.attr,
833 &dev_attr_rxip_del4.attr,
834 &dev_attr_rxip_add6.attr,
835 &dev_attr_rxip_del6.attr,
839 static const struct attribute_group qeth_device_rxip_group = {
841 .attrs = qeth_rxip_device_attrs,
844 static const struct attribute_group *qeth_l3_only_attr_groups[] = {
845 &qeth_l3_device_attr_group,
846 &qeth_device_ipato_group,
847 &qeth_device_vipa_group,
848 &qeth_device_rxip_group,
852 int qeth_l3_create_device_attributes(struct device *dev)
854 return sysfs_create_groups(&dev->kobj, qeth_l3_only_attr_groups);
857 void qeth_l3_remove_device_attributes(struct device *dev)
859 sysfs_remove_groups(&dev->kobj, qeth_l3_only_attr_groups);
862 const struct attribute_group *qeth_l3_attr_groups[] = {
863 &qeth_device_attr_group,
864 &qeth_device_blkt_group,
865 /* l3 specific, see qeth_l3_only_attr_groups: */
866 &qeth_l3_device_attr_group,
867 &qeth_device_ipato_group,
868 &qeth_device_vipa_group,
869 &qeth_device_rxip_group,