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);
66 return qeth_l3_dev_route_show(card, &card->options.route4, buf);
69 static ssize_t qeth_l3_dev_route_store(struct qeth_card *card,
70 struct qeth_routing_info *route, enum qeth_prot_versions prot,
71 const char *buf, size_t count)
73 enum qeth_routing_types old_route_type = route->type;
76 mutex_lock(&card->conf_mutex);
77 if (sysfs_streq(buf, "no_router")) {
78 route->type = NO_ROUTER;
79 } else if (sysfs_streq(buf, "primary_connector")) {
80 route->type = PRIMARY_CONNECTOR;
81 } else if (sysfs_streq(buf, "secondary_connector")) {
82 route->type = SECONDARY_CONNECTOR;
83 } else if (sysfs_streq(buf, "primary_router")) {
84 route->type = PRIMARY_ROUTER;
85 } else if (sysfs_streq(buf, "secondary_router")) {
86 route->type = SECONDARY_ROUTER;
87 } else if (sysfs_streq(buf, "multicast_router")) {
88 route->type = MULTICAST_ROUTER;
93 if (qeth_card_hw_is_reachable(card) &&
94 (old_route_type != route->type)) {
95 if (prot == QETH_PROT_IPV4)
96 rc = qeth_l3_setrouting_v4(card);
97 else if (prot == QETH_PROT_IPV6)
98 rc = qeth_l3_setrouting_v6(card);
102 route->type = old_route_type;
103 mutex_unlock(&card->conf_mutex);
104 return rc ? rc : count;
107 static ssize_t qeth_l3_dev_route4_store(struct device *dev,
108 struct device_attribute *attr, const char *buf, size_t count)
110 struct qeth_card *card = dev_get_drvdata(dev);
115 return qeth_l3_dev_route_store(card, &card->options.route4,
116 QETH_PROT_IPV4, buf, count);
119 static DEVICE_ATTR(route4, 0644, qeth_l3_dev_route4_show,
120 qeth_l3_dev_route4_store);
122 static ssize_t qeth_l3_dev_route6_show(struct device *dev,
123 struct device_attribute *attr, char *buf)
125 struct qeth_card *card = dev_get_drvdata(dev);
130 return qeth_l3_dev_route_show(card, &card->options.route6, buf);
133 static ssize_t qeth_l3_dev_route6_store(struct device *dev,
134 struct device_attribute *attr, const char *buf, size_t count)
136 struct qeth_card *card = dev_get_drvdata(dev);
141 return qeth_l3_dev_route_store(card, &card->options.route6,
142 QETH_PROT_IPV6, buf, count);
145 static DEVICE_ATTR(route6, 0644, qeth_l3_dev_route6_show,
146 qeth_l3_dev_route6_store);
148 static ssize_t qeth_l3_dev_fake_broadcast_show(struct device *dev,
149 struct device_attribute *attr, char *buf)
151 struct qeth_card *card = dev_get_drvdata(dev);
156 return sprintf(buf, "%i\n", card->options.fake_broadcast? 1:0);
159 static ssize_t qeth_l3_dev_fake_broadcast_store(struct device *dev,
160 struct device_attribute *attr, const char *buf, size_t count)
162 struct qeth_card *card = dev_get_drvdata(dev);
169 mutex_lock(&card->conf_mutex);
170 if ((card->state != CARD_STATE_DOWN) &&
171 (card->state != CARD_STATE_RECOVER)) {
176 i = simple_strtoul(buf, &tmp, 16);
177 if ((i == 0) || (i == 1))
178 card->options.fake_broadcast = i;
182 mutex_unlock(&card->conf_mutex);
183 return rc ? rc : count;
186 static DEVICE_ATTR(fake_broadcast, 0644, qeth_l3_dev_fake_broadcast_show,
187 qeth_l3_dev_fake_broadcast_store);
189 static ssize_t qeth_l3_dev_sniffer_show(struct device *dev,
190 struct device_attribute *attr, char *buf)
192 struct qeth_card *card = dev_get_drvdata(dev);
197 return sprintf(buf, "%i\n", card->options.sniffer ? 1 : 0);
200 static ssize_t qeth_l3_dev_sniffer_store(struct device *dev,
201 struct device_attribute *attr, const char *buf, size_t count)
203 struct qeth_card *card = dev_get_drvdata(dev);
210 if (card->info.type != QETH_CARD_TYPE_IQD)
212 if (card->options.cq == QETH_CQ_ENABLED)
215 mutex_lock(&card->conf_mutex);
216 if ((card->state != CARD_STATE_DOWN) &&
217 (card->state != CARD_STATE_RECOVER)) {
222 rc = kstrtoul(buf, 16, &i);
229 card->options.sniffer = i;
232 qdio_get_ssqd_desc(CARD_DDEV(card), &card->ssqd);
233 if (card->ssqd.qdioac2 & QETH_SNIFF_AVAIL) {
234 card->options.sniffer = i;
235 if (card->qdio.init_pool.buf_count !=
236 QETH_IN_BUF_COUNT_MAX)
237 qeth_realloc_buffer_pool(card,
238 QETH_IN_BUF_COUNT_MAX);
246 mutex_unlock(&card->conf_mutex);
247 return rc ? rc : count;
250 static DEVICE_ATTR(sniffer, 0644, qeth_l3_dev_sniffer_show,
251 qeth_l3_dev_sniffer_store);
254 static ssize_t qeth_l3_dev_hsuid_show(struct device *dev,
255 struct device_attribute *attr, char *buf)
257 struct qeth_card *card = dev_get_drvdata(dev);
263 if (card->info.type != QETH_CARD_TYPE_IQD)
266 memcpy(tmp_hsuid, card->options.hsuid, sizeof(tmp_hsuid));
267 EBCASC(tmp_hsuid, 8);
268 return sprintf(buf, "%s\n", tmp_hsuid);
271 static ssize_t qeth_l3_dev_hsuid_store(struct device *dev,
272 struct device_attribute *attr, const char *buf, size_t count)
274 struct qeth_card *card = dev_get_drvdata(dev);
281 if (card->info.type != QETH_CARD_TYPE_IQD)
283 if (card->state != CARD_STATE_DOWN &&
284 card->state != CARD_STATE_RECOVER)
286 if (card->options.sniffer)
288 if (card->options.cq == QETH_CQ_NOTAVAILABLE)
291 tmp = strsep((char **)&buf, "\n");
295 if (card->options.hsuid[0])
296 /* delete old ip address */
297 qeth_l3_modify_hsuid(card, false);
299 if (strlen(tmp) == 0) {
300 /* delete ip address only */
301 card->options.hsuid[0] = '\0';
302 memcpy(card->dev->perm_addr, card->options.hsuid, 9);
303 qeth_configure_cq(card, QETH_CQ_DISABLED);
307 if (qeth_configure_cq(card, QETH_CQ_ENABLED))
310 snprintf(card->options.hsuid, sizeof(card->options.hsuid),
312 ASCEBC(card->options.hsuid, 8);
313 memcpy(card->dev->perm_addr, card->options.hsuid, 9);
315 rc = qeth_l3_modify_hsuid(card, true);
317 return rc ? rc : count;
320 static DEVICE_ATTR(hsuid, 0644, qeth_l3_dev_hsuid_show,
321 qeth_l3_dev_hsuid_store);
324 static struct attribute *qeth_l3_device_attrs[] = {
325 &dev_attr_route4.attr,
326 &dev_attr_route6.attr,
327 &dev_attr_fake_broadcast.attr,
328 &dev_attr_sniffer.attr,
329 &dev_attr_hsuid.attr,
333 static const struct attribute_group qeth_l3_device_attr_group = {
334 .attrs = qeth_l3_device_attrs,
337 static ssize_t qeth_l3_dev_ipato_enable_show(struct device *dev,
338 struct device_attribute *attr, char *buf)
340 struct qeth_card *card = dev_get_drvdata(dev);
345 return sprintf(buf, "%i\n", card->ipato.enabled? 1:0);
348 static ssize_t qeth_l3_dev_ipato_enable_store(struct device *dev,
349 struct device_attribute *attr, const char *buf, size_t count)
351 struct qeth_card *card = dev_get_drvdata(dev);
358 mutex_lock(&card->conf_mutex);
359 if ((card->state != CARD_STATE_DOWN) &&
360 (card->state != CARD_STATE_RECOVER)) {
365 if (sysfs_streq(buf, "toggle")) {
366 enable = !card->ipato.enabled;
367 } else if (kstrtobool(buf, &enable)) {
372 if (card->ipato.enabled != enable) {
373 card->ipato.enabled = enable;
374 spin_lock_bh(&card->ip_lock);
375 qeth_l3_update_ipato(card);
376 spin_unlock_bh(&card->ip_lock);
379 mutex_unlock(&card->conf_mutex);
380 return rc ? rc : count;
383 static QETH_DEVICE_ATTR(ipato_enable, enable, 0644,
384 qeth_l3_dev_ipato_enable_show,
385 qeth_l3_dev_ipato_enable_store);
387 static ssize_t qeth_l3_dev_ipato_invert4_show(struct device *dev,
388 struct device_attribute *attr, char *buf)
390 struct qeth_card *card = dev_get_drvdata(dev);
395 return sprintf(buf, "%i\n", card->ipato.invert4? 1:0);
398 static ssize_t qeth_l3_dev_ipato_invert4_store(struct device *dev,
399 struct device_attribute *attr,
400 const char *buf, size_t count)
402 struct qeth_card *card = dev_get_drvdata(dev);
409 mutex_lock(&card->conf_mutex);
410 if (sysfs_streq(buf, "toggle")) {
411 invert = !card->ipato.invert4;
412 } else if (kstrtobool(buf, &invert)) {
417 if (card->ipato.invert4 != invert) {
418 card->ipato.invert4 = invert;
419 spin_lock_bh(&card->ip_lock);
420 qeth_l3_update_ipato(card);
421 spin_unlock_bh(&card->ip_lock);
424 mutex_unlock(&card->conf_mutex);
425 return rc ? rc : count;
428 static QETH_DEVICE_ATTR(ipato_invert4, invert4, 0644,
429 qeth_l3_dev_ipato_invert4_show,
430 qeth_l3_dev_ipato_invert4_store);
432 static ssize_t qeth_l3_dev_ipato_add_show(char *buf, struct qeth_card *card,
433 enum qeth_prot_versions proto)
435 struct qeth_ipato_entry *ipatoe;
437 int entry_len; /* length of 1 entry string, differs between v4 and v6 */
440 entry_len = (proto == QETH_PROT_IPV4)? 12 : 40;
441 /* add strlen for "/<mask>\n" */
442 entry_len += (proto == QETH_PROT_IPV4)? 5 : 6;
443 spin_lock_bh(&card->ip_lock);
444 list_for_each_entry(ipatoe, &card->ipato.entries, entry) {
445 if (ipatoe->proto != proto)
447 /* String must not be longer than PAGE_SIZE. So we check if
448 * string length gets near PAGE_SIZE. Then we can savely display
449 * the next IPv6 address (worst case, compared to IPv4) */
450 if ((PAGE_SIZE - i) <= entry_len)
452 qeth_l3_ipaddr_to_string(proto, ipatoe->addr, addr_str);
453 i += snprintf(buf + i, PAGE_SIZE - i,
454 "%s/%i\n", addr_str, ipatoe->mask_bits);
456 spin_unlock_bh(&card->ip_lock);
457 i += snprintf(buf + i, PAGE_SIZE - i, "\n");
462 static ssize_t qeth_l3_dev_ipato_add4_show(struct device *dev,
463 struct device_attribute *attr, char *buf)
465 struct qeth_card *card = dev_get_drvdata(dev);
470 return qeth_l3_dev_ipato_add_show(buf, card, QETH_PROT_IPV4);
473 static int qeth_l3_parse_ipatoe(const char *buf, enum qeth_prot_versions proto,
474 u8 *addr, int *mask_bits)
476 const char *start, *end;
478 char buffer[40] = {0, };
481 /* get address string */
482 end = strchr(start, '/');
483 if (!end || (end - start >= 40)) {
486 strncpy(buffer, start, end - start);
487 if (qeth_l3_string_to_ipaddr(buffer, proto, addr)) {
491 *mask_bits = simple_strtoul(start, &tmp, 10);
492 if (!strlen(start) ||
494 (*mask_bits > ((proto == QETH_PROT_IPV4) ? 32 : 128))) {
500 static ssize_t qeth_l3_dev_ipato_add_store(const char *buf, size_t count,
501 struct qeth_card *card, enum qeth_prot_versions proto)
503 struct qeth_ipato_entry *ipatoe;
508 mutex_lock(&card->conf_mutex);
509 rc = qeth_l3_parse_ipatoe(buf, proto, addr, &mask_bits);
513 ipatoe = kzalloc(sizeof(struct qeth_ipato_entry), GFP_KERNEL);
518 ipatoe->proto = proto;
519 memcpy(ipatoe->addr, addr, (proto == QETH_PROT_IPV4)? 4:16);
520 ipatoe->mask_bits = mask_bits;
522 rc = qeth_l3_add_ipato_entry(card, ipatoe);
526 mutex_unlock(&card->conf_mutex);
527 return rc ? rc : count;
530 static ssize_t qeth_l3_dev_ipato_add4_store(struct device *dev,
531 struct device_attribute *attr, const char *buf, size_t count)
533 struct qeth_card *card = dev_get_drvdata(dev);
538 return qeth_l3_dev_ipato_add_store(buf, count, card, QETH_PROT_IPV4);
541 static QETH_DEVICE_ATTR(ipato_add4, add4, 0644,
542 qeth_l3_dev_ipato_add4_show,
543 qeth_l3_dev_ipato_add4_store);
545 static ssize_t qeth_l3_dev_ipato_del_store(const char *buf, size_t count,
546 struct qeth_card *card, enum qeth_prot_versions proto)
552 mutex_lock(&card->conf_mutex);
553 rc = qeth_l3_parse_ipatoe(buf, proto, addr, &mask_bits);
555 rc = qeth_l3_del_ipato_entry(card, proto, addr, mask_bits);
556 mutex_unlock(&card->conf_mutex);
557 return rc ? rc : count;
560 static ssize_t qeth_l3_dev_ipato_del4_store(struct device *dev,
561 struct device_attribute *attr, const char *buf, size_t count)
563 struct qeth_card *card = dev_get_drvdata(dev);
568 return qeth_l3_dev_ipato_del_store(buf, count, card, QETH_PROT_IPV4);
571 static QETH_DEVICE_ATTR(ipato_del4, del4, 0200, NULL,
572 qeth_l3_dev_ipato_del4_store);
574 static ssize_t qeth_l3_dev_ipato_invert6_show(struct device *dev,
575 struct device_attribute *attr, char *buf)
577 struct qeth_card *card = dev_get_drvdata(dev);
582 return sprintf(buf, "%i\n", card->ipato.invert6? 1:0);
585 static ssize_t qeth_l3_dev_ipato_invert6_store(struct device *dev,
586 struct device_attribute *attr, const char *buf, size_t count)
588 struct qeth_card *card = dev_get_drvdata(dev);
595 mutex_lock(&card->conf_mutex);
596 if (sysfs_streq(buf, "toggle")) {
597 invert = !card->ipato.invert6;
598 } else if (kstrtobool(buf, &invert)) {
603 if (card->ipato.invert6 != invert) {
604 card->ipato.invert6 = invert;
605 spin_lock_bh(&card->ip_lock);
606 qeth_l3_update_ipato(card);
607 spin_unlock_bh(&card->ip_lock);
610 mutex_unlock(&card->conf_mutex);
611 return rc ? rc : count;
614 static QETH_DEVICE_ATTR(ipato_invert6, invert6, 0644,
615 qeth_l3_dev_ipato_invert6_show,
616 qeth_l3_dev_ipato_invert6_store);
619 static ssize_t qeth_l3_dev_ipato_add6_show(struct device *dev,
620 struct device_attribute *attr, char *buf)
622 struct qeth_card *card = dev_get_drvdata(dev);
627 return qeth_l3_dev_ipato_add_show(buf, card, QETH_PROT_IPV6);
630 static ssize_t qeth_l3_dev_ipato_add6_store(struct device *dev,
631 struct device_attribute *attr, const char *buf, size_t count)
633 struct qeth_card *card = dev_get_drvdata(dev);
638 return qeth_l3_dev_ipato_add_store(buf, count, card, QETH_PROT_IPV6);
641 static QETH_DEVICE_ATTR(ipato_add6, add6, 0644,
642 qeth_l3_dev_ipato_add6_show,
643 qeth_l3_dev_ipato_add6_store);
645 static ssize_t qeth_l3_dev_ipato_del6_store(struct device *dev,
646 struct device_attribute *attr, const char *buf, size_t count)
648 struct qeth_card *card = dev_get_drvdata(dev);
653 return qeth_l3_dev_ipato_del_store(buf, count, card, QETH_PROT_IPV6);
656 static QETH_DEVICE_ATTR(ipato_del6, del6, 0200, NULL,
657 qeth_l3_dev_ipato_del6_store);
659 static struct attribute *qeth_ipato_device_attrs[] = {
660 &dev_attr_ipato_enable.attr,
661 &dev_attr_ipato_invert4.attr,
662 &dev_attr_ipato_add4.attr,
663 &dev_attr_ipato_del4.attr,
664 &dev_attr_ipato_invert6.attr,
665 &dev_attr_ipato_add6.attr,
666 &dev_attr_ipato_del6.attr,
670 static const struct attribute_group qeth_device_ipato_group = {
671 .name = "ipa_takeover",
672 .attrs = qeth_ipato_device_attrs,
675 static ssize_t qeth_l3_dev_ip_add_show(struct device *dev, char *buf,
676 enum qeth_prot_versions proto,
677 enum qeth_ip_types type)
679 struct qeth_card *card = dev_get_drvdata(dev);
680 struct qeth_ipaddr *ipaddr;
683 int entry_len; /* length of 1 entry string, differs between v4 and v6 */
689 entry_len = (proto == QETH_PROT_IPV4)? 12 : 40;
690 entry_len += 2; /* \n + terminator */
691 spin_lock_bh(&card->ip_lock);
692 hash_for_each(card->ip_htable, i, ipaddr, hnode) {
693 if (ipaddr->proto != proto || ipaddr->type != type)
695 /* String must not be longer than PAGE_SIZE. So we check if
696 * string length gets near PAGE_SIZE. Then we can savely display
697 * the next IPv6 address (worst case, compared to IPv4) */
698 if ((PAGE_SIZE - str_len) <= entry_len)
700 qeth_l3_ipaddr_to_string(proto, (const u8 *)&ipaddr->u,
702 str_len += snprintf(buf + str_len, PAGE_SIZE - str_len, "%s\n",
705 spin_unlock_bh(&card->ip_lock);
706 str_len += snprintf(buf + str_len, PAGE_SIZE - str_len, "\n");
711 static ssize_t qeth_l3_dev_vipa_add4_show(struct device *dev,
712 struct device_attribute *attr,
715 return qeth_l3_dev_ip_add_show(dev, buf, QETH_PROT_IPV4,
719 static int qeth_l3_parse_vipae(const char *buf, enum qeth_prot_versions proto,
722 if (qeth_l3_string_to_ipaddr(buf, proto, addr)) {
728 static ssize_t qeth_l3_dev_vipa_add_store(const char *buf, size_t count,
729 struct qeth_card *card, enum qeth_prot_versions proto)
734 mutex_lock(&card->conf_mutex);
735 rc = qeth_l3_parse_vipae(buf, proto, addr);
737 rc = qeth_l3_modify_rxip_vipa(card, true, addr,
738 QETH_IP_TYPE_VIPA, proto);
739 mutex_unlock(&card->conf_mutex);
740 return rc ? rc : count;
743 static ssize_t qeth_l3_dev_vipa_add4_store(struct device *dev,
744 struct device_attribute *attr, const char *buf, size_t count)
746 struct qeth_card *card = dev_get_drvdata(dev);
751 return qeth_l3_dev_vipa_add_store(buf, count, card, QETH_PROT_IPV4);
754 static QETH_DEVICE_ATTR(vipa_add4, add4, 0644,
755 qeth_l3_dev_vipa_add4_show,
756 qeth_l3_dev_vipa_add4_store);
758 static ssize_t qeth_l3_dev_vipa_del_store(const char *buf, size_t count,
759 struct qeth_card *card, enum qeth_prot_versions proto)
764 mutex_lock(&card->conf_mutex);
765 rc = qeth_l3_parse_vipae(buf, proto, addr);
767 rc = qeth_l3_modify_rxip_vipa(card, false, addr,
768 QETH_IP_TYPE_VIPA, proto);
769 mutex_unlock(&card->conf_mutex);
770 return rc ? rc : count;
773 static ssize_t qeth_l3_dev_vipa_del4_store(struct device *dev,
774 struct device_attribute *attr, const char *buf, size_t count)
776 struct qeth_card *card = dev_get_drvdata(dev);
781 return qeth_l3_dev_vipa_del_store(buf, count, card, QETH_PROT_IPV4);
784 static QETH_DEVICE_ATTR(vipa_del4, del4, 0200, NULL,
785 qeth_l3_dev_vipa_del4_store);
787 static ssize_t qeth_l3_dev_vipa_add6_show(struct device *dev,
788 struct device_attribute *attr,
791 return qeth_l3_dev_ip_add_show(dev, buf, QETH_PROT_IPV6,
795 static ssize_t qeth_l3_dev_vipa_add6_store(struct device *dev,
796 struct device_attribute *attr, const char *buf, size_t count)
798 struct qeth_card *card = dev_get_drvdata(dev);
803 return qeth_l3_dev_vipa_add_store(buf, count, card, QETH_PROT_IPV6);
806 static QETH_DEVICE_ATTR(vipa_add6, add6, 0644,
807 qeth_l3_dev_vipa_add6_show,
808 qeth_l3_dev_vipa_add6_store);
810 static ssize_t qeth_l3_dev_vipa_del6_store(struct device *dev,
811 struct device_attribute *attr, const char *buf, size_t count)
813 struct qeth_card *card = dev_get_drvdata(dev);
818 return qeth_l3_dev_vipa_del_store(buf, count, card, QETH_PROT_IPV6);
821 static QETH_DEVICE_ATTR(vipa_del6, del6, 0200, NULL,
822 qeth_l3_dev_vipa_del6_store);
824 static struct attribute *qeth_vipa_device_attrs[] = {
825 &dev_attr_vipa_add4.attr,
826 &dev_attr_vipa_del4.attr,
827 &dev_attr_vipa_add6.attr,
828 &dev_attr_vipa_del6.attr,
832 static const struct attribute_group qeth_device_vipa_group = {
834 .attrs = qeth_vipa_device_attrs,
837 static ssize_t qeth_l3_dev_rxip_add4_show(struct device *dev,
838 struct device_attribute *attr,
841 return qeth_l3_dev_ip_add_show(dev, buf, QETH_PROT_IPV4,
845 static int qeth_l3_parse_rxipe(const char *buf, enum qeth_prot_versions proto,
849 struct in6_addr ipv6_addr;
851 if (qeth_l3_string_to_ipaddr(buf, proto, addr)) {
854 if (proto == QETH_PROT_IPV4) {
855 memcpy(&ipv4_addr, addr, sizeof(ipv4_addr));
856 if (ipv4_is_multicast(ipv4_addr)) {
857 QETH_DBF_MESSAGE(2, "multicast rxip not supported.\n");
860 } else if (proto == QETH_PROT_IPV6) {
861 memcpy(&ipv6_addr, addr, sizeof(ipv6_addr));
862 if (ipv6_addr_is_multicast(&ipv6_addr)) {
863 QETH_DBF_MESSAGE(2, "multicast rxip not supported.\n");
871 static ssize_t qeth_l3_dev_rxip_add_store(const char *buf, size_t count,
872 struct qeth_card *card, enum qeth_prot_versions proto)
877 mutex_lock(&card->conf_mutex);
878 rc = qeth_l3_parse_rxipe(buf, proto, addr);
880 rc = qeth_l3_modify_rxip_vipa(card, true, addr,
881 QETH_IP_TYPE_RXIP, proto);
882 mutex_unlock(&card->conf_mutex);
883 return rc ? rc : count;
886 static ssize_t qeth_l3_dev_rxip_add4_store(struct device *dev,
887 struct device_attribute *attr, const char *buf, size_t count)
889 struct qeth_card *card = dev_get_drvdata(dev);
894 return qeth_l3_dev_rxip_add_store(buf, count, card, QETH_PROT_IPV4);
897 static QETH_DEVICE_ATTR(rxip_add4, add4, 0644,
898 qeth_l3_dev_rxip_add4_show,
899 qeth_l3_dev_rxip_add4_store);
901 static ssize_t qeth_l3_dev_rxip_del_store(const char *buf, size_t count,
902 struct qeth_card *card, enum qeth_prot_versions proto)
907 mutex_lock(&card->conf_mutex);
908 rc = qeth_l3_parse_rxipe(buf, proto, addr);
910 rc = qeth_l3_modify_rxip_vipa(card, false, addr,
911 QETH_IP_TYPE_RXIP, proto);
912 mutex_unlock(&card->conf_mutex);
913 return rc ? rc : count;
916 static ssize_t qeth_l3_dev_rxip_del4_store(struct device *dev,
917 struct device_attribute *attr, const char *buf, size_t count)
919 struct qeth_card *card = dev_get_drvdata(dev);
924 return qeth_l3_dev_rxip_del_store(buf, count, card, QETH_PROT_IPV4);
927 static QETH_DEVICE_ATTR(rxip_del4, del4, 0200, NULL,
928 qeth_l3_dev_rxip_del4_store);
930 static ssize_t qeth_l3_dev_rxip_add6_show(struct device *dev,
931 struct device_attribute *attr,
934 return qeth_l3_dev_ip_add_show(dev, buf, QETH_PROT_IPV6,
938 static ssize_t qeth_l3_dev_rxip_add6_store(struct device *dev,
939 struct device_attribute *attr, const char *buf, size_t count)
941 struct qeth_card *card = dev_get_drvdata(dev);
946 return qeth_l3_dev_rxip_add_store(buf, count, card, QETH_PROT_IPV6);
949 static QETH_DEVICE_ATTR(rxip_add6, add6, 0644,
950 qeth_l3_dev_rxip_add6_show,
951 qeth_l3_dev_rxip_add6_store);
953 static ssize_t qeth_l3_dev_rxip_del6_store(struct device *dev,
954 struct device_attribute *attr, const char *buf, size_t count)
956 struct qeth_card *card = dev_get_drvdata(dev);
961 return qeth_l3_dev_rxip_del_store(buf, count, card, QETH_PROT_IPV6);
964 static QETH_DEVICE_ATTR(rxip_del6, del6, 0200, NULL,
965 qeth_l3_dev_rxip_del6_store);
967 static struct attribute *qeth_rxip_device_attrs[] = {
968 &dev_attr_rxip_add4.attr,
969 &dev_attr_rxip_del4.attr,
970 &dev_attr_rxip_add6.attr,
971 &dev_attr_rxip_del6.attr,
975 static const struct attribute_group qeth_device_rxip_group = {
977 .attrs = qeth_rxip_device_attrs,
980 static const struct attribute_group *qeth_l3_only_attr_groups[] = {
981 &qeth_l3_device_attr_group,
982 &qeth_device_ipato_group,
983 &qeth_device_vipa_group,
984 &qeth_device_rxip_group,
988 int qeth_l3_create_device_attributes(struct device *dev)
990 return sysfs_create_groups(&dev->kobj, qeth_l3_only_attr_groups);
993 void qeth_l3_remove_device_attributes(struct device *dev)
995 sysfs_remove_groups(&dev->kobj, qeth_l3_only_attr_groups);
998 const struct attribute_group *qeth_l3_attr_groups[] = {
999 &qeth_device_attr_group,
1000 &qeth_device_blkt_group,
1001 /* l3 specific, see qeth_l3_only_attr_groups: */
1002 &qeth_l3_device_attr_group,
1003 &qeth_device_ipato_group,
1004 &qeth_device_vipa_group,
1005 &qeth_device_rxip_group,