1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34#include <linux/ctype.h>
35
36#include "ipath_kernel.h"
37#include "ipath_verbs.h"
38#include "ipath_common.h"
39
40
41
42
43
44
45
46
47int ipath_parse_ushort(const char *str, unsigned short *valp)
48{
49 unsigned long val;
50 char *end;
51 int ret;
52
53 if (!isdigit(str[0])) {
54 ret = -EINVAL;
55 goto bail;
56 }
57
58 val = simple_strtoul(str, &end, 0);
59
60 if (val > 0xffff) {
61 ret = -EINVAL;
62 goto bail;
63 }
64
65 *valp = val;
66
67 ret = end + 1 - str;
68 if (ret == 0)
69 ret = -EINVAL;
70
71bail:
72 return ret;
73}
74
75static ssize_t show_version(struct device_driver *dev, char *buf)
76{
77
78 return scnprintf(buf, PAGE_SIZE, "%s", ib_ipath_version);
79}
80
81static ssize_t show_num_units(struct device_driver *dev, char *buf)
82{
83 return scnprintf(buf, PAGE_SIZE, "%d\n",
84 ipath_count_units(NULL, NULL, NULL));
85}
86
87static ssize_t show_status(struct device *dev,
88 struct device_attribute *attr,
89 char *buf)
90{
91 struct ipath_devdata *dd = dev_get_drvdata(dev);
92 ssize_t ret;
93
94 if (!dd->ipath_statusp) {
95 ret = -EINVAL;
96 goto bail;
97 }
98
99 ret = scnprintf(buf, PAGE_SIZE, "0x%llx\n",
100 (unsigned long long) *(dd->ipath_statusp));
101
102bail:
103 return ret;
104}
105
106static const char *ipath_status_str[] = {
107 "Initted",
108 "Disabled",
109 "Admin_Disabled",
110 "",
111 "",
112 "Present",
113 "IB_link_up",
114 "IB_configured",
115 "NoIBcable",
116 "Fatal_Hardware_Error",
117 NULL,
118};
119
120static ssize_t show_status_str(struct device *dev,
121 struct device_attribute *attr,
122 char *buf)
123{
124 struct ipath_devdata *dd = dev_get_drvdata(dev);
125 int i, any;
126 u64 s;
127 ssize_t ret;
128
129 if (!dd->ipath_statusp) {
130 ret = -EINVAL;
131 goto bail;
132 }
133
134 s = *(dd->ipath_statusp);
135 *buf = '\0';
136 for (any = i = 0; s && ipath_status_str[i]; i++) {
137 if (s & 1) {
138 if (any && strlcat(buf, " ", PAGE_SIZE) >=
139 PAGE_SIZE)
140
141 break;
142 if (strlcat(buf, ipath_status_str[i],
143 PAGE_SIZE) >= PAGE_SIZE)
144 break;
145 any = 1;
146 }
147 s >>= 1;
148 }
149 if (any)
150 strlcat(buf, "\n", PAGE_SIZE);
151
152 ret = strlen(buf);
153
154bail:
155 return ret;
156}
157
158static ssize_t show_boardversion(struct device *dev,
159 struct device_attribute *attr,
160 char *buf)
161{
162 struct ipath_devdata *dd = dev_get_drvdata(dev);
163
164 return scnprintf(buf, PAGE_SIZE, "%s", dd->ipath_boardversion);
165}
166
167static ssize_t show_localbus_info(struct device *dev,
168 struct device_attribute *attr,
169 char *buf)
170{
171 struct ipath_devdata *dd = dev_get_drvdata(dev);
172
173 return scnprintf(buf, PAGE_SIZE, "%s", dd->ipath_lbus_info);
174}
175
176static ssize_t show_lmc(struct device *dev,
177 struct device_attribute *attr,
178 char *buf)
179{
180 struct ipath_devdata *dd = dev_get_drvdata(dev);
181
182 return scnprintf(buf, PAGE_SIZE, "%u\n", dd->ipath_lmc);
183}
184
185static ssize_t store_lmc(struct device *dev,
186 struct device_attribute *attr,
187 const char *buf,
188 size_t count)
189{
190 struct ipath_devdata *dd = dev_get_drvdata(dev);
191 u16 lmc = 0;
192 int ret;
193
194 ret = ipath_parse_ushort(buf, &lmc);
195 if (ret < 0)
196 goto invalid;
197
198 if (lmc > 7) {
199 ret = -EINVAL;
200 goto invalid;
201 }
202
203 ipath_set_lid(dd, dd->ipath_lid, lmc);
204
205 goto bail;
206invalid:
207 ipath_dev_err(dd, "attempt to set invalid LMC %u\n", lmc);
208bail:
209 return ret;
210}
211
212static ssize_t show_lid(struct device *dev,
213 struct device_attribute *attr,
214 char *buf)
215{
216 struct ipath_devdata *dd = dev_get_drvdata(dev);
217
218 return scnprintf(buf, PAGE_SIZE, "0x%x\n", dd->ipath_lid);
219}
220
221static ssize_t store_lid(struct device *dev,
222 struct device_attribute *attr,
223 const char *buf,
224 size_t count)
225{
226 struct ipath_devdata *dd = dev_get_drvdata(dev);
227 u16 lid = 0;
228 int ret;
229
230 ret = ipath_parse_ushort(buf, &lid);
231 if (ret < 0)
232 goto invalid;
233
234 if (lid == 0 || lid >= IPATH_MULTICAST_LID_BASE) {
235 ret = -EINVAL;
236 goto invalid;
237 }
238
239 ipath_set_lid(dd, lid, dd->ipath_lmc);
240
241 goto bail;
242invalid:
243 ipath_dev_err(dd, "attempt to set invalid LID 0x%x\n", lid);
244bail:
245 return ret;
246}
247
248static ssize_t show_mlid(struct device *dev,
249 struct device_attribute *attr,
250 char *buf)
251{
252 struct ipath_devdata *dd = dev_get_drvdata(dev);
253
254 return scnprintf(buf, PAGE_SIZE, "0x%x\n", dd->ipath_mlid);
255}
256
257static ssize_t store_mlid(struct device *dev,
258 struct device_attribute *attr,
259 const char *buf,
260 size_t count)
261{
262 struct ipath_devdata *dd = dev_get_drvdata(dev);
263 u16 mlid;
264 int ret;
265
266 ret = ipath_parse_ushort(buf, &mlid);
267 if (ret < 0 || mlid < IPATH_MULTICAST_LID_BASE)
268 goto invalid;
269
270 dd->ipath_mlid = mlid;
271
272 goto bail;
273invalid:
274 ipath_dev_err(dd, "attempt to set invalid MLID\n");
275bail:
276 return ret;
277}
278
279static ssize_t show_guid(struct device *dev,
280 struct device_attribute *attr,
281 char *buf)
282{
283 struct ipath_devdata *dd = dev_get_drvdata(dev);
284 u8 *guid;
285
286 guid = (u8 *) & (dd->ipath_guid);
287
288 return scnprintf(buf, PAGE_SIZE,
289 "%02x:%02x:%02x:%02x:%02x:%02x:%02x:%02x\n",
290 guid[0], guid[1], guid[2], guid[3],
291 guid[4], guid[5], guid[6], guid[7]);
292}
293
294static ssize_t store_guid(struct device *dev,
295 struct device_attribute *attr,
296 const char *buf,
297 size_t count)
298{
299 struct ipath_devdata *dd = dev_get_drvdata(dev);
300 ssize_t ret;
301 unsigned short guid[8];
302 __be64 new_guid;
303 u8 *ng;
304 int i;
305
306 if (sscanf(buf, "%hx:%hx:%hx:%hx:%hx:%hx:%hx:%hx",
307 &guid[0], &guid[1], &guid[2], &guid[3],
308 &guid[4], &guid[5], &guid[6], &guid[7]) != 8)
309 goto invalid;
310
311 ng = (u8 *) &new_guid;
312
313 for (i = 0; i < 8; i++) {
314 if (guid[i] > 0xff)
315 goto invalid;
316 ng[i] = guid[i];
317 }
318
319 if (new_guid == 0)
320 goto invalid;
321
322 dd->ipath_guid = new_guid;
323 dd->ipath_nguid = 1;
324 if (dd->verbs_dev)
325 dd->verbs_dev->ibdev.node_guid = new_guid;
326
327 ret = strlen(buf);
328 goto bail;
329
330invalid:
331 ipath_dev_err(dd, "attempt to set invalid GUID\n");
332 ret = -EINVAL;
333
334bail:
335 return ret;
336}
337
338static ssize_t show_nguid(struct device *dev,
339 struct device_attribute *attr,
340 char *buf)
341{
342 struct ipath_devdata *dd = dev_get_drvdata(dev);
343
344 return scnprintf(buf, PAGE_SIZE, "%u\n", dd->ipath_nguid);
345}
346
347static ssize_t show_nports(struct device *dev,
348 struct device_attribute *attr,
349 char *buf)
350{
351 struct ipath_devdata *dd = dev_get_drvdata(dev);
352
353
354 return scnprintf(buf, PAGE_SIZE, "%u\n", dd->ipath_cfgports - 1);
355}
356
357static ssize_t show_serial(struct device *dev,
358 struct device_attribute *attr,
359 char *buf)
360{
361 struct ipath_devdata *dd = dev_get_drvdata(dev);
362
363 buf[sizeof dd->ipath_serial] = '\0';
364 memcpy(buf, dd->ipath_serial, sizeof dd->ipath_serial);
365 strcat(buf, "\n");
366 return strlen(buf);
367}
368
369static ssize_t show_unit(struct device *dev,
370 struct device_attribute *attr,
371 char *buf)
372{
373 struct ipath_devdata *dd = dev_get_drvdata(dev);
374
375 return scnprintf(buf, PAGE_SIZE, "%u\n", dd->ipath_unit);
376}
377
378static ssize_t show_jint_max_packets(struct device *dev,
379 struct device_attribute *attr,
380 char *buf)
381{
382 struct ipath_devdata *dd = dev_get_drvdata(dev);
383
384 return scnprintf(buf, PAGE_SIZE, "%hu\n", dd->ipath_jint_max_packets);
385}
386
387static ssize_t store_jint_max_packets(struct device *dev,
388 struct device_attribute *attr,
389 const char *buf,
390 size_t count)
391{
392 struct ipath_devdata *dd = dev_get_drvdata(dev);
393 u16 v = 0;
394 int ret;
395
396 ret = ipath_parse_ushort(buf, &v);
397 if (ret < 0)
398 ipath_dev_err(dd, "invalid jint_max_packets.\n");
399 else
400 dd->ipath_f_config_jint(dd, dd->ipath_jint_idle_ticks, v);
401
402 return ret;
403}
404
405static ssize_t show_jint_idle_ticks(struct device *dev,
406 struct device_attribute *attr,
407 char *buf)
408{
409 struct ipath_devdata *dd = dev_get_drvdata(dev);
410
411 return scnprintf(buf, PAGE_SIZE, "%hu\n", dd->ipath_jint_idle_ticks);
412}
413
414static ssize_t store_jint_idle_ticks(struct device *dev,
415 struct device_attribute *attr,
416 const char *buf,
417 size_t count)
418{
419 struct ipath_devdata *dd = dev_get_drvdata(dev);
420 u16 v = 0;
421 int ret;
422
423 ret = ipath_parse_ushort(buf, &v);
424 if (ret < 0)
425 ipath_dev_err(dd, "invalid jint_idle_ticks.\n");
426 else
427 dd->ipath_f_config_jint(dd, v, dd->ipath_jint_max_packets);
428
429 return ret;
430}
431
432#define DEVICE_COUNTER(name, attr) \
433 static ssize_t show_counter_##name(struct device *dev, \
434 struct device_attribute *attr, \
435 char *buf) \
436 { \
437 struct ipath_devdata *dd = dev_get_drvdata(dev); \
438 return scnprintf(\
439 buf, PAGE_SIZE, "%llu\n", (unsigned long long) \
440 ipath_snap_cntr( \
441 dd, offsetof(struct infinipath_counters, \
442 attr) / sizeof(u64))); \
443 } \
444 static DEVICE_ATTR(name, S_IRUGO, show_counter_##name, NULL);
445
446DEVICE_COUNTER(ib_link_downeds, IBLinkDownedCnt);
447DEVICE_COUNTER(ib_link_err_recoveries, IBLinkErrRecoveryCnt);
448DEVICE_COUNTER(ib_status_changes, IBStatusChangeCnt);
449DEVICE_COUNTER(ib_symbol_errs, IBSymbolErrCnt);
450DEVICE_COUNTER(lb_flow_stalls, LBFlowStallCnt);
451DEVICE_COUNTER(lb_ints, LBIntCnt);
452DEVICE_COUNTER(rx_bad_formats, RxBadFormatCnt);
453DEVICE_COUNTER(rx_buf_ovfls, RxBufOvflCnt);
454DEVICE_COUNTER(rx_data_pkts, RxDataPktCnt);
455DEVICE_COUNTER(rx_dropped_pkts, RxDroppedPktCnt);
456DEVICE_COUNTER(rx_dwords, RxDwordCnt);
457DEVICE_COUNTER(rx_ebps, RxEBPCnt);
458DEVICE_COUNTER(rx_flow_ctrl_errs, RxFlowCtrlErrCnt);
459DEVICE_COUNTER(rx_flow_pkts, RxFlowPktCnt);
460DEVICE_COUNTER(rx_icrc_errs, RxICRCErrCnt);
461DEVICE_COUNTER(rx_len_errs, RxLenErrCnt);
462DEVICE_COUNTER(rx_link_problems, RxLinkProblemCnt);
463DEVICE_COUNTER(rx_lpcrc_errs, RxLPCRCErrCnt);
464DEVICE_COUNTER(rx_max_min_len_errs, RxMaxMinLenErrCnt);
465DEVICE_COUNTER(rx_p0_hdr_egr_ovfls, RxP0HdrEgrOvflCnt);
466DEVICE_COUNTER(rx_p1_hdr_egr_ovfls, RxP1HdrEgrOvflCnt);
467DEVICE_COUNTER(rx_p2_hdr_egr_ovfls, RxP2HdrEgrOvflCnt);
468DEVICE_COUNTER(rx_p3_hdr_egr_ovfls, RxP3HdrEgrOvflCnt);
469DEVICE_COUNTER(rx_p4_hdr_egr_ovfls, RxP4HdrEgrOvflCnt);
470DEVICE_COUNTER(rx_p5_hdr_egr_ovfls, RxP5HdrEgrOvflCnt);
471DEVICE_COUNTER(rx_p6_hdr_egr_ovfls, RxP6HdrEgrOvflCnt);
472DEVICE_COUNTER(rx_p7_hdr_egr_ovfls, RxP7HdrEgrOvflCnt);
473DEVICE_COUNTER(rx_p8_hdr_egr_ovfls, RxP8HdrEgrOvflCnt);
474DEVICE_COUNTER(rx_pkey_mismatches, RxPKeyMismatchCnt);
475DEVICE_COUNTER(rx_tid_full_errs, RxTIDFullErrCnt);
476DEVICE_COUNTER(rx_tid_valid_errs, RxTIDValidErrCnt);
477DEVICE_COUNTER(rx_vcrc_errs, RxVCRCErrCnt);
478DEVICE_COUNTER(tx_data_pkts, TxDataPktCnt);
479DEVICE_COUNTER(tx_dropped_pkts, TxDroppedPktCnt);
480DEVICE_COUNTER(tx_dwords, TxDwordCnt);
481DEVICE_COUNTER(tx_flow_pkts, TxFlowPktCnt);
482DEVICE_COUNTER(tx_flow_stalls, TxFlowStallCnt);
483DEVICE_COUNTER(tx_len_errs, TxLenErrCnt);
484DEVICE_COUNTER(tx_max_min_len_errs, TxMaxMinLenErrCnt);
485DEVICE_COUNTER(tx_underruns, TxUnderrunCnt);
486DEVICE_COUNTER(tx_unsup_vl_errs, TxUnsupVLErrCnt);
487
488static struct attribute *dev_counter_attributes[] = {
489 &dev_attr_ib_link_downeds.attr,
490 &dev_attr_ib_link_err_recoveries.attr,
491 &dev_attr_ib_status_changes.attr,
492 &dev_attr_ib_symbol_errs.attr,
493 &dev_attr_lb_flow_stalls.attr,
494 &dev_attr_lb_ints.attr,
495 &dev_attr_rx_bad_formats.attr,
496 &dev_attr_rx_buf_ovfls.attr,
497 &dev_attr_rx_data_pkts.attr,
498 &dev_attr_rx_dropped_pkts.attr,
499 &dev_attr_rx_dwords.attr,
500 &dev_attr_rx_ebps.attr,
501 &dev_attr_rx_flow_ctrl_errs.attr,
502 &dev_attr_rx_flow_pkts.attr,
503 &dev_attr_rx_icrc_errs.attr,
504 &dev_attr_rx_len_errs.attr,
505 &dev_attr_rx_link_problems.attr,
506 &dev_attr_rx_lpcrc_errs.attr,
507 &dev_attr_rx_max_min_len_errs.attr,
508 &dev_attr_rx_p0_hdr_egr_ovfls.attr,
509 &dev_attr_rx_p1_hdr_egr_ovfls.attr,
510 &dev_attr_rx_p2_hdr_egr_ovfls.attr,
511 &dev_attr_rx_p3_hdr_egr_ovfls.attr,
512 &dev_attr_rx_p4_hdr_egr_ovfls.attr,
513 &dev_attr_rx_p5_hdr_egr_ovfls.attr,
514 &dev_attr_rx_p6_hdr_egr_ovfls.attr,
515 &dev_attr_rx_p7_hdr_egr_ovfls.attr,
516 &dev_attr_rx_p8_hdr_egr_ovfls.attr,
517 &dev_attr_rx_pkey_mismatches.attr,
518 &dev_attr_rx_tid_full_errs.attr,
519 &dev_attr_rx_tid_valid_errs.attr,
520 &dev_attr_rx_vcrc_errs.attr,
521 &dev_attr_tx_data_pkts.attr,
522 &dev_attr_tx_dropped_pkts.attr,
523 &dev_attr_tx_dwords.attr,
524 &dev_attr_tx_flow_pkts.attr,
525 &dev_attr_tx_flow_stalls.attr,
526 &dev_attr_tx_len_errs.attr,
527 &dev_attr_tx_max_min_len_errs.attr,
528 &dev_attr_tx_underruns.attr,
529 &dev_attr_tx_unsup_vl_errs.attr,
530 NULL
531};
532
533static struct attribute_group dev_counter_attr_group = {
534 .name = "counters",
535 .attrs = dev_counter_attributes
536};
537
538static ssize_t store_reset(struct device *dev,
539 struct device_attribute *attr,
540 const char *buf,
541 size_t count)
542{
543 struct ipath_devdata *dd = dev_get_drvdata(dev);
544 int ret;
545
546 if (count < 5 || memcmp(buf, "reset", 5)) {
547 ret = -EINVAL;
548 goto bail;
549 }
550
551 if (dd->ipath_flags & IPATH_DISABLED) {
552
553
554
555
556
557 dev_info(dev,"Unit %d is disabled, can't reset\n",
558 dd->ipath_unit);
559 ret = -EINVAL;
560 }
561 ret = ipath_reset_device(dd->ipath_unit);
562bail:
563 return ret<0 ? ret : count;
564}
565
566static ssize_t store_link_state(struct device *dev,
567 struct device_attribute *attr,
568 const char *buf,
569 size_t count)
570{
571 struct ipath_devdata *dd = dev_get_drvdata(dev);
572 int ret, r;
573 u16 state;
574
575 ret = ipath_parse_ushort(buf, &state);
576 if (ret < 0)
577 goto invalid;
578
579 r = ipath_set_linkstate(dd, state);
580 if (r < 0) {
581 ret = r;
582 goto bail;
583 }
584
585 goto bail;
586invalid:
587 ipath_dev_err(dd, "attempt to set invalid link state\n");
588bail:
589 return ret;
590}
591
592static ssize_t show_mtu(struct device *dev,
593 struct device_attribute *attr,
594 char *buf)
595{
596 struct ipath_devdata *dd = dev_get_drvdata(dev);
597 return scnprintf(buf, PAGE_SIZE, "%u\n", dd->ipath_ibmtu);
598}
599
600static ssize_t store_mtu(struct device *dev,
601 struct device_attribute *attr,
602 const char *buf,
603 size_t count)
604{
605 struct ipath_devdata *dd = dev_get_drvdata(dev);
606 ssize_t ret;
607 u16 mtu = 0;
608 int r;
609
610 ret = ipath_parse_ushort(buf, &mtu);
611 if (ret < 0)
612 goto invalid;
613
614 r = ipath_set_mtu(dd, mtu);
615 if (r < 0)
616 ret = r;
617
618 goto bail;
619invalid:
620 ipath_dev_err(dd, "attempt to set invalid MTU\n");
621bail:
622 return ret;
623}
624
625static ssize_t show_enabled(struct device *dev,
626 struct device_attribute *attr,
627 char *buf)
628{
629 struct ipath_devdata *dd = dev_get_drvdata(dev);
630 return scnprintf(buf, PAGE_SIZE, "%u\n",
631 (dd->ipath_flags & IPATH_DISABLED) ? 0 : 1);
632}
633
634static ssize_t store_enabled(struct device *dev,
635 struct device_attribute *attr,
636 const char *buf,
637 size_t count)
638{
639 struct ipath_devdata *dd = dev_get_drvdata(dev);
640 ssize_t ret;
641 u16 enable = 0;
642
643 ret = ipath_parse_ushort(buf, &enable);
644 if (ret < 0) {
645 ipath_dev_err(dd, "attempt to use non-numeric on enable\n");
646 goto bail;
647 }
648
649 if (enable) {
650 if (!(dd->ipath_flags & IPATH_DISABLED))
651 goto bail;
652
653 dev_info(dev, "Enabling unit %d\n", dd->ipath_unit);
654
655 ret = ipath_init_chip(dd, 1);
656 if (ret)
657 ipath_dev_err(dd, "Failed to enable unit %d\n",
658 dd->ipath_unit);
659 else {
660 dd->ipath_flags &= ~IPATH_DISABLED;
661 *dd->ipath_statusp &= ~IPATH_STATUS_ADMIN_DISABLED;
662 }
663 }
664 else if (!(dd->ipath_flags & IPATH_DISABLED)) {
665 dev_info(dev, "Disabling unit %d\n", dd->ipath_unit);
666 ipath_shutdown_device(dd);
667 dd->ipath_flags |= IPATH_DISABLED;
668 *dd->ipath_statusp |= IPATH_STATUS_ADMIN_DISABLED;
669 }
670
671bail:
672 return ret;
673}
674
675static ssize_t store_rx_pol_inv(struct device *dev,
676 struct device_attribute *attr,
677 const char *buf,
678 size_t count)
679{
680 struct ipath_devdata *dd = dev_get_drvdata(dev);
681 int ret, r;
682 u16 val;
683
684 ret = ipath_parse_ushort(buf, &val);
685 if (ret < 0)
686 goto invalid;
687
688 r = ipath_set_rx_pol_inv(dd, val);
689 if (r < 0) {
690 ret = r;
691 goto bail;
692 }
693
694 goto bail;
695invalid:
696 ipath_dev_err(dd, "attempt to set invalid Rx Polarity invert\n");
697bail:
698 return ret;
699}
700
701static ssize_t store_led_override(struct device *dev,
702 struct device_attribute *attr,
703 const char *buf,
704 size_t count)
705{
706 struct ipath_devdata *dd = dev_get_drvdata(dev);
707 int ret;
708 u16 val;
709
710 ret = ipath_parse_ushort(buf, &val);
711 if (ret > 0)
712 ipath_set_led_override(dd, val);
713 else
714 ipath_dev_err(dd, "attempt to set invalid LED override\n");
715 return ret;
716}
717
718static ssize_t show_logged_errs(struct device *dev,
719 struct device_attribute *attr,
720 char *buf)
721{
722 struct ipath_devdata *dd = dev_get_drvdata(dev);
723 int idx, count;
724
725
726 if (ipath_update_eeprom_log(dd) != 0)
727 return -ENXIO;
728
729 count = 0;
730 for (idx = 0; idx < IPATH_EEP_LOG_CNT; ++idx) {
731 count += scnprintf(buf + count, PAGE_SIZE - count, "%d%c",
732 dd->ipath_eep_st_errs[idx],
733 idx == (IPATH_EEP_LOG_CNT - 1) ? '\n' : ' ');
734 }
735
736 return count;
737}
738
739
740
741
742
743
744
745static ssize_t show_hrtbt_enb(struct device *dev,
746 struct device_attribute *attr,
747 char *buf)
748{
749 struct ipath_devdata *dd = dev_get_drvdata(dev);
750 int ret;
751
752 ret = dd->ipath_f_get_ib_cfg(dd, IPATH_IB_CFG_HRTBT);
753 if (ret >= 0)
754 ret = scnprintf(buf, PAGE_SIZE, "%d\n", ret);
755 return ret;
756}
757
758static ssize_t store_hrtbt_enb(struct device *dev,
759 struct device_attribute *attr,
760 const char *buf,
761 size_t count)
762{
763 struct ipath_devdata *dd = dev_get_drvdata(dev);
764 int ret, r;
765 u16 val;
766
767 ret = ipath_parse_ushort(buf, &val);
768 if (ret >= 0 && val > 3)
769 ret = -EINVAL;
770 if (ret < 0) {
771 ipath_dev_err(dd, "attempt to set invalid Heartbeat enable\n");
772 goto bail;
773 }
774
775
776
777
778
779
780
781
782 r = dd->ipath_f_set_ib_cfg(dd, IPATH_IB_CFG_HRTBT, val);
783 if (r < 0)
784 ret = r;
785 else if (val == IPATH_IB_HRTBT_OFF)
786 dd->ipath_flags |= IPATH_NO_HRTBT;
787 else
788 dd->ipath_flags &= ~IPATH_NO_HRTBT;
789
790bail:
791 return ret;
792}
793
794
795
796
797
798static ssize_t show_lwid_enb(struct device *dev,
799 struct device_attribute *attr,
800 char *buf)
801{
802 struct ipath_devdata *dd = dev_get_drvdata(dev);
803 int ret;
804
805 ret = dd->ipath_f_get_ib_cfg(dd, IPATH_IB_CFG_LWID_ENB);
806 if (ret >= 0)
807 ret = scnprintf(buf, PAGE_SIZE, "%d\n", ret);
808 return ret;
809}
810
811static ssize_t store_lwid_enb(struct device *dev,
812 struct device_attribute *attr,
813 const char *buf,
814 size_t count)
815{
816 struct ipath_devdata *dd = dev_get_drvdata(dev);
817 int ret, r;
818 u16 val;
819
820 ret = ipath_parse_ushort(buf, &val);
821 if (ret >= 0 && (val == 0 || val > 3))
822 ret = -EINVAL;
823 if (ret < 0) {
824 ipath_dev_err(dd,
825 "attempt to set invalid Link Width (enable)\n");
826 goto bail;
827 }
828
829 r = dd->ipath_f_set_ib_cfg(dd, IPATH_IB_CFG_LWID_ENB, val);
830 if (r < 0)
831 ret = r;
832
833bail:
834 return ret;
835}
836
837
838static ssize_t show_lwid(struct device *dev,
839 struct device_attribute *attr,
840 char *buf)
841
842{
843 struct ipath_devdata *dd = dev_get_drvdata(dev);
844 int ret;
845
846 ret = dd->ipath_f_get_ib_cfg(dd, IPATH_IB_CFG_LWID);
847 if (ret >= 0)
848 ret = scnprintf(buf, PAGE_SIZE, "%d\n", ret);
849 return ret;
850}
851
852
853
854
855static ssize_t show_spd_enb(struct device *dev,
856 struct device_attribute *attr,
857 char *buf)
858{
859 struct ipath_devdata *dd = dev_get_drvdata(dev);
860 int ret;
861
862 ret = dd->ipath_f_get_ib_cfg(dd, IPATH_IB_CFG_SPD_ENB);
863 if (ret >= 0)
864 ret = scnprintf(buf, PAGE_SIZE, "%d\n", ret);
865 return ret;
866}
867
868static ssize_t store_spd_enb(struct device *dev,
869 struct device_attribute *attr,
870 const char *buf,
871 size_t count)
872{
873 struct ipath_devdata *dd = dev_get_drvdata(dev);
874 int ret, r;
875 u16 val;
876
877 ret = ipath_parse_ushort(buf, &val);
878 if (ret >= 0 && (val == 0 || val > (IPATH_IB_SDR | IPATH_IB_DDR)))
879 ret = -EINVAL;
880 if (ret < 0) {
881 ipath_dev_err(dd,
882 "attempt to set invalid Link Speed (enable)\n");
883 goto bail;
884 }
885
886 r = dd->ipath_f_set_ib_cfg(dd, IPATH_IB_CFG_SPD_ENB, val);
887 if (r < 0)
888 ret = r;
889
890bail:
891 return ret;
892}
893
894
895static ssize_t show_spd(struct device *dev,
896 struct device_attribute *attr,
897 char *buf)
898{
899 struct ipath_devdata *dd = dev_get_drvdata(dev);
900 int ret;
901
902 ret = dd->ipath_f_get_ib_cfg(dd, IPATH_IB_CFG_SPD);
903 if (ret >= 0)
904 ret = scnprintf(buf, PAGE_SIZE, "%d\n", ret);
905 return ret;
906}
907
908
909
910
911static ssize_t show_rx_polinv_enb(struct device *dev,
912 struct device_attribute *attr,
913 char *buf)
914{
915 struct ipath_devdata *dd = dev_get_drvdata(dev);
916 int ret;
917
918 ret = dd->ipath_f_get_ib_cfg(dd, IPATH_IB_CFG_RXPOL_ENB);
919 if (ret >= 0)
920 ret = scnprintf(buf, PAGE_SIZE, "%d\n", ret);
921 return ret;
922}
923
924static ssize_t store_rx_polinv_enb(struct device *dev,
925 struct device_attribute *attr,
926 const char *buf,
927 size_t count)
928{
929 struct ipath_devdata *dd = dev_get_drvdata(dev);
930 int ret, r;
931 u16 val;
932
933 ret = ipath_parse_ushort(buf, &val);
934 if (ret >= 0 && val > 1) {
935 ipath_dev_err(dd,
936 "attempt to set invalid Rx Polarity (enable)\n");
937 ret = -EINVAL;
938 goto bail;
939 }
940
941 r = dd->ipath_f_set_ib_cfg(dd, IPATH_IB_CFG_RXPOL_ENB, val);
942 if (r < 0)
943 ret = r;
944
945bail:
946 return ret;
947}
948
949
950
951
952static ssize_t show_lanerev_enb(struct device *dev,
953 struct device_attribute *attr,
954 char *buf)
955{
956 struct ipath_devdata *dd = dev_get_drvdata(dev);
957 int ret;
958
959 ret = dd->ipath_f_get_ib_cfg(dd, IPATH_IB_CFG_LREV_ENB);
960 if (ret >= 0)
961 ret = scnprintf(buf, PAGE_SIZE, "%d\n", ret);
962 return ret;
963}
964
965static ssize_t store_lanerev_enb(struct device *dev,
966 struct device_attribute *attr,
967 const char *buf,
968 size_t count)
969{
970 struct ipath_devdata *dd = dev_get_drvdata(dev);
971 int ret, r;
972 u16 val;
973
974 ret = ipath_parse_ushort(buf, &val);
975 if (ret >= 0 && val > 1) {
976 ret = -EINVAL;
977 ipath_dev_err(dd,
978 "attempt to set invalid Lane reversal (enable)\n");
979 goto bail;
980 }
981
982 r = dd->ipath_f_set_ib_cfg(dd, IPATH_IB_CFG_LREV_ENB, val);
983 if (r < 0)
984 ret = r;
985
986bail:
987 return ret;
988}
989
990static DRIVER_ATTR(num_units, S_IRUGO, show_num_units, NULL);
991static DRIVER_ATTR(version, S_IRUGO, show_version, NULL);
992
993static struct attribute *driver_attributes[] = {
994 &driver_attr_num_units.attr,
995 &driver_attr_version.attr,
996 NULL
997};
998
999static struct attribute_group driver_attr_group = {
1000 .attrs = driver_attributes
1001};
1002
1003static ssize_t store_tempsense(struct device *dev,
1004 struct device_attribute *attr,
1005 const char *buf,
1006 size_t count)
1007{
1008 struct ipath_devdata *dd = dev_get_drvdata(dev);
1009 int ret, stat;
1010 u16 val;
1011
1012 ret = ipath_parse_ushort(buf, &val);
1013 if (ret <= 0) {
1014 ipath_dev_err(dd, "attempt to set invalid tempsense config\n");
1015 goto bail;
1016 }
1017
1018 stat = ipath_tempsense_write(dd, 9, (val == 0x7f7f) ? 0x80 : 0);
1019 if (stat) {
1020 ipath_dev_err(dd, "Unable to set tempsense config\n");
1021 ret = -1;
1022 goto bail;
1023 }
1024 stat = ipath_tempsense_write(dd, 0xB, (u8) (val & 0xFF));
1025 if (stat) {
1026 ipath_dev_err(dd, "Unable to set local Tcrit\n");
1027 ret = -1;
1028 goto bail;
1029 }
1030 stat = ipath_tempsense_write(dd, 0xD, (u8) (val >> 8));
1031 if (stat) {
1032 ipath_dev_err(dd, "Unable to set remote Tcrit\n");
1033 ret = -1;
1034 goto bail;
1035 }
1036
1037bail:
1038 return ret;
1039}
1040
1041
1042
1043
1044static ssize_t show_tempsense(struct device *dev,
1045 struct device_attribute *attr,
1046 char *buf)
1047{
1048 struct ipath_devdata *dd = dev_get_drvdata(dev);
1049 int ret;
1050 int idx;
1051 u8 regvals[8];
1052
1053 ret = -ENXIO;
1054 for (idx = 0; idx < 8; ++idx) {
1055 if (idx == 6)
1056 continue;
1057 ret = ipath_tempsense_read(dd, idx);
1058 if (ret < 0)
1059 break;
1060 regvals[idx] = ret;
1061 }
1062 if (idx == 8)
1063 ret = scnprintf(buf, PAGE_SIZE, "%d %d %02X %02X %d %d\n",
1064 *(signed char *)(regvals),
1065 *(signed char *)(regvals + 1),
1066 regvals[2], regvals[3],
1067 *(signed char *)(regvals + 5),
1068 *(signed char *)(regvals + 7));
1069 return ret;
1070}
1071
1072const struct attribute_group *ipath_driver_attr_groups[] = {
1073 &driver_attr_group,
1074 NULL,
1075};
1076
1077static DEVICE_ATTR(guid, S_IWUSR | S_IRUGO, show_guid, store_guid);
1078static DEVICE_ATTR(lmc, S_IWUSR | S_IRUGO, show_lmc, store_lmc);
1079static DEVICE_ATTR(lid, S_IWUSR | S_IRUGO, show_lid, store_lid);
1080static DEVICE_ATTR(link_state, S_IWUSR, NULL, store_link_state);
1081static DEVICE_ATTR(mlid, S_IWUSR | S_IRUGO, show_mlid, store_mlid);
1082static DEVICE_ATTR(mtu, S_IWUSR | S_IRUGO, show_mtu, store_mtu);
1083static DEVICE_ATTR(enabled, S_IWUSR | S_IRUGO, show_enabled, store_enabled);
1084static DEVICE_ATTR(nguid, S_IRUGO, show_nguid, NULL);
1085static DEVICE_ATTR(nports, S_IRUGO, show_nports, NULL);
1086static DEVICE_ATTR(reset, S_IWUSR, NULL, store_reset);
1087static DEVICE_ATTR(serial, S_IRUGO, show_serial, NULL);
1088static DEVICE_ATTR(status, S_IRUGO, show_status, NULL);
1089static DEVICE_ATTR(status_str, S_IRUGO, show_status_str, NULL);
1090static DEVICE_ATTR(boardversion, S_IRUGO, show_boardversion, NULL);
1091static DEVICE_ATTR(unit, S_IRUGO, show_unit, NULL);
1092static DEVICE_ATTR(rx_pol_inv, S_IWUSR, NULL, store_rx_pol_inv);
1093static DEVICE_ATTR(led_override, S_IWUSR, NULL, store_led_override);
1094static DEVICE_ATTR(logged_errors, S_IRUGO, show_logged_errs, NULL);
1095static DEVICE_ATTR(localbus_info, S_IRUGO, show_localbus_info, NULL);
1096static DEVICE_ATTR(jint_max_packets, S_IWUSR | S_IRUGO,
1097 show_jint_max_packets, store_jint_max_packets);
1098static DEVICE_ATTR(jint_idle_ticks, S_IWUSR | S_IRUGO,
1099 show_jint_idle_ticks, store_jint_idle_ticks);
1100static DEVICE_ATTR(tempsense, S_IWUSR | S_IRUGO,
1101 show_tempsense, store_tempsense);
1102
1103static struct attribute *dev_attributes[] = {
1104 &dev_attr_guid.attr,
1105 &dev_attr_lmc.attr,
1106 &dev_attr_lid.attr,
1107 &dev_attr_link_state.attr,
1108 &dev_attr_mlid.attr,
1109 &dev_attr_mtu.attr,
1110 &dev_attr_nguid.attr,
1111 &dev_attr_nports.attr,
1112 &dev_attr_serial.attr,
1113 &dev_attr_status.attr,
1114 &dev_attr_status_str.attr,
1115 &dev_attr_boardversion.attr,
1116 &dev_attr_unit.attr,
1117 &dev_attr_enabled.attr,
1118 &dev_attr_rx_pol_inv.attr,
1119 &dev_attr_led_override.attr,
1120 &dev_attr_logged_errors.attr,
1121 &dev_attr_tempsense.attr,
1122 &dev_attr_localbus_info.attr,
1123 NULL
1124};
1125
1126static struct attribute_group dev_attr_group = {
1127 .attrs = dev_attributes
1128};
1129
1130static DEVICE_ATTR(hrtbt_enable, S_IWUSR | S_IRUGO, show_hrtbt_enb,
1131 store_hrtbt_enb);
1132static DEVICE_ATTR(link_width_enable, S_IWUSR | S_IRUGO, show_lwid_enb,
1133 store_lwid_enb);
1134static DEVICE_ATTR(link_width, S_IRUGO, show_lwid, NULL);
1135static DEVICE_ATTR(link_speed_enable, S_IWUSR | S_IRUGO, show_spd_enb,
1136 store_spd_enb);
1137static DEVICE_ATTR(link_speed, S_IRUGO, show_spd, NULL);
1138static DEVICE_ATTR(rx_pol_inv_enable, S_IWUSR | S_IRUGO, show_rx_polinv_enb,
1139 store_rx_polinv_enb);
1140static DEVICE_ATTR(rx_lane_rev_enable, S_IWUSR | S_IRUGO, show_lanerev_enb,
1141 store_lanerev_enb);
1142
1143static struct attribute *dev_ibcfg_attributes[] = {
1144 &dev_attr_hrtbt_enable.attr,
1145 &dev_attr_link_width_enable.attr,
1146 &dev_attr_link_width.attr,
1147 &dev_attr_link_speed_enable.attr,
1148 &dev_attr_link_speed.attr,
1149 &dev_attr_rx_pol_inv_enable.attr,
1150 &dev_attr_rx_lane_rev_enable.attr,
1151 NULL
1152};
1153
1154static struct attribute_group dev_ibcfg_attr_group = {
1155 .attrs = dev_ibcfg_attributes
1156};
1157
1158
1159
1160
1161
1162
1163
1164
1165
1166
1167
1168
1169int ipath_expose_reset(struct device *dev)
1170{
1171 static int exposed;
1172 int ret;
1173
1174 if (!exposed) {
1175 ret = device_create_file(dev, &dev_attr_reset);
1176 exposed = 1;
1177 }
1178 else
1179 ret = 0;
1180
1181 return ret;
1182}
1183
1184int ipath_device_create_group(struct device *dev, struct ipath_devdata *dd)
1185{
1186 int ret;
1187
1188 ret = sysfs_create_group(&dev->kobj, &dev_attr_group);
1189 if (ret)
1190 goto bail;
1191
1192 ret = sysfs_create_group(&dev->kobj, &dev_counter_attr_group);
1193 if (ret)
1194 goto bail_attrs;
1195
1196 if (dd->ipath_flags & IPATH_HAS_MULT_IB_SPEED) {
1197 ret = device_create_file(dev, &dev_attr_jint_idle_ticks);
1198 if (ret)
1199 goto bail_counter;
1200 ret = device_create_file(dev, &dev_attr_jint_max_packets);
1201 if (ret)
1202 goto bail_idle;
1203
1204 ret = sysfs_create_group(&dev->kobj, &dev_ibcfg_attr_group);
1205 if (ret)
1206 goto bail_max;
1207 }
1208
1209 return 0;
1210
1211bail_max:
1212 device_remove_file(dev, &dev_attr_jint_max_packets);
1213bail_idle:
1214 device_remove_file(dev, &dev_attr_jint_idle_ticks);
1215bail_counter:
1216 sysfs_remove_group(&dev->kobj, &dev_counter_attr_group);
1217bail_attrs:
1218 sysfs_remove_group(&dev->kobj, &dev_attr_group);
1219bail:
1220 return ret;
1221}
1222
1223void ipath_device_remove_group(struct device *dev, struct ipath_devdata *dd)
1224{
1225 sysfs_remove_group(&dev->kobj, &dev_counter_attr_group);
1226
1227 if (dd->ipath_flags & IPATH_HAS_MULT_IB_SPEED) {
1228 sysfs_remove_group(&dev->kobj, &dev_ibcfg_attr_group);
1229 device_remove_file(dev, &dev_attr_jint_idle_ticks);
1230 device_remove_file(dev, &dev_attr_jint_max_packets);
1231 }
1232
1233 sysfs_remove_group(&dev->kobj, &dev_attr_group);
1234
1235 device_remove_file(dev, &dev_attr_reset);
1236}
1237