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';
303 memcpy(card->dev->perm_addr, card->options.hsuid, 9);
304 qeth_configure_cq(card, QETH_CQ_DISABLED);
308 if (qeth_configure_cq(card, QETH_CQ_ENABLED))
311 snprintf(card->options.hsuid, sizeof(card->options.hsuid),
313 ASCEBC(card->options.hsuid, 8);
315 memcpy(card->dev->perm_addr, card->options.hsuid, 9);
317 rc = qeth_l3_modify_hsuid(card, true);
319 return rc ? rc : count;
322 static DEVICE_ATTR(hsuid, 0644, qeth_l3_dev_hsuid_show,
323 qeth_l3_dev_hsuid_store);
326 static struct attribute *qeth_l3_device_attrs[] = {
327 &dev_attr_route4.attr,
328 &dev_attr_route6.attr,
329 &dev_attr_fake_broadcast.attr,
330 &dev_attr_sniffer.attr,
331 &dev_attr_hsuid.attr,
335 static const struct attribute_group qeth_l3_device_attr_group = {
336 .attrs = qeth_l3_device_attrs,
339 static ssize_t qeth_l3_dev_ipato_enable_show(struct device *dev,
340 struct device_attribute *attr, char *buf)
342 struct qeth_card *card = dev_get_drvdata(dev);
347 return sprintf(buf, "%i\n", card->ipato.enabled? 1:0);
350 static ssize_t qeth_l3_dev_ipato_enable_store(struct device *dev,
351 struct device_attribute *attr, const char *buf, size_t count)
353 struct qeth_card *card = dev_get_drvdata(dev);
360 mutex_lock(&card->conf_mutex);
361 if ((card->state != CARD_STATE_DOWN) &&
362 (card->state != CARD_STATE_RECOVER)) {
367 if (sysfs_streq(buf, "toggle")) {
368 enable = !card->ipato.enabled;
369 } else if (kstrtobool(buf, &enable)) {
374 if (card->ipato.enabled != enable) {
375 card->ipato.enabled = enable;
376 spin_lock_bh(&card->ip_lock);
377 qeth_l3_update_ipato(card);
378 spin_unlock_bh(&card->ip_lock);
381 mutex_unlock(&card->conf_mutex);
382 return rc ? rc : count;
385 static QETH_DEVICE_ATTR(ipato_enable, enable, 0644,
386 qeth_l3_dev_ipato_enable_show,
387 qeth_l3_dev_ipato_enable_store);
389 static ssize_t qeth_l3_dev_ipato_invert4_show(struct device *dev,
390 struct device_attribute *attr, char *buf)
392 struct qeth_card *card = dev_get_drvdata(dev);
397 return sprintf(buf, "%i\n", card->ipato.invert4? 1:0);
400 static ssize_t qeth_l3_dev_ipato_invert4_store(struct device *dev,
401 struct device_attribute *attr,
402 const char *buf, size_t count)
404 struct qeth_card *card = dev_get_drvdata(dev);
411 mutex_lock(&card->conf_mutex);
412 if (sysfs_streq(buf, "toggle")) {
413 invert = !card->ipato.invert4;
414 } else if (kstrtobool(buf, &invert)) {
419 if (card->ipato.invert4 != invert) {
420 card->ipato.invert4 = invert;
421 spin_lock_bh(&card->ip_lock);
422 qeth_l3_update_ipato(card);
423 spin_unlock_bh(&card->ip_lock);
426 mutex_unlock(&card->conf_mutex);
427 return rc ? rc : count;
430 static QETH_DEVICE_ATTR(ipato_invert4, invert4, 0644,
431 qeth_l3_dev_ipato_invert4_show,
432 qeth_l3_dev_ipato_invert4_store);
434 static ssize_t qeth_l3_dev_ipato_add_show(char *buf, struct qeth_card *card,
435 enum qeth_prot_versions proto)
437 struct qeth_ipato_entry *ipatoe;
439 int entry_len; /* length of 1 entry string, differs between v4 and v6 */
442 entry_len = (proto == QETH_PROT_IPV4)? 12 : 40;
443 /* add strlen for "/<mask>\n" */
444 entry_len += (proto == QETH_PROT_IPV4)? 5 : 6;
445 spin_lock_bh(&card->ip_lock);
446 list_for_each_entry(ipatoe, &card->ipato.entries, entry) {
447 if (ipatoe->proto != proto)
449 /* String must not be longer than PAGE_SIZE. So we check if
450 * string length gets near PAGE_SIZE. Then we can savely display
451 * the next IPv6 address (worst case, compared to IPv4) */
452 if ((PAGE_SIZE - i) <= entry_len)
454 qeth_l3_ipaddr_to_string(proto, ipatoe->addr, addr_str);
455 i += snprintf(buf + i, PAGE_SIZE - i,
456 "%s/%i\n", addr_str, ipatoe->mask_bits);
458 spin_unlock_bh(&card->ip_lock);
459 i += snprintf(buf + i, PAGE_SIZE - i, "\n");
464 static ssize_t qeth_l3_dev_ipato_add4_show(struct device *dev,
465 struct device_attribute *attr, char *buf)
467 struct qeth_card *card = dev_get_drvdata(dev);
472 return qeth_l3_dev_ipato_add_show(buf, card, QETH_PROT_IPV4);
475 static int qeth_l3_parse_ipatoe(const char *buf, enum qeth_prot_versions proto,
476 u8 *addr, int *mask_bits)
478 const char *start, *end;
480 char buffer[40] = {0, };
483 /* get address string */
484 end = strchr(start, '/');
485 if (!end || (end - start >= 40)) {
488 strncpy(buffer, start, end - start);
489 if (qeth_l3_string_to_ipaddr(buffer, proto, addr)) {
493 *mask_bits = simple_strtoul(start, &tmp, 10);
494 if (!strlen(start) ||
496 (*mask_bits > ((proto == QETH_PROT_IPV4) ? 32 : 128))) {
502 static ssize_t qeth_l3_dev_ipato_add_store(const char *buf, size_t count,
503 struct qeth_card *card, enum qeth_prot_versions proto)
505 struct qeth_ipato_entry *ipatoe;
510 mutex_lock(&card->conf_mutex);
511 rc = qeth_l3_parse_ipatoe(buf, proto, addr, &mask_bits);
515 ipatoe = kzalloc(sizeof(struct qeth_ipato_entry), GFP_KERNEL);
520 ipatoe->proto = proto;
521 memcpy(ipatoe->addr, addr, (proto == QETH_PROT_IPV4)? 4:16);
522 ipatoe->mask_bits = mask_bits;
524 rc = qeth_l3_add_ipato_entry(card, ipatoe);
528 mutex_unlock(&card->conf_mutex);
529 return rc ? rc : count;
532 static ssize_t qeth_l3_dev_ipato_add4_store(struct device *dev,
533 struct device_attribute *attr, const char *buf, size_t count)
535 struct qeth_card *card = dev_get_drvdata(dev);
540 return qeth_l3_dev_ipato_add_store(buf, count, card, QETH_PROT_IPV4);
543 static QETH_DEVICE_ATTR(ipato_add4, add4, 0644,
544 qeth_l3_dev_ipato_add4_show,
545 qeth_l3_dev_ipato_add4_store);
547 static ssize_t qeth_l3_dev_ipato_del_store(const char *buf, size_t count,
548 struct qeth_card *card, enum qeth_prot_versions proto)
554 mutex_lock(&card->conf_mutex);
555 rc = qeth_l3_parse_ipatoe(buf, proto, addr, &mask_bits);
557 rc = qeth_l3_del_ipato_entry(card, proto, addr, mask_bits);
558 mutex_unlock(&card->conf_mutex);
559 return rc ? rc : count;
562 static ssize_t qeth_l3_dev_ipato_del4_store(struct device *dev,
563 struct device_attribute *attr, const char *buf, size_t count)
565 struct qeth_card *card = dev_get_drvdata(dev);
570 return qeth_l3_dev_ipato_del_store(buf, count, card, QETH_PROT_IPV4);
573 static QETH_DEVICE_ATTR(ipato_del4, del4, 0200, NULL,
574 qeth_l3_dev_ipato_del4_store);
576 static ssize_t qeth_l3_dev_ipato_invert6_show(struct device *dev,
577 struct device_attribute *attr, char *buf)
579 struct qeth_card *card = dev_get_drvdata(dev);
584 return sprintf(buf, "%i\n", card->ipato.invert6? 1:0);
587 static ssize_t qeth_l3_dev_ipato_invert6_store(struct device *dev,
588 struct device_attribute *attr, const char *buf, size_t count)
590 struct qeth_card *card = dev_get_drvdata(dev);
597 mutex_lock(&card->conf_mutex);
598 if (sysfs_streq(buf, "toggle")) {
599 invert = !card->ipato.invert6;
600 } else if (kstrtobool(buf, &invert)) {
605 if (card->ipato.invert6 != invert) {
606 card->ipato.invert6 = invert;
607 spin_lock_bh(&card->ip_lock);
608 qeth_l3_update_ipato(card);
609 spin_unlock_bh(&card->ip_lock);
612 mutex_unlock(&card->conf_mutex);
613 return rc ? rc : count;
616 static QETH_DEVICE_ATTR(ipato_invert6, invert6, 0644,
617 qeth_l3_dev_ipato_invert6_show,
618 qeth_l3_dev_ipato_invert6_store);
621 static ssize_t qeth_l3_dev_ipato_add6_show(struct device *dev,
622 struct device_attribute *attr, char *buf)
624 struct qeth_card *card = dev_get_drvdata(dev);
629 return qeth_l3_dev_ipato_add_show(buf, card, QETH_PROT_IPV6);
632 static ssize_t qeth_l3_dev_ipato_add6_store(struct device *dev,
633 struct device_attribute *attr, const char *buf, size_t count)
635 struct qeth_card *card = dev_get_drvdata(dev);
640 return qeth_l3_dev_ipato_add_store(buf, count, card, QETH_PROT_IPV6);
643 static QETH_DEVICE_ATTR(ipato_add6, add6, 0644,
644 qeth_l3_dev_ipato_add6_show,
645 qeth_l3_dev_ipato_add6_store);
647 static ssize_t qeth_l3_dev_ipato_del6_store(struct device *dev,
648 struct device_attribute *attr, const char *buf, size_t count)
650 struct qeth_card *card = dev_get_drvdata(dev);
655 return qeth_l3_dev_ipato_del_store(buf, count, card, QETH_PROT_IPV6);
658 static QETH_DEVICE_ATTR(ipato_del6, del6, 0200, NULL,
659 qeth_l3_dev_ipato_del6_store);
661 static struct attribute *qeth_ipato_device_attrs[] = {
662 &dev_attr_ipato_enable.attr,
663 &dev_attr_ipato_invert4.attr,
664 &dev_attr_ipato_add4.attr,
665 &dev_attr_ipato_del4.attr,
666 &dev_attr_ipato_invert6.attr,
667 &dev_attr_ipato_add6.attr,
668 &dev_attr_ipato_del6.attr,
672 static const struct attribute_group qeth_device_ipato_group = {
673 .name = "ipa_takeover",
674 .attrs = qeth_ipato_device_attrs,
677 static ssize_t qeth_l3_dev_ip_add_show(struct device *dev, char *buf,
678 enum qeth_prot_versions proto,
679 enum qeth_ip_types type)
681 struct qeth_card *card = dev_get_drvdata(dev);
682 struct qeth_ipaddr *ipaddr;
685 int entry_len; /* length of 1 entry string, differs between v4 and v6 */
691 entry_len = (proto == QETH_PROT_IPV4)? 12 : 40;
692 entry_len += 2; /* \n + terminator */
693 spin_lock_bh(&card->ip_lock);
694 hash_for_each(card->ip_htable, i, ipaddr, hnode) {
695 if (ipaddr->proto != proto || ipaddr->type != type)
697 /* String must not be longer than PAGE_SIZE. So we check if
698 * string length gets near PAGE_SIZE. Then we can savely display
699 * the next IPv6 address (worst case, compared to IPv4) */
700 if ((PAGE_SIZE - str_len) <= entry_len)
702 qeth_l3_ipaddr_to_string(proto, (const u8 *)&ipaddr->u,
704 str_len += snprintf(buf + str_len, PAGE_SIZE - str_len, "%s\n",
707 spin_unlock_bh(&card->ip_lock);
708 str_len += snprintf(buf + str_len, PAGE_SIZE - str_len, "\n");
713 static ssize_t qeth_l3_dev_vipa_add4_show(struct device *dev,
714 struct device_attribute *attr,
717 return qeth_l3_dev_ip_add_show(dev, buf, QETH_PROT_IPV4,
721 static int qeth_l3_parse_vipae(const char *buf, enum qeth_prot_versions proto,
724 if (qeth_l3_string_to_ipaddr(buf, proto, addr)) {
730 static ssize_t qeth_l3_dev_vipa_add_store(const char *buf, size_t count,
731 struct qeth_card *card, enum qeth_prot_versions proto)
736 mutex_lock(&card->conf_mutex);
737 rc = qeth_l3_parse_vipae(buf, proto, addr);
739 rc = qeth_l3_modify_rxip_vipa(card, true, addr,
740 QETH_IP_TYPE_VIPA, proto);
741 mutex_unlock(&card->conf_mutex);
742 return rc ? rc : count;
745 static ssize_t qeth_l3_dev_vipa_add4_store(struct device *dev,
746 struct device_attribute *attr, const char *buf, size_t count)
748 struct qeth_card *card = dev_get_drvdata(dev);
753 return qeth_l3_dev_vipa_add_store(buf, count, card, QETH_PROT_IPV4);
756 static QETH_DEVICE_ATTR(vipa_add4, add4, 0644,
757 qeth_l3_dev_vipa_add4_show,
758 qeth_l3_dev_vipa_add4_store);
760 static ssize_t qeth_l3_dev_vipa_del_store(const char *buf, size_t count,
761 struct qeth_card *card, enum qeth_prot_versions proto)
766 mutex_lock(&card->conf_mutex);
767 rc = qeth_l3_parse_vipae(buf, proto, addr);
769 rc = qeth_l3_modify_rxip_vipa(card, false, addr,
770 QETH_IP_TYPE_VIPA, proto);
771 mutex_unlock(&card->conf_mutex);
772 return rc ? rc : count;
775 static ssize_t qeth_l3_dev_vipa_del4_store(struct device *dev,
776 struct device_attribute *attr, const char *buf, size_t count)
778 struct qeth_card *card = dev_get_drvdata(dev);
783 return qeth_l3_dev_vipa_del_store(buf, count, card, QETH_PROT_IPV4);
786 static QETH_DEVICE_ATTR(vipa_del4, del4, 0200, NULL,
787 qeth_l3_dev_vipa_del4_store);
789 static ssize_t qeth_l3_dev_vipa_add6_show(struct device *dev,
790 struct device_attribute *attr,
793 return qeth_l3_dev_ip_add_show(dev, buf, QETH_PROT_IPV6,
797 static ssize_t qeth_l3_dev_vipa_add6_store(struct device *dev,
798 struct device_attribute *attr, const char *buf, size_t count)
800 struct qeth_card *card = dev_get_drvdata(dev);
805 return qeth_l3_dev_vipa_add_store(buf, count, card, QETH_PROT_IPV6);
808 static QETH_DEVICE_ATTR(vipa_add6, add6, 0644,
809 qeth_l3_dev_vipa_add6_show,
810 qeth_l3_dev_vipa_add6_store);
812 static ssize_t qeth_l3_dev_vipa_del6_store(struct device *dev,
813 struct device_attribute *attr, const char *buf, size_t count)
815 struct qeth_card *card = dev_get_drvdata(dev);
820 return qeth_l3_dev_vipa_del_store(buf, count, card, QETH_PROT_IPV6);
823 static QETH_DEVICE_ATTR(vipa_del6, del6, 0200, NULL,
824 qeth_l3_dev_vipa_del6_store);
826 static struct attribute *qeth_vipa_device_attrs[] = {
827 &dev_attr_vipa_add4.attr,
828 &dev_attr_vipa_del4.attr,
829 &dev_attr_vipa_add6.attr,
830 &dev_attr_vipa_del6.attr,
834 static const struct attribute_group qeth_device_vipa_group = {
836 .attrs = qeth_vipa_device_attrs,
839 static ssize_t qeth_l3_dev_rxip_add4_show(struct device *dev,
840 struct device_attribute *attr,
843 return qeth_l3_dev_ip_add_show(dev, buf, QETH_PROT_IPV4,
847 static int qeth_l3_parse_rxipe(const char *buf, enum qeth_prot_versions proto,
851 struct in6_addr ipv6_addr;
853 if (qeth_l3_string_to_ipaddr(buf, proto, addr)) {
856 if (proto == QETH_PROT_IPV4) {
857 memcpy(&ipv4_addr, addr, sizeof(ipv4_addr));
858 if (ipv4_is_multicast(ipv4_addr)) {
859 QETH_DBF_MESSAGE(2, "multicast rxip not supported.\n");
862 } else if (proto == QETH_PROT_IPV6) {
863 memcpy(&ipv6_addr, addr, sizeof(ipv6_addr));
864 if (ipv6_addr_is_multicast(&ipv6_addr)) {
865 QETH_DBF_MESSAGE(2, "multicast rxip not supported.\n");
873 static ssize_t qeth_l3_dev_rxip_add_store(const char *buf, size_t count,
874 struct qeth_card *card, enum qeth_prot_versions proto)
879 mutex_lock(&card->conf_mutex);
880 rc = qeth_l3_parse_rxipe(buf, proto, addr);
882 rc = qeth_l3_modify_rxip_vipa(card, true, addr,
883 QETH_IP_TYPE_RXIP, proto);
884 mutex_unlock(&card->conf_mutex);
885 return rc ? rc : count;
888 static ssize_t qeth_l3_dev_rxip_add4_store(struct device *dev,
889 struct device_attribute *attr, const char *buf, size_t count)
891 struct qeth_card *card = dev_get_drvdata(dev);
896 return qeth_l3_dev_rxip_add_store(buf, count, card, QETH_PROT_IPV4);
899 static QETH_DEVICE_ATTR(rxip_add4, add4, 0644,
900 qeth_l3_dev_rxip_add4_show,
901 qeth_l3_dev_rxip_add4_store);
903 static ssize_t qeth_l3_dev_rxip_del_store(const char *buf, size_t count,
904 struct qeth_card *card, enum qeth_prot_versions proto)
909 mutex_lock(&card->conf_mutex);
910 rc = qeth_l3_parse_rxipe(buf, proto, addr);
912 rc = qeth_l3_modify_rxip_vipa(card, false, addr,
913 QETH_IP_TYPE_RXIP, proto);
914 mutex_unlock(&card->conf_mutex);
915 return rc ? rc : count;
918 static ssize_t qeth_l3_dev_rxip_del4_store(struct device *dev,
919 struct device_attribute *attr, const char *buf, size_t count)
921 struct qeth_card *card = dev_get_drvdata(dev);
926 return qeth_l3_dev_rxip_del_store(buf, count, card, QETH_PROT_IPV4);
929 static QETH_DEVICE_ATTR(rxip_del4, del4, 0200, NULL,
930 qeth_l3_dev_rxip_del4_store);
932 static ssize_t qeth_l3_dev_rxip_add6_show(struct device *dev,
933 struct device_attribute *attr,
936 return qeth_l3_dev_ip_add_show(dev, buf, QETH_PROT_IPV6,
940 static ssize_t qeth_l3_dev_rxip_add6_store(struct device *dev,
941 struct device_attribute *attr, const char *buf, size_t count)
943 struct qeth_card *card = dev_get_drvdata(dev);
948 return qeth_l3_dev_rxip_add_store(buf, count, card, QETH_PROT_IPV6);
951 static QETH_DEVICE_ATTR(rxip_add6, add6, 0644,
952 qeth_l3_dev_rxip_add6_show,
953 qeth_l3_dev_rxip_add6_store);
955 static ssize_t qeth_l3_dev_rxip_del6_store(struct device *dev,
956 struct device_attribute *attr, const char *buf, size_t count)
958 struct qeth_card *card = dev_get_drvdata(dev);
963 return qeth_l3_dev_rxip_del_store(buf, count, card, QETH_PROT_IPV6);
966 static QETH_DEVICE_ATTR(rxip_del6, del6, 0200, NULL,
967 qeth_l3_dev_rxip_del6_store);
969 static struct attribute *qeth_rxip_device_attrs[] = {
970 &dev_attr_rxip_add4.attr,
971 &dev_attr_rxip_del4.attr,
972 &dev_attr_rxip_add6.attr,
973 &dev_attr_rxip_del6.attr,
977 static const struct attribute_group qeth_device_rxip_group = {
979 .attrs = qeth_rxip_device_attrs,
982 static const struct attribute_group *qeth_l3_only_attr_groups[] = {
983 &qeth_l3_device_attr_group,
984 &qeth_device_ipato_group,
985 &qeth_device_vipa_group,
986 &qeth_device_rxip_group,
990 int qeth_l3_create_device_attributes(struct device *dev)
992 return sysfs_create_groups(&dev->kobj, qeth_l3_only_attr_groups);
995 void qeth_l3_remove_device_attributes(struct device *dev)
997 sysfs_remove_groups(&dev->kobj, qeth_l3_only_attr_groups);
1000 const struct attribute_group *qeth_l3_attr_groups[] = {
1001 &qeth_device_attr_group,
1002 &qeth_device_blkt_group,
1003 /* l3 specific, see qeth_l3_only_attr_groups: */
1004 &qeth_l3_device_attr_group,
1005 &qeth_device_ipato_group,
1006 &qeth_device_vipa_group,
1007 &qeth_device_rxip_group,