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