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