1
2
3
4
5
6
7
8
9
10#include <linux/slab.h>
11#include <asm/ebcdic.h>
12#include <linux/hashtable.h>
13#include <linux/inet.h>
14#include "qeth_l3.h"
15
16#define QETH_DEVICE_ATTR(_id, _name, _mode, _show, _store) \
17struct device_attribute dev_attr_##_id = __ATTR(_name, _mode, _show, _store)
18
19static int qeth_l3_string_to_ipaddr(const char *buf,
20 enum qeth_prot_versions proto, u8 *addr)
21{
22 const char *end;
23
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)))
26 return -EINVAL;
27 return 0;
28}
29
30static ssize_t qeth_l3_dev_route_show(struct qeth_card *card,
31 struct qeth_routing_info *route, char *buf)
32{
33 switch (route->type) {
34 case PRIMARY_ROUTER:
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+");
41 else
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+");
46 else
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+");
51 else
52 return sprintf(buf, "%s\n", "secondary connector");
53 default:
54 return sprintf(buf, "%s\n", "no");
55 }
56}
57
58static ssize_t qeth_l3_dev_route4_show(struct device *dev,
59 struct device_attribute *attr, char *buf)
60{
61 struct qeth_card *card = dev_get_drvdata(dev);
62
63 return qeth_l3_dev_route_show(card, &card->options.route4, buf);
64}
65
66static 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)
69{
70 enum qeth_routing_types old_route_type = route->type;
71 int rc = 0;
72
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;
86 } else {
87 rc = -EINVAL;
88 goto out;
89 }
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);
96 }
97out:
98 if (rc)
99 route->type = old_route_type;
100 mutex_unlock(&card->conf_mutex);
101 return rc ? rc : count;
102}
103
104static ssize_t qeth_l3_dev_route4_store(struct device *dev,
105 struct device_attribute *attr, const char *buf, size_t count)
106{
107 struct qeth_card *card = dev_get_drvdata(dev);
108
109 return qeth_l3_dev_route_store(card, &card->options.route4,
110 QETH_PROT_IPV4, buf, count);
111}
112
113static DEVICE_ATTR(route4, 0644, qeth_l3_dev_route4_show,
114 qeth_l3_dev_route4_store);
115
116static ssize_t qeth_l3_dev_route6_show(struct device *dev,
117 struct device_attribute *attr, char *buf)
118{
119 struct qeth_card *card = dev_get_drvdata(dev);
120
121 return qeth_l3_dev_route_show(card, &card->options.route6, buf);
122}
123
124static ssize_t qeth_l3_dev_route6_store(struct device *dev,
125 struct device_attribute *attr, const char *buf, size_t count)
126{
127 struct qeth_card *card = dev_get_drvdata(dev);
128
129 return qeth_l3_dev_route_store(card, &card->options.route6,
130 QETH_PROT_IPV6, buf, count);
131}
132
133static DEVICE_ATTR(route6, 0644, qeth_l3_dev_route6_show,
134 qeth_l3_dev_route6_store);
135
136static ssize_t qeth_l3_dev_sniffer_show(struct device *dev,
137 struct device_attribute *attr, char *buf)
138{
139 struct qeth_card *card = dev_get_drvdata(dev);
140
141 return sprintf(buf, "%i\n", card->options.sniffer ? 1 : 0);
142}
143
144static ssize_t qeth_l3_dev_sniffer_store(struct device *dev,
145 struct device_attribute *attr, const char *buf, size_t count)
146{
147 struct qeth_card *card = dev_get_drvdata(dev);
148 int rc = 0;
149 unsigned long i;
150
151 if (!IS_IQD(card))
152 return -EPERM;
153 if (card->options.cq == QETH_CQ_ENABLED)
154 return -EPERM;
155
156 mutex_lock(&card->conf_mutex);
157 if (card->state != CARD_STATE_DOWN) {
158 rc = -EPERM;
159 goto out;
160 }
161
162 rc = kstrtoul(buf, 16, &i);
163 if (rc) {
164 rc = -EINVAL;
165 goto out;
166 }
167 switch (i) {
168 case 0:
169 card->options.sniffer = i;
170 break;
171 case 1:
172 qdio_get_ssqd_desc(CARD_DDEV(card), &card->ssqd);
173 if (card->ssqd.qdioac2 & CHSC_AC2_SNIFFER_AVAILABLE) {
174 card->options.sniffer = i;
175 qeth_resize_buffer_pool(card, QETH_IN_BUF_COUNT_MAX);
176 } else {
177 rc = -EPERM;
178 }
179
180 break;
181 default:
182 rc = -EINVAL;
183 }
184out:
185 mutex_unlock(&card->conf_mutex);
186 return rc ? rc : count;
187}
188
189static DEVICE_ATTR(sniffer, 0644, qeth_l3_dev_sniffer_show,
190 qeth_l3_dev_sniffer_store);
191
192static ssize_t qeth_l3_dev_hsuid_show(struct device *dev,
193 struct device_attribute *attr, char *buf)
194{
195 struct qeth_card *card = dev_get_drvdata(dev);
196 char tmp_hsuid[9];
197
198 if (!IS_IQD(card))
199 return -EPERM;
200
201 memcpy(tmp_hsuid, card->options.hsuid, sizeof(tmp_hsuid));
202 EBCASC(tmp_hsuid, 8);
203 return sprintf(buf, "%s\n", tmp_hsuid);
204}
205
206static ssize_t qeth_l3_dev_hsuid_store(struct device *dev,
207 struct device_attribute *attr, const char *buf, size_t count)
208{
209 struct qeth_card *card = dev_get_drvdata(dev);
210 int rc = 0;
211 char *tmp;
212
213 if (!IS_IQD(card))
214 return -EPERM;
215
216 mutex_lock(&card->conf_mutex);
217 if (card->state != CARD_STATE_DOWN) {
218 rc = -EPERM;
219 goto out;
220 }
221
222 if (card->options.sniffer) {
223 rc = -EPERM;
224 goto out;
225 }
226
227 if (card->options.cq == QETH_CQ_NOTAVAILABLE) {
228 rc = -EPERM;
229 goto out;
230 }
231
232 tmp = strsep((char **)&buf, "\n");
233 if (strlen(tmp) > 8) {
234 rc = -EINVAL;
235 goto out;
236 }
237
238 if (card->options.hsuid[0])
239
240 qeth_l3_modify_hsuid(card, false);
241
242 if (strlen(tmp) == 0) {
243
244 card->options.hsuid[0] = '\0';
245 memcpy(card->dev->perm_addr, card->options.hsuid, 9);
246 qeth_configure_cq(card, QETH_CQ_DISABLED);
247 goto out;
248 }
249
250 if (qeth_configure_cq(card, QETH_CQ_ENABLED)) {
251 rc = -EPERM;
252 goto out;
253 }
254
255 snprintf(card->options.hsuid, sizeof(card->options.hsuid),
256 "%-8s", tmp);
257 ASCEBC(card->options.hsuid, 8);
258 memcpy(card->dev->perm_addr, card->options.hsuid, 9);
259
260 rc = qeth_l3_modify_hsuid(card, true);
261
262out:
263 mutex_unlock(&card->conf_mutex);
264 return rc ? rc : count;
265}
266
267static DEVICE_ATTR(hsuid, 0644, qeth_l3_dev_hsuid_show,
268 qeth_l3_dev_hsuid_store);
269
270
271static struct attribute *qeth_l3_device_attrs[] = {
272 &dev_attr_route4.attr,
273 &dev_attr_route6.attr,
274 &dev_attr_sniffer.attr,
275 &dev_attr_hsuid.attr,
276 NULL,
277};
278
279static const struct attribute_group qeth_l3_device_attr_group = {
280 .attrs = qeth_l3_device_attrs,
281};
282
283static ssize_t qeth_l3_dev_ipato_enable_show(struct device *dev,
284 struct device_attribute *attr, char *buf)
285{
286 struct qeth_card *card = dev_get_drvdata(dev);
287
288 return sprintf(buf, "%i\n", card->ipato.enabled? 1:0);
289}
290
291static ssize_t qeth_l3_dev_ipato_enable_store(struct device *dev,
292 struct device_attribute *attr, const char *buf, size_t count)
293{
294 struct qeth_card *card = dev_get_drvdata(dev);
295 bool enable;
296 int rc = 0;
297
298 mutex_lock(&card->conf_mutex);
299 if (card->state != CARD_STATE_DOWN) {
300 rc = -EPERM;
301 goto out;
302 }
303
304 if (sysfs_streq(buf, "toggle")) {
305 enable = !card->ipato.enabled;
306 } else if (kstrtobool(buf, &enable)) {
307 rc = -EINVAL;
308 goto out;
309 }
310
311 if (card->ipato.enabled != enable) {
312 card->ipato.enabled = enable;
313 mutex_lock(&card->ip_lock);
314 qeth_l3_update_ipato(card);
315 mutex_unlock(&card->ip_lock);
316 }
317out:
318 mutex_unlock(&card->conf_mutex);
319 return rc ? rc : count;
320}
321
322static QETH_DEVICE_ATTR(ipato_enable, enable, 0644,
323 qeth_l3_dev_ipato_enable_show,
324 qeth_l3_dev_ipato_enable_store);
325
326static ssize_t qeth_l3_dev_ipato_invert4_show(struct device *dev,
327 struct device_attribute *attr, char *buf)
328{
329 struct qeth_card *card = dev_get_drvdata(dev);
330
331 return sprintf(buf, "%i\n", card->ipato.invert4? 1:0);
332}
333
334static ssize_t qeth_l3_dev_ipato_invert4_store(struct device *dev,
335 struct device_attribute *attr,
336 const char *buf, size_t count)
337{
338 struct qeth_card *card = dev_get_drvdata(dev);
339 bool invert;
340 int rc = 0;
341
342 mutex_lock(&card->conf_mutex);
343 if (sysfs_streq(buf, "toggle")) {
344 invert = !card->ipato.invert4;
345 } else if (kstrtobool(buf, &invert)) {
346 rc = -EINVAL;
347 goto out;
348 }
349
350 if (card->ipato.invert4 != invert) {
351 card->ipato.invert4 = invert;
352 mutex_lock(&card->ip_lock);
353 qeth_l3_update_ipato(card);
354 mutex_unlock(&card->ip_lock);
355 }
356out:
357 mutex_unlock(&card->conf_mutex);
358 return rc ? rc : count;
359}
360
361static QETH_DEVICE_ATTR(ipato_invert4, invert4, 0644,
362 qeth_l3_dev_ipato_invert4_show,
363 qeth_l3_dev_ipato_invert4_store);
364
365static ssize_t qeth_l3_dev_ipato_add_show(char *buf, struct qeth_card *card,
366 enum qeth_prot_versions proto)
367{
368 struct qeth_ipato_entry *ipatoe;
369 int str_len = 0;
370
371 mutex_lock(&card->ip_lock);
372 list_for_each_entry(ipatoe, &card->ipato.entries, entry) {
373 char addr_str[40];
374 int entry_len;
375
376 if (ipatoe->proto != proto)
377 continue;
378
379 entry_len = qeth_l3_ipaddr_to_string(proto, ipatoe->addr,
380 addr_str);
381 if (entry_len < 0)
382 continue;
383
384
385 entry_len += 1 + ((proto == QETH_PROT_IPV4) ? 2 : 3);
386
387 if (entry_len + 1 > PAGE_SIZE - str_len - 1)
388 break;
389
390 entry_len = scnprintf(buf, PAGE_SIZE - str_len,
391 "%s/%i\n", addr_str, ipatoe->mask_bits);
392 str_len += entry_len;
393 buf += entry_len;
394 }
395 mutex_unlock(&card->ip_lock);
396
397 return str_len ? str_len : scnprintf(buf, PAGE_SIZE, "\n");
398}
399
400static ssize_t qeth_l3_dev_ipato_add4_show(struct device *dev,
401 struct device_attribute *attr, char *buf)
402{
403 struct qeth_card *card = dev_get_drvdata(dev);
404
405 return qeth_l3_dev_ipato_add_show(buf, card, QETH_PROT_IPV4);
406}
407
408static int qeth_l3_parse_ipatoe(const char *buf, enum qeth_prot_versions proto,
409 u8 *addr, int *mask_bits)
410{
411 const char *start, *end;
412 char *tmp;
413 char buffer[40] = {0, };
414
415 start = buf;
416
417 end = strchr(start, '/');
418 if (!end || (end - start >= 40)) {
419 return -EINVAL;
420 }
421 strncpy(buffer, start, end - start);
422 if (qeth_l3_string_to_ipaddr(buffer, proto, addr)) {
423 return -EINVAL;
424 }
425 start = end + 1;
426 *mask_bits = simple_strtoul(start, &tmp, 10);
427 if (!strlen(start) ||
428 (tmp == start) ||
429 (*mask_bits > ((proto == QETH_PROT_IPV4) ? 32 : 128))) {
430 return -EINVAL;
431 }
432 return 0;
433}
434
435static ssize_t qeth_l3_dev_ipato_add_store(const char *buf, size_t count,
436 struct qeth_card *card, enum qeth_prot_versions proto)
437{
438 struct qeth_ipato_entry *ipatoe;
439 u8 addr[16];
440 int mask_bits;
441 int rc = 0;
442
443 rc = qeth_l3_parse_ipatoe(buf, proto, addr, &mask_bits);
444 if (rc)
445 return rc;
446
447 ipatoe = kzalloc(sizeof(struct qeth_ipato_entry), GFP_KERNEL);
448 if (!ipatoe)
449 return -ENOMEM;
450
451 ipatoe->proto = proto;
452 memcpy(ipatoe->addr, addr, (proto == QETH_PROT_IPV4)? 4:16);
453 ipatoe->mask_bits = mask_bits;
454
455 rc = qeth_l3_add_ipato_entry(card, ipatoe);
456 if (rc)
457 kfree(ipatoe);
458
459 return rc ? rc : count;
460}
461
462static ssize_t qeth_l3_dev_ipato_add4_store(struct device *dev,
463 struct device_attribute *attr, const char *buf, size_t count)
464{
465 struct qeth_card *card = dev_get_drvdata(dev);
466
467 return qeth_l3_dev_ipato_add_store(buf, count, card, QETH_PROT_IPV4);
468}
469
470static QETH_DEVICE_ATTR(ipato_add4, add4, 0644,
471 qeth_l3_dev_ipato_add4_show,
472 qeth_l3_dev_ipato_add4_store);
473
474static ssize_t qeth_l3_dev_ipato_del_store(const char *buf, size_t count,
475 struct qeth_card *card, enum qeth_prot_versions proto)
476{
477 u8 addr[16];
478 int mask_bits;
479 int rc = 0;
480
481 rc = qeth_l3_parse_ipatoe(buf, proto, addr, &mask_bits);
482 if (!rc)
483 rc = qeth_l3_del_ipato_entry(card, proto, addr, mask_bits);
484 return rc ? rc : count;
485}
486
487static ssize_t qeth_l3_dev_ipato_del4_store(struct device *dev,
488 struct device_attribute *attr, const char *buf, size_t count)
489{
490 struct qeth_card *card = dev_get_drvdata(dev);
491
492 return qeth_l3_dev_ipato_del_store(buf, count, card, QETH_PROT_IPV4);
493}
494
495static QETH_DEVICE_ATTR(ipato_del4, del4, 0200, NULL,
496 qeth_l3_dev_ipato_del4_store);
497
498static ssize_t qeth_l3_dev_ipato_invert6_show(struct device *dev,
499 struct device_attribute *attr, char *buf)
500{
501 struct qeth_card *card = dev_get_drvdata(dev);
502
503 return sprintf(buf, "%i\n", card->ipato.invert6? 1:0);
504}
505
506static ssize_t qeth_l3_dev_ipato_invert6_store(struct device *dev,
507 struct device_attribute *attr, const char *buf, size_t count)
508{
509 struct qeth_card *card = dev_get_drvdata(dev);
510 bool invert;
511 int rc = 0;
512
513 mutex_lock(&card->conf_mutex);
514 if (sysfs_streq(buf, "toggle")) {
515 invert = !card->ipato.invert6;
516 } else if (kstrtobool(buf, &invert)) {
517 rc = -EINVAL;
518 goto out;
519 }
520
521 if (card->ipato.invert6 != invert) {
522 card->ipato.invert6 = invert;
523 mutex_lock(&card->ip_lock);
524 qeth_l3_update_ipato(card);
525 mutex_unlock(&card->ip_lock);
526 }
527out:
528 mutex_unlock(&card->conf_mutex);
529 return rc ? rc : count;
530}
531
532static QETH_DEVICE_ATTR(ipato_invert6, invert6, 0644,
533 qeth_l3_dev_ipato_invert6_show,
534 qeth_l3_dev_ipato_invert6_store);
535
536
537static ssize_t qeth_l3_dev_ipato_add6_show(struct device *dev,
538 struct device_attribute *attr, char *buf)
539{
540 struct qeth_card *card = dev_get_drvdata(dev);
541
542 return qeth_l3_dev_ipato_add_show(buf, card, QETH_PROT_IPV6);
543}
544
545static ssize_t qeth_l3_dev_ipato_add6_store(struct device *dev,
546 struct device_attribute *attr, const char *buf, size_t count)
547{
548 struct qeth_card *card = dev_get_drvdata(dev);
549
550 return qeth_l3_dev_ipato_add_store(buf, count, card, QETH_PROT_IPV6);
551}
552
553static QETH_DEVICE_ATTR(ipato_add6, add6, 0644,
554 qeth_l3_dev_ipato_add6_show,
555 qeth_l3_dev_ipato_add6_store);
556
557static ssize_t qeth_l3_dev_ipato_del6_store(struct device *dev,
558 struct device_attribute *attr, const char *buf, size_t count)
559{
560 struct qeth_card *card = dev_get_drvdata(dev);
561
562 return qeth_l3_dev_ipato_del_store(buf, count, card, QETH_PROT_IPV6);
563}
564
565static QETH_DEVICE_ATTR(ipato_del6, del6, 0200, NULL,
566 qeth_l3_dev_ipato_del6_store);
567
568static struct attribute *qeth_ipato_device_attrs[] = {
569 &dev_attr_ipato_enable.attr,
570 &dev_attr_ipato_invert4.attr,
571 &dev_attr_ipato_add4.attr,
572 &dev_attr_ipato_del4.attr,
573 &dev_attr_ipato_invert6.attr,
574 &dev_attr_ipato_add6.attr,
575 &dev_attr_ipato_del6.attr,
576 NULL,
577};
578
579static const struct attribute_group qeth_device_ipato_group = {
580 .name = "ipa_takeover",
581 .attrs = qeth_ipato_device_attrs,
582};
583
584static ssize_t qeth_l3_dev_ip_add_show(struct device *dev, char *buf,
585 enum qeth_prot_versions proto,
586 enum qeth_ip_types type)
587{
588 struct qeth_card *card = dev_get_drvdata(dev);
589 struct qeth_ipaddr *ipaddr;
590 int str_len = 0;
591 int i;
592
593 mutex_lock(&card->ip_lock);
594 hash_for_each(card->ip_htable, i, ipaddr, hnode) {
595 char addr_str[40];
596 int entry_len;
597
598 if (ipaddr->proto != proto || ipaddr->type != type)
599 continue;
600
601 entry_len = qeth_l3_ipaddr_to_string(proto, (u8 *)&ipaddr->u,
602 addr_str);
603 if (entry_len < 0)
604 continue;
605
606
607 if (entry_len + 1 > PAGE_SIZE - str_len - 1)
608 break;
609
610 entry_len = scnprintf(buf, PAGE_SIZE - str_len, "%s\n",
611 addr_str);
612 str_len += entry_len;
613 buf += entry_len;
614 }
615 mutex_unlock(&card->ip_lock);
616
617 return str_len ? str_len : scnprintf(buf, PAGE_SIZE, "\n");
618}
619
620static ssize_t qeth_l3_dev_vipa_add4_show(struct device *dev,
621 struct device_attribute *attr,
622 char *buf)
623{
624 return qeth_l3_dev_ip_add_show(dev, buf, QETH_PROT_IPV4,
625 QETH_IP_TYPE_VIPA);
626}
627
628static ssize_t qeth_l3_vipa_store(struct device *dev, const char *buf, bool add,
629 size_t count, enum qeth_prot_versions proto)
630{
631 struct qeth_card *card = dev_get_drvdata(dev);
632 u8 addr[16] = {0, };
633 int rc;
634
635 rc = qeth_l3_string_to_ipaddr(buf, proto, addr);
636 if (!rc)
637 rc = qeth_l3_modify_rxip_vipa(card, add, addr,
638 QETH_IP_TYPE_VIPA, proto);
639 return rc ? rc : count;
640}
641
642static ssize_t qeth_l3_dev_vipa_add4_store(struct device *dev,
643 struct device_attribute *attr, const char *buf, size_t count)
644{
645 return qeth_l3_vipa_store(dev, buf, true, count, QETH_PROT_IPV4);
646}
647
648static QETH_DEVICE_ATTR(vipa_add4, add4, 0644,
649 qeth_l3_dev_vipa_add4_show,
650 qeth_l3_dev_vipa_add4_store);
651
652static ssize_t qeth_l3_dev_vipa_del4_store(struct device *dev,
653 struct device_attribute *attr, const char *buf, size_t count)
654{
655 return qeth_l3_vipa_store(dev, buf, true, count, QETH_PROT_IPV4);
656}
657
658static QETH_DEVICE_ATTR(vipa_del4, del4, 0200, NULL,
659 qeth_l3_dev_vipa_del4_store);
660
661static ssize_t qeth_l3_dev_vipa_add6_show(struct device *dev,
662 struct device_attribute *attr,
663 char *buf)
664{
665 return qeth_l3_dev_ip_add_show(dev, buf, QETH_PROT_IPV6,
666 QETH_IP_TYPE_VIPA);
667}
668
669static ssize_t qeth_l3_dev_vipa_add6_store(struct device *dev,
670 struct device_attribute *attr, const char *buf, size_t count)
671{
672 return qeth_l3_vipa_store(dev, buf, true, count, QETH_PROT_IPV6);
673}
674
675static QETH_DEVICE_ATTR(vipa_add6, add6, 0644,
676 qeth_l3_dev_vipa_add6_show,
677 qeth_l3_dev_vipa_add6_store);
678
679static ssize_t qeth_l3_dev_vipa_del6_store(struct device *dev,
680 struct device_attribute *attr, const char *buf, size_t count)
681{
682 return qeth_l3_vipa_store(dev, buf, false, count, QETH_PROT_IPV6);
683}
684
685static QETH_DEVICE_ATTR(vipa_del6, del6, 0200, NULL,
686 qeth_l3_dev_vipa_del6_store);
687
688static struct attribute *qeth_vipa_device_attrs[] = {
689 &dev_attr_vipa_add4.attr,
690 &dev_attr_vipa_del4.attr,
691 &dev_attr_vipa_add6.attr,
692 &dev_attr_vipa_del6.attr,
693 NULL,
694};
695
696static const struct attribute_group qeth_device_vipa_group = {
697 .name = "vipa",
698 .attrs = qeth_vipa_device_attrs,
699};
700
701static ssize_t qeth_l3_dev_rxip_add4_show(struct device *dev,
702 struct device_attribute *attr,
703 char *buf)
704{
705 return qeth_l3_dev_ip_add_show(dev, buf, QETH_PROT_IPV4,
706 QETH_IP_TYPE_RXIP);
707}
708
709static int qeth_l3_parse_rxipe(const char *buf, enum qeth_prot_versions proto,
710 u8 *addr)
711{
712 __be32 ipv4_addr;
713 struct in6_addr ipv6_addr;
714
715 if (qeth_l3_string_to_ipaddr(buf, proto, addr)) {
716 return -EINVAL;
717 }
718 if (proto == QETH_PROT_IPV4) {
719 memcpy(&ipv4_addr, addr, sizeof(ipv4_addr));
720 if (ipv4_is_multicast(ipv4_addr)) {
721 QETH_DBF_MESSAGE(2, "multicast rxip not supported.\n");
722 return -EINVAL;
723 }
724 } else if (proto == QETH_PROT_IPV6) {
725 memcpy(&ipv6_addr, addr, sizeof(ipv6_addr));
726 if (ipv6_addr_is_multicast(&ipv6_addr)) {
727 QETH_DBF_MESSAGE(2, "multicast rxip not supported.\n");
728 return -EINVAL;
729 }
730 }
731
732 return 0;
733}
734
735static ssize_t qeth_l3_rxip_store(struct device *dev, const char *buf, bool add,
736 size_t count, enum qeth_prot_versions proto)
737{
738 struct qeth_card *card = dev_get_drvdata(dev);
739 u8 addr[16] = {0, };
740 int rc;
741
742 rc = qeth_l3_parse_rxipe(buf, proto, addr);
743 if (!rc)
744 rc = qeth_l3_modify_rxip_vipa(card, add, addr,
745 QETH_IP_TYPE_RXIP, proto);
746 return rc ? rc : count;
747}
748
749static ssize_t qeth_l3_dev_rxip_add4_store(struct device *dev,
750 struct device_attribute *attr, const char *buf, size_t count)
751{
752 return qeth_l3_rxip_store(dev, buf, true, count, QETH_PROT_IPV4);
753}
754
755static QETH_DEVICE_ATTR(rxip_add4, add4, 0644,
756 qeth_l3_dev_rxip_add4_show,
757 qeth_l3_dev_rxip_add4_store);
758
759static ssize_t qeth_l3_dev_rxip_del4_store(struct device *dev,
760 struct device_attribute *attr, const char *buf, size_t count)
761{
762 return qeth_l3_rxip_store(dev, buf, false, count, QETH_PROT_IPV4);
763}
764
765static QETH_DEVICE_ATTR(rxip_del4, del4, 0200, NULL,
766 qeth_l3_dev_rxip_del4_store);
767
768static ssize_t qeth_l3_dev_rxip_add6_show(struct device *dev,
769 struct device_attribute *attr,
770 char *buf)
771{
772 return qeth_l3_dev_ip_add_show(dev, buf, QETH_PROT_IPV6,
773 QETH_IP_TYPE_RXIP);
774}
775
776static ssize_t qeth_l3_dev_rxip_add6_store(struct device *dev,
777 struct device_attribute *attr, const char *buf, size_t count)
778{
779 return qeth_l3_rxip_store(dev, buf, true, count, QETH_PROT_IPV6);
780}
781
782static QETH_DEVICE_ATTR(rxip_add6, add6, 0644,
783 qeth_l3_dev_rxip_add6_show,
784 qeth_l3_dev_rxip_add6_store);
785
786static ssize_t qeth_l3_dev_rxip_del6_store(struct device *dev,
787 struct device_attribute *attr, const char *buf, size_t count)
788{
789 return qeth_l3_rxip_store(dev, buf, false, count, QETH_PROT_IPV6);
790}
791
792static QETH_DEVICE_ATTR(rxip_del6, del6, 0200, NULL,
793 qeth_l3_dev_rxip_del6_store);
794
795static struct attribute *qeth_rxip_device_attrs[] = {
796 &dev_attr_rxip_add4.attr,
797 &dev_attr_rxip_del4.attr,
798 &dev_attr_rxip_add6.attr,
799 &dev_attr_rxip_del6.attr,
800 NULL,
801};
802
803static const struct attribute_group qeth_device_rxip_group = {
804 .name = "rxip",
805 .attrs = qeth_rxip_device_attrs,
806};
807
808static const struct attribute_group *qeth_l3_only_attr_groups[] = {
809 &qeth_l3_device_attr_group,
810 &qeth_device_ipato_group,
811 &qeth_device_vipa_group,
812 &qeth_device_rxip_group,
813 NULL,
814};
815
816int qeth_l3_create_device_attributes(struct device *dev)
817{
818 return sysfs_create_groups(&dev->kobj, qeth_l3_only_attr_groups);
819}
820
821void qeth_l3_remove_device_attributes(struct device *dev)
822{
823 sysfs_remove_groups(&dev->kobj, qeth_l3_only_attr_groups);
824}
825
826const struct attribute_group *qeth_l3_attr_groups[] = {
827 &qeth_device_attr_group,
828 &qeth_device_blkt_group,
829
830 &qeth_l3_device_attr_group,
831 &qeth_device_ipato_group,
832 &qeth_device_vipa_group,
833 &qeth_device_rxip_group,
834 NULL,
835};
836
