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