projects / linux-2.6-block.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Merge branch 'for-next' of git://git.kernel.org/pub/scm/linux/kernel/git/sameo/mfd-2.6
[linux-2.6-block.git] / drivers / s390 / net / qeth_l3_sys.c
CommitLineData
4a71df50
FB		 1/*
2 * drivers/s390/net/qeth_l3_sys.c
3 *
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>
9 */
10
11#include "qeth_l3.h"
12
13#define QETH_DEVICE_ATTR(_id, _name, _mode, _show, _store) \
14struct device_attribute dev_attr_##_id = __ATTR(_name, _mode, _show, _store)
15
16static const char *qeth_l3_get_checksum_str(struct qeth_card *card)
17{
18 if (card->options.checksum_type == SW_CHECKSUMMING)
19 return "sw";
20 else if (card->options.checksum_type == HW_CHECKSUMMING)
21 return "hw";
22 else
23 return "no";
24}
25
26static ssize_t qeth_l3_dev_route_show(struct qeth_card *card,
27 struct qeth_routing_info *route, char *buf)
28{
29 switch (route->type) {
30 case PRIMARY_ROUTER:
31 return sprintf(buf, "%s\n", "primary router");
32 case SECONDARY_ROUTER:
33 return sprintf(buf, "%s\n", "secondary router");
34 case MULTICAST_ROUTER:
35 if (card->info.broadcast_capable == QETH_BROADCAST_WITHOUT_ECHO)
36 return sprintf(buf, "%s\n", "multicast router+");
37 else
38 return sprintf(buf, "%s\n", "multicast router");
39 case PRIMARY_CONNECTOR:
40 if (card->info.broadcast_capable == QETH_BROADCAST_WITHOUT_ECHO)
41 return sprintf(buf, "%s\n", "primary connector+");
42 else
43 return sprintf(buf, "%s\n", "primary connector");
44 case SECONDARY_CONNECTOR:
45 if (card->info.broadcast_capable == QETH_BROADCAST_WITHOUT_ECHO)
46 return sprintf(buf, "%s\n", "secondary connector+");
47 else
48 return sprintf(buf, "%s\n", "secondary connector");
49 default:
50 return sprintf(buf, "%s\n", "no");
51 }
52}
53
54static ssize_t qeth_l3_dev_route4_show(struct device *dev,
55 struct device_attribute *attr, char *buf)
56{
57 struct qeth_card *card = dev_get_drvdata(dev);
58
59 if (!card)
60 return -EINVAL;
61
62 return qeth_l3_dev_route_show(card, &card->options.route4, buf);
63}
64
65static ssize_t qeth_l3_dev_route_store(struct qeth_card *card,
66 struct qeth_routing_info *route, enum qeth_prot_versions prot,
67 const char *buf, size_t count)
68{
69 enum qeth_routing_types old_route_type = route->type;
70 char *tmp;
71 int rc;
72
73 tmp = strsep((char **) &buf, "\n");
74
75 if (!strcmp(tmp, "no_router")) {
76 route->type = NO_ROUTER;
77 } else if (!strcmp(tmp, "primary_connector")) {
78 route->type = PRIMARY_CONNECTOR;
79 } else if (!strcmp(tmp, "secondary_connector")) {
80 route->type = SECONDARY_CONNECTOR;
81 } else if (!strcmp(tmp, "primary_router")) {
82 route->type = PRIMARY_ROUTER;
83 } else if (!strcmp(tmp, "secondary_router")) {
84 route->type = SECONDARY_ROUTER;
85 } else if (!strcmp(tmp, "multicast_router")) {
86 route->type = MULTICAST_ROUTER;
87 } else {
4a71df50
FB		 88 return -EINVAL;
89 }
90 if (((card->state == CARD_STATE_SOFTSETUP) ||
91 (card->state == CARD_STATE_UP)) &&
92 (old_route_type != route->type)) {
93 if (prot == QETH_PROT_IPV4)
94 rc = qeth_l3_setrouting_v4(card);
95 else if (prot == QETH_PROT_IPV6)
96 rc = qeth_l3_setrouting_v6(card);
97 }
98 return count;
99}
100
101static ssize_t qeth_l3_dev_route4_store(struct device *dev,
102 struct device_attribute *attr, const char *buf, size_t count)
103{
104 struct qeth_card *card = dev_get_drvdata(dev);
105
106 if (!card)
107 return -EINVAL;
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 if (!card)
122 return -EINVAL;
123
4a71df50
FB		 124 return qeth_l3_dev_route_show(card, &card->options.route6, buf);
125}
126
127static ssize_t qeth_l3_dev_route6_store(struct device *dev,
128 struct device_attribute *attr, const char *buf, size_t count)
129{
130 struct qeth_card *card = dev_get_drvdata(dev);
131
132 if (!card)
133 return -EINVAL;
134
4a71df50
FB		 135 return qeth_l3_dev_route_store(card, &card->options.route6,
136 QETH_PROT_IPV6, buf, count);
137}
138
139static DEVICE_ATTR(route6, 0644, qeth_l3_dev_route6_show,
140 qeth_l3_dev_route6_store);
141
142static ssize_t qeth_l3_dev_fake_broadcast_show(struct device *dev,
143 struct device_attribute *attr, char *buf)
144{
145 struct qeth_card *card = dev_get_drvdata(dev);
146
147 if (!card)
148 return -EINVAL;
149
150 return sprintf(buf, "%i\n", card->options.fake_broadcast? 1:0);
151}
152
153static ssize_t qeth_l3_dev_fake_broadcast_store(struct device *dev,
154 struct device_attribute *attr, const char *buf, size_t count)
155{
156 struct qeth_card *card = dev_get_drvdata(dev);
157 char *tmp;
158 int i;
159
160 if (!card)
161 return -EINVAL;
162
163 if ((card->state != CARD_STATE_DOWN) &&
164 (card->state != CARD_STATE_RECOVER))
165 return -EPERM;
166
167 i = simple_strtoul(buf, &tmp, 16);
168 if ((i == 0) || (i == 1))
169 card->options.fake_broadcast = i;
170 else {
4a71df50
FB		 171 return -EINVAL;
172 }
173 return count;
174}
175
176static DEVICE_ATTR(fake_broadcast, 0644, qeth_l3_dev_fake_broadcast_show,
177 qeth_l3_dev_fake_broadcast_store);
178
179static ssize_t qeth_l3_dev_broadcast_mode_show(struct device *dev,
180 struct device_attribute *attr, char *buf)
181{
182 struct qeth_card *card = dev_get_drvdata(dev);
183
184 if (!card)
185 return -EINVAL;
186
187 if (!((card->info.link_type == QETH_LINK_TYPE_HSTR) ||
188 (card->info.link_type == QETH_LINK_TYPE_LANE_TR)))
189 return sprintf(buf, "n/a\n");
190
191 return sprintf(buf, "%s\n", (card->options.broadcast_mode ==
192 QETH_TR_BROADCAST_ALLRINGS)?
193 "all rings":"local");
194}
195
196static ssize_t qeth_l3_dev_broadcast_mode_store(struct device *dev,
197 struct device_attribute *attr, const char *buf, size_t count)
198{
199 struct qeth_card *card = dev_get_drvdata(dev);
200 char *tmp;
201
202 if (!card)
203 return -EINVAL;
204
205 if ((card->state != CARD_STATE_DOWN) &&
206 (card->state != CARD_STATE_RECOVER))
207 return -EPERM;
208
209 if (!((card->info.link_type == QETH_LINK_TYPE_HSTR) ||
210 (card->info.link_type == QETH_LINK_TYPE_LANE_TR))) {
4a71df50
FB		 211 return -EINVAL;
212 }
213
214 tmp = strsep((char **) &buf, "\n");
215
216 if (!strcmp(tmp, "local")) {
217 card->options.broadcast_mode = QETH_TR_BROADCAST_LOCAL;
218 return count;
219 } else if (!strcmp(tmp, "all_rings")) {
220 card->options.broadcast_mode = QETH_TR_BROADCAST_ALLRINGS;
221 return count;
222 } else {
4a71df50
FB		 223 return -EINVAL;
224 }
225 return count;
226}
227
228static DEVICE_ATTR(broadcast_mode, 0644, qeth_l3_dev_broadcast_mode_show,
229 qeth_l3_dev_broadcast_mode_store);
230
231static ssize_t qeth_l3_dev_canonical_macaddr_show(struct device *dev,
232 struct device_attribute *attr, char *buf)
233{
234 struct qeth_card *card = dev_get_drvdata(dev);
235
236 if (!card)
237 return -EINVAL;
238
239 if (!((card->info.link_type == QETH_LINK_TYPE_HSTR) ||
240 (card->info.link_type == QETH_LINK_TYPE_LANE_TR)))
241 return sprintf(buf, "n/a\n");
242
243 return sprintf(buf, "%i\n", (card->options.macaddr_mode ==
244 QETH_TR_MACADDR_CANONICAL)? 1:0);
245}
246
247static ssize_t qeth_l3_dev_canonical_macaddr_store(struct device *dev,
248 struct device_attribute *attr, const char *buf, size_t count)
249{
250 struct qeth_card *card = dev_get_drvdata(dev);
251 char *tmp;
252 int i;
253
254 if (!card)
255 return -EINVAL;
256
257 if ((card->state != CARD_STATE_DOWN) &&
258 (card->state != CARD_STATE_RECOVER))
259 return -EPERM;
260
261 if (!((card->info.link_type == QETH_LINK_TYPE_HSTR) ||
262 (card->info.link_type == QETH_LINK_TYPE_LANE_TR))) {
4a71df50
FB		 263 return -EINVAL;
264 }
265
266 i = simple_strtoul(buf, &tmp, 16);
267 if ((i == 0) || (i == 1))
268 card->options.macaddr_mode = i?
269 QETH_TR_MACADDR_CANONICAL :
270 QETH_TR_MACADDR_NONCANONICAL;
271 else {
4a71df50
FB		 272 return -EINVAL;
273 }
274 return count;
275}
276
277static DEVICE_ATTR(canonical_macaddr, 0644, qeth_l3_dev_canonical_macaddr_show,
278 qeth_l3_dev_canonical_macaddr_store);
279
280static ssize_t qeth_l3_dev_checksum_show(struct device *dev,
281 struct device_attribute *attr, char *buf)
282{
283 struct qeth_card *card = dev_get_drvdata(dev);
284
285 if (!card)
286 return -EINVAL;
287
288 return sprintf(buf, "%s checksumming\n",
289 qeth_l3_get_checksum_str(card));
290}
291
292static ssize_t qeth_l3_dev_checksum_store(struct device *dev,
293 struct device_attribute *attr, const char *buf, size_t count)
294{
295 struct qeth_card *card = dev_get_drvdata(dev);
3fd434d8 296 enum qeth_checksum_types csum_type;
4a71df50 297 char *tmp;
3fd434d8 298 int rc;
4a71df50
FB		 299
300 if (!card)
301 return -EINVAL;
302
4a71df50
FB		 303 tmp = strsep((char **) &buf, "\n");
304 if (!strcmp(tmp, "sw_checksumming"))
3fd434d8 305 csum_type = SW_CHECKSUMMING;
4a71df50 306 else if (!strcmp(tmp, "hw_checksumming"))
3fd434d8 307 csum_type = HW_CHECKSUMMING;
4a71df50 308 else if (!strcmp(tmp, "no_checksumming"))
3fd434d8
FB		 309 csum_type = NO_CHECKSUMMING;
310 else
4a71df50 311 return -EINVAL;
3fd434d8
FB		 312
313 rc = qeth_l3_set_rx_csum(card, csum_type);
314 if (rc)
315 return rc;
4a71df50
FB		 316 return count;
317}
318
319static DEVICE_ATTR(checksumming, 0644, qeth_l3_dev_checksum_show,
320 qeth_l3_dev_checksum_store);
321
c3b4a740
FB		 322static ssize_t qeth_l3_dev_large_send_show(struct device *dev,
323 struct device_attribute *attr, char *buf)
324{
325 struct qeth_card *card = dev_get_drvdata(dev);
326
327 if (!card)
328 return -EINVAL;
329
330 switch (card->options.large_send) {
331 case QETH_LARGE_SEND_NO:
332 return sprintf(buf, "%s\n", "no");
333 case QETH_LARGE_SEND_TSO:
334 return sprintf(buf, "%s\n", "TSO");
335 default:
336 return sprintf(buf, "%s\n", "N/A");
337 }
338}
339
340static ssize_t qeth_l3_dev_large_send_store(struct device *dev,
341 struct device_attribute *attr, const char *buf, size_t count)
342{
343 struct qeth_card *card = dev_get_drvdata(dev);
344 enum qeth_large_send_types type;
345 int rc = 0;
346 char *tmp;
347
348 if (!card)
349 return -EINVAL;
350 tmp = strsep((char **) &buf, "\n");
351 if (!strcmp(tmp, "no"))
352 type = QETH_LARGE_SEND_NO;
353 else if (!strcmp(tmp, "TSO"))
354 type = QETH_LARGE_SEND_TSO;
355 else
356 return -EINVAL;
357
358 if (card->options.large_send == type)
359 return count;
360 rc = qeth_l3_set_large_send(card, type);
361 if (rc)
362 return rc;
363 return count;
364}
365
366static DEVICE_ATTR(large_send, 0644, qeth_l3_dev_large_send_show,
367 qeth_l3_dev_large_send_store);
368
4a71df50
FB		 369static struct attribute *qeth_l3_device_attrs[] = {
370 &dev_attr_route4.attr,
371 &dev_attr_route6.attr,
372 &dev_attr_fake_broadcast.attr,
373 &dev_attr_broadcast_mode.attr,
374 &dev_attr_canonical_macaddr.attr,
375 &dev_attr_checksumming.attr,
c3b4a740 376 &dev_attr_large_send.attr,
4a71df50
FB		 377 NULL,
378};
379
380static struct attribute_group qeth_l3_device_attr_group = {
381 .attrs = qeth_l3_device_attrs,
382};
383
384static ssize_t qeth_l3_dev_ipato_enable_show(struct device *dev,
385 struct device_attribute *attr, char *buf)
386{
387 struct qeth_card *card = dev_get_drvdata(dev);
388
389 if (!card)
390 return -EINVAL;
391
392 return sprintf(buf, "%i\n", card->ipato.enabled? 1:0);
393}
394
395static ssize_t qeth_l3_dev_ipato_enable_store(struct device *dev,
396 struct device_attribute *attr, const char *buf, size_t count)
397{
398 struct qeth_card *card = dev_get_drvdata(dev);
399 char *tmp;
400
401 if (!card)
402 return -EINVAL;
403
404 if ((card->state != CARD_STATE_DOWN) &&
405 (card->state != CARD_STATE_RECOVER))
406 return -EPERM;
407
408 tmp = strsep((char **) &buf, "\n");
409 if (!strcmp(tmp, "toggle")) {
410 card->ipato.enabled = (card->ipato.enabled)? 0 : 1;
411 } else if (!strcmp(tmp, "1")) {
412 card->ipato.enabled = 1;
413 } else if (!strcmp(tmp, "0")) {
414 card->ipato.enabled = 0;
415 } else {
4a71df50
FB		 416 return -EINVAL;
417 }
418 return count;
419}
420
421static QETH_DEVICE_ATTR(ipato_enable, enable, 0644,
422 qeth_l3_dev_ipato_enable_show,
423 qeth_l3_dev_ipato_enable_store);
424
425static ssize_t qeth_l3_dev_ipato_invert4_show(struct device *dev,
426 struct device_attribute *attr, char *buf)
427{
428 struct qeth_card *card = dev_get_drvdata(dev);
429
430 if (!card)
431 return -EINVAL;
432
433 return sprintf(buf, "%i\n", card->ipato.invert4? 1:0);
434}
435
436static ssize_t qeth_l3_dev_ipato_invert4_store(struct device *dev,
437 struct device_attribute *attr,
438 const char *buf, size_t count)
439{
440 struct qeth_card *card = dev_get_drvdata(dev);
441 char *tmp;
442
443 if (!card)
444 return -EINVAL;
445
446 tmp = strsep((char **) &buf, "\n");
447 if (!strcmp(tmp, "toggle")) {
448 card->ipato.invert4 = (card->ipato.invert4)? 0 : 1;
449 } else if (!strcmp(tmp, "1")) {
450 card->ipato.invert4 = 1;
451 } else if (!strcmp(tmp, "0")) {
452 card->ipato.invert4 = 0;
453 } else {
4a71df50
FB		 454 return -EINVAL;
455 }
456 return count;
457}
458
459static QETH_DEVICE_ATTR(ipato_invert4, invert4, 0644,
460 qeth_l3_dev_ipato_invert4_show,
461 qeth_l3_dev_ipato_invert4_store);
462
463static ssize_t qeth_l3_dev_ipato_add_show(char *buf, struct qeth_card *card,
464 enum qeth_prot_versions proto)
465{
466 struct qeth_ipato_entry *ipatoe;
467 unsigned long flags;
468 char addr_str[40];
469 int entry_len; /* length of 1 entry string, differs between v4 and v6 */
470 int i = 0;
471
472 entry_len = (proto == QETH_PROT_IPV4)? 12 : 40;
473 /* add strlen for "/<mask>\n" */
474 entry_len += (proto == QETH_PROT_IPV4)? 5 : 6;
475 spin_lock_irqsave(&card->ip_lock, flags);
476 list_for_each_entry(ipatoe, &card->ipato.entries, entry) {
477 if (ipatoe->proto != proto)
478 continue;
479 /* String must not be longer than PAGE_SIZE. So we check if
480 * string length gets near PAGE_SIZE. Then we can savely display
481 * the next IPv6 address (worst case, compared to IPv4) */
482 if ((PAGE_SIZE - i) <= entry_len)
483 break;
484 qeth_l3_ipaddr_to_string(proto, ipatoe->addr, addr_str);
485 i += snprintf(buf + i, PAGE_SIZE - i,
486 "%s/%i\n", addr_str, ipatoe->mask_bits);
487 }
488 spin_unlock_irqrestore(&card->ip_lock, flags);
489 i += snprintf(buf + i, PAGE_SIZE - i, "\n");
490
491 return i;
492}
493
494static ssize_t qeth_l3_dev_ipato_add4_show(struct device *dev,
495 struct device_attribute *attr, char *buf)
496{
497 struct qeth_card *card = dev_get_drvdata(dev);
498
499 if (!card)
500 return -EINVAL;
501
502 return qeth_l3_dev_ipato_add_show(buf, card, QETH_PROT_IPV4);
503}
504
505static int qeth_l3_parse_ipatoe(const char *buf, enum qeth_prot_versions proto,
506 u8 *addr, int *mask_bits)
507{
508 const char *start, *end;
509 char *tmp;
510 char buffer[40] = {0, };
511
512 start = buf;
513 /* get address string */
514 end = strchr(start, '/');
515 if (!end || (end - start >= 40)) {
4a71df50
FB		 516 return -EINVAL;
517 }
518 strncpy(buffer, start, end - start);
519 if (qeth_l3_string_to_ipaddr(buffer, proto, addr)) {
4a71df50
FB		 520 return -EINVAL;
521 }
522 start = end + 1;
523 *mask_bits = simple_strtoul(start, &tmp, 10);
524 if (!strlen(start) ||
525 (tmp == start) ||
526 (*mask_bits > ((proto == QETH_PROT_IPV4) ? 32 : 128))) {
4a71df50
FB		 527 return -EINVAL;
528 }
529 return 0;
530}
531
532static ssize_t qeth_l3_dev_ipato_add_store(const char *buf, size_t count,
533 struct qeth_card *card, enum qeth_prot_versions proto)
534{
535 struct qeth_ipato_entry *ipatoe;
536 u8 addr[16];
537 int mask_bits;
538 int rc;
539
540 rc = qeth_l3_parse_ipatoe(buf, proto, addr, &mask_bits);
541 if (rc)
542 return rc;
543
544 ipatoe = kzalloc(sizeof(struct qeth_ipato_entry), GFP_KERNEL);
545 if (!ipatoe) {
4a71df50
FB		 546 return -ENOMEM;
547 }
548 ipatoe->proto = proto;
549 memcpy(ipatoe->addr, addr, (proto == QETH_PROT_IPV4)? 4:16);
550 ipatoe->mask_bits = mask_bits;
551
552 rc = qeth_l3_add_ipato_entry(card, ipatoe);
553 if (rc) {
554 kfree(ipatoe);
555 return rc;
556 }
557
558 return count;
559}
560
561static ssize_t qeth_l3_dev_ipato_add4_store(struct device *dev,
562 struct device_attribute *attr, const char *buf, size_t count)
563{
564 struct qeth_card *card = dev_get_drvdata(dev);
565
566 if (!card)
567 return -EINVAL;
568
569 return qeth_l3_dev_ipato_add_store(buf, count, card, QETH_PROT_IPV4);
570}
571
572static QETH_DEVICE_ATTR(ipato_add4, add4, 0644,
573 qeth_l3_dev_ipato_add4_show,
574 qeth_l3_dev_ipato_add4_store);
575
576static ssize_t qeth_l3_dev_ipato_del_store(const char *buf, size_t count,
577 struct qeth_card *card, enum qeth_prot_versions proto)
578{
579 u8 addr[16];
580 int mask_bits;
581 int rc;
582
583 rc = qeth_l3_parse_ipatoe(buf, proto, addr, &mask_bits);
584 if (rc)
585 return rc;
586
587 qeth_l3_del_ipato_entry(card, proto, addr, mask_bits);
588
589 return count;
590}
591
592static ssize_t qeth_l3_dev_ipato_del4_store(struct device *dev,
593 struct device_attribute *attr, const char *buf, size_t count)
594{
595 struct qeth_card *card = dev_get_drvdata(dev);
596
597 if (!card)
598 return -EINVAL;
599
600 return qeth_l3_dev_ipato_del_store(buf, count, card, QETH_PROT_IPV4);
601}
602
603static QETH_DEVICE_ATTR(ipato_del4, del4, 0200, NULL,
604 qeth_l3_dev_ipato_del4_store);
605
606static ssize_t qeth_l3_dev_ipato_invert6_show(struct device *dev,
607 struct device_attribute *attr, char *buf)
608{
609 struct qeth_card *card = dev_get_drvdata(dev);
610
611 if (!card)
612 return -EINVAL;
613
614 return sprintf(buf, "%i\n", card->ipato.invert6? 1:0);
615}
616
617static ssize_t qeth_l3_dev_ipato_invert6_store(struct device *dev,
618 struct device_attribute *attr, const char *buf, size_t count)
619{
620 struct qeth_card *card = dev_get_drvdata(dev);
621 char *tmp;
622
623 if (!card)
624 return -EINVAL;
625
626 tmp = strsep((char **) &buf, "\n");
627 if (!strcmp(tmp, "toggle")) {
628 card->ipato.invert6 = (card->ipato.invert6)? 0 : 1;
629 } else if (!strcmp(tmp, "1")) {
630 card->ipato.invert6 = 1;
631 } else if (!strcmp(tmp, "0")) {
632 card->ipato.invert6 = 0;
633 } else {
4a71df50
FB		 634 return -EINVAL;
635 }
636 return count;
637}
638
639static QETH_DEVICE_ATTR(ipato_invert6, invert6, 0644,
640 qeth_l3_dev_ipato_invert6_show,
641 qeth_l3_dev_ipato_invert6_store);
642
643
644static ssize_t qeth_l3_dev_ipato_add6_show(struct device *dev,
645 struct device_attribute *attr, char *buf)
646{
647 struct qeth_card *card = dev_get_drvdata(dev);
648
649 if (!card)
650 return -EINVAL;
651
652 return qeth_l3_dev_ipato_add_show(buf, card, QETH_PROT_IPV6);
653}
654
655static ssize_t qeth_l3_dev_ipato_add6_store(struct device *dev,
656 struct device_attribute *attr, const char *buf, size_t count)
657{
658 struct qeth_card *card = dev_get_drvdata(dev);
659
660 if (!card)
661 return -EINVAL;
662
663 return qeth_l3_dev_ipato_add_store(buf, count, card, QETH_PROT_IPV6);
664}
665
666static QETH_DEVICE_ATTR(ipato_add6, add6, 0644,
667 qeth_l3_dev_ipato_add6_show,
668 qeth_l3_dev_ipato_add6_store);
669
670static ssize_t qeth_l3_dev_ipato_del6_store(struct device *dev,
671 struct device_attribute *attr, const char *buf, size_t count)
672{
673 struct qeth_card *card = dev_get_drvdata(dev);
674
675 if (!card)
676 return -EINVAL;
677
678 return qeth_l3_dev_ipato_del_store(buf, count, card, QETH_PROT_IPV6);
679}
680
681static QETH_DEVICE_ATTR(ipato_del6, del6, 0200, NULL,
682 qeth_l3_dev_ipato_del6_store);
683
684static struct attribute *qeth_ipato_device_attrs[] = {
685 &dev_attr_ipato_enable.attr,
686 &dev_attr_ipato_invert4.attr,
687 &dev_attr_ipato_add4.attr,
688 &dev_attr_ipato_del4.attr,
689 &dev_attr_ipato_invert6.attr,
690 &dev_attr_ipato_add6.attr,
691 &dev_attr_ipato_del6.attr,
692 NULL,
693};
694
695static struct attribute_group qeth_device_ipato_group = {
696 .name = "ipa_takeover",
697 .attrs = qeth_ipato_device_attrs,
698};
699
700static ssize_t qeth_l3_dev_vipa_add_show(char *buf, struct qeth_card *card,
701 enum qeth_prot_versions proto)
702{
703 struct qeth_ipaddr *ipaddr;
704 char addr_str[40];
705 int entry_len; /* length of 1 entry string, differs between v4 and v6 */
706 unsigned long flags;
707 int i = 0;
708
709 entry_len = (proto == QETH_PROT_IPV4)? 12 : 40;
710 entry_len += 2; /* \n + terminator */
711 spin_lock_irqsave(&card->ip_lock, flags);
712 list_for_each_entry(ipaddr, &card->ip_list, entry) {
713 if (ipaddr->proto != proto)
714 continue;
715 if (ipaddr->type != QETH_IP_TYPE_VIPA)
716 continue;
717 /* String must not be longer than PAGE_SIZE. So we check if
718 * string length gets near PAGE_SIZE. Then we can savely display
719 * the next IPv6 address (worst case, compared to IPv4) */
720 if ((PAGE_SIZE - i) <= entry_len)
721 break;
722 qeth_l3_ipaddr_to_string(proto, (const u8 *)&ipaddr->u,
723 addr_str);
724 i += snprintf(buf + i, PAGE_SIZE - i, "%s\n", addr_str);
725 }
726 spin_unlock_irqrestore(&card->ip_lock, flags);
727 i += snprintf(buf + i, PAGE_SIZE - i, "\n");
728
729 return i;
730}
731
732static ssize_t qeth_l3_dev_vipa_add4_show(struct device *dev,
733 struct device_attribute *attr, char *buf)
734{
735 struct qeth_card *card = dev_get_drvdata(dev);
736
737 if (!card)
738 return -EINVAL;
739
740 return qeth_l3_dev_vipa_add_show(buf, card, QETH_PROT_IPV4);
741}
742
743static int qeth_l3_parse_vipae(const char *buf, enum qeth_prot_versions proto,
744 u8 *addr)
745{
746 if (qeth_l3_string_to_ipaddr(buf, proto, addr)) {
4a71df50
FB		 747 return -EINVAL;
748 }
749 return 0;
750}
751
752static ssize_t qeth_l3_dev_vipa_add_store(const char *buf, size_t count,
753 struct qeth_card *card, enum qeth_prot_versions proto)
754{
755 u8 addr[16] = {0, };
756 int rc;
757
758 rc = qeth_l3_parse_vipae(buf, proto, addr);
759 if (rc)
760 return rc;
761
762 rc = qeth_l3_add_vipa(card, proto, addr);
763 if (rc)
764 return rc;
765
766 return count;
767}
768
769static ssize_t qeth_l3_dev_vipa_add4_store(struct device *dev,
770 struct device_attribute *attr, const char *buf, size_t count)
771{
772 struct qeth_card *card = dev_get_drvdata(dev);
773
774 if (!card)
775 return -EINVAL;
776
777 return qeth_l3_dev_vipa_add_store(buf, count, card, QETH_PROT_IPV4);
778}
779
780static QETH_DEVICE_ATTR(vipa_add4, add4, 0644,
781 qeth_l3_dev_vipa_add4_show,
782 qeth_l3_dev_vipa_add4_store);
783
784static ssize_t qeth_l3_dev_vipa_del_store(const char *buf, size_t count,
785 struct qeth_card *card, enum qeth_prot_versions proto)
786{
787 u8 addr[16];
788 int rc;
789
790 rc = qeth_l3_parse_vipae(buf, proto, addr);
791 if (rc)
792 return rc;
793
794 qeth_l3_del_vipa(card, proto, addr);
795
796 return count;
797}
798
799static ssize_t qeth_l3_dev_vipa_del4_store(struct device *dev,
800 struct device_attribute *attr, const char *buf, size_t count)
801{
802 struct qeth_card *card = dev_get_drvdata(dev);
803
804 if (!card)
805 return -EINVAL;
806
807 return qeth_l3_dev_vipa_del_store(buf, count, card, QETH_PROT_IPV4);
808}
809
810static QETH_DEVICE_ATTR(vipa_del4, del4, 0200, NULL,
811 qeth_l3_dev_vipa_del4_store);
812
813static ssize_t qeth_l3_dev_vipa_add6_show(struct device *dev,
814 struct device_attribute *attr, char *buf)
815{
816 struct qeth_card *card = dev_get_drvdata(dev);
817
818 if (!card)
819 return -EINVAL;
820
821 return qeth_l3_dev_vipa_add_show(buf, card, QETH_PROT_IPV6);
822}
823
824static ssize_t qeth_l3_dev_vipa_add6_store(struct device *dev,
825 struct device_attribute *attr, const char *buf, size_t count)
826{
827 struct qeth_card *card = dev_get_drvdata(dev);
828
829 if (!card)
830 return -EINVAL;
831
832 return qeth_l3_dev_vipa_add_store(buf, count, card, QETH_PROT_IPV6);
833}
834
835static QETH_DEVICE_ATTR(vipa_add6, add6, 0644,
836 qeth_l3_dev_vipa_add6_show,
837 qeth_l3_dev_vipa_add6_store);
838
839static ssize_t qeth_l3_dev_vipa_del6_store(struct device *dev,
840 struct device_attribute *attr, const char *buf, size_t count)
841{
842 struct qeth_card *card = dev_get_drvdata(dev);
843
844 if (!card)
845 return -EINVAL;
846
847 return qeth_l3_dev_vipa_del_store(buf, count, card, QETH_PROT_IPV6);
848}
849
850static QETH_DEVICE_ATTR(vipa_del6, del6, 0200, NULL,
851 qeth_l3_dev_vipa_del6_store);
852
853static struct attribute *qeth_vipa_device_attrs[] = {
854 &dev_attr_vipa_add4.attr,
855 &dev_attr_vipa_del4.attr,
856 &dev_attr_vipa_add6.attr,
857 &dev_attr_vipa_del6.attr,
858 NULL,
859};
860
861static struct attribute_group qeth_device_vipa_group = {
862 .name = "vipa",
863 .attrs = qeth_vipa_device_attrs,
864};
865
866static ssize_t qeth_l3_dev_rxip_add_show(char *buf, struct qeth_card *card,
867 enum qeth_prot_versions proto)
868{
869 struct qeth_ipaddr *ipaddr;
870 char addr_str[40];
871 int entry_len; /* length of 1 entry string, differs between v4 and v6 */
872 unsigned long flags;
873 int i = 0;
874
875 entry_len = (proto == QETH_PROT_IPV4)? 12 : 40;
876 entry_len += 2; /* \n + terminator */
877 spin_lock_irqsave(&card->ip_lock, flags);
878 list_for_each_entry(ipaddr, &card->ip_list, entry) {
879 if (ipaddr->proto != proto)
880 continue;
881 if (ipaddr->type != QETH_IP_TYPE_RXIP)
882 continue;
883 /* String must not be longer than PAGE_SIZE. So we check if
884 * string length gets near PAGE_SIZE. Then we can savely display
885 * the next IPv6 address (worst case, compared to IPv4) */
886 if ((PAGE_SIZE - i) <= entry_len)
887 break;
888 qeth_l3_ipaddr_to_string(proto, (const u8 *)&ipaddr->u,
889 addr_str);
890 i += snprintf(buf + i, PAGE_SIZE - i, "%s\n", addr_str);
891 }
892 spin_unlock_irqrestore(&card->ip_lock, flags);
893 i += snprintf(buf + i, PAGE_SIZE - i, "\n");
894
895 return i;
896}
897
898static ssize_t qeth_l3_dev_rxip_add4_show(struct device *dev,
899 struct device_attribute *attr, char *buf)
900{
901 struct qeth_card *card = dev_get_drvdata(dev);
902
903 if (!card)
904 return -EINVAL;
905
906 return qeth_l3_dev_rxip_add_show(buf, card, QETH_PROT_IPV4);
907}
908
909static int qeth_l3_parse_rxipe(const char *buf, enum qeth_prot_versions proto,
910 u8 *addr)
911{
912 if (qeth_l3_string_to_ipaddr(buf, proto, addr)) {
4a71df50
FB		 913 return -EINVAL;
914 }
915 return 0;
916}
917
918static ssize_t qeth_l3_dev_rxip_add_store(const char *buf, size_t count,
919 struct qeth_card *card, enum qeth_prot_versions proto)
920{
921 u8 addr[16] = {0, };
922 int rc;
923
924 rc = qeth_l3_parse_rxipe(buf, proto, addr);
925 if (rc)
926 return rc;
927
928 rc = qeth_l3_add_rxip(card, proto, addr);
929 if (rc)
930 return rc;
931
932 return count;
933}
934
935static ssize_t qeth_l3_dev_rxip_add4_store(struct device *dev,
936 struct device_attribute *attr, const char *buf, size_t count)
937{
938 struct qeth_card *card = dev_get_drvdata(dev);
939
940 if (!card)
941 return -EINVAL;
942
943 return qeth_l3_dev_rxip_add_store(buf, count, card, QETH_PROT_IPV4);
944}
945
946static QETH_DEVICE_ATTR(rxip_add4, add4, 0644,
947 qeth_l3_dev_rxip_add4_show,
948 qeth_l3_dev_rxip_add4_store);
949
950static ssize_t qeth_l3_dev_rxip_del_store(const char *buf, size_t count,
951 struct qeth_card *card, enum qeth_prot_versions proto)
952{
953 u8 addr[16];
954 int rc;
955
956 rc = qeth_l3_parse_rxipe(buf, proto, addr);
957 if (rc)
958 return rc;
959
960 qeth_l3_del_rxip(card, proto, addr);
961
962 return count;
963}
964
965static ssize_t qeth_l3_dev_rxip_del4_store(struct device *dev,
966 struct device_attribute *attr, const char *buf, size_t count)
967{
968 struct qeth_card *card = dev_get_drvdata(dev);
969
970 if (!card)
971 return -EINVAL;
972
973 return qeth_l3_dev_rxip_del_store(buf, count, card, QETH_PROT_IPV4);
974}
975
976static QETH_DEVICE_ATTR(rxip_del4, del4, 0200, NULL,
977 qeth_l3_dev_rxip_del4_store);
978
979static ssize_t qeth_l3_dev_rxip_add6_show(struct device *dev,
980 struct device_attribute *attr, char *buf)
981{
982 struct qeth_card *card = dev_get_drvdata(dev);
983
984 if (!card)
985 return -EINVAL;
986
987 return qeth_l3_dev_rxip_add_show(buf, card, QETH_PROT_IPV6);
988}
989
990static ssize_t qeth_l3_dev_rxip_add6_store(struct device *dev,
991 struct device_attribute *attr, const char *buf, size_t count)
992{
993 struct qeth_card *card = dev_get_drvdata(dev);
994
995 if (!card)
996 return -EINVAL;
997
998 return qeth_l3_dev_rxip_add_store(buf, count, card, QETH_PROT_IPV6);
999}
1000
1001static QETH_DEVICE_ATTR(rxip_add6, add6, 0644,
1002 qeth_l3_dev_rxip_add6_show,
1003 qeth_l3_dev_rxip_add6_store);
1004
1005static ssize_t qeth_l3_dev_rxip_del6_store(struct device *dev,
1006 struct device_attribute *attr, const char *buf, size_t count)
1007{
1008 struct qeth_card *card = dev_get_drvdata(dev);
1009
1010 if (!card)
1011 return -EINVAL;
1012
1013 return qeth_l3_dev_rxip_del_store(buf, count, card, QETH_PROT_IPV6);
1014}
1015
1016static QETH_DEVICE_ATTR(rxip_del6, del6, 0200, NULL,
1017 qeth_l3_dev_rxip_del6_store);
1018
1019static struct attribute *qeth_rxip_device_attrs[] = {
1020 &dev_attr_rxip_add4.attr,
1021 &dev_attr_rxip_del4.attr,
1022 &dev_attr_rxip_add6.attr,
1023 &dev_attr_rxip_del6.attr,
1024 NULL,
1025};
1026
1027static struct attribute_group qeth_device_rxip_group = {
1028 .name = "rxip",
1029 .attrs = qeth_rxip_device_attrs,
1030};
1031
1032int qeth_l3_create_device_attributes(struct device *dev)
1033{
1034 int ret;
1035
1036 ret = sysfs_create_group(&dev->kobj, &qeth_l3_device_attr_group);
1037 if (ret)
1038 return ret;
1039
1040 ret = sysfs_create_group(&dev->kobj, &qeth_device_ipato_group);
1041 if (ret) {
1042 sysfs_remove_group(&dev->kobj, &qeth_l3_device_attr_group);
1043 return ret;
1044 }
1045
1046 ret = sysfs_create_group(&dev->kobj, &qeth_device_vipa_group);
1047 if (ret) {
1048 sysfs_remove_group(&dev->kobj, &qeth_l3_device_attr_group);
1049 sysfs_remove_group(&dev->kobj, &qeth_device_ipato_group);
1050 return ret;
1051 }
1052
1053 ret = sysfs_create_group(&dev->kobj, &qeth_device_rxip_group);
1054 if (ret) {
1055 sysfs_remove_group(&dev->kobj, &qeth_l3_device_attr_group);
1056 sysfs_remove_group(&dev->kobj, &qeth_device_ipato_group);
1057 sysfs_remove_group(&dev->kobj, &qeth_device_vipa_group);
1058 return ret;
1059 }
1060 return 0;
1061}
1062
1063void qeth_l3_remove_device_attributes(struct device *dev)
1064{
1065 sysfs_remove_group(&dev->kobj, &qeth_l3_device_attr_group);
1066 sysfs_remove_group(&dev->kobj, &qeth_device_ipato_group);
1067 sysfs_remove_group(&dev->kobj, &qeth_device_vipa_group);
1068 sysfs_remove_group(&dev->kobj, &qeth_device_rxip_group);
1069}
Linux 6.x block layer and io_uring tree(s)