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