3 * linux/drivers/s390/net/qeth_sys.c ($Revision: 1.54 $)
5 * Linux on zSeries OSA Express and HiperSockets support
6 * This file contains code related to sysfs.
8 * Copyright 2000,2003 IBM Corporation
10 * Author(s): Thomas Spatzier <tspat@de.ibm.com>
11 * Frank Pavlic <pavlic@de.ibm.com>
14 #include <linux/list.h>
15 #include <linux/rwsem.h>
17 #include <asm/ebcdic.h>
23 const char *VERSION_QETH_SYS_C
= "$Revision: 1.54 $";
25 /*****************************************************************************/
27 /* /sys-fs stuff UNDER DEVELOPMENT !!! */
29 /*****************************************************************************/
33 qeth_dev_state_show(struct device
*dev
, struct device_attribute
*attr
, char *buf
)
35 struct qeth_card
*card
= dev
->driver_data
;
39 switch (card
->state
) {
41 return sprintf(buf
, "DOWN\n");
42 case CARD_STATE_HARDSETUP
:
43 return sprintf(buf
, "HARDSETUP\n");
44 case CARD_STATE_SOFTSETUP
:
45 return sprintf(buf
, "SOFTSETUP\n");
48 return sprintf(buf
, "UP (LAN ONLINE)\n");
50 return sprintf(buf
, "UP (LAN OFFLINE)\n");
51 case CARD_STATE_RECOVER
:
52 return sprintf(buf
, "RECOVER\n");
54 return sprintf(buf
, "UNKNOWN\n");
58 static DEVICE_ATTR(state
, 0444, qeth_dev_state_show
, NULL
);
61 qeth_dev_chpid_show(struct device
*dev
, struct device_attribute
*attr
, char *buf
)
63 struct qeth_card
*card
= dev
->driver_data
;
67 return sprintf(buf
, "%02X\n", card
->info
.chpid
);
70 static DEVICE_ATTR(chpid
, 0444, qeth_dev_chpid_show
, NULL
);
73 qeth_dev_if_name_show(struct device
*dev
, struct device_attribute
*attr
, char *buf
)
75 struct qeth_card
*card
= dev
->driver_data
;
78 return sprintf(buf
, "%s\n", QETH_CARD_IFNAME(card
));
81 static DEVICE_ATTR(if_name
, 0444, qeth_dev_if_name_show
, NULL
);
84 qeth_dev_card_type_show(struct device
*dev
, struct device_attribute
*attr
, char *buf
)
86 struct qeth_card
*card
= dev
->driver_data
;
90 return sprintf(buf
, "%s\n", qeth_get_cardname_short(card
));
93 static DEVICE_ATTR(card_type
, 0444, qeth_dev_card_type_show
, NULL
);
96 qeth_dev_portno_show(struct device
*dev
, struct device_attribute
*attr
, char *buf
)
98 struct qeth_card
*card
= dev
->driver_data
;
102 return sprintf(buf
, "%i\n", card
->info
.portno
);
106 qeth_dev_portno_store(struct device
*dev
, struct device_attribute
*attr
, const char *buf
, size_t count
)
108 struct qeth_card
*card
= dev
->driver_data
;
115 if ((card
->state
!= CARD_STATE_DOWN
) &&
116 (card
->state
!= CARD_STATE_RECOVER
))
119 portno
= simple_strtoul(buf
, &tmp
, 16);
120 if ((portno
< 0) || (portno
> MAX_PORTNO
)){
121 PRINT_WARN("portno 0x%X is out of range\n", portno
);
125 card
->info
.portno
= portno
;
129 static DEVICE_ATTR(portno
, 0644, qeth_dev_portno_show
, qeth_dev_portno_store
);
132 qeth_dev_portname_show(struct device
*dev
, struct device_attribute
*attr
, char *buf
)
134 struct qeth_card
*card
= dev
->driver_data
;
135 char portname
[9] = {0, };
140 if (card
->info
.portname_required
) {
141 memcpy(portname
, card
->info
.portname
+ 1, 8);
143 return sprintf(buf
, "%s\n", portname
);
145 return sprintf(buf
, "no portname required\n");
149 qeth_dev_portname_store(struct device
*dev
, struct device_attribute
*attr
, const char *buf
, size_t count
)
151 struct qeth_card
*card
= dev
->driver_data
;
158 if ((card
->state
!= CARD_STATE_DOWN
) &&
159 (card
->state
!= CARD_STATE_RECOVER
))
162 tmp
= strsep((char **) &buf
, "\n");
163 if ((strlen(tmp
) > 8) || (strlen(tmp
) < 2))
166 card
->info
.portname
[0] = strlen(tmp
);
167 /* for beauty reasons */
168 for (i
= 1; i
< 9; i
++)
169 card
->info
.portname
[i
] = ' ';
170 strcpy(card
->info
.portname
+ 1, tmp
);
171 ASCEBC(card
->info
.portname
+ 1, 8);
176 static DEVICE_ATTR(portname
, 0644, qeth_dev_portname_show
,
177 qeth_dev_portname_store
);
180 qeth_dev_checksum_show(struct device
*dev
, struct device_attribute
*attr
, char *buf
)
182 struct qeth_card
*card
= dev
->driver_data
;
187 return sprintf(buf
, "%s checksumming\n", qeth_get_checksum_str(card
));
191 qeth_dev_checksum_store(struct device
*dev
, struct device_attribute
*attr
, const char *buf
, size_t count
)
193 struct qeth_card
*card
= dev
->driver_data
;
199 if ((card
->state
!= CARD_STATE_DOWN
) &&
200 (card
->state
!= CARD_STATE_RECOVER
))
203 tmp
= strsep((char **) &buf
, "\n");
204 if (!strcmp(tmp
, "sw_checksumming"))
205 card
->options
.checksum_type
= SW_CHECKSUMMING
;
206 else if (!strcmp(tmp
, "hw_checksumming"))
207 card
->options
.checksum_type
= HW_CHECKSUMMING
;
208 else if (!strcmp(tmp
, "no_checksumming"))
209 card
->options
.checksum_type
= NO_CHECKSUMMING
;
211 PRINT_WARN("Unknown checksumming type '%s'\n", tmp
);
217 static DEVICE_ATTR(checksumming
, 0644, qeth_dev_checksum_show
,
218 qeth_dev_checksum_store
);
221 qeth_dev_prioqing_show(struct device
*dev
, struct device_attribute
*attr
, char *buf
)
223 struct qeth_card
*card
= dev
->driver_data
;
228 switch (card
->qdio
.do_prio_queueing
) {
229 case QETH_PRIO_Q_ING_PREC
:
230 return sprintf(buf
, "%s\n", "by precedence");
231 case QETH_PRIO_Q_ING_TOS
:
232 return sprintf(buf
, "%s\n", "by type of service");
234 return sprintf(buf
, "always queue %i\n",
235 card
->qdio
.default_out_queue
);
240 qeth_dev_prioqing_store(struct device
*dev
, struct device_attribute
*attr
, const char *buf
, size_t count
)
242 struct qeth_card
*card
= dev
->driver_data
;
248 if ((card
->state
!= CARD_STATE_DOWN
) &&
249 (card
->state
!= CARD_STATE_RECOVER
))
252 /* check if 1920 devices are supported ,
253 * if though we have to permit priority queueing
255 if (card
->qdio
.no_out_queues
== 1) {
256 PRINT_WARN("Priority queueing disabled due "
257 "to hardware limitations!\n");
258 card
->qdio
.do_prio_queueing
= QETH_PRIOQ_DEFAULT
;
262 tmp
= strsep((char **) &buf
, "\n");
263 if (!strcmp(tmp
, "prio_queueing_prec"))
264 card
->qdio
.do_prio_queueing
= QETH_PRIO_Q_ING_PREC
;
265 else if (!strcmp(tmp
, "prio_queueing_tos"))
266 card
->qdio
.do_prio_queueing
= QETH_PRIO_Q_ING_TOS
;
267 else if (!strcmp(tmp
, "no_prio_queueing:0")) {
268 card
->qdio
.do_prio_queueing
= QETH_NO_PRIO_QUEUEING
;
269 card
->qdio
.default_out_queue
= 0;
270 } else if (!strcmp(tmp
, "no_prio_queueing:1")) {
271 card
->qdio
.do_prio_queueing
= QETH_NO_PRIO_QUEUEING
;
272 card
->qdio
.default_out_queue
= 1;
273 } else if (!strcmp(tmp
, "no_prio_queueing:2")) {
274 card
->qdio
.do_prio_queueing
= QETH_NO_PRIO_QUEUEING
;
275 card
->qdio
.default_out_queue
= 2;
276 } else if (!strcmp(tmp
, "no_prio_queueing:3")) {
277 card
->qdio
.do_prio_queueing
= QETH_NO_PRIO_QUEUEING
;
278 card
->qdio
.default_out_queue
= 3;
279 } else if (!strcmp(tmp
, "no_prio_queueing")) {
280 card
->qdio
.do_prio_queueing
= QETH_NO_PRIO_QUEUEING
;
281 card
->qdio
.default_out_queue
= QETH_DEFAULT_QUEUE
;
283 PRINT_WARN("Unknown queueing type '%s'\n", tmp
);
289 static DEVICE_ATTR(priority_queueing
, 0644, qeth_dev_prioqing_show
,
290 qeth_dev_prioqing_store
);
293 qeth_dev_bufcnt_show(struct device
*dev
, struct device_attribute
*attr
, char *buf
)
295 struct qeth_card
*card
= dev
->driver_data
;
300 return sprintf(buf
, "%i\n", card
->qdio
.in_buf_pool
.buf_count
);
304 qeth_dev_bufcnt_store(struct device
*dev
, struct device_attribute
*attr
, const char *buf
, size_t count
)
306 struct qeth_card
*card
= dev
->driver_data
;
314 if ((card
->state
!= CARD_STATE_DOWN
) &&
315 (card
->state
!= CARD_STATE_RECOVER
))
318 old_cnt
= card
->qdio
.in_buf_pool
.buf_count
;
319 cnt
= simple_strtoul(buf
, &tmp
, 10);
320 cnt
= (cnt
< QETH_IN_BUF_COUNT_MIN
) ? QETH_IN_BUF_COUNT_MIN
:
321 ((cnt
> QETH_IN_BUF_COUNT_MAX
) ? QETH_IN_BUF_COUNT_MAX
: cnt
);
322 if (old_cnt
!= cnt
) {
323 if ((rc
= qeth_realloc_buffer_pool(card
, cnt
)))
324 PRINT_WARN("Error (%d) while setting "
325 "buffer count.\n", rc
);
330 static DEVICE_ATTR(buffer_count
, 0644, qeth_dev_bufcnt_show
,
331 qeth_dev_bufcnt_store
);
333 static inline ssize_t
334 qeth_dev_route_show(struct qeth_card
*card
, struct qeth_routing_info
*route
,
337 switch (route
->type
) {
339 return sprintf(buf
, "%s\n", "primary router");
340 case SECONDARY_ROUTER
:
341 return sprintf(buf
, "%s\n", "secondary router");
342 case MULTICAST_ROUTER
:
343 if (card
->info
.broadcast_capable
== QETH_BROADCAST_WITHOUT_ECHO
)
344 return sprintf(buf
, "%s\n", "multicast router+");
346 return sprintf(buf
, "%s\n", "multicast router");
347 case PRIMARY_CONNECTOR
:
348 if (card
->info
.broadcast_capable
== QETH_BROADCAST_WITHOUT_ECHO
)
349 return sprintf(buf
, "%s\n", "primary connector+");
351 return sprintf(buf
, "%s\n", "primary connector");
352 case SECONDARY_CONNECTOR
:
353 if (card
->info
.broadcast_capable
== QETH_BROADCAST_WITHOUT_ECHO
)
354 return sprintf(buf
, "%s\n", "secondary connector+");
356 return sprintf(buf
, "%s\n", "secondary connector");
358 return sprintf(buf
, "%s\n", "no");
363 qeth_dev_route4_show(struct device
*dev
, struct device_attribute
*attr
, char *buf
)
365 struct qeth_card
*card
= dev
->driver_data
;
370 return qeth_dev_route_show(card
, &card
->options
.route4
, buf
);
373 static inline ssize_t
374 qeth_dev_route_store(struct qeth_card
*card
, struct qeth_routing_info
*route
,
375 enum qeth_prot_versions prot
, const char *buf
, size_t count
)
377 enum qeth_routing_types old_route_type
= route
->type
;
381 tmp
= strsep((char **) &buf
, "\n");
383 if (!strcmp(tmp
, "no_router")){
384 route
->type
= NO_ROUTER
;
385 } else if (!strcmp(tmp
, "primary_connector")) {
386 route
->type
= PRIMARY_CONNECTOR
;
387 } else if (!strcmp(tmp
, "secondary_connector")) {
388 route
->type
= SECONDARY_CONNECTOR
;
389 } else if (!strcmp(tmp
, "multicast_router")) {
390 route
->type
= MULTICAST_ROUTER
;
391 } else if (!strcmp(tmp
, "primary_router")) {
392 route
->type
= PRIMARY_ROUTER
;
393 } else if (!strcmp(tmp
, "secondary_router")) {
394 route
->type
= SECONDARY_ROUTER
;
395 } else if (!strcmp(tmp
, "multicast_router")) {
396 route
->type
= MULTICAST_ROUTER
;
398 PRINT_WARN("Invalid routing type '%s'.\n", tmp
);
401 if (((card
->state
== CARD_STATE_SOFTSETUP
) ||
402 (card
->state
== CARD_STATE_UP
)) &&
403 (old_route_type
!= route
->type
)){
404 if (prot
== QETH_PROT_IPV4
)
405 rc
= qeth_setrouting_v4(card
);
406 else if (prot
== QETH_PROT_IPV6
)
407 rc
= qeth_setrouting_v6(card
);
413 qeth_dev_route4_store(struct device
*dev
, struct device_attribute
*attr
, const char *buf
, size_t count
)
415 struct qeth_card
*card
= dev
->driver_data
;
420 return qeth_dev_route_store(card
, &card
->options
.route4
,
421 QETH_PROT_IPV4
, buf
, count
);
424 static DEVICE_ATTR(route4
, 0644, qeth_dev_route4_show
, qeth_dev_route4_store
);
426 #ifdef CONFIG_QETH_IPV6
428 qeth_dev_route6_show(struct device
*dev
, struct device_attribute
*attr
, char *buf
)
430 struct qeth_card
*card
= dev
->driver_data
;
435 if (!qeth_is_supported(card
, IPA_IPV6
))
436 return sprintf(buf
, "%s\n", "n/a");
438 return qeth_dev_route_show(card
, &card
->options
.route6
, buf
);
442 qeth_dev_route6_store(struct device
*dev
, struct device_attribute
*attr
, const char *buf
, size_t count
)
444 struct qeth_card
*card
= dev
->driver_data
;
449 if (!qeth_is_supported(card
, IPA_IPV6
)){
450 PRINT_WARN("IPv6 not supported for interface %s.\n"
451 "Routing status no changed.\n",
452 QETH_CARD_IFNAME(card
));
456 return qeth_dev_route_store(card
, &card
->options
.route6
,
457 QETH_PROT_IPV6
, buf
, count
);
460 static DEVICE_ATTR(route6
, 0644, qeth_dev_route6_show
, qeth_dev_route6_store
);
464 qeth_dev_add_hhlen_show(struct device
*dev
, struct device_attribute
*attr
, char *buf
)
466 struct qeth_card
*card
= dev
->driver_data
;
471 return sprintf(buf
, "%i\n", card
->options
.add_hhlen
);
475 qeth_dev_add_hhlen_store(struct device
*dev
, struct device_attribute
*attr
, const char *buf
, size_t count
)
477 struct qeth_card
*card
= dev
->driver_data
;
484 if ((card
->state
!= CARD_STATE_DOWN
) &&
485 (card
->state
!= CARD_STATE_RECOVER
))
488 i
= simple_strtoul(buf
, &tmp
, 10);
489 if ((i
< 0) || (i
> MAX_ADD_HHLEN
)) {
490 PRINT_WARN("add_hhlen out of range\n");
493 card
->options
.add_hhlen
= i
;
498 static DEVICE_ATTR(add_hhlen
, 0644, qeth_dev_add_hhlen_show
,
499 qeth_dev_add_hhlen_store
);
502 qeth_dev_fake_ll_show(struct device
*dev
, struct device_attribute
*attr
, char *buf
)
504 struct qeth_card
*card
= dev
->driver_data
;
509 return sprintf(buf
, "%i\n", card
->options
.fake_ll
? 1:0);
513 qeth_dev_fake_ll_store(struct device
*dev
, struct device_attribute
*attr
, const char *buf
, size_t count
)
515 struct qeth_card
*card
= dev
->driver_data
;
522 if ((card
->state
!= CARD_STATE_DOWN
) &&
523 (card
->state
!= CARD_STATE_RECOVER
))
526 i
= simple_strtoul(buf
, &tmp
, 16);
527 if ((i
!= 0) && (i
!= 1)) {
528 PRINT_WARN("fake_ll: write 0 or 1 to this file!\n");
531 card
->options
.fake_ll
= i
;
535 static DEVICE_ATTR(fake_ll
, 0644, qeth_dev_fake_ll_show
,
536 qeth_dev_fake_ll_store
);
539 qeth_dev_fake_broadcast_show(struct device
*dev
, struct device_attribute
*attr
, char *buf
)
541 struct qeth_card
*card
= dev
->driver_data
;
546 return sprintf(buf
, "%i\n", card
->options
.fake_broadcast
? 1:0);
550 qeth_dev_fake_broadcast_store(struct device
*dev
, struct device_attribute
*attr
, const char *buf
, size_t count
)
552 struct qeth_card
*card
= dev
->driver_data
;
559 if ((card
->state
!= CARD_STATE_DOWN
) &&
560 (card
->state
!= CARD_STATE_RECOVER
))
563 i
= simple_strtoul(buf
, &tmp
, 16);
564 if ((i
== 0) || (i
== 1))
565 card
->options
.fake_broadcast
= i
;
567 PRINT_WARN("fake_broadcast: write 0 or 1 to this file!\n");
573 static DEVICE_ATTR(fake_broadcast
, 0644, qeth_dev_fake_broadcast_show
,
574 qeth_dev_fake_broadcast_store
);
577 qeth_dev_recover_store(struct device
*dev
, struct device_attribute
*attr
, const char *buf
, size_t count
)
579 struct qeth_card
*card
= dev
->driver_data
;
586 if (card
->state
!= CARD_STATE_UP
)
589 i
= simple_strtoul(buf
, &tmp
, 16);
591 qeth_schedule_recovery(card
);
596 static DEVICE_ATTR(recover
, 0200, NULL
, qeth_dev_recover_store
);
599 qeth_dev_broadcast_mode_show(struct device
*dev
, struct device_attribute
*attr
, char *buf
)
601 struct qeth_card
*card
= dev
->driver_data
;
606 if (!((card
->info
.link_type
== QETH_LINK_TYPE_HSTR
) ||
607 (card
->info
.link_type
== QETH_LINK_TYPE_LANE_TR
)))
608 return sprintf(buf
, "n/a\n");
610 return sprintf(buf
, "%s\n", (card
->options
.broadcast_mode
==
611 QETH_TR_BROADCAST_ALLRINGS
)?
612 "all rings":"local");
616 qeth_dev_broadcast_mode_store(struct device
*dev
, struct device_attribute
*attr
, const char *buf
, size_t count
)
618 struct qeth_card
*card
= dev
->driver_data
;
624 if ((card
->state
!= CARD_STATE_DOWN
) &&
625 (card
->state
!= CARD_STATE_RECOVER
))
628 if (!((card
->info
.link_type
== QETH_LINK_TYPE_HSTR
) ||
629 (card
->info
.link_type
== QETH_LINK_TYPE_LANE_TR
))){
630 PRINT_WARN("Device is not a tokenring device!\n");
634 tmp
= strsep((char **) &buf
, "\n");
636 if (!strcmp(tmp
, "local")){
637 card
->options
.broadcast_mode
= QETH_TR_BROADCAST_LOCAL
;
639 } else if (!strcmp(tmp
, "all_rings")) {
640 card
->options
.broadcast_mode
= QETH_TR_BROADCAST_ALLRINGS
;
643 PRINT_WARN("broadcast_mode: invalid mode %s!\n",
650 static DEVICE_ATTR(broadcast_mode
, 0644, qeth_dev_broadcast_mode_show
,
651 qeth_dev_broadcast_mode_store
);
654 qeth_dev_canonical_macaddr_show(struct device
*dev
, struct device_attribute
*attr
, char *buf
)
656 struct qeth_card
*card
= dev
->driver_data
;
661 if (!((card
->info
.link_type
== QETH_LINK_TYPE_HSTR
) ||
662 (card
->info
.link_type
== QETH_LINK_TYPE_LANE_TR
)))
663 return sprintf(buf
, "n/a\n");
665 return sprintf(buf
, "%i\n", (card
->options
.macaddr_mode
==
666 QETH_TR_MACADDR_CANONICAL
)? 1:0);
670 qeth_dev_canonical_macaddr_store(struct device
*dev
, struct device_attribute
*attr
, const char *buf
,
673 struct qeth_card
*card
= dev
->driver_data
;
680 if ((card
->state
!= CARD_STATE_DOWN
) &&
681 (card
->state
!= CARD_STATE_RECOVER
))
684 if (!((card
->info
.link_type
== QETH_LINK_TYPE_HSTR
) ||
685 (card
->info
.link_type
== QETH_LINK_TYPE_LANE_TR
))){
686 PRINT_WARN("Device is not a tokenring device!\n");
690 i
= simple_strtoul(buf
, &tmp
, 16);
691 if ((i
== 0) || (i
== 1))
692 card
->options
.macaddr_mode
= i
?
693 QETH_TR_MACADDR_CANONICAL
:
694 QETH_TR_MACADDR_NONCANONICAL
;
696 PRINT_WARN("canonical_macaddr: write 0 or 1 to this file!\n");
702 static DEVICE_ATTR(canonical_macaddr
, 0644, qeth_dev_canonical_macaddr_show
,
703 qeth_dev_canonical_macaddr_store
);
706 qeth_dev_layer2_show(struct device
*dev
, struct device_attribute
*attr
, char *buf
)
708 struct qeth_card
*card
= dev
->driver_data
;
713 return sprintf(buf
, "%i\n", card
->options
.layer2
? 1:0);
717 qeth_dev_layer2_store(struct device
*dev
, struct device_attribute
*attr
, const char *buf
, size_t count
)
719 struct qeth_card
*card
= dev
->driver_data
;
725 if (card
->info
.type
== QETH_CARD_TYPE_IQD
) {
726 PRINT_WARN("Layer2 on Hipersockets is not supported! \n");
730 if (((card
->state
!= CARD_STATE_DOWN
) &&
731 (card
->state
!= CARD_STATE_RECOVER
)))
734 i
= simple_strtoul(buf
, &tmp
, 16);
735 if ((i
== 0) || (i
== 1))
736 card
->options
.layer2
= i
;
738 PRINT_WARN("layer2: write 0 or 1 to this file!\n");
744 static DEVICE_ATTR(layer2
, 0644, qeth_dev_layer2_show
,
745 qeth_dev_layer2_store
);
748 qeth_dev_large_send_show(struct device
*dev
, struct device_attribute
*attr
, char *buf
)
750 struct qeth_card
*card
= dev
->driver_data
;
755 switch (card
->options
.large_send
) {
756 case QETH_LARGE_SEND_NO
:
757 return sprintf(buf
, "%s\n", "no");
758 case QETH_LARGE_SEND_EDDP
:
759 return sprintf(buf
, "%s\n", "EDDP");
760 case QETH_LARGE_SEND_TSO
:
761 return sprintf(buf
, "%s\n", "TSO");
763 return sprintf(buf
, "%s\n", "N/A");
768 qeth_dev_large_send_store(struct device
*dev
, struct device_attribute
*attr
, const char *buf
, size_t count
)
770 struct qeth_card
*card
= dev
->driver_data
;
771 enum qeth_large_send_types type
;
777 tmp
= strsep((char **) &buf
, "\n");
778 if (!strcmp(tmp
, "no")){
779 type
= QETH_LARGE_SEND_NO
;
780 } else if (!strcmp(tmp
, "EDDP")) {
781 type
= QETH_LARGE_SEND_EDDP
;
782 } else if (!strcmp(tmp
, "TSO")) {
783 type
= QETH_LARGE_SEND_TSO
;
785 PRINT_WARN("large_send: invalid mode %s!\n", tmp
);
788 if (card
->options
.large_send
== type
)
790 if ((rc
= qeth_set_large_send(card
, type
)))
795 static DEVICE_ATTR(large_send
, 0644, qeth_dev_large_send_show
,
796 qeth_dev_large_send_store
);
799 qeth_dev_blkt_show(char *buf
, struct qeth_card
*card
, int value
)
805 return sprintf(buf
, "%i\n", value
);
809 qeth_dev_blkt_store(struct qeth_card
*card
, const char *buf
, size_t count
,
810 int *value
, int max_value
)
818 if ((card
->state
!= CARD_STATE_DOWN
) &&
819 (card
->state
!= CARD_STATE_RECOVER
))
822 i
= simple_strtoul(buf
, &tmp
, 10);
823 if (i
<= max_value
) {
826 PRINT_WARN("blkt total time: write values between"
827 " 0 and %d to this file!\n", max_value
);
834 qeth_dev_blkt_total_show(struct device
*dev
, struct device_attribute
*attr
, char *buf
)
836 struct qeth_card
*card
= dev
->driver_data
;
838 return qeth_dev_blkt_show(buf
, card
, card
->info
.blkt
.time_total
);
843 qeth_dev_blkt_total_store(struct device
*dev
, struct device_attribute
*attr
, const char *buf
, size_t count
)
845 struct qeth_card
*card
= dev
->driver_data
;
847 return qeth_dev_blkt_store(card
, buf
, count
,
848 &card
->info
.blkt
.time_total
,1000);
853 static DEVICE_ATTR(total
, 0644, qeth_dev_blkt_total_show
,
854 qeth_dev_blkt_total_store
);
857 qeth_dev_blkt_inter_show(struct device
*dev
, struct device_attribute
*attr
, char *buf
)
859 struct qeth_card
*card
= dev
->driver_data
;
861 return qeth_dev_blkt_show(buf
, card
, card
->info
.blkt
.inter_packet
);
866 qeth_dev_blkt_inter_store(struct device
*dev
, struct device_attribute
*attr
, const char *buf
, size_t count
)
868 struct qeth_card
*card
= dev
->driver_data
;
870 return qeth_dev_blkt_store(card
, buf
, count
,
871 &card
->info
.blkt
.inter_packet
,100);
874 static DEVICE_ATTR(inter
, 0644, qeth_dev_blkt_inter_show
,
875 qeth_dev_blkt_inter_store
);
878 qeth_dev_blkt_inter_jumbo_show(struct device
*dev
, struct device_attribute
*attr
, char *buf
)
880 struct qeth_card
*card
= dev
->driver_data
;
882 return qeth_dev_blkt_show(buf
, card
,
883 card
->info
.blkt
.inter_packet_jumbo
);
888 qeth_dev_blkt_inter_jumbo_store(struct device
*dev
, struct device_attribute
*attr
, const char *buf
, size_t count
)
890 struct qeth_card
*card
= dev
->driver_data
;
892 return qeth_dev_blkt_store(card
, buf
, count
,
893 &card
->info
.blkt
.inter_packet_jumbo
,100);
896 static DEVICE_ATTR(inter_jumbo
, 0644, qeth_dev_blkt_inter_jumbo_show
,
897 qeth_dev_blkt_inter_jumbo_store
);
899 static struct device_attribute
* qeth_blkt_device_attrs
[] = {
902 &dev_attr_inter_jumbo
,
906 static struct attribute_group qeth_device_blkt_group
= {
908 .attrs
= (struct attribute
**)qeth_blkt_device_attrs
,
911 static struct device_attribute
* qeth_device_attrs
[] = {
918 &dev_attr_checksumming
,
919 &dev_attr_priority_queueing
,
920 &dev_attr_buffer_count
,
922 #ifdef CONFIG_QETH_IPV6
927 &dev_attr_fake_broadcast
,
929 &dev_attr_broadcast_mode
,
930 &dev_attr_canonical_macaddr
,
932 &dev_attr_large_send
,
936 static struct attribute_group qeth_device_attr_group
= {
937 .attrs
= (struct attribute
**)qeth_device_attrs
,
941 #define QETH_DEVICE_ATTR(_id,_name,_mode,_show,_store) \
942 struct device_attribute dev_attr_##_id = { \
943 .attr = {.name=__stringify(_name), .mode=_mode, .owner=THIS_MODULE },\
949 qeth_check_layer2(struct qeth_card
*card
)
951 if (card
->options
.layer2
)
958 qeth_dev_ipato_enable_show(struct device
*dev
, struct device_attribute
*attr
, char *buf
)
960 struct qeth_card
*card
= dev
->driver_data
;
965 if (qeth_check_layer2(card
))
967 return sprintf(buf
, "%i\n", card
->ipato
.enabled
? 1:0);
971 qeth_dev_ipato_enable_store(struct device
*dev
, struct device_attribute
*attr
, const char *buf
, size_t count
)
973 struct qeth_card
*card
= dev
->driver_data
;
979 if ((card
->state
!= CARD_STATE_DOWN
) &&
980 (card
->state
!= CARD_STATE_RECOVER
))
983 if (qeth_check_layer2(card
))
986 tmp
= strsep((char **) &buf
, "\n");
987 if (!strcmp(tmp
, "toggle")){
988 card
->ipato
.enabled
= (card
->ipato
.enabled
)? 0 : 1;
989 } else if (!strcmp(tmp
, "1")){
990 card
->ipato
.enabled
= 1;
991 } else if (!strcmp(tmp
, "0")){
992 card
->ipato
.enabled
= 0;
994 PRINT_WARN("ipato_enable: write 0, 1 or 'toggle' to "
1001 static QETH_DEVICE_ATTR(ipato_enable
, enable
, 0644,
1002 qeth_dev_ipato_enable_show
,
1003 qeth_dev_ipato_enable_store
);
1006 qeth_dev_ipato_invert4_show(struct device
*dev
, struct device_attribute
*attr
, char *buf
)
1008 struct qeth_card
*card
= dev
->driver_data
;
1013 if (qeth_check_layer2(card
))
1016 return sprintf(buf
, "%i\n", card
->ipato
.invert4
? 1:0);
1020 qeth_dev_ipato_invert4_store(struct device
*dev
, struct device_attribute
*attr
, const char *buf
, size_t count
)
1022 struct qeth_card
*card
= dev
->driver_data
;
1028 if (qeth_check_layer2(card
))
1031 tmp
= strsep((char **) &buf
, "\n");
1032 if (!strcmp(tmp
, "toggle")){
1033 card
->ipato
.invert4
= (card
->ipato
.invert4
)? 0 : 1;
1034 } else if (!strcmp(tmp
, "1")){
1035 card
->ipato
.invert4
= 1;
1036 } else if (!strcmp(tmp
, "0")){
1037 card
->ipato
.invert4
= 0;
1039 PRINT_WARN("ipato_invert4: write 0, 1 or 'toggle' to "
1046 static QETH_DEVICE_ATTR(ipato_invert4
, invert4
, 0644,
1047 qeth_dev_ipato_invert4_show
,
1048 qeth_dev_ipato_invert4_store
);
1050 static inline ssize_t
1051 qeth_dev_ipato_add_show(char *buf
, struct qeth_card
*card
,
1052 enum qeth_prot_versions proto
)
1054 struct qeth_ipato_entry
*ipatoe
;
1055 unsigned long flags
;
1057 int entry_len
; /* length of 1 entry string, differs between v4 and v6 */
1060 if (qeth_check_layer2(card
))
1063 entry_len
= (proto
== QETH_PROT_IPV4
)? 12 : 40;
1064 /* add strlen for "/<mask>\n" */
1065 entry_len
+= (proto
== QETH_PROT_IPV4
)? 5 : 6;
1066 spin_lock_irqsave(&card
->ip_lock
, flags
);
1067 list_for_each_entry(ipatoe
, &card
->ipato
.entries
, entry
){
1068 if (ipatoe
->proto
!= proto
)
1070 /* String must not be longer than PAGE_SIZE. So we check if
1071 * string length gets near PAGE_SIZE. Then we can savely display
1072 * the next IPv6 address (worst case, compared to IPv4) */
1073 if ((PAGE_SIZE
- i
) <= entry_len
)
1075 qeth_ipaddr_to_string(proto
, ipatoe
->addr
, addr_str
);
1076 i
+= snprintf(buf
+ i
, PAGE_SIZE
- i
,
1077 "%s/%i\n", addr_str
, ipatoe
->mask_bits
);
1079 spin_unlock_irqrestore(&card
->ip_lock
, flags
);
1080 i
+= snprintf(buf
+ i
, PAGE_SIZE
- i
, "\n");
1086 qeth_dev_ipato_add4_show(struct device
*dev
, struct device_attribute
*attr
, char *buf
)
1088 struct qeth_card
*card
= dev
->driver_data
;
1093 return qeth_dev_ipato_add_show(buf
, card
, QETH_PROT_IPV4
);
1097 qeth_parse_ipatoe(const char* buf
, enum qeth_prot_versions proto
,
1098 u8
*addr
, int *mask_bits
)
1100 const char *start
, *end
;
1102 char buffer
[49] = {0, };
1105 /* get address string */
1106 end
= strchr(start
, '/');
1108 PRINT_WARN("Invalid format for ipato_addx/delx. "
1109 "Use <ip addr>/<mask bits>\n");
1112 strncpy(buffer
, start
, end
- start
);
1113 if (qeth_string_to_ipaddr(buffer
, proto
, addr
)){
1114 PRINT_WARN("Invalid IP address format!\n");
1118 *mask_bits
= simple_strtoul(start
, &tmp
, 10);
1123 static inline ssize_t
1124 qeth_dev_ipato_add_store(const char *buf
, size_t count
,
1125 struct qeth_card
*card
, enum qeth_prot_versions proto
)
1127 struct qeth_ipato_entry
*ipatoe
;
1132 if (qeth_check_layer2(card
))
1134 if ((rc
= qeth_parse_ipatoe(buf
, proto
, addr
, &mask_bits
)))
1137 if (!(ipatoe
= kmalloc(sizeof(struct qeth_ipato_entry
), GFP_KERNEL
))){
1138 PRINT_WARN("No memory to allocate ipato entry\n");
1141 memset(ipatoe
, 0, sizeof(struct qeth_ipato_entry
));
1142 ipatoe
->proto
= proto
;
1143 memcpy(ipatoe
->addr
, addr
, (proto
== QETH_PROT_IPV4
)? 4:16);
1144 ipatoe
->mask_bits
= mask_bits
;
1146 if ((rc
= qeth_add_ipato_entry(card
, ipatoe
))){
1155 qeth_dev_ipato_add4_store(struct device
*dev
, struct device_attribute
*attr
, const char *buf
, size_t count
)
1157 struct qeth_card
*card
= dev
->driver_data
;
1162 return qeth_dev_ipato_add_store(buf
, count
, card
, QETH_PROT_IPV4
);
1165 static QETH_DEVICE_ATTR(ipato_add4
, add4
, 0644,
1166 qeth_dev_ipato_add4_show
,
1167 qeth_dev_ipato_add4_store
);
1169 static inline ssize_t
1170 qeth_dev_ipato_del_store(const char *buf
, size_t count
,
1171 struct qeth_card
*card
, enum qeth_prot_versions proto
)
1177 if (qeth_check_layer2(card
))
1179 if ((rc
= qeth_parse_ipatoe(buf
, proto
, addr
, &mask_bits
)))
1182 qeth_del_ipato_entry(card
, proto
, addr
, mask_bits
);
1188 qeth_dev_ipato_del4_store(struct device
*dev
, struct device_attribute
*attr
, const char *buf
, size_t count
)
1190 struct qeth_card
*card
= dev
->driver_data
;
1195 return qeth_dev_ipato_del_store(buf
, count
, card
, QETH_PROT_IPV4
);
1198 static QETH_DEVICE_ATTR(ipato_del4
, del4
, 0200, NULL
,
1199 qeth_dev_ipato_del4_store
);
1201 #ifdef CONFIG_QETH_IPV6
1203 qeth_dev_ipato_invert6_show(struct device
*dev
, struct device_attribute
*attr
, char *buf
)
1205 struct qeth_card
*card
= dev
->driver_data
;
1210 if (qeth_check_layer2(card
))
1213 return sprintf(buf
, "%i\n", card
->ipato
.invert6
? 1:0);
1217 qeth_dev_ipato_invert6_store(struct device
*dev
, struct device_attribute
*attr
, const char *buf
, size_t count
)
1219 struct qeth_card
*card
= dev
->driver_data
;
1225 if (qeth_check_layer2(card
))
1228 tmp
= strsep((char **) &buf
, "\n");
1229 if (!strcmp(tmp
, "toggle")){
1230 card
->ipato
.invert6
= (card
->ipato
.invert6
)? 0 : 1;
1231 } else if (!strcmp(tmp
, "1")){
1232 card
->ipato
.invert6
= 1;
1233 } else if (!strcmp(tmp
, "0")){
1234 card
->ipato
.invert6
= 0;
1236 PRINT_WARN("ipato_invert6: write 0, 1 or 'toggle' to "
1243 static QETH_DEVICE_ATTR(ipato_invert6
, invert6
, 0644,
1244 qeth_dev_ipato_invert6_show
,
1245 qeth_dev_ipato_invert6_store
);
1249 qeth_dev_ipato_add6_show(struct device
*dev
, struct device_attribute
*attr
, char *buf
)
1251 struct qeth_card
*card
= dev
->driver_data
;
1256 return qeth_dev_ipato_add_show(buf
, card
, QETH_PROT_IPV6
);
1260 qeth_dev_ipato_add6_store(struct device
*dev
, struct device_attribute
*attr
, const char *buf
, size_t count
)
1262 struct qeth_card
*card
= dev
->driver_data
;
1267 return qeth_dev_ipato_add_store(buf
, count
, card
, QETH_PROT_IPV6
);
1270 static QETH_DEVICE_ATTR(ipato_add6
, add6
, 0644,
1271 qeth_dev_ipato_add6_show
,
1272 qeth_dev_ipato_add6_store
);
1275 qeth_dev_ipato_del6_store(struct device
*dev
, struct device_attribute
*attr
, const char *buf
, size_t count
)
1277 struct qeth_card
*card
= dev
->driver_data
;
1282 return qeth_dev_ipato_del_store(buf
, count
, card
, QETH_PROT_IPV6
);
1285 static QETH_DEVICE_ATTR(ipato_del6
, del6
, 0200, NULL
,
1286 qeth_dev_ipato_del6_store
);
1287 #endif /* CONFIG_QETH_IPV6 */
1289 static struct device_attribute
* qeth_ipato_device_attrs
[] = {
1290 &dev_attr_ipato_enable
,
1291 &dev_attr_ipato_invert4
,
1292 &dev_attr_ipato_add4
,
1293 &dev_attr_ipato_del4
,
1294 #ifdef CONFIG_QETH_IPV6
1295 &dev_attr_ipato_invert6
,
1296 &dev_attr_ipato_add6
,
1297 &dev_attr_ipato_del6
,
1302 static struct attribute_group qeth_device_ipato_group
= {
1303 .name
= "ipa_takeover",
1304 .attrs
= (struct attribute
**)qeth_ipato_device_attrs
,
1307 static inline ssize_t
1308 qeth_dev_vipa_add_show(char *buf
, struct qeth_card
*card
,
1309 enum qeth_prot_versions proto
)
1311 struct qeth_ipaddr
*ipaddr
;
1313 int entry_len
; /* length of 1 entry string, differs between v4 and v6 */
1314 unsigned long flags
;
1317 if (qeth_check_layer2(card
))
1320 entry_len
= (proto
== QETH_PROT_IPV4
)? 12 : 40;
1321 entry_len
+= 2; /* \n + terminator */
1322 spin_lock_irqsave(&card
->ip_lock
, flags
);
1323 list_for_each_entry(ipaddr
, &card
->ip_list
, entry
){
1324 if (ipaddr
->proto
!= proto
)
1326 if (ipaddr
->type
!= QETH_IP_TYPE_VIPA
)
1328 /* String must not be longer than PAGE_SIZE. So we check if
1329 * string length gets near PAGE_SIZE. Then we can savely display
1330 * the next IPv6 address (worst case, compared to IPv4) */
1331 if ((PAGE_SIZE
- i
) <= entry_len
)
1333 qeth_ipaddr_to_string(proto
, (const u8
*)&ipaddr
->u
, addr_str
);
1334 i
+= snprintf(buf
+ i
, PAGE_SIZE
- i
, "%s\n", addr_str
);
1336 spin_unlock_irqrestore(&card
->ip_lock
, flags
);
1337 i
+= snprintf(buf
+ i
, PAGE_SIZE
- i
, "\n");
1343 qeth_dev_vipa_add4_show(struct device
*dev
, struct device_attribute
*attr
, char *buf
)
1345 struct qeth_card
*card
= dev
->driver_data
;
1350 return qeth_dev_vipa_add_show(buf
, card
, QETH_PROT_IPV4
);
1354 qeth_parse_vipae(const char* buf
, enum qeth_prot_versions proto
,
1357 if (qeth_string_to_ipaddr(buf
, proto
, addr
)){
1358 PRINT_WARN("Invalid IP address format!\n");
1364 static inline ssize_t
1365 qeth_dev_vipa_add_store(const char *buf
, size_t count
,
1366 struct qeth_card
*card
, enum qeth_prot_versions proto
)
1368 u8 addr
[16] = {0, };
1371 if (qeth_check_layer2(card
))
1373 if ((rc
= qeth_parse_vipae(buf
, proto
, addr
)))
1376 if ((rc
= qeth_add_vipa(card
, proto
, addr
)))
1383 qeth_dev_vipa_add4_store(struct device
*dev
, struct device_attribute
*attr
, const char *buf
, size_t count
)
1385 struct qeth_card
*card
= dev
->driver_data
;
1390 return qeth_dev_vipa_add_store(buf
, count
, card
, QETH_PROT_IPV4
);
1393 static QETH_DEVICE_ATTR(vipa_add4
, add4
, 0644,
1394 qeth_dev_vipa_add4_show
,
1395 qeth_dev_vipa_add4_store
);
1397 static inline ssize_t
1398 qeth_dev_vipa_del_store(const char *buf
, size_t count
,
1399 struct qeth_card
*card
, enum qeth_prot_versions proto
)
1404 if (qeth_check_layer2(card
))
1406 if ((rc
= qeth_parse_vipae(buf
, proto
, addr
)))
1409 qeth_del_vipa(card
, proto
, addr
);
1415 qeth_dev_vipa_del4_store(struct device
*dev
, struct device_attribute
*attr
, const char *buf
, size_t count
)
1417 struct qeth_card
*card
= dev
->driver_data
;
1422 return qeth_dev_vipa_del_store(buf
, count
, card
, QETH_PROT_IPV4
);
1425 static QETH_DEVICE_ATTR(vipa_del4
, del4
, 0200, NULL
,
1426 qeth_dev_vipa_del4_store
);
1428 #ifdef CONFIG_QETH_IPV6
1430 qeth_dev_vipa_add6_show(struct device
*dev
, struct device_attribute
*attr
, char *buf
)
1432 struct qeth_card
*card
= dev
->driver_data
;
1437 return qeth_dev_vipa_add_show(buf
, card
, QETH_PROT_IPV6
);
1441 qeth_dev_vipa_add6_store(struct device
*dev
, struct device_attribute
*attr
, const char *buf
, size_t count
)
1443 struct qeth_card
*card
= dev
->driver_data
;
1448 return qeth_dev_vipa_add_store(buf
, count
, card
, QETH_PROT_IPV6
);
1451 static QETH_DEVICE_ATTR(vipa_add6
, add6
, 0644,
1452 qeth_dev_vipa_add6_show
,
1453 qeth_dev_vipa_add6_store
);
1456 qeth_dev_vipa_del6_store(struct device
*dev
, struct device_attribute
*attr
, const char *buf
, size_t count
)
1458 struct qeth_card
*card
= dev
->driver_data
;
1463 if (qeth_check_layer2(card
))
1466 return qeth_dev_vipa_del_store(buf
, count
, card
, QETH_PROT_IPV6
);
1469 static QETH_DEVICE_ATTR(vipa_del6
, del6
, 0200, NULL
,
1470 qeth_dev_vipa_del6_store
);
1471 #endif /* CONFIG_QETH_IPV6 */
1473 static struct device_attribute
* qeth_vipa_device_attrs
[] = {
1474 &dev_attr_vipa_add4
,
1475 &dev_attr_vipa_del4
,
1476 #ifdef CONFIG_QETH_IPV6
1477 &dev_attr_vipa_add6
,
1478 &dev_attr_vipa_del6
,
1483 static struct attribute_group qeth_device_vipa_group
= {
1485 .attrs
= (struct attribute
**)qeth_vipa_device_attrs
,
1488 static inline ssize_t
1489 qeth_dev_rxip_add_show(char *buf
, struct qeth_card
*card
,
1490 enum qeth_prot_versions proto
)
1492 struct qeth_ipaddr
*ipaddr
;
1494 int entry_len
; /* length of 1 entry string, differs between v4 and v6 */
1495 unsigned long flags
;
1498 if (qeth_check_layer2(card
))
1501 entry_len
= (proto
== QETH_PROT_IPV4
)? 12 : 40;
1502 entry_len
+= 2; /* \n + terminator */
1503 spin_lock_irqsave(&card
->ip_lock
, flags
);
1504 list_for_each_entry(ipaddr
, &card
->ip_list
, entry
){
1505 if (ipaddr
->proto
!= proto
)
1507 if (ipaddr
->type
!= QETH_IP_TYPE_RXIP
)
1509 /* String must not be longer than PAGE_SIZE. So we check if
1510 * string length gets near PAGE_SIZE. Then we can savely display
1511 * the next IPv6 address (worst case, compared to IPv4) */
1512 if ((PAGE_SIZE
- i
) <= entry_len
)
1514 qeth_ipaddr_to_string(proto
, (const u8
*)&ipaddr
->u
, addr_str
);
1515 i
+= snprintf(buf
+ i
, PAGE_SIZE
- i
, "%s\n", addr_str
);
1517 spin_unlock_irqrestore(&card
->ip_lock
, flags
);
1518 i
+= snprintf(buf
+ i
, PAGE_SIZE
- i
, "\n");
1524 qeth_dev_rxip_add4_show(struct device
*dev
, struct device_attribute
*attr
, char *buf
)
1526 struct qeth_card
*card
= dev
->driver_data
;
1531 return qeth_dev_rxip_add_show(buf
, card
, QETH_PROT_IPV4
);
1535 qeth_parse_rxipe(const char* buf
, enum qeth_prot_versions proto
,
1538 if (qeth_string_to_ipaddr(buf
, proto
, addr
)){
1539 PRINT_WARN("Invalid IP address format!\n");
1545 static inline ssize_t
1546 qeth_dev_rxip_add_store(const char *buf
, size_t count
,
1547 struct qeth_card
*card
, enum qeth_prot_versions proto
)
1549 u8 addr
[16] = {0, };
1552 if (qeth_check_layer2(card
))
1554 if ((rc
= qeth_parse_rxipe(buf
, proto
, addr
)))
1557 if ((rc
= qeth_add_rxip(card
, proto
, addr
)))
1564 qeth_dev_rxip_add4_store(struct device
*dev
, struct device_attribute
*attr
, const char *buf
, size_t count
)
1566 struct qeth_card
*card
= dev
->driver_data
;
1571 return qeth_dev_rxip_add_store(buf
, count
, card
, QETH_PROT_IPV4
);
1574 static QETH_DEVICE_ATTR(rxip_add4
, add4
, 0644,
1575 qeth_dev_rxip_add4_show
,
1576 qeth_dev_rxip_add4_store
);
1578 static inline ssize_t
1579 qeth_dev_rxip_del_store(const char *buf
, size_t count
,
1580 struct qeth_card
*card
, enum qeth_prot_versions proto
)
1585 if (qeth_check_layer2(card
))
1587 if ((rc
= qeth_parse_rxipe(buf
, proto
, addr
)))
1590 qeth_del_rxip(card
, proto
, addr
);
1596 qeth_dev_rxip_del4_store(struct device
*dev
, struct device_attribute
*attr
, const char *buf
, size_t count
)
1598 struct qeth_card
*card
= dev
->driver_data
;
1603 return qeth_dev_rxip_del_store(buf
, count
, card
, QETH_PROT_IPV4
);
1606 static QETH_DEVICE_ATTR(rxip_del4
, del4
, 0200, NULL
,
1607 qeth_dev_rxip_del4_store
);
1609 #ifdef CONFIG_QETH_IPV6
1611 qeth_dev_rxip_add6_show(struct device
*dev
, struct device_attribute
*attr
, char *buf
)
1613 struct qeth_card
*card
= dev
->driver_data
;
1618 return qeth_dev_rxip_add_show(buf
, card
, QETH_PROT_IPV6
);
1622 qeth_dev_rxip_add6_store(struct device
*dev
, struct device_attribute
*attr
, const char *buf
, size_t count
)
1624 struct qeth_card
*card
= dev
->driver_data
;
1629 return qeth_dev_rxip_add_store(buf
, count
, card
, QETH_PROT_IPV6
);
1632 static QETH_DEVICE_ATTR(rxip_add6
, add6
, 0644,
1633 qeth_dev_rxip_add6_show
,
1634 qeth_dev_rxip_add6_store
);
1637 qeth_dev_rxip_del6_store(struct device
*dev
, struct device_attribute
*attr
, const char *buf
, size_t count
)
1639 struct qeth_card
*card
= dev
->driver_data
;
1644 return qeth_dev_rxip_del_store(buf
, count
, card
, QETH_PROT_IPV6
);
1647 static QETH_DEVICE_ATTR(rxip_del6
, del6
, 0200, NULL
,
1648 qeth_dev_rxip_del6_store
);
1649 #endif /* CONFIG_QETH_IPV6 */
1651 static struct device_attribute
* qeth_rxip_device_attrs
[] = {
1652 &dev_attr_rxip_add4
,
1653 &dev_attr_rxip_del4
,
1654 #ifdef CONFIG_QETH_IPV6
1655 &dev_attr_rxip_add6
,
1656 &dev_attr_rxip_del6
,
1661 static struct attribute_group qeth_device_rxip_group
= {
1663 .attrs
= (struct attribute
**)qeth_rxip_device_attrs
,
1667 qeth_create_device_attributes(struct device
*dev
)
1671 if ((ret
= sysfs_create_group(&dev
->kobj
, &qeth_device_attr_group
)))
1673 if ((ret
= sysfs_create_group(&dev
->kobj
, &qeth_device_ipato_group
))){
1674 sysfs_remove_group(&dev
->kobj
, &qeth_device_attr_group
);
1677 if ((ret
= sysfs_create_group(&dev
->kobj
, &qeth_device_vipa_group
))){
1678 sysfs_remove_group(&dev
->kobj
, &qeth_device_attr_group
);
1679 sysfs_remove_group(&dev
->kobj
, &qeth_device_ipato_group
);
1682 if ((ret
= sysfs_create_group(&dev
->kobj
, &qeth_device_rxip_group
))){
1683 sysfs_remove_group(&dev
->kobj
, &qeth_device_attr_group
);
1684 sysfs_remove_group(&dev
->kobj
, &qeth_device_ipato_group
);
1685 sysfs_remove_group(&dev
->kobj
, &qeth_device_vipa_group
);
1687 if ((ret
= sysfs_create_group(&dev
->kobj
, &qeth_device_blkt_group
)))
1694 qeth_remove_device_attributes(struct device
*dev
)
1696 sysfs_remove_group(&dev
->kobj
, &qeth_device_attr_group
);
1697 sysfs_remove_group(&dev
->kobj
, &qeth_device_ipato_group
);
1698 sysfs_remove_group(&dev
->kobj
, &qeth_device_vipa_group
);
1699 sysfs_remove_group(&dev
->kobj
, &qeth_device_rxip_group
);
1700 sysfs_remove_group(&dev
->kobj
, &qeth_device_blkt_group
);
1703 /**********************/
1704 /* DRIVER ATTRIBUTES */
1705 /**********************/
1707 qeth_driver_group_store(struct device_driver
*ddrv
, const char *buf
,
1710 const char *start
, *end
;
1711 char bus_ids
[3][BUS_ID_SIZE
], *argv
[3];
1716 for (i
= 0; i
< 3; i
++) {
1717 static const char delim
[] = { ',', ',', '\n' };
1720 if (!(end
= strchr(start
, delim
[i
])))
1722 len
= min_t(ptrdiff_t, BUS_ID_SIZE
, end
- start
);
1723 strncpy(bus_ids
[i
], start
, len
);
1724 bus_ids
[i
][len
] = '\0';
1726 argv
[i
] = bus_ids
[i
];
1728 err
= ccwgroup_create(qeth_root_dev
, qeth_ccwgroup_driver
.driver_id
,
1729 &qeth_ccw_driver
, 3, argv
);
1737 static DRIVER_ATTR(group
, 0200, 0, qeth_driver_group_store
);
1740 qeth_driver_notifier_register_store(struct device_driver
*ddrv
, const char *buf
,
1747 tmp
= strsep((char **) &buf
, "\n");
1748 if (!strncmp(tmp
, "unregister", 10)){
1749 if ((rc
= qeth_notifier_unregister(current
)))
1754 signum
= simple_strtoul(tmp
, &tmp2
, 10);
1755 if ((signum
< 0) || (signum
> 32)){
1756 PRINT_WARN("Signal number %d is out of range\n", signum
);
1759 if ((rc
= qeth_notifier_register(current
, signum
)))
1765 static DRIVER_ATTR(notifier_register
, 0200, 0,
1766 qeth_driver_notifier_register_store
);
1769 qeth_create_driver_attributes(void)
1773 if ((rc
= driver_create_file(&qeth_ccwgroup_driver
.driver
,
1774 &driver_attr_group
)))
1776 return driver_create_file(&qeth_ccwgroup_driver
.driver
,
1777 &driver_attr_notifier_register
);
1781 qeth_remove_driver_attributes(void)
1783 driver_remove_file(&qeth_ccwgroup_driver
.driver
,
1784 &driver_attr_group
);
1785 driver_remove_file(&qeth_ccwgroup_driver
.driver
,
1786 &driver_attr_notifier_register
);