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