projects / deliverable / linux.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
[S390] Fix sparse warnings.
[deliverable/linux.git] / drivers / s390 / net / qeth_sys.c
CommitLineData
1da177e4
LT		 1/*
2 *
e018ba1f 3 * linux/drivers/s390/net/qeth_sys.c
1da177e4
LT		 4 *
5 * Linux on zSeries OSA Express and HiperSockets support
6 * This file contains code related to sysfs.
7 *
8 * Copyright 2000,2003 IBM Corporation
9 *
10 * Author(s): Thomas Spatzier <tspat@de.ibm.com>
1387780f 11 * Frank Pavlic <fpavlic@de.ibm.com>
1da177e4
LT		 12 *
13 */
14#include <linux/list.h>
15#include <linux/rwsem.h>
16
17#include <asm/ebcdic.h>
18
19#include "qeth.h"
20#include "qeth_mpc.h"
21#include "qeth_fs.h"
22
1da177e4
LT		 23/*****************************************************************************/
24/* */
25/* /sys-fs stuff UNDER DEVELOPMENT !!! */
26/* */
27/*****************************************************************************/
28//low/high watermark
29
30static ssize_t
10523b3b 31qeth_dev_state_show(struct device *dev, struct device_attribute *attr, char *buf)
1da177e4
LT		 32{
33 struct qeth_card *card = dev->driver_data;
34 if (!card)
35 return -EINVAL;
36
37 switch (card->state) {
38 case CARD_STATE_DOWN:
39 return sprintf(buf, "DOWN\n");
40 case CARD_STATE_HARDSETUP:
41 return sprintf(buf, "HARDSETUP\n");
42 case CARD_STATE_SOFTSETUP:
43 return sprintf(buf, "SOFTSETUP\n");
44 case CARD_STATE_UP:
45 if (card->lan_online)
46 return sprintf(buf, "UP (LAN ONLINE)\n");
47 else
48 return sprintf(buf, "UP (LAN OFFLINE)\n");
49 case CARD_STATE_RECOVER:
50 return sprintf(buf, "RECOVER\n");
51 default:
52 return sprintf(buf, "UNKNOWN\n");
53 }
54}
55
56static DEVICE_ATTR(state, 0444, qeth_dev_state_show, NULL);
57
58static ssize_t
10523b3b 59qeth_dev_chpid_show(struct device *dev, struct device_attribute *attr, char *buf)
1da177e4
LT		 60{
61 struct qeth_card *card = dev->driver_data;
62 if (!card)
63 return -EINVAL;
64
65 return sprintf(buf, "%02X\n", card->info.chpid);
66}
67
68static DEVICE_ATTR(chpid, 0444, qeth_dev_chpid_show, NULL);
69
70static ssize_t
10523b3b 71qeth_dev_if_name_show(struct device *dev, struct device_attribute *attr, char *buf)
1da177e4
LT		 72{
73 struct qeth_card *card = dev->driver_data;
74 if (!card)
75 return -EINVAL;
76 return sprintf(buf, "%s\n", QETH_CARD_IFNAME(card));
77}
78
79static DEVICE_ATTR(if_name, 0444, qeth_dev_if_name_show, NULL);
80
81static ssize_t
10523b3b 82qeth_dev_card_type_show(struct device *dev, struct device_attribute *attr, char *buf)
1da177e4
LT		 83{
84 struct qeth_card *card = dev->driver_data;
85 if (!card)
86 return -EINVAL;
87
88 return sprintf(buf, "%s\n", qeth_get_cardname_short(card));
89}
90
91static DEVICE_ATTR(card_type, 0444, qeth_dev_card_type_show, NULL);
92
93static ssize_t
10523b3b 94qeth_dev_portno_show(struct device *dev, struct device_attribute *attr, char *buf)
1da177e4
LT		 95{
96 struct qeth_card *card = dev->driver_data;
97 if (!card)
98 return -EINVAL;
99
100 return sprintf(buf, "%i\n", card->info.portno);
101}
102
103static ssize_t
10523b3b 104qeth_dev_portno_store(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
1da177e4
LT		 105{
106 struct qeth_card *card = dev->driver_data;
107 char *tmp;
108 unsigned int portno;
109
110 if (!card)
111 return -EINVAL;
112
113 if ((card->state != CARD_STATE_DOWN) &&
114 (card->state != CARD_STATE_RECOVER))
115 return -EPERM;
116
117 portno = simple_strtoul(buf, &tmp, 16);
1380fee2 118 if (portno > MAX_PORTNO){
1da177e4
LT		 119 PRINT_WARN("portno 0x%X is out of range\n", portno);
120 return -EINVAL;
121 }
122
123 card->info.portno = portno;
124 return count;
125}
126
127static DEVICE_ATTR(portno, 0644, qeth_dev_portno_show, qeth_dev_portno_store);
128
129static ssize_t
10523b3b 130qeth_dev_portname_show(struct device *dev, struct device_attribute *attr, char *buf)
1da177e4
LT		 131{
132 struct qeth_card *card = dev->driver_data;
133 char portname[9] = {0, };
134
135 if (!card)
136 return -EINVAL;
137
138 if (card->info.portname_required) {
139 memcpy(portname, card->info.portname + 1, 8);
140 EBCASC(portname, 8);
141 return sprintf(buf, "%s\n", portname);
142 } else
143 return sprintf(buf, "no portname required\n");
144}
145
146static ssize_t
10523b3b 147qeth_dev_portname_store(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
1da177e4
LT		 148{
149 struct qeth_card *card = dev->driver_data;
150 char *tmp;
151 int i;
152
153 if (!card)
154 return -EINVAL;
155
156 if ((card->state != CARD_STATE_DOWN) &&
157 (card->state != CARD_STATE_RECOVER))
158 return -EPERM;
159
160 tmp = strsep((char **) &buf, "\n");
6c6b3e7c 161 if ((strlen(tmp) > 8) || (strlen(tmp) == 0))
1da177e4
LT		 162 return -EINVAL;
163
164 card->info.portname[0] = strlen(tmp);
165 /* for beauty reasons */
166 for (i = 1; i < 9; i++)
167 card->info.portname[i] = ' ';
168 strcpy(card->info.portname + 1, tmp);
169 ASCEBC(card->info.portname + 1, 8);
170
171 return count;
172}
173
174static DEVICE_ATTR(portname, 0644, qeth_dev_portname_show,
175 qeth_dev_portname_store);
176
177static ssize_t
10523b3b 178qeth_dev_checksum_show(struct device *dev, struct device_attribute *attr, char *buf)
1da177e4
LT		 179{
180 struct qeth_card *card = dev->driver_data;
181
182 if (!card)
183 return -EINVAL;
184
185 return sprintf(buf, "%s checksumming\n", qeth_get_checksum_str(card));
186}
187
188static ssize_t
10523b3b 189qeth_dev_checksum_store(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
1da177e4
LT		 190{
191 struct qeth_card *card = dev->driver_data;
192 char *tmp;
193
194 if (!card)
195 return -EINVAL;
196
197 if ((card->state != CARD_STATE_DOWN) &&
198 (card->state != CARD_STATE_RECOVER))
199 return -EPERM;
200
201 tmp = strsep((char **) &buf, "\n");
202 if (!strcmp(tmp, "sw_checksumming"))
203 card->options.checksum_type = SW_CHECKSUMMING;
204 else if (!strcmp(tmp, "hw_checksumming"))
205 card->options.checksum_type = HW_CHECKSUMMING;
206 else if (!strcmp(tmp, "no_checksumming"))
207 card->options.checksum_type = NO_CHECKSUMMING;
208 else {
209 PRINT_WARN("Unknown checksumming type '%s'\n", tmp);
210 return -EINVAL;
211 }
212 return count;
213}
214
215static DEVICE_ATTR(checksumming, 0644, qeth_dev_checksum_show,
216 qeth_dev_checksum_store);
217
218static ssize_t
10523b3b 219qeth_dev_prioqing_show(struct device *dev, struct device_attribute *attr, char *buf)
1da177e4
LT		 220{
221 struct qeth_card *card = dev->driver_data;
222
223 if (!card)
224 return -EINVAL;
225
226 switch (card->qdio.do_prio_queueing) {
227 case QETH_PRIO_Q_ING_PREC:
228 return sprintf(buf, "%s\n", "by precedence");
229 case QETH_PRIO_Q_ING_TOS:
230 return sprintf(buf, "%s\n", "by type of service");
231 default:
232 return sprintf(buf, "always queue %i\n",
233 card->qdio.default_out_queue);
234 }
235}
236
237static ssize_t
10523b3b 238qeth_dev_prioqing_store(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
1da177e4
LT		 239{
240 struct qeth_card *card = dev->driver_data;
241 char *tmp;
242
243 if (!card)
244 return -EINVAL;
245
246 if ((card->state != CARD_STATE_DOWN) &&
247 (card->state != CARD_STATE_RECOVER))
248 return -EPERM;
249
250 /* check if 1920 devices are supported ,
251 * if though we have to permit priority queueing
252 */
253 if (card->qdio.no_out_queues == 1) {
254 PRINT_WARN("Priority queueing disabled due "
255 "to hardware limitations!\n");
256 card->qdio.do_prio_queueing = QETH_PRIOQ_DEFAULT;
257 return -EPERM;
258 }
259
260 tmp = strsep((char **) &buf, "\n");
261 if (!strcmp(tmp, "prio_queueing_prec"))
262 card->qdio.do_prio_queueing = QETH_PRIO_Q_ING_PREC;
263 else if (!strcmp(tmp, "prio_queueing_tos"))
264 card->qdio.do_prio_queueing = QETH_PRIO_Q_ING_TOS;
265 else if (!strcmp(tmp, "no_prio_queueing:0")) {
266 card->qdio.do_prio_queueing = QETH_NO_PRIO_QUEUEING;
267 card->qdio.default_out_queue = 0;
268 } else if (!strcmp(tmp, "no_prio_queueing:1")) {
269 card->qdio.do_prio_queueing = QETH_NO_PRIO_QUEUEING;
270 card->qdio.default_out_queue = 1;
271 } else if (!strcmp(tmp, "no_prio_queueing:2")) {
272 card->qdio.do_prio_queueing = QETH_NO_PRIO_QUEUEING;
273 card->qdio.default_out_queue = 2;
274 } else if (!strcmp(tmp, "no_prio_queueing:3")) {
275 card->qdio.do_prio_queueing = QETH_NO_PRIO_QUEUEING;
276 card->qdio.default_out_queue = 3;
277 } else if (!strcmp(tmp, "no_prio_queueing")) {
278 card->qdio.do_prio_queueing = QETH_NO_PRIO_QUEUEING;
279 card->qdio.default_out_queue = QETH_DEFAULT_QUEUE;
280 } else {
281 PRINT_WARN("Unknown queueing type '%s'\n", tmp);
282 return -EINVAL;
283 }
284 return count;
285}
286
287static DEVICE_ATTR(priority_queueing, 0644, qeth_dev_prioqing_show,
288 qeth_dev_prioqing_store);
289
290static ssize_t
10523b3b 291qeth_dev_bufcnt_show(struct device *dev, struct device_attribute *attr, char *buf)
1da177e4
LT		 292{
293 struct qeth_card *card = dev->driver_data;
294
295 if (!card)
296 return -EINVAL;
297
298 return sprintf(buf, "%i\n", card->qdio.in_buf_pool.buf_count);
299}
300
301static ssize_t
10523b3b 302qeth_dev_bufcnt_store(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
1da177e4
LT		 303{
304 struct qeth_card *card = dev->driver_data;
305 char *tmp;
306 int cnt, old_cnt;
307 int rc;
308
309 if (!card)
310 return -EINVAL;
311
312 if ((card->state != CARD_STATE_DOWN) &&
313 (card->state != CARD_STATE_RECOVER))
314 return -EPERM;
315
316 old_cnt = card->qdio.in_buf_pool.buf_count;
317 cnt = simple_strtoul(buf, &tmp, 10);
318 cnt = (cnt < QETH_IN_BUF_COUNT_MIN) ? QETH_IN_BUF_COUNT_MIN :
319 ((cnt > QETH_IN_BUF_COUNT_MAX) ? QETH_IN_BUF_COUNT_MAX : cnt);
320 if (old_cnt != cnt) {
321 if ((rc = qeth_realloc_buffer_pool(card, cnt)))
322 PRINT_WARN("Error (%d) while setting "
323 "buffer count.\n", rc);
324 }
325 return count;
326}
327
328static DEVICE_ATTR(buffer_count, 0644, qeth_dev_bufcnt_show,
329 qeth_dev_bufcnt_store);
330
331static inline ssize_t
332qeth_dev_route_show(struct qeth_card *card, struct qeth_routing_info *route,
333 char *buf)
334{
335 switch (route->type) {
336 case PRIMARY_ROUTER:
337 return sprintf(buf, "%s\n", "primary router");
338 case SECONDARY_ROUTER:
339 return sprintf(buf, "%s\n", "secondary router");
340 case MULTICAST_ROUTER:
341 if (card->info.broadcast_capable == QETH_BROADCAST_WITHOUT_ECHO)
342 return sprintf(buf, "%s\n", "multicast router+");
343 else
344 return sprintf(buf, "%s\n", "multicast router");
345 case PRIMARY_CONNECTOR:
346 if (card->info.broadcast_capable == QETH_BROADCAST_WITHOUT_ECHO)
347 return sprintf(buf, "%s\n", "primary connector+");
348 else
349 return sprintf(buf, "%s\n", "primary connector");
350 case SECONDARY_CONNECTOR:
351 if (card->info.broadcast_capable == QETH_BROADCAST_WITHOUT_ECHO)
352 return sprintf(buf, "%s\n", "secondary connector+");
353 else
354 return sprintf(buf, "%s\n", "secondary connector");
355 default:
356 return sprintf(buf, "%s\n", "no");
357 }
358}
359
360static ssize_t
10523b3b 361qeth_dev_route4_show(struct device *dev, struct device_attribute *attr, char *buf)
1da177e4
LT		 362{
363 struct qeth_card *card = dev->driver_data;
364
365 if (!card)
366 return -EINVAL;
367
368 return qeth_dev_route_show(card, &card->options.route4, buf);
369}
370
371static inline ssize_t
372qeth_dev_route_store(struct qeth_card *card, struct qeth_routing_info *route,
373 enum qeth_prot_versions prot, const char *buf, size_t count)
374{
375 enum qeth_routing_types old_route_type = route->type;
376 char *tmp;
377 int rc;
378
379 tmp = strsep((char **) &buf, "\n");
380
381 if (!strcmp(tmp, "no_router")){
382 route->type = NO_ROUTER;
383 } else if (!strcmp(tmp, "primary_connector")) {
384 route->type = PRIMARY_CONNECTOR;
385 } else if (!strcmp(tmp, "secondary_connector")) {
386 route->type = SECONDARY_CONNECTOR;
387 } else if (!strcmp(tmp, "multicast_router")) {
388 route->type = MULTICAST_ROUTER;
389 } else if (!strcmp(tmp, "primary_router")) {
390 route->type = PRIMARY_ROUTER;
391 } else if (!strcmp(tmp, "secondary_router")) {
392 route->type = SECONDARY_ROUTER;
393 } else if (!strcmp(tmp, "multicast_router")) {
394 route->type = MULTICAST_ROUTER;
395 } else {
396 PRINT_WARN("Invalid routing type '%s'.\n", tmp);
397 return -EINVAL;
398 }
399 if (((card->state == CARD_STATE_SOFTSETUP) ||
400 (card->state == CARD_STATE_UP)) &&
401 (old_route_type != route->type)){
402 if (prot == QETH_PROT_IPV4)
403 rc = qeth_setrouting_v4(card);
404 else if (prot == QETH_PROT_IPV6)
405 rc = qeth_setrouting_v6(card);
406 }
407 return count;
408}
409
410static ssize_t
10523b3b 411qeth_dev_route4_store(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
1da177e4
LT		 412{
413 struct qeth_card *card = dev->driver_data;
414
415 if (!card)
416 return -EINVAL;
417
418 return qeth_dev_route_store(card, &card->options.route4,
419 QETH_PROT_IPV4, buf, count);
420}
421
422static DEVICE_ATTR(route4, 0644, qeth_dev_route4_show, qeth_dev_route4_store);
423
424#ifdef CONFIG_QETH_IPV6
425static ssize_t
10523b3b 426qeth_dev_route6_show(struct device *dev, struct device_attribute *attr, char *buf)
1da177e4
LT		 427{
428 struct qeth_card *card = dev->driver_data;
429
430 if (!card)
431 return -EINVAL;
432
433 if (!qeth_is_supported(card, IPA_IPV6))
434 return sprintf(buf, "%s\n", "n/a");
435
436 return qeth_dev_route_show(card, &card->options.route6, buf);
437}
438
439static ssize_t
10523b3b 440qeth_dev_route6_store(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
1da177e4
LT		 441{
442 struct qeth_card *card = dev->driver_data;
443
444 if (!card)
445 return -EINVAL;
446
447 if (!qeth_is_supported(card, IPA_IPV6)){
448 PRINT_WARN("IPv6 not supported for interface %s.\n"
449 "Routing status no changed.\n",
450 QETH_CARD_IFNAME(card));
451 return -ENOTSUPP;
452 }
453
454 return qeth_dev_route_store(card, &card->options.route6,
455 QETH_PROT_IPV6, buf, count);
456}
457
458static DEVICE_ATTR(route6, 0644, qeth_dev_route6_show, qeth_dev_route6_store);
459#endif
460
461static ssize_t
10523b3b 462qeth_dev_add_hhlen_show(struct device *dev, struct device_attribute *attr, char *buf)
1da177e4
LT		 463{
464 struct qeth_card *card = dev->driver_data;
465
466 if (!card)
467 return -EINVAL;
468
469 return sprintf(buf, "%i\n", card->options.add_hhlen);
470}
471
472static ssize_t
10523b3b 473qeth_dev_add_hhlen_store(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
1da177e4
LT		 474{
475 struct qeth_card *card = dev->driver_data;
476 char *tmp;
477 int i;
478
479 if (!card)
480 return -EINVAL;
481
482 if ((card->state != CARD_STATE_DOWN) &&
483 (card->state != CARD_STATE_RECOVER))
484 return -EPERM;
485
486 i = simple_strtoul(buf, &tmp, 10);
487 if ((i < 0) || (i > MAX_ADD_HHLEN)) {
488 PRINT_WARN("add_hhlen out of range\n");
489 return -EINVAL;
490 }
491 card->options.add_hhlen = i;
492
493 return count;
494}
495
496static DEVICE_ATTR(add_hhlen, 0644, qeth_dev_add_hhlen_show,
497 qeth_dev_add_hhlen_store);
498
499static ssize_t
10523b3b 500qeth_dev_fake_ll_show(struct device *dev, struct device_attribute *attr, char *buf)
1da177e4
LT		 501{
502 struct qeth_card *card = dev->driver_data;
503
504 if (!card)
505 return -EINVAL;
506
507 return sprintf(buf, "%i\n", card->options.fake_ll? 1:0);
508}
509
510static ssize_t
10523b3b 511qeth_dev_fake_ll_store(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
1da177e4
LT		 512{
513 struct qeth_card *card = dev->driver_data;
514 char *tmp;
515 int i;
516
517 if (!card)
518 return -EINVAL;
519
520 if ((card->state != CARD_STATE_DOWN) &&
521 (card->state != CARD_STATE_RECOVER))
522 return -EPERM;
523
524 i = simple_strtoul(buf, &tmp, 16);
525 if ((i != 0) && (i != 1)) {
526 PRINT_WARN("fake_ll: write 0 or 1 to this file!\n");
527 return -EINVAL;
528 }
529 card->options.fake_ll = i;
530 return count;
531}
532
533static DEVICE_ATTR(fake_ll, 0644, qeth_dev_fake_ll_show,
534 qeth_dev_fake_ll_store);
535
536static ssize_t
10523b3b 537qeth_dev_fake_broadcast_show(struct device *dev, struct device_attribute *attr, char *buf)
1da177e4
LT		 538{
539 struct qeth_card *card = dev->driver_data;
540
541 if (!card)
542 return -EINVAL;
543
544 return sprintf(buf, "%i\n", card->options.fake_broadcast? 1:0);
545}
546
547static ssize_t
10523b3b 548qeth_dev_fake_broadcast_store(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
1da177e4
LT		 549{
550 struct qeth_card *card = dev->driver_data;
551 char *tmp;
552 int i;
553
554 if (!card)
555 return -EINVAL;
556
557 if ((card->state != CARD_STATE_DOWN) &&
558 (card->state != CARD_STATE_RECOVER))
559 return -EPERM;
560
561 i = simple_strtoul(buf, &tmp, 16);
562 if ((i == 0) || (i == 1))
563 card->options.fake_broadcast = i;
564 else {
565 PRINT_WARN("fake_broadcast: write 0 or 1 to this file!\n");
566 return -EINVAL;
567 }
568 return count;
569}
570
571static DEVICE_ATTR(fake_broadcast, 0644, qeth_dev_fake_broadcast_show,
572 qeth_dev_fake_broadcast_store);
573
574static ssize_t
10523b3b 575qeth_dev_recover_store(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
1da177e4
LT		 576{
577 struct qeth_card *card = dev->driver_data;
578 char *tmp;
579 int i;
580
581 if (!card)
582 return -EINVAL;
583
584 if (card->state != CARD_STATE_UP)
585 return -EPERM;
586
587 i = simple_strtoul(buf, &tmp, 16);
588 if (i == 1)
589 qeth_schedule_recovery(card);
590
591 return count;
592}
593
594static DEVICE_ATTR(recover, 0200, NULL, qeth_dev_recover_store);
595
596static ssize_t
10523b3b 597qeth_dev_broadcast_mode_show(struct device *dev, struct device_attribute *attr, char *buf)
1da177e4
LT		 598{
599 struct qeth_card *card = dev->driver_data;
600
601 if (!card)
602 return -EINVAL;
603
604 if (!((card->info.link_type == QETH_LINK_TYPE_HSTR) ||
605 (card->info.link_type == QETH_LINK_TYPE_LANE_TR)))
606 return sprintf(buf, "n/a\n");
607
608 return sprintf(buf, "%s\n", (card->options.broadcast_mode ==
609 QETH_TR_BROADCAST_ALLRINGS)?
610 "all rings":"local");
611}
612
613static ssize_t
10523b3b 614qeth_dev_broadcast_mode_store(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
1da177e4
LT		 615{
616 struct qeth_card *card = dev->driver_data;
617 char *tmp;
618
619 if (!card)
620 return -EINVAL;
621
622 if ((card->state != CARD_STATE_DOWN) &&
623 (card->state != CARD_STATE_RECOVER))
624 return -EPERM;
625
626 if (!((card->info.link_type == QETH_LINK_TYPE_HSTR) ||
627 (card->info.link_type == QETH_LINK_TYPE_LANE_TR))){
628 PRINT_WARN("Device is not a tokenring device!\n");
629 return -EINVAL;
630 }
631
632 tmp = strsep((char **) &buf, "\n");
633
634 if (!strcmp(tmp, "local")){
635 card->options.broadcast_mode = QETH_TR_BROADCAST_LOCAL;
636 return count;
637 } else if (!strcmp(tmp, "all_rings")) {
638 card->options.broadcast_mode = QETH_TR_BROADCAST_ALLRINGS;
639 return count;
640 } else {
641 PRINT_WARN("broadcast_mode: invalid mode %s!\n",
642 tmp);
643 return -EINVAL;
644 }
645 return count;
646}
647
648static DEVICE_ATTR(broadcast_mode, 0644, qeth_dev_broadcast_mode_show,
649 qeth_dev_broadcast_mode_store);
650
651static ssize_t
10523b3b 652qeth_dev_canonical_macaddr_show(struct device *dev, struct device_attribute *attr, char *buf)
1da177e4
LT		 653{
654 struct qeth_card *card = dev->driver_data;
655
656 if (!card)
657 return -EINVAL;
658
659 if (!((card->info.link_type == QETH_LINK_TYPE_HSTR) ||
660 (card->info.link_type == QETH_LINK_TYPE_LANE_TR)))
661 return sprintf(buf, "n/a\n");
662
663 return sprintf(buf, "%i\n", (card->options.macaddr_mode ==
664 QETH_TR_MACADDR_CANONICAL)? 1:0);
665}
666
667static ssize_t
10523b3b 668qeth_dev_canonical_macaddr_store(struct device *dev, struct device_attribute *attr, const char *buf,
1da177e4
LT		 669 size_t count)
670{
671 struct qeth_card *card = dev->driver_data;
672 char *tmp;
673 int i;
674
675 if (!card)
676 return -EINVAL;
677
678 if ((card->state != CARD_STATE_DOWN) &&
679 (card->state != CARD_STATE_RECOVER))
680 return -EPERM;
681
682 if (!((card->info.link_type == QETH_LINK_TYPE_HSTR) ||
683 (card->info.link_type == QETH_LINK_TYPE_LANE_TR))){
684 PRINT_WARN("Device is not a tokenring device!\n");
685 return -EINVAL;
686 }
687
688 i = simple_strtoul(buf, &tmp, 16);
689 if ((i == 0) || (i == 1))
690 card->options.macaddr_mode = i?
691 QETH_TR_MACADDR_CANONICAL :
692 QETH_TR_MACADDR_NONCANONICAL;
693 else {
694 PRINT_WARN("canonical_macaddr: write 0 or 1 to this file!\n");
695 return -EINVAL;
696 }
697 return count;
698}
699
700static DEVICE_ATTR(canonical_macaddr, 0644, qeth_dev_canonical_macaddr_show,
701 qeth_dev_canonical_macaddr_store);
702
703static ssize_t
10523b3b 704qeth_dev_layer2_show(struct device *dev, struct device_attribute *attr, char *buf)
1da177e4
LT		 705{
706 struct qeth_card *card = dev->driver_data;
707
708 if (!card)
709 return -EINVAL;
710
711 return sprintf(buf, "%i\n", card->options.layer2 ? 1:0);
712}
713
714static ssize_t
10523b3b 715qeth_dev_layer2_store(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
1da177e4
LT		 716{
717 struct qeth_card *card = dev->driver_data;
718 char *tmp;
719 int i;
720
721 if (!card)
722 return -EINVAL;
f3d242e8
FP		 723 if (card->info.type == QETH_CARD_TYPE_IQD) {
724 PRINT_WARN("Layer2 on Hipersockets is not supported! \n");
725 return -EPERM;
726 }
1da177e4
LT		 727
728 if (((card->state != CARD_STATE_DOWN) &&
f3d242e8 729 (card->state != CARD_STATE_RECOVER)))
1da177e4
LT		 730 return -EPERM;
731
732 i = simple_strtoul(buf, &tmp, 16);
733 if ((i == 0) || (i == 1))
734 card->options.layer2 = i;
735 else {
736 PRINT_WARN("layer2: write 0 or 1 to this file!\n");
737 return -EINVAL;
738 }
739 return count;
740}
741
742static DEVICE_ATTR(layer2, 0644, qeth_dev_layer2_show,
743 qeth_dev_layer2_store);
744
745static ssize_t
10523b3b 746qeth_dev_large_send_show(struct device *dev, struct device_attribute *attr, char *buf)
1da177e4
LT		 747{
748 struct qeth_card *card = dev->driver_data;
749
750 if (!card)
751 return -EINVAL;
752
753 switch (card->options.large_send) {
754 case QETH_LARGE_SEND_NO:
755 return sprintf(buf, "%s\n", "no");
756 case QETH_LARGE_SEND_EDDP:
757 return sprintf(buf, "%s\n", "EDDP");
758 case QETH_LARGE_SEND_TSO:
759 return sprintf(buf, "%s\n", "TSO");
760 default:
761 return sprintf(buf, "%s\n", "N/A");
762 }
763}
764
765static ssize_t
10523b3b 766qeth_dev_large_send_store(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
1da177e4
LT		 767{
768 struct qeth_card *card = dev->driver_data;
769 enum qeth_large_send_types type;
770 int rc = 0;
771 char *tmp;
772
773 if (!card)
774 return -EINVAL;
1da177e4 775 tmp = strsep((char **) &buf, "\n");
1da177e4
LT		 776 if (!strcmp(tmp, "no")){
777 type = QETH_LARGE_SEND_NO;
778 } else if (!strcmp(tmp, "EDDP")) {
779 type = QETH_LARGE_SEND_EDDP;
780 } else if (!strcmp(tmp, "TSO")) {
781 type = QETH_LARGE_SEND_TSO;
782 } else {
783 PRINT_WARN("large_send: invalid mode %s!\n", tmp);
784 return -EINVAL;
785 }
786 if (card->options.large_send == type)
787 return count;
e82b0f2c 788 if ((rc = qeth_set_large_send(card, type)))
1da177e4 789 return rc;
1da177e4
LT		 790 return count;
791}
792
793static DEVICE_ATTR(large_send, 0644, qeth_dev_large_send_show,
794 qeth_dev_large_send_store);
795
796static ssize_t
797qeth_dev_blkt_show(char *buf, struct qeth_card *card, int value )
798{
799
800 if (!card)
801 return -EINVAL;
802
803 return sprintf(buf, "%i\n", value);
804}
805
806static ssize_t
807qeth_dev_blkt_store(struct qeth_card *card, const char *buf, size_t count,
808 int *value, int max_value)
809{
810 char *tmp;
811 int i;
812
813 if (!card)
814 return -EINVAL;
815
816 if ((card->state != CARD_STATE_DOWN) &&
817 (card->state != CARD_STATE_RECOVER))
818 return -EPERM;
819
820 i = simple_strtoul(buf, &tmp, 10);
821 if (i <= max_value) {
822 *value = i;
823 } else {
824 PRINT_WARN("blkt total time: write values between"
825 " 0 and %d to this file!\n", max_value);
826 return -EINVAL;
827 }
828 return count;
829}
830
831static ssize_t
10523b3b 832qeth_dev_blkt_total_show(struct device *dev, struct device_attribute *attr, char *buf)
1da177e4
LT		 833{
834 struct qeth_card *card = dev->driver_data;
835
836 return qeth_dev_blkt_show(buf, card, card->info.blkt.time_total);
837}
838
839
840static ssize_t
10523b3b 841qeth_dev_blkt_total_store(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
1da177e4
LT		 842{
843 struct qeth_card *card = dev->driver_data;
844
845 return qeth_dev_blkt_store(card, buf, count,
846 &card->info.blkt.time_total,1000);
847}
848
849
850
851static DEVICE_ATTR(total, 0644, qeth_dev_blkt_total_show,
852 qeth_dev_blkt_total_store);
853
854static ssize_t
10523b3b 855qeth_dev_blkt_inter_show(struct device *dev, struct device_attribute *attr, char *buf)
1da177e4
LT		 856{
857 struct qeth_card *card = dev->driver_data;
858
859 return qeth_dev_blkt_show(buf, card, card->info.blkt.inter_packet);
860}
861
862
863static ssize_t
10523b3b 864qeth_dev_blkt_inter_store(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
1da177e4
LT		 865{
866 struct qeth_card *card = dev->driver_data;
867
868 return qeth_dev_blkt_store(card, buf, count,
869 &card->info.blkt.inter_packet,100);
870}
871
872static DEVICE_ATTR(inter, 0644, qeth_dev_blkt_inter_show,
873 qeth_dev_blkt_inter_store);
874
875static ssize_t
10523b3b 876qeth_dev_blkt_inter_jumbo_show(struct device *dev, struct device_attribute *attr, char *buf)
1da177e4
LT		 877{
878 struct qeth_card *card = dev->driver_data;
879
880 return qeth_dev_blkt_show(buf, card,
881 card->info.blkt.inter_packet_jumbo);
882}
883
884
885static ssize_t
10523b3b 886qeth_dev_blkt_inter_jumbo_store(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
1da177e4
LT		 887{
888 struct qeth_card *card = dev->driver_data;
889
890 return qeth_dev_blkt_store(card, buf, count,
891 &card->info.blkt.inter_packet_jumbo,100);
892}
893
894static DEVICE_ATTR(inter_jumbo, 0644, qeth_dev_blkt_inter_jumbo_show,
895 qeth_dev_blkt_inter_jumbo_store);
896
897static struct device_attribute * qeth_blkt_device_attrs[] = {
898 &dev_attr_total,
899 &dev_attr_inter,
900 &dev_attr_inter_jumbo,
901 NULL,
902};
903
904static struct attribute_group qeth_device_blkt_group = {
905 .name = "blkt",
906 .attrs = (struct attribute **)qeth_blkt_device_attrs,
907};
908
909static struct device_attribute * qeth_device_attrs[] = {
910 &dev_attr_state,
911 &dev_attr_chpid,
912 &dev_attr_if_name,
913 &dev_attr_card_type,
914 &dev_attr_portno,
915 &dev_attr_portname,
916 &dev_attr_checksumming,
917 &dev_attr_priority_queueing,
918 &dev_attr_buffer_count,
919 &dev_attr_route4,
920#ifdef CONFIG_QETH_IPV6
921 &dev_attr_route6,
922#endif
923 &dev_attr_add_hhlen,
924 &dev_attr_fake_ll,
925 &dev_attr_fake_broadcast,
926 &dev_attr_recover,
927 &dev_attr_broadcast_mode,
928 &dev_attr_canonical_macaddr,
929 &dev_attr_layer2,
930 &dev_attr_large_send,
931 NULL,
932};
933
934static struct attribute_group qeth_device_attr_group = {
935 .attrs = (struct attribute **)qeth_device_attrs,
936};
937
500f83ab
UB		 938static struct device_attribute * qeth_osn_device_attrs[] = {
939 &dev_attr_state,
940 &dev_attr_chpid,
941 &dev_attr_if_name,
942 &dev_attr_card_type,
943 &dev_attr_buffer_count,
944 &dev_attr_recover,
945 NULL,
946};
947
948static struct attribute_group qeth_osn_device_attr_group = {
949 .attrs = (struct attribute **)qeth_osn_device_attrs,
950};
1da177e4
LT		 951
952#define QETH_DEVICE_ATTR(_id,_name,_mode,_show,_store) \
953struct device_attribute dev_attr_##_id = { \
954 .attr = {.name=__stringify(_name), .mode=_mode, .owner=THIS_MODULE },\
955 .show = _show, \
956 .store = _store, \
957};
958
959int
960qeth_check_layer2(struct qeth_card *card)
961{
962 if (card->options.layer2)
963 return -EPERM;
964 return 0;
965}
966
967
968static ssize_t
10523b3b 969qeth_dev_ipato_enable_show(struct device *dev, struct device_attribute *attr, char *buf)
1da177e4
LT		 970{
971 struct qeth_card *card = dev->driver_data;
972
973 if (!card)
974 return -EINVAL;
975
976 if (qeth_check_layer2(card))
977 return -EPERM;
978 return sprintf(buf, "%i\n", card->ipato.enabled? 1:0);
979}
980
981static ssize_t
10523b3b 982qeth_dev_ipato_enable_store(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
1da177e4
LT		 983{
984 struct qeth_card *card = dev->driver_data;
985 char *tmp;
986
987 if (!card)
988 return -EINVAL;
989
990 if ((card->state != CARD_STATE_DOWN) &&
991 (card->state != CARD_STATE_RECOVER))
992 return -EPERM;
993
994 if (qeth_check_layer2(card))
995 return -EPERM;
996
997 tmp = strsep((char **) &buf, "\n");
998 if (!strcmp(tmp, "toggle")){
999 card->ipato.enabled = (card->ipato.enabled)? 0 : 1;
1000 } else if (!strcmp(tmp, "1")){
1001 card->ipato.enabled = 1;
1002 } else if (!strcmp(tmp, "0")){
1003 card->ipato.enabled = 0;
1004 } else {
1005 PRINT_WARN("ipato_enable: write 0, 1 or 'toggle' to "
1006 "this file\n");
1007 return -EINVAL;
1008 }
1009 return count;
1010}
1011
1012static QETH_DEVICE_ATTR(ipato_enable, enable, 0644,
1013 qeth_dev_ipato_enable_show,
1014 qeth_dev_ipato_enable_store);
1015
1016static ssize_t
10523b3b 1017qeth_dev_ipato_invert4_show(struct device *dev, struct device_attribute *attr, char *buf)
1da177e4
LT		 1018{
1019 struct qeth_card *card = dev->driver_data;
1020
1021 if (!card)
1022 return -EINVAL;
1023
1024 if (qeth_check_layer2(card))
1025 return -EPERM;
1026
1027 return sprintf(buf, "%i\n", card->ipato.invert4? 1:0);
1028}
1029
1030static ssize_t
10523b3b 1031qeth_dev_ipato_invert4_store(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
1da177e4
LT		 1032{
1033 struct qeth_card *card = dev->driver_data;
1034 char *tmp;
1035
1036 if (!card)
1037 return -EINVAL;
1038
1039 if (qeth_check_layer2(card))
1040 return -EPERM;
1041
1042 tmp = strsep((char **) &buf, "\n");
1043 if (!strcmp(tmp, "toggle")){
1044 card->ipato.invert4 = (card->ipato.invert4)? 0 : 1;
1045 } else if (!strcmp(tmp, "1")){
1046 card->ipato.invert4 = 1;
1047 } else if (!strcmp(tmp, "0")){
1048 card->ipato.invert4 = 0;
1049 } else {
1050 PRINT_WARN("ipato_invert4: write 0, 1 or 'toggle' to "
1051 "this file\n");
1052 return -EINVAL;
1053 }
1054 return count;
1055}
1056
1057static QETH_DEVICE_ATTR(ipato_invert4, invert4, 0644,
1058 qeth_dev_ipato_invert4_show,
1059 qeth_dev_ipato_invert4_store);
1060
1061static inline ssize_t
1062qeth_dev_ipato_add_show(char *buf, struct qeth_card *card,
1063 enum qeth_prot_versions proto)
1064{
1065 struct qeth_ipato_entry *ipatoe;
1066 unsigned long flags;
1067 char addr_str[40];
1068 int entry_len; /* length of 1 entry string, differs between v4 and v6 */
1069 int i = 0;
1070
1071 if (qeth_check_layer2(card))
1072 return -EPERM;
1073
1074 entry_len = (proto == QETH_PROT_IPV4)? 12 : 40;
1075 /* add strlen for "/<mask>\n" */
1076 entry_len += (proto == QETH_PROT_IPV4)? 5 : 6;
1077 spin_lock_irqsave(&card->ip_lock, flags);
1078 list_for_each_entry(ipatoe, &card->ipato.entries, entry){
1079 if (ipatoe->proto != proto)
1080 continue;
1081 /* String must not be longer than PAGE_SIZE. So we check if
1082 * string length gets near PAGE_SIZE. Then we can savely display
1083 * the next IPv6 address (worst case, compared to IPv4) */
1084 if ((PAGE_SIZE - i) <= entry_len)
1085 break;
1086 qeth_ipaddr_to_string(proto, ipatoe->addr, addr_str);
1087 i += snprintf(buf + i, PAGE_SIZE - i,
1088 "%s/%i\n", addr_str, ipatoe->mask_bits);
1089 }
1090 spin_unlock_irqrestore(&card->ip_lock, flags);
1091 i += snprintf(buf + i, PAGE_SIZE - i, "\n");
1092
1093 return i;
1094}
1095
1096static ssize_t
10523b3b 1097qeth_dev_ipato_add4_show(struct device *dev, struct device_attribute *attr, char *buf)
1da177e4
LT		 1098{
1099 struct qeth_card *card = dev->driver_data;
1100
1101 if (!card)
1102 return -EINVAL;
1103
1104 return qeth_dev_ipato_add_show(buf, card, QETH_PROT_IPV4);
1105}
1106
1107static inline int
1108qeth_parse_ipatoe(const char* buf, enum qeth_prot_versions proto,
1109 u8 *addr, int *mask_bits)
1110{
1111 const char *start, *end;
1112 char *tmp;
1113 char buffer[49] = {0, };
1114
1115 start = buf;
1116 /* get address string */
1117 end = strchr(start, '/');
bd389b90 1118 if (!end || (end-start >= 49)){
1da177e4
LT		 1119 PRINT_WARN("Invalid format for ipato_addx/delx. "
1120 "Use <ip addr>/<mask bits>\n");
1121 return -EINVAL;
1122 }
1123 strncpy(buffer, start, end - start);
1124 if (qeth_string_to_ipaddr(buffer, proto, addr)){
1125 PRINT_WARN("Invalid IP address format!\n");
1126 return -EINVAL;
1127 }
1128 start = end + 1;
1129 *mask_bits = simple_strtoul(start, &tmp, 10);
1130
1131 return 0;
1132}
1133
1134static inline ssize_t
1135qeth_dev_ipato_add_store(const char *buf, size_t count,
1136 struct qeth_card *card, enum qeth_prot_versions proto)
1137{
1138 struct qeth_ipato_entry *ipatoe;
1139 u8 addr[16];
1140 int mask_bits;
1141 int rc;
1142
1143 if (qeth_check_layer2(card))
1144 return -EPERM;
1145 if ((rc = qeth_parse_ipatoe(buf, proto, addr, &mask_bits)))
1146 return rc;
1147
88abaab4 1148 if (!(ipatoe = kzalloc(sizeof(struct qeth_ipato_entry), GFP_KERNEL))){
1da177e4
LT		 1149 PRINT_WARN("No memory to allocate ipato entry\n");
1150 return -ENOMEM;
1151 }
1da177e4
LT		 1152 ipatoe->proto = proto;
1153 memcpy(ipatoe->addr, addr, (proto == QETH_PROT_IPV4)? 4:16);
1154 ipatoe->mask_bits = mask_bits;
1155
1156 if ((rc = qeth_add_ipato_entry(card, ipatoe))){
1157 kfree(ipatoe);
1158 return rc;
1159 }
1160
1161 return count;
1162}
1163
1164static ssize_t
10523b3b 1165qeth_dev_ipato_add4_store(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
1da177e4
LT		 1166{
1167 struct qeth_card *card = dev->driver_data;
1168
1169 if (!card)
1170 return -EINVAL;
1171
1172 return qeth_dev_ipato_add_store(buf, count, card, QETH_PROT_IPV4);
1173}
1174
1175static QETH_DEVICE_ATTR(ipato_add4, add4, 0644,
1176 qeth_dev_ipato_add4_show,
1177 qeth_dev_ipato_add4_store);
1178
1179static inline ssize_t
1180qeth_dev_ipato_del_store(const char *buf, size_t count,
1181 struct qeth_card *card, enum qeth_prot_versions proto)
1182{
1183 u8 addr[16];
1184 int mask_bits;
1185 int rc;
1186
1187 if (qeth_check_layer2(card))
1188 return -EPERM;
1189 if ((rc = qeth_parse_ipatoe(buf, proto, addr, &mask_bits)))
1190 return rc;
1191
1192 qeth_del_ipato_entry(card, proto, addr, mask_bits);
1193
1194 return count;
1195}
1196
1197static ssize_t
10523b3b 1198qeth_dev_ipato_del4_store(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
1da177e4
LT		 1199{
1200 struct qeth_card *card = dev->driver_data;
1201
1202 if (!card)
1203 return -EINVAL;
1204
1205 return qeth_dev_ipato_del_store(buf, count, card, QETH_PROT_IPV4);
1206}
1207
1208static QETH_DEVICE_ATTR(ipato_del4, del4, 0200, NULL,
1209 qeth_dev_ipato_del4_store);
1210
1211#ifdef CONFIG_QETH_IPV6
1212static ssize_t
10523b3b 1213qeth_dev_ipato_invert6_show(struct device *dev, struct device_attribute *attr, char *buf)
1da177e4
LT		 1214{
1215 struct qeth_card *card = dev->driver_data;
1216
1217 if (!card)
1218 return -EINVAL;
1219
1220 if (qeth_check_layer2(card))
1221 return -EPERM;
1222
1223 return sprintf(buf, "%i\n", card->ipato.invert6? 1:0);
1224}
1225
1226static ssize_t
10523b3b 1227qeth_dev_ipato_invert6_store(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
1da177e4
LT		 1228{
1229 struct qeth_card *card = dev->driver_data;
1230 char *tmp;
1231
1232 if (!card)
1233 return -EINVAL;
1234
1235 if (qeth_check_layer2(card))
1236 return -EPERM;
1237
1238 tmp = strsep((char **) &buf, "\n");
1239 if (!strcmp(tmp, "toggle")){
1240 card->ipato.invert6 = (card->ipato.invert6)? 0 : 1;
1241 } else if (!strcmp(tmp, "1")){
1242 card->ipato.invert6 = 1;
1243 } else if (!strcmp(tmp, "0")){
1244 card->ipato.invert6 = 0;
1245 } else {
1246 PRINT_WARN("ipato_invert6: write 0, 1 or 'toggle' to "
1247 "this file\n");
1248 return -EINVAL;
1249 }
1250 return count;
1251}
1252
1253static QETH_DEVICE_ATTR(ipato_invert6, invert6, 0644,
1254 qeth_dev_ipato_invert6_show,
1255 qeth_dev_ipato_invert6_store);
1256
1257
1258static ssize_t
10523b3b 1259qeth_dev_ipato_add6_show(struct device *dev, struct device_attribute *attr, char *buf)
1da177e4
LT		 1260{
1261 struct qeth_card *card = dev->driver_data;
1262
1263 if (!card)
1264 return -EINVAL;
1265
1266 return qeth_dev_ipato_add_show(buf, card, QETH_PROT_IPV6);
1267}
1268
1269static ssize_t
10523b3b 1270qeth_dev_ipato_add6_store(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
1da177e4
LT		 1271{
1272 struct qeth_card *card = dev->driver_data;
1273
1274 if (!card)
1275 return -EINVAL;
1276
1277 return qeth_dev_ipato_add_store(buf, count, card, QETH_PROT_IPV6);
1278}
1279
1280static QETH_DEVICE_ATTR(ipato_add6, add6, 0644,
1281 qeth_dev_ipato_add6_show,
1282 qeth_dev_ipato_add6_store);
1283
1284static ssize_t
10523b3b 1285qeth_dev_ipato_del6_store(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
1da177e4
LT		 1286{
1287 struct qeth_card *card = dev->driver_data;
1288
1289 if (!card)
1290 return -EINVAL;
1291
1292 return qeth_dev_ipato_del_store(buf, count, card, QETH_PROT_IPV6);
1293}
1294
1295static QETH_DEVICE_ATTR(ipato_del6, del6, 0200, NULL,
1296 qeth_dev_ipato_del6_store);
1297#endif /* CONFIG_QETH_IPV6 */
1298
1299static struct device_attribute * qeth_ipato_device_attrs[] = {
1300 &dev_attr_ipato_enable,
1301 &dev_attr_ipato_invert4,
1302 &dev_attr_ipato_add4,
1303 &dev_attr_ipato_del4,
1304#ifdef CONFIG_QETH_IPV6
1305 &dev_attr_ipato_invert6,
1306 &dev_attr_ipato_add6,
1307 &dev_attr_ipato_del6,
1308#endif
1309 NULL,
1310};
1311
1312static struct attribute_group qeth_device_ipato_group = {
1313 .name = "ipa_takeover",
1314 .attrs = (struct attribute **)qeth_ipato_device_attrs,
1315};
1316
1317static inline ssize_t
1318qeth_dev_vipa_add_show(char *buf, struct qeth_card *card,
1319 enum qeth_prot_versions proto)
1320{
1321 struct qeth_ipaddr *ipaddr;
1322 char addr_str[40];
1323 int entry_len; /* length of 1 entry string, differs between v4 and v6 */
1324 unsigned long flags;
1325 int i = 0;
1326
1327 if (qeth_check_layer2(card))
1328 return -EPERM;
1329
1330 entry_len = (proto == QETH_PROT_IPV4)? 12 : 40;
1331 entry_len += 2; /* \n + terminator */
1332 spin_lock_irqsave(&card->ip_lock, flags);
1333 list_for_each_entry(ipaddr, &card->ip_list, entry){
1334 if (ipaddr->proto != proto)
1335 continue;
1336 if (ipaddr->type != QETH_IP_TYPE_VIPA)
1337 continue;
1338 /* String must not be longer than PAGE_SIZE. So we check if
1339 * string length gets near PAGE_SIZE. Then we can savely display
1340 * the next IPv6 address (worst case, compared to IPv4) */
1341 if ((PAGE_SIZE - i) <= entry_len)
1342 break;
1343 qeth_ipaddr_to_string(proto, (const u8 *)&ipaddr->u, addr_str);
1344 i += snprintf(buf + i, PAGE_SIZE - i, "%s\n", addr_str);
1345 }
1346 spin_unlock_irqrestore(&card->ip_lock, flags);
1347 i += snprintf(buf + i, PAGE_SIZE - i, "\n");
1348
1349 return i;
1350}
1351
1352static ssize_t
10523b3b 1353qeth_dev_vipa_add4_show(struct device *dev, struct device_attribute *attr, char *buf)
1da177e4
LT		 1354{
1355 struct qeth_card *card = dev->driver_data;
1356
1357 if (!card)
1358 return -EINVAL;
1359
1360 return qeth_dev_vipa_add_show(buf, card, QETH_PROT_IPV4);
1361}
1362
1363static inline int
1364qeth_parse_vipae(const char* buf, enum qeth_prot_versions proto,
1365 u8 *addr)
1366{
1367 if (qeth_string_to_ipaddr(buf, proto, addr)){
1368 PRINT_WARN("Invalid IP address format!\n");
1369 return -EINVAL;
1370 }
1371 return 0;
1372}
1373
1374static inline ssize_t
1375qeth_dev_vipa_add_store(const char *buf, size_t count,
1376 struct qeth_card *card, enum qeth_prot_versions proto)
1377{
1378 u8 addr[16] = {0, };
1379 int rc;
1380
1381 if (qeth_check_layer2(card))
1382 return -EPERM;
1383 if ((rc = qeth_parse_vipae(buf, proto, addr)))
1384 return rc;
1385
1386 if ((rc = qeth_add_vipa(card, proto, addr)))
1387 return rc;
1388
1389 return count;
1390}
1391
1392static ssize_t
10523b3b 1393qeth_dev_vipa_add4_store(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
1da177e4
LT		 1394{
1395 struct qeth_card *card = dev->driver_data;
1396
1397 if (!card)
1398 return -EINVAL;
1399
1400 return qeth_dev_vipa_add_store(buf, count, card, QETH_PROT_IPV4);
1401}
1402
1403static QETH_DEVICE_ATTR(vipa_add4, add4, 0644,
1404 qeth_dev_vipa_add4_show,
1405 qeth_dev_vipa_add4_store);
1406
1407static inline ssize_t
1408qeth_dev_vipa_del_store(const char *buf, size_t count,
1409 struct qeth_card *card, enum qeth_prot_versions proto)
1410{
1411 u8 addr[16];
1412 int rc;
1413
1414 if (qeth_check_layer2(card))
1415 return -EPERM;
1416 if ((rc = qeth_parse_vipae(buf, proto, addr)))
1417 return rc;
1418
1419 qeth_del_vipa(card, proto, addr);
1420
1421 return count;
1422}
1423
1424static ssize_t
10523b3b 1425qeth_dev_vipa_del4_store(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
1da177e4
LT		 1426{
1427 struct qeth_card *card = dev->driver_data;
1428
1429 if (!card)
1430 return -EINVAL;
1431
1432 return qeth_dev_vipa_del_store(buf, count, card, QETH_PROT_IPV4);
1433}
1434
1435static QETH_DEVICE_ATTR(vipa_del4, del4, 0200, NULL,
1436 qeth_dev_vipa_del4_store);
1437
1438#ifdef CONFIG_QETH_IPV6
1439static ssize_t
10523b3b 1440qeth_dev_vipa_add6_show(struct device *dev, struct device_attribute *attr, char *buf)
1da177e4
LT		 1441{
1442 struct qeth_card *card = dev->driver_data;
1443
1444 if (!card)
1445 return -EINVAL;
1446
1447 return qeth_dev_vipa_add_show(buf, card, QETH_PROT_IPV6);
1448}
1449
1450static ssize_t
10523b3b 1451qeth_dev_vipa_add6_store(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
1da177e4
LT		 1452{
1453 struct qeth_card *card = dev->driver_data;
1454
1455 if (!card)
1456 return -EINVAL;
1457
1458 return qeth_dev_vipa_add_store(buf, count, card, QETH_PROT_IPV6);
1459}
1460
1461static QETH_DEVICE_ATTR(vipa_add6, add6, 0644,
1462 qeth_dev_vipa_add6_show,
1463 qeth_dev_vipa_add6_store);
1464
1465static ssize_t
10523b3b 1466qeth_dev_vipa_del6_store(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
1da177e4
LT		 1467{
1468 struct qeth_card *card = dev->driver_data;
1469
1470 if (!card)
1471 return -EINVAL;
1472
1473 if (qeth_check_layer2(card))
1474 return -EPERM;
1475
1476 return qeth_dev_vipa_del_store(buf, count, card, QETH_PROT_IPV6);
1477}
1478
1479static QETH_DEVICE_ATTR(vipa_del6, del6, 0200, NULL,
1480 qeth_dev_vipa_del6_store);
1481#endif /* CONFIG_QETH_IPV6 */
1482
1483static struct device_attribute * qeth_vipa_device_attrs[] = {
1484 &dev_attr_vipa_add4,
1485 &dev_attr_vipa_del4,
1486#ifdef CONFIG_QETH_IPV6
1487 &dev_attr_vipa_add6,
1488 &dev_attr_vipa_del6,
1489#endif
1490 NULL,
1491};
1492
1493static struct attribute_group qeth_device_vipa_group = {
1494 .name = "vipa",
1495 .attrs = (struct attribute **)qeth_vipa_device_attrs,
1496};
1497
1498static inline ssize_t
1499qeth_dev_rxip_add_show(char *buf, struct qeth_card *card,
1500 enum qeth_prot_versions proto)
1501{
1502 struct qeth_ipaddr *ipaddr;
1503 char addr_str[40];
1504 int entry_len; /* length of 1 entry string, differs between v4 and v6 */
1505 unsigned long flags;
1506 int i = 0;
1507
1508 if (qeth_check_layer2(card))
1509 return -EPERM;
1510
1511 entry_len = (proto == QETH_PROT_IPV4)? 12 : 40;
1512 entry_len += 2; /* \n + terminator */
1513 spin_lock_irqsave(&card->ip_lock, flags);
1514 list_for_each_entry(ipaddr, &card->ip_list, entry){
1515 if (ipaddr->proto != proto)
1516 continue;
1517 if (ipaddr->type != QETH_IP_TYPE_RXIP)
1518 continue;
1519 /* String must not be longer than PAGE_SIZE. So we check if
1520 * string length gets near PAGE_SIZE. Then we can savely display
1521 * the next IPv6 address (worst case, compared to IPv4) */
1522 if ((PAGE_SIZE - i) <= entry_len)
1523 break;
1524 qeth_ipaddr_to_string(proto, (const u8 *)&ipaddr->u, addr_str);
1525 i += snprintf(buf + i, PAGE_SIZE - i, "%s\n", addr_str);
1526 }
1527 spin_unlock_irqrestore(&card->ip_lock, flags);
1528 i += snprintf(buf + i, PAGE_SIZE - i, "\n");
1529
1530 return i;
1531}
1532
1533static ssize_t
10523b3b 1534qeth_dev_rxip_add4_show(struct device *dev, struct device_attribute *attr, char *buf)
1da177e4
LT		 1535{
1536 struct qeth_card *card = dev->driver_data;
1537
1538 if (!card)
1539 return -EINVAL;
1540
1541 return qeth_dev_rxip_add_show(buf, card, QETH_PROT_IPV4);
1542}
1543
1544static inline int
1545qeth_parse_rxipe(const char* buf, enum qeth_prot_versions proto,
1546 u8 *addr)
1547{
1548 if (qeth_string_to_ipaddr(buf, proto, addr)){
1549 PRINT_WARN("Invalid IP address format!\n");
1550 return -EINVAL;
1551 }
1552 return 0;
1553}
1554
1555static inline ssize_t
1556qeth_dev_rxip_add_store(const char *buf, size_t count,
1557 struct qeth_card *card, enum qeth_prot_versions proto)
1558{
1559 u8 addr[16] = {0, };
1560 int rc;
1561
1562 if (qeth_check_layer2(card))
1563 return -EPERM;
1564 if ((rc = qeth_parse_rxipe(buf, proto, addr)))
1565 return rc;
1566
1567 if ((rc = qeth_add_rxip(card, proto, addr)))
1568 return rc;
1569
1570 return count;
1571}
1572
1573static ssize_t
10523b3b 1574qeth_dev_rxip_add4_store(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
1da177e4
LT		 1575{
1576 struct qeth_card *card = dev->driver_data;
1577
1578 if (!card)
1579 return -EINVAL;
1580
1581 return qeth_dev_rxip_add_store(buf, count, card, QETH_PROT_IPV4);
1582}
1583
1584static QETH_DEVICE_ATTR(rxip_add4, add4, 0644,
1585 qeth_dev_rxip_add4_show,
1586 qeth_dev_rxip_add4_store);
1587
1588static inline ssize_t
1589qeth_dev_rxip_del_store(const char *buf, size_t count,
1590 struct qeth_card *card, enum qeth_prot_versions proto)
1591{
1592 u8 addr[16];
1593 int rc;
1594
1595 if (qeth_check_layer2(card))
1596 return -EPERM;
1597 if ((rc = qeth_parse_rxipe(buf, proto, addr)))
1598 return rc;
1599
1600 qeth_del_rxip(card, proto, addr);
1601
1602 return count;
1603}
1604
1605static ssize_t
10523b3b 1606qeth_dev_rxip_del4_store(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
1da177e4
LT		 1607{
1608 struct qeth_card *card = dev->driver_data;
1609
1610 if (!card)
1611 return -EINVAL;
1612
1613 return qeth_dev_rxip_del_store(buf, count, card, QETH_PROT_IPV4);
1614}
1615
1616static QETH_DEVICE_ATTR(rxip_del4, del4, 0200, NULL,
1617 qeth_dev_rxip_del4_store);
1618
1619#ifdef CONFIG_QETH_IPV6
1620static ssize_t
10523b3b 1621qeth_dev_rxip_add6_show(struct device *dev, struct device_attribute *attr, char *buf)
1da177e4
LT		 1622{
1623 struct qeth_card *card = dev->driver_data;
1624
1625 if (!card)
1626 return -EINVAL;
1627
1628 return qeth_dev_rxip_add_show(buf, card, QETH_PROT_IPV6);
1629}
1630
1631static ssize_t
10523b3b 1632qeth_dev_rxip_add6_store(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
1da177e4
LT		 1633{
1634 struct qeth_card *card = dev->driver_data;
1635
1636 if (!card)
1637 return -EINVAL;
1638
1639 return qeth_dev_rxip_add_store(buf, count, card, QETH_PROT_IPV6);
1640}
1641
1642static QETH_DEVICE_ATTR(rxip_add6, add6, 0644,
1643 qeth_dev_rxip_add6_show,
1644 qeth_dev_rxip_add6_store);
1645
1646static ssize_t
10523b3b 1647qeth_dev_rxip_del6_store(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
1da177e4
LT		 1648{
1649 struct qeth_card *card = dev->driver_data;
1650
1651 if (!card)
1652 return -EINVAL;
1653
1654 return qeth_dev_rxip_del_store(buf, count, card, QETH_PROT_IPV6);
1655}
1656
1657static QETH_DEVICE_ATTR(rxip_del6, del6, 0200, NULL,
1658 qeth_dev_rxip_del6_store);
1659#endif /* CONFIG_QETH_IPV6 */
1660
1661static struct device_attribute * qeth_rxip_device_attrs[] = {
1662 &dev_attr_rxip_add4,
1663 &dev_attr_rxip_del4,
1664#ifdef CONFIG_QETH_IPV6
1665 &dev_attr_rxip_add6,
1666 &dev_attr_rxip_del6,
1667#endif
1668 NULL,
1669};
1670
1671static struct attribute_group qeth_device_rxip_group = {
1672 .name = "rxip",
1673 .attrs = (struct attribute **)qeth_rxip_device_attrs,
1674};
1675
1676int
1677qeth_create_device_attributes(struct device *dev)
1678{
1679 int ret;
500f83ab 1680 struct qeth_card *card = dev->driver_data;
1da177e4 1681
500f83ab
UB		 1682 if (card->info.type == QETH_CARD_TYPE_OSN)
1683 return sysfs_create_group(&dev->kobj,
1684 &qeth_osn_device_attr_group);
e82b0f2c 1685
1da177e4
LT		 1686 if ((ret = sysfs_create_group(&dev->kobj, &qeth_device_attr_group)))
1687 return ret;
1688 if ((ret = sysfs_create_group(&dev->kobj, &qeth_device_ipato_group))){
1689 sysfs_remove_group(&dev->kobj, &qeth_device_attr_group);
1690 return ret;
1691 }
1692 if ((ret = sysfs_create_group(&dev->kobj, &qeth_device_vipa_group))){
1693 sysfs_remove_group(&dev->kobj, &qeth_device_attr_group);
1694 sysfs_remove_group(&dev->kobj, &qeth_device_ipato_group);
1695 return ret;
1696 }
1697 if ((ret = sysfs_create_group(&dev->kobj, &qeth_device_rxip_group))){
1698 sysfs_remove_group(&dev->kobj, &qeth_device_attr_group);
1699 sysfs_remove_group(&dev->kobj, &qeth_device_ipato_group);
1700 sysfs_remove_group(&dev->kobj, &qeth_device_vipa_group);
1701 }
1702 if ((ret = sysfs_create_group(&dev->kobj, &qeth_device_blkt_group)))
1703 return ret;
1704
1705 return ret;
1706}
1707
1708void
1709qeth_remove_device_attributes(struct device *dev)
1710{
500f83ab
UB		 1711 struct qeth_card *card = dev->driver_data;
1712
1713 if (card->info.type == QETH_CARD_TYPE_OSN)
1714 return sysfs_remove_group(&dev->kobj,
1715 &qeth_osn_device_attr_group);
e82b0f2c 1716
1da177e4
LT		 1717 sysfs_remove_group(&dev->kobj, &qeth_device_attr_group);
1718 sysfs_remove_group(&dev->kobj, &qeth_device_ipato_group);
1719 sysfs_remove_group(&dev->kobj, &qeth_device_vipa_group);
1720 sysfs_remove_group(&dev->kobj, &qeth_device_rxip_group);
1721 sysfs_remove_group(&dev->kobj, &qeth_device_blkt_group);
1722}
1723
1724/**********************/
1725/* DRIVER ATTRIBUTES */
1726/**********************/
1727static ssize_t
1728qeth_driver_group_store(struct device_driver *ddrv, const char *buf,
1729 size_t count)
1730{
1731 const char *start, *end;
1732 char bus_ids[3][BUS_ID_SIZE], *argv[3];
1733 int i;
1734 int err;
1735
1736 start = buf;
1737 for (i = 0; i < 3; i++) {
1738 static const char delim[] = { ',', ',', '\n' };
1739 int len;
1740
1741 if (!(end = strchr(start, delim[i])))
1742 return -EINVAL;
1743 len = min_t(ptrdiff_t, BUS_ID_SIZE, end - start);
1744 strncpy(bus_ids[i], start, len);
1745 bus_ids[i][len] = '\0';
1746 start = end + 1;
1747 argv[i] = bus_ids[i];
1748 }
1749 err = ccwgroup_create(qeth_root_dev, qeth_ccwgroup_driver.driver_id,
1750 &qeth_ccw_driver, 3, argv);
1751 if (err)
1752 return err;
1753 else
1754 return count;
1755}
1756
1757
d2c993d8 1758static DRIVER_ATTR(group, 0200, NULL, qeth_driver_group_store);
1da177e4
LT		 1759
1760static ssize_t
1761qeth_driver_notifier_register_store(struct device_driver *ddrv, const char *buf,
1762 size_t count)
1763{
1764 int rc;
1765 int signum;
1766 char *tmp, *tmp2;
1767
1768 tmp = strsep((char **) &buf, "\n");
1769 if (!strncmp(tmp, "unregister", 10)){
1770 if ((rc = qeth_notifier_unregister(current)))
1771 return rc;
1772 return count;
1773 }
1774
1775 signum = simple_strtoul(tmp, &tmp2, 10);
1776 if ((signum < 0) || (signum > 32)){
1777 PRINT_WARN("Signal number %d is out of range\n", signum);
1778 return -EINVAL;
1779 }
1780 if ((rc = qeth_notifier_register(current, signum)))
1781 return rc;
1782
1783 return count;
1784}
1785
d2c993d8 1786static DRIVER_ATTR(notifier_register, 0200, NULL,
1da177e4
LT		 1787 qeth_driver_notifier_register_store);
1788
1789int
1790qeth_create_driver_attributes(void)
1791{
1792 int rc;
1793
1794 if ((rc = driver_create_file(&qeth_ccwgroup_driver.driver,
1795 &driver_attr_group)))
1796 return rc;
1797 return driver_create_file(&qeth_ccwgroup_driver.driver,
1798 &driver_attr_notifier_register);
1799}
1800
1801void
1802qeth_remove_driver_attributes(void)
1803{
1804 driver_remove_file(&qeth_ccwgroup_driver.driver,
1805 &driver_attr_group);
1806 driver_remove_file(&qeth_ccwgroup_driver.driver,
1807 &driver_attr_notifier_register);
1808}
Linux kernel - Deliverables
This page took 0.250262 seconds and 5 git commands to generate.