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);