[S390] cmm, smsgiucv_app: convert sender to uppercase
[linux-2.6.git] / drivers / s390 / net / qeth_core_sys.c
1 /*
2  *  drivers/s390/net/qeth_core_sys.c
3  *
4  *    Copyright IBM Corp. 2007
5  *    Author(s): Utz Bacher <utz.bacher@de.ibm.com>,
6  *               Frank Pavlic <fpavlic@de.ibm.com>,
7  *               Thomas Spatzier <tspat@de.ibm.com>,
8  *               Frank Blaschka <frank.blaschka@de.ibm.com>
9  */
10
11 #define KMSG_COMPONENT "qeth"
12 #define pr_fmt(fmt) KMSG_COMPONENT ": " fmt
13
14 #include <linux/list.h>
15 #include <linux/rwsem.h>
16 #include <asm/ebcdic.h>
17
18 #include "qeth_core.h"
19
20 static ssize_t qeth_dev_state_show(struct device *dev,
21                                 struct device_attribute *attr, char *buf)
22 {
23         struct qeth_card *card = dev_get_drvdata(dev);
24         if (!card)
25                 return -EINVAL;
26
27         switch (card->state) {
28         case CARD_STATE_DOWN:
29                 return sprintf(buf, "DOWN\n");
30         case CARD_STATE_HARDSETUP:
31                 return sprintf(buf, "HARDSETUP\n");
32         case CARD_STATE_SOFTSETUP:
33                 return sprintf(buf, "SOFTSETUP\n");
34         case CARD_STATE_UP:
35                 if (card->lan_online)
36                 return sprintf(buf, "UP (LAN ONLINE)\n");
37                 else
38                         return sprintf(buf, "UP (LAN OFFLINE)\n");
39         case CARD_STATE_RECOVER:
40                 return sprintf(buf, "RECOVER\n");
41         default:
42                 return sprintf(buf, "UNKNOWN\n");
43         }
44 }
45
46 static DEVICE_ATTR(state, 0444, qeth_dev_state_show, NULL);
47
48 static ssize_t qeth_dev_chpid_show(struct device *dev,
49                                 struct device_attribute *attr, char *buf)
50 {
51         struct qeth_card *card = dev_get_drvdata(dev);
52         if (!card)
53                 return -EINVAL;
54
55         return sprintf(buf, "%02X\n", card->info.chpid);
56 }
57
58 static DEVICE_ATTR(chpid, 0444, qeth_dev_chpid_show, NULL);
59
60 static ssize_t qeth_dev_if_name_show(struct device *dev,
61                                 struct device_attribute *attr, char *buf)
62 {
63         struct qeth_card *card = dev_get_drvdata(dev);
64         if (!card)
65                 return -EINVAL;
66         return sprintf(buf, "%s\n", QETH_CARD_IFNAME(card));
67 }
68
69 static DEVICE_ATTR(if_name, 0444, qeth_dev_if_name_show, NULL);
70
71 static ssize_t qeth_dev_card_type_show(struct device *dev,
72                                 struct device_attribute *attr, char *buf)
73 {
74         struct qeth_card *card = dev_get_drvdata(dev);
75         if (!card)
76                 return -EINVAL;
77
78         return sprintf(buf, "%s\n", qeth_get_cardname_short(card));
79 }
80
81 static DEVICE_ATTR(card_type, 0444, qeth_dev_card_type_show, NULL);
82
83 static inline const char *qeth_get_bufsize_str(struct qeth_card *card)
84 {
85         if (card->qdio.in_buf_size == 16384)
86                 return "16k";
87         else if (card->qdio.in_buf_size == 24576)
88                 return "24k";
89         else if (card->qdio.in_buf_size == 32768)
90                 return "32k";
91         else if (card->qdio.in_buf_size == 40960)
92                 return "40k";
93         else
94                 return "64k";
95 }
96
97 static ssize_t qeth_dev_inbuf_size_show(struct device *dev,
98                                 struct device_attribute *attr, char *buf)
99 {
100         struct qeth_card *card = dev_get_drvdata(dev);
101         if (!card)
102                 return -EINVAL;
103
104         return sprintf(buf, "%s\n", qeth_get_bufsize_str(card));
105 }
106
107 static DEVICE_ATTR(inbuf_size, 0444, qeth_dev_inbuf_size_show, NULL);
108
109 static ssize_t qeth_dev_portno_show(struct device *dev,
110                         struct device_attribute *attr, char *buf)
111 {
112         struct qeth_card *card = dev_get_drvdata(dev);
113         if (!card)
114                 return -EINVAL;
115
116         return sprintf(buf, "%i\n", card->info.portno);
117 }
118
119 static ssize_t qeth_dev_portno_store(struct device *dev,
120                 struct device_attribute *attr, const char *buf, size_t count)
121 {
122         struct qeth_card *card = dev_get_drvdata(dev);
123         char *tmp;
124         unsigned int portno, limit;
125         int rc = 0;
126
127         if (!card)
128                 return -EINVAL;
129
130         mutex_lock(&card->conf_mutex);
131         if ((card->state != CARD_STATE_DOWN) &&
132             (card->state != CARD_STATE_RECOVER)) {
133                 rc = -EPERM;
134                 goto out;
135         }
136
137         portno = simple_strtoul(buf, &tmp, 16);
138         if (portno > QETH_MAX_PORTNO) {
139                 rc = -EINVAL;
140                 goto out;
141         }
142         limit = (card->ssqd.pcnt ? card->ssqd.pcnt - 1 : card->ssqd.pcnt);
143         if (portno > limit) {
144                 rc = -EINVAL;
145                 goto out;
146         }
147         card->info.portno = portno;
148 out:
149         mutex_unlock(&card->conf_mutex);
150         return rc ? rc : count;
151 }
152
153 static DEVICE_ATTR(portno, 0644, qeth_dev_portno_show, qeth_dev_portno_store);
154
155 static ssize_t qeth_dev_portname_show(struct device *dev,
156                                 struct device_attribute *attr, char *buf)
157 {
158         struct qeth_card *card = dev_get_drvdata(dev);
159         char portname[9] = {0, };
160
161         if (!card)
162                 return -EINVAL;
163
164         if (card->info.portname_required) {
165                 memcpy(portname, card->info.portname + 1, 8);
166                 EBCASC(portname, 8);
167                 return sprintf(buf, "%s\n", portname);
168         } else
169                 return sprintf(buf, "no portname required\n");
170 }
171
172 static ssize_t qeth_dev_portname_store(struct device *dev,
173                 struct device_attribute *attr, const char *buf, size_t count)
174 {
175         struct qeth_card *card = dev_get_drvdata(dev);
176         char *tmp;
177         int i, rc = 0;
178
179         if (!card)
180                 return -EINVAL;
181
182         mutex_lock(&card->conf_mutex);
183         if ((card->state != CARD_STATE_DOWN) &&
184             (card->state != CARD_STATE_RECOVER)) {
185                 rc = -EPERM;
186                 goto out;
187         }
188
189         tmp = strsep((char **) &buf, "\n");
190         if ((strlen(tmp) > 8) || (strlen(tmp) == 0)) {
191                 rc = -EINVAL;
192                 goto out;
193         }
194
195         card->info.portname[0] = strlen(tmp);
196         /* for beauty reasons */
197         for (i = 1; i < 9; i++)
198                 card->info.portname[i] = ' ';
199         strcpy(card->info.portname + 1, tmp);
200         ASCEBC(card->info.portname + 1, 8);
201 out:
202         mutex_unlock(&card->conf_mutex);
203         return rc ? rc : count;
204 }
205
206 static DEVICE_ATTR(portname, 0644, qeth_dev_portname_show,
207                 qeth_dev_portname_store);
208
209 static ssize_t qeth_dev_prioqing_show(struct device *dev,
210                                 struct device_attribute *attr, char *buf)
211 {
212         struct qeth_card *card = dev_get_drvdata(dev);
213
214         if (!card)
215                 return -EINVAL;
216
217         switch (card->qdio.do_prio_queueing) {
218         case QETH_PRIO_Q_ING_PREC:
219                 return sprintf(buf, "%s\n", "by precedence");
220         case QETH_PRIO_Q_ING_TOS:
221                 return sprintf(buf, "%s\n", "by type of service");
222         default:
223                 return sprintf(buf, "always queue %i\n",
224                                card->qdio.default_out_queue);
225         }
226 }
227
228 static ssize_t qeth_dev_prioqing_store(struct device *dev,
229                 struct device_attribute *attr, const char *buf, size_t count)
230 {
231         struct qeth_card *card = dev_get_drvdata(dev);
232         char *tmp;
233         int rc = 0;
234
235         if (!card)
236                 return -EINVAL;
237
238         mutex_lock(&card->conf_mutex);
239         if ((card->state != CARD_STATE_DOWN) &&
240             (card->state != CARD_STATE_RECOVER)) {
241                 rc = -EPERM;
242                 goto out;
243         }
244
245         /* check if 1920 devices are supported ,
246          * if though we have to permit priority queueing
247          */
248         if (card->qdio.no_out_queues == 1) {
249                 card->qdio.do_prio_queueing = QETH_PRIOQ_DEFAULT;
250                 rc = -EPERM;
251                 goto out;
252         }
253
254         tmp = strsep((char **) &buf, "\n");
255         if (!strcmp(tmp, "prio_queueing_prec"))
256                 card->qdio.do_prio_queueing = QETH_PRIO_Q_ING_PREC;
257         else if (!strcmp(tmp, "prio_queueing_tos"))
258                 card->qdio.do_prio_queueing = QETH_PRIO_Q_ING_TOS;
259         else if (!strcmp(tmp, "no_prio_queueing:0")) {
260                 card->qdio.do_prio_queueing = QETH_NO_PRIO_QUEUEING;
261                 card->qdio.default_out_queue = 0;
262         } else if (!strcmp(tmp, "no_prio_queueing:1")) {
263                 card->qdio.do_prio_queueing = QETH_NO_PRIO_QUEUEING;
264                 card->qdio.default_out_queue = 1;
265         } else if (!strcmp(tmp, "no_prio_queueing:2")) {
266                 card->qdio.do_prio_queueing = QETH_NO_PRIO_QUEUEING;
267                 card->qdio.default_out_queue = 2;
268         } else if (!strcmp(tmp, "no_prio_queueing:3")) {
269                 card->qdio.do_prio_queueing = QETH_NO_PRIO_QUEUEING;
270                 card->qdio.default_out_queue = 3;
271         } else if (!strcmp(tmp, "no_prio_queueing")) {
272                 card->qdio.do_prio_queueing = QETH_NO_PRIO_QUEUEING;
273                 card->qdio.default_out_queue = QETH_DEFAULT_QUEUE;
274         } else
275                 rc = -EINVAL;
276 out:
277         mutex_unlock(&card->conf_mutex);
278         return rc ? rc : count;
279 }
280
281 static DEVICE_ATTR(priority_queueing, 0644, qeth_dev_prioqing_show,
282                 qeth_dev_prioqing_store);
283
284 static ssize_t qeth_dev_bufcnt_show(struct device *dev,
285                                 struct device_attribute *attr, char *buf)
286 {
287         struct qeth_card *card = dev_get_drvdata(dev);
288
289         if (!card)
290                 return -EINVAL;
291
292         return sprintf(buf, "%i\n", card->qdio.in_buf_pool.buf_count);
293 }
294
295 static ssize_t qeth_dev_bufcnt_store(struct device *dev,
296                 struct device_attribute *attr, const char *buf, size_t count)
297 {
298         struct qeth_card *card = dev_get_drvdata(dev);
299         char *tmp;
300         int cnt, old_cnt;
301         int rc = 0;
302
303         if (!card)
304                 return -EINVAL;
305
306         mutex_lock(&card->conf_mutex);
307         if ((card->state != CARD_STATE_DOWN) &&
308             (card->state != CARD_STATE_RECOVER)) {
309                 rc = -EPERM;
310                 goto out;
311         }
312
313         old_cnt = card->qdio.in_buf_pool.buf_count;
314         cnt = simple_strtoul(buf, &tmp, 10);
315         cnt = (cnt < QETH_IN_BUF_COUNT_MIN) ? QETH_IN_BUF_COUNT_MIN :
316                 ((cnt > QETH_IN_BUF_COUNT_MAX) ? QETH_IN_BUF_COUNT_MAX : cnt);
317         if (old_cnt != cnt) {
318                 rc = qeth_realloc_buffer_pool(card, cnt);
319         }
320 out:
321         mutex_unlock(&card->conf_mutex);
322         return rc ? rc : count;
323 }
324
325 static DEVICE_ATTR(buffer_count, 0644, qeth_dev_bufcnt_show,
326                 qeth_dev_bufcnt_store);
327
328 static ssize_t qeth_dev_recover_store(struct device *dev,
329                 struct device_attribute *attr, const char *buf, size_t count)
330 {
331         struct qeth_card *card = dev_get_drvdata(dev);
332         char *tmp;
333         int i;
334
335         if (!card)
336                 return -EINVAL;
337
338         if (card->state != CARD_STATE_UP)
339                 return -EPERM;
340
341         i = simple_strtoul(buf, &tmp, 16);
342         if (i == 1)
343                 qeth_schedule_recovery(card);
344
345         return count;
346 }
347
348 static DEVICE_ATTR(recover, 0200, NULL, qeth_dev_recover_store);
349
350 static ssize_t qeth_dev_performance_stats_show(struct device *dev,
351                                 struct device_attribute *attr, char *buf)
352 {
353         struct qeth_card *card = dev_get_drvdata(dev);
354
355         if (!card)
356                 return -EINVAL;
357
358         return sprintf(buf, "%i\n", card->options.performance_stats ? 1:0);
359 }
360
361 static ssize_t qeth_dev_performance_stats_store(struct device *dev,
362                 struct device_attribute *attr, const char *buf, size_t count)
363 {
364         struct qeth_card *card = dev_get_drvdata(dev);
365         char *tmp;
366         int i, rc = 0;
367
368         if (!card)
369                 return -EINVAL;
370
371         mutex_lock(&card->conf_mutex);
372         i = simple_strtoul(buf, &tmp, 16);
373         if ((i == 0) || (i == 1)) {
374                 if (i == card->options.performance_stats)
375                         goto out;;
376                 card->options.performance_stats = i;
377                 if (i == 0)
378                         memset(&card->perf_stats, 0,
379                                 sizeof(struct qeth_perf_stats));
380                 card->perf_stats.initial_rx_packets = card->stats.rx_packets;
381                 card->perf_stats.initial_tx_packets = card->stats.tx_packets;
382         } else
383                 rc = -EINVAL;
384 out:
385         mutex_unlock(&card->conf_mutex);
386         return rc ? rc : count;
387 }
388
389 static DEVICE_ATTR(performance_stats, 0644, qeth_dev_performance_stats_show,
390                    qeth_dev_performance_stats_store);
391
392 static ssize_t qeth_dev_layer2_show(struct device *dev,
393                 struct device_attribute *attr, char *buf)
394 {
395         struct qeth_card *card = dev_get_drvdata(dev);
396
397         if (!card)
398                 return -EINVAL;
399
400         return sprintf(buf, "%i\n", card->options.layer2);
401 }
402
403 static ssize_t qeth_dev_layer2_store(struct device *dev,
404                 struct device_attribute *attr, const char *buf, size_t count)
405 {
406         struct qeth_card *card = dev_get_drvdata(dev);
407         char *tmp;
408         int i, rc = 0;
409         enum qeth_discipline_id newdis;
410
411         if (!card)
412                 return -EINVAL;
413
414         mutex_lock(&card->discipline_mutex);
415         if (card->state != CARD_STATE_DOWN) {
416                 rc = -EPERM;
417                 goto out;
418         }
419
420         i = simple_strtoul(buf, &tmp, 16);
421         switch (i) {
422         case 0:
423                 newdis = QETH_DISCIPLINE_LAYER3;
424                 break;
425         case 1:
426                 newdis = QETH_DISCIPLINE_LAYER2;
427                 break;
428         default:
429                 rc = -EINVAL;
430                 goto out;
431         }
432
433         if (card->options.layer2 == newdis)
434                 goto out;
435         else {
436                 card->info.mac_bits  = 0;
437                 if (card->discipline.ccwgdriver) {
438                         card->discipline.ccwgdriver->remove(card->gdev);
439                         qeth_core_free_discipline(card);
440                 }
441         }
442
443         rc = qeth_core_load_discipline(card, newdis);
444         if (rc)
445                 goto out;
446
447         rc = card->discipline.ccwgdriver->probe(card->gdev);
448 out:
449         mutex_unlock(&card->discipline_mutex);
450         return rc ? rc : count;
451 }
452
453 static DEVICE_ATTR(layer2, 0644, qeth_dev_layer2_show,
454                    qeth_dev_layer2_store);
455
456 #define ATTR_QETH_ISOLATION_NONE        ("none")
457 #define ATTR_QETH_ISOLATION_FWD         ("forward")
458 #define ATTR_QETH_ISOLATION_DROP        ("drop")
459
460 static ssize_t qeth_dev_isolation_show(struct device *dev,
461                                 struct device_attribute *attr, char *buf)
462 {
463         struct qeth_card *card = dev_get_drvdata(dev);
464
465         if (!card)
466                 return -EINVAL;
467
468         switch (card->options.isolation) {
469         case ISOLATION_MODE_NONE:
470                 return snprintf(buf, 6, "%s\n", ATTR_QETH_ISOLATION_NONE);
471         case ISOLATION_MODE_FWD:
472                 return snprintf(buf, 9, "%s\n", ATTR_QETH_ISOLATION_FWD);
473         case ISOLATION_MODE_DROP:
474                 return snprintf(buf, 6, "%s\n", ATTR_QETH_ISOLATION_DROP);
475         default:
476                 return snprintf(buf, 5, "%s\n", "N/A");
477         }
478 }
479
480 static ssize_t qeth_dev_isolation_store(struct device *dev,
481                 struct device_attribute *attr, const char *buf, size_t count)
482 {
483         struct qeth_card *card = dev_get_drvdata(dev);
484         enum qeth_ipa_isolation_modes isolation;
485         int rc = 0;
486         char *tmp, *curtoken;
487         curtoken = (char *) buf;
488
489         if (!card)
490                 return -EINVAL;
491
492         mutex_lock(&card->conf_mutex);
493         /* check for unknown, too, in case we do not yet know who we are */
494         if (card->info.type != QETH_CARD_TYPE_OSD &&
495             card->info.type != QETH_CARD_TYPE_OSX &&
496             card->info.type != QETH_CARD_TYPE_UNKNOWN) {
497                 rc = -EOPNOTSUPP;
498                 dev_err(&card->gdev->dev, "Adapter does not "
499                         "support QDIO data connection isolation\n");
500                 goto out;
501         }
502
503         /* parse input into isolation mode */
504         tmp = strsep(&curtoken, "\n");
505         if (!strcmp(tmp, ATTR_QETH_ISOLATION_NONE)) {
506                 isolation = ISOLATION_MODE_NONE;
507         } else if (!strcmp(tmp, ATTR_QETH_ISOLATION_FWD)) {
508                 isolation = ISOLATION_MODE_FWD;
509         } else if (!strcmp(tmp, ATTR_QETH_ISOLATION_DROP)) {
510                 isolation = ISOLATION_MODE_DROP;
511         } else {
512                 rc = -EINVAL;
513                 goto out;
514         }
515         rc = count;
516
517         /* defer IP assist if device is offline (until discipline->set_online)*/
518         card->options.isolation = isolation;
519         if (card->state == CARD_STATE_SOFTSETUP ||
520             card->state == CARD_STATE_UP) {
521                 int ipa_rc = qeth_set_access_ctrl_online(card);
522                 if (ipa_rc != 0)
523                         rc = ipa_rc;
524         }
525 out:
526         mutex_unlock(&card->conf_mutex);
527         return rc;
528 }
529
530 static DEVICE_ATTR(isolation, 0644, qeth_dev_isolation_show,
531                    qeth_dev_isolation_store);
532
533 static ssize_t qeth_dev_blkt_show(char *buf, struct qeth_card *card, int value)
534 {
535
536         if (!card)
537                 return -EINVAL;
538
539         return sprintf(buf, "%i\n", value);
540 }
541
542 static ssize_t qeth_dev_blkt_store(struct qeth_card *card,
543                 const char *buf, size_t count, int *value, int max_value)
544 {
545         char *tmp;
546         int i, rc = 0;
547
548         if (!card)
549                 return -EINVAL;
550
551         mutex_lock(&card->conf_mutex);
552         if ((card->state != CARD_STATE_DOWN) &&
553             (card->state != CARD_STATE_RECOVER)) {
554                 rc = -EPERM;
555                 goto out;
556         }
557         i = simple_strtoul(buf, &tmp, 10);
558         if (i <= max_value)
559                 *value = i;
560         else
561                 rc = -EINVAL;
562 out:
563         mutex_unlock(&card->conf_mutex);
564         return rc ? rc : count;
565 }
566
567 static ssize_t qeth_dev_blkt_total_show(struct device *dev,
568                                 struct device_attribute *attr, char *buf)
569 {
570         struct qeth_card *card = dev_get_drvdata(dev);
571
572         return qeth_dev_blkt_show(buf, card, card->info.blkt.time_total);
573 }
574
575 static ssize_t qeth_dev_blkt_total_store(struct device *dev,
576                 struct device_attribute *attr, const char *buf, size_t count)
577 {
578         struct qeth_card *card = dev_get_drvdata(dev);
579
580         return qeth_dev_blkt_store(card, buf, count,
581                                    &card->info.blkt.time_total, 5000);
582 }
583
584
585
586 static DEVICE_ATTR(total, 0644, qeth_dev_blkt_total_show,
587                    qeth_dev_blkt_total_store);
588
589 static ssize_t qeth_dev_blkt_inter_show(struct device *dev,
590                                 struct device_attribute *attr, char *buf)
591 {
592         struct qeth_card *card = dev_get_drvdata(dev);
593
594         return qeth_dev_blkt_show(buf, card, card->info.blkt.inter_packet);
595 }
596
597 static ssize_t qeth_dev_blkt_inter_store(struct device *dev,
598                 struct device_attribute *attr, const char *buf, size_t count)
599 {
600         struct qeth_card *card = dev_get_drvdata(dev);
601
602         return qeth_dev_blkt_store(card, buf, count,
603                                    &card->info.blkt.inter_packet, 1000);
604 }
605
606 static DEVICE_ATTR(inter, 0644, qeth_dev_blkt_inter_show,
607                    qeth_dev_blkt_inter_store);
608
609 static ssize_t qeth_dev_blkt_inter_jumbo_show(struct device *dev,
610                                 struct device_attribute *attr, char *buf)
611 {
612         struct qeth_card *card = dev_get_drvdata(dev);
613
614         return qeth_dev_blkt_show(buf, card,
615                                   card->info.blkt.inter_packet_jumbo);
616 }
617
618 static ssize_t qeth_dev_blkt_inter_jumbo_store(struct device *dev,
619                 struct device_attribute *attr, const char *buf, size_t count)
620 {
621         struct qeth_card *card = dev_get_drvdata(dev);
622
623         return qeth_dev_blkt_store(card, buf, count,
624                                    &card->info.blkt.inter_packet_jumbo, 1000);
625 }
626
627 static DEVICE_ATTR(inter_jumbo, 0644, qeth_dev_blkt_inter_jumbo_show,
628                    qeth_dev_blkt_inter_jumbo_store);
629
630 static struct attribute *qeth_blkt_device_attrs[] = {
631         &dev_attr_total.attr,
632         &dev_attr_inter.attr,
633         &dev_attr_inter_jumbo.attr,
634         NULL,
635 };
636
637 static struct attribute_group qeth_device_blkt_group = {
638         .name = "blkt",
639         .attrs = qeth_blkt_device_attrs,
640 };
641
642 static struct attribute *qeth_device_attrs[] = {
643         &dev_attr_state.attr,
644         &dev_attr_chpid.attr,
645         &dev_attr_if_name.attr,
646         &dev_attr_card_type.attr,
647         &dev_attr_inbuf_size.attr,
648         &dev_attr_portno.attr,
649         &dev_attr_portname.attr,
650         &dev_attr_priority_queueing.attr,
651         &dev_attr_buffer_count.attr,
652         &dev_attr_recover.attr,
653         &dev_attr_performance_stats.attr,
654         &dev_attr_layer2.attr,
655         &dev_attr_isolation.attr,
656         NULL,
657 };
658
659 static struct attribute_group qeth_device_attr_group = {
660         .attrs = qeth_device_attrs,
661 };
662
663 static struct attribute *qeth_osn_device_attrs[] = {
664         &dev_attr_state.attr,
665         &dev_attr_chpid.attr,
666         &dev_attr_if_name.attr,
667         &dev_attr_card_type.attr,
668         &dev_attr_buffer_count.attr,
669         &dev_attr_recover.attr,
670         NULL,
671 };
672
673 static struct attribute_group qeth_osn_device_attr_group = {
674         .attrs = qeth_osn_device_attrs,
675 };
676
677 int qeth_core_create_device_attributes(struct device *dev)
678 {
679         int ret;
680         ret = sysfs_create_group(&dev->kobj, &qeth_device_attr_group);
681         if (ret)
682                 return ret;
683         ret = sysfs_create_group(&dev->kobj, &qeth_device_blkt_group);
684         if (ret)
685                 sysfs_remove_group(&dev->kobj, &qeth_device_attr_group);
686
687         return 0;
688 }
689
690 void qeth_core_remove_device_attributes(struct device *dev)
691 {
692         sysfs_remove_group(&dev->kobj, &qeth_device_attr_group);
693         sysfs_remove_group(&dev->kobj, &qeth_device_blkt_group);
694 }
695
696 int qeth_core_create_osn_attributes(struct device *dev)
697 {
698         return sysfs_create_group(&dev->kobj, &qeth_osn_device_attr_group);
699 }
700
701 void qeth_core_remove_osn_attributes(struct device *dev)
702 {
703         sysfs_remove_group(&dev->kobj, &qeth_osn_device_attr_group);
704         return;
705 }