Pull cpu-hotplug into release branch
[linux-2.6] / drivers / infiniband / hw / ipath / ipath_sysfs.c
1 /*
2  * Copyright (c) 2006 PathScale, Inc. All rights reserved.
3  *
4  * This software is available to you under a choice of one of two
5  * licenses.  You may choose to be licensed under the terms of the GNU
6  * General Public License (GPL) Version 2, available from the file
7  * COPYING in the main directory of this source tree, or the
8  * OpenIB.org BSD license below:
9  *
10  *     Redistribution and use in source and binary forms, with or
11  *     without modification, are permitted provided that the following
12  *     conditions are met:
13  *
14  *      - Redistributions of source code must retain the above
15  *        copyright notice, this list of conditions and the following
16  *        disclaimer.
17  *
18  *      - Redistributions in binary form must reproduce the above
19  *        copyright notice, this list of conditions and the following
20  *        disclaimer in the documentation and/or other materials
21  *        provided with the distribution.
22  *
23  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
24  * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
25  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
26  * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
27  * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
28  * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
29  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
30  * SOFTWARE.
31  */
32
33 #include <linux/ctype.h>
34 #include <linux/pci.h>
35
36 #include "ipath_kernel.h"
37 #include "ips_common.h"
38 #include "ipath_layer.h"
39
40 /**
41  * ipath_parse_ushort - parse an unsigned short value in an arbitrary base
42  * @str: the string containing the number
43  * @valp: where to put the result
44  *
45  * returns the number of bytes consumed, or negative value on error
46  */
47 int 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
71 bail:
72         return ret;
73 }
74
75 static ssize_t show_version(struct device_driver *dev, char *buf)
76 {
77         /* The string printed here is already newline-terminated. */
78         return scnprintf(buf, PAGE_SIZE, "%s", ipath_core_version);
79 }
80
81 static 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
87 #define DRIVER_STAT(name, attr) \
88         static ssize_t show_stat_##name(struct device_driver *dev, \
89                                         char *buf) \
90         { \
91                 return scnprintf( \
92                         buf, PAGE_SIZE, "%llu\n", \
93                         (unsigned long long) ipath_stats.sps_ ##attr); \
94         } \
95         static DRIVER_ATTR(name, S_IRUGO, show_stat_##name, NULL)
96
97 DRIVER_STAT(intrs, ints);
98 DRIVER_STAT(err_intrs, errints);
99 DRIVER_STAT(errs, errs);
100 DRIVER_STAT(pkt_errs, pkterrs);
101 DRIVER_STAT(crc_errs, crcerrs);
102 DRIVER_STAT(hw_errs, hwerrs);
103 DRIVER_STAT(ib_link, iblink);
104 DRIVER_STAT(port0_pkts, port0pkts);
105 DRIVER_STAT(ether_spkts, ether_spkts);
106 DRIVER_STAT(ether_rpkts, ether_rpkts);
107 DRIVER_STAT(sma_spkts, sma_spkts);
108 DRIVER_STAT(sma_rpkts, sma_rpkts);
109 DRIVER_STAT(hdrq_full, hdrqfull);
110 DRIVER_STAT(etid_full, etidfull);
111 DRIVER_STAT(no_piobufs, nopiobufs);
112 DRIVER_STAT(ports, ports);
113 DRIVER_STAT(pkey0, pkeys[0]);
114 DRIVER_STAT(pkey1, pkeys[1]);
115 DRIVER_STAT(pkey2, pkeys[2]);
116 DRIVER_STAT(pkey3, pkeys[3]);
117 /* XXX fix the following when dynamic table of devices used */
118 DRIVER_STAT(lid0, lid[0]);
119 DRIVER_STAT(lid1, lid[1]);
120 DRIVER_STAT(lid2, lid[2]);
121 DRIVER_STAT(lid3, lid[3]);
122
123 DRIVER_STAT(nports, nports);
124 DRIVER_STAT(null_intr, nullintr);
125 DRIVER_STAT(max_pkts_call, maxpkts_call);
126 DRIVER_STAT(avg_pkts_call, avgpkts_call);
127 DRIVER_STAT(page_locks, pagelocks);
128 DRIVER_STAT(page_unlocks, pageunlocks);
129 DRIVER_STAT(krdrops, krdrops);
130 /* XXX fix the following when dynamic table of devices used */
131 DRIVER_STAT(mlid0, mlid[0]);
132 DRIVER_STAT(mlid1, mlid[1]);
133 DRIVER_STAT(mlid2, mlid[2]);
134 DRIVER_STAT(mlid3, mlid[3]);
135
136 static struct attribute *driver_stat_attributes[] = {
137         &driver_attr_intrs.attr,
138         &driver_attr_err_intrs.attr,
139         &driver_attr_errs.attr,
140         &driver_attr_pkt_errs.attr,
141         &driver_attr_crc_errs.attr,
142         &driver_attr_hw_errs.attr,
143         &driver_attr_ib_link.attr,
144         &driver_attr_port0_pkts.attr,
145         &driver_attr_ether_spkts.attr,
146         &driver_attr_ether_rpkts.attr,
147         &driver_attr_sma_spkts.attr,
148         &driver_attr_sma_rpkts.attr,
149         &driver_attr_hdrq_full.attr,
150         &driver_attr_etid_full.attr,
151         &driver_attr_no_piobufs.attr,
152         &driver_attr_ports.attr,
153         &driver_attr_pkey0.attr,
154         &driver_attr_pkey1.attr,
155         &driver_attr_pkey2.attr,
156         &driver_attr_pkey3.attr,
157         &driver_attr_lid0.attr,
158         &driver_attr_lid1.attr,
159         &driver_attr_lid2.attr,
160         &driver_attr_lid3.attr,
161         &driver_attr_nports.attr,
162         &driver_attr_null_intr.attr,
163         &driver_attr_max_pkts_call.attr,
164         &driver_attr_avg_pkts_call.attr,
165         &driver_attr_page_locks.attr,
166         &driver_attr_page_unlocks.attr,
167         &driver_attr_krdrops.attr,
168         &driver_attr_mlid0.attr,
169         &driver_attr_mlid1.attr,
170         &driver_attr_mlid2.attr,
171         &driver_attr_mlid3.attr,
172         NULL
173 };
174
175 static struct attribute_group driver_stat_attr_group = {
176         .name = "stats",
177         .attrs = driver_stat_attributes
178 };
179
180 static ssize_t show_status(struct device *dev,
181                            struct device_attribute *attr,
182                            char *buf)
183 {
184         struct ipath_devdata *dd = dev_get_drvdata(dev);
185         ssize_t ret;
186
187         if (!dd->ipath_statusp) {
188                 ret = -EINVAL;
189                 goto bail;
190         }
191
192         ret = scnprintf(buf, PAGE_SIZE, "0x%llx\n",
193                         (unsigned long long) *(dd->ipath_statusp));
194
195 bail:
196         return ret;
197 }
198
199 static const char *ipath_status_str[] = {
200         "Initted",
201         "Disabled",
202         "Admin_Disabled",
203         "OIB_SMA",
204         "SMA",
205         "Present",
206         "IB_link_up",
207         "IB_configured",
208         "NoIBcable",
209         "Fatal_Hardware_Error",
210         NULL,
211 };
212
213 static ssize_t show_status_str(struct device *dev,
214                                struct device_attribute *attr,
215                                char *buf)
216 {
217         struct ipath_devdata *dd = dev_get_drvdata(dev);
218         int i, any;
219         u64 s;
220         ssize_t ret;
221
222         if (!dd->ipath_statusp) {
223                 ret = -EINVAL;
224                 goto bail;
225         }
226
227         s = *(dd->ipath_statusp);
228         *buf = '\0';
229         for (any = i = 0; s && ipath_status_str[i]; i++) {
230                 if (s & 1) {
231                         if (any && strlcat(buf, " ", PAGE_SIZE) >=
232                             PAGE_SIZE)
233                                 /* overflow */
234                                 break;
235                         if (strlcat(buf, ipath_status_str[i],
236                                     PAGE_SIZE) >= PAGE_SIZE)
237                                 break;
238                         any = 1;
239                 }
240                 s >>= 1;
241         }
242         if (any)
243                 strlcat(buf, "\n", PAGE_SIZE);
244
245         ret = strlen(buf);
246
247 bail:
248         return ret;
249 }
250
251 static ssize_t show_boardversion(struct device *dev,
252                                struct device_attribute *attr,
253                                char *buf)
254 {
255         struct ipath_devdata *dd = dev_get_drvdata(dev);
256         /* The string printed here is already newline-terminated. */
257         return scnprintf(buf, PAGE_SIZE, "%s", dd->ipath_boardversion);
258 }
259
260 static ssize_t show_lid(struct device *dev,
261                         struct device_attribute *attr,
262                         char *buf)
263 {
264         struct ipath_devdata *dd = dev_get_drvdata(dev);
265
266         return scnprintf(buf, PAGE_SIZE, "0x%x\n", dd->ipath_lid);
267 }
268
269 static ssize_t store_lid(struct device *dev,
270                          struct device_attribute *attr,
271                           const char *buf,
272                           size_t count)
273 {
274         struct ipath_devdata *dd = dev_get_drvdata(dev);
275         u16 lid;
276         int ret;
277
278         ret = ipath_parse_ushort(buf, &lid);
279         if (ret < 0)
280                 goto invalid;
281
282         if (lid == 0 || lid >= 0xc000) {
283                 ret = -EINVAL;
284                 goto invalid;
285         }
286
287         ipath_set_sps_lid(dd, lid, 0);
288
289         goto bail;
290 invalid:
291         ipath_dev_err(dd, "attempt to set invalid LID\n");
292 bail:
293         return ret;
294 }
295
296 static ssize_t show_mlid(struct device *dev,
297                          struct device_attribute *attr,
298                          char *buf)
299 {
300         struct ipath_devdata *dd = dev_get_drvdata(dev);
301
302         return scnprintf(buf, PAGE_SIZE, "0x%x\n", dd->ipath_mlid);
303 }
304
305 static ssize_t store_mlid(struct device *dev,
306                          struct device_attribute *attr,
307                           const char *buf,
308                           size_t count)
309 {
310         struct ipath_devdata *dd = dev_get_drvdata(dev);
311         int unit;
312         u16 mlid;
313         int ret;
314
315         ret = ipath_parse_ushort(buf, &mlid);
316         if (ret < 0)
317                 goto invalid;
318
319         unit = dd->ipath_unit;
320
321         dd->ipath_mlid = mlid;
322         ipath_stats.sps_mlid[unit] = mlid;
323         ipath_layer_intr(dd, IPATH_LAYER_INT_BCAST);
324
325         goto bail;
326 invalid:
327         ipath_dev_err(dd, "attempt to set invalid MLID\n");
328 bail:
329         return ret;
330 }
331
332 static ssize_t show_guid(struct device *dev,
333                          struct device_attribute *attr,
334                          char *buf)
335 {
336         struct ipath_devdata *dd = dev_get_drvdata(dev);
337         u8 *guid;
338
339         guid = (u8 *) & (dd->ipath_guid);
340
341         return scnprintf(buf, PAGE_SIZE,
342                          "%02x:%02x:%02x:%02x:%02x:%02x:%02x:%02x\n",
343                          guid[0], guid[1], guid[2], guid[3],
344                          guid[4], guid[5], guid[6], guid[7]);
345 }
346
347 static ssize_t store_guid(struct device *dev,
348                          struct device_attribute *attr,
349                           const char *buf,
350                           size_t count)
351 {
352         struct ipath_devdata *dd = dev_get_drvdata(dev);
353         ssize_t ret;
354         unsigned short guid[8];
355         __be64 nguid;
356         u8 *ng;
357         int i;
358
359         if (sscanf(buf, "%hx:%hx:%hx:%hx:%hx:%hx:%hx:%hx",
360                    &guid[0], &guid[1], &guid[2], &guid[3],
361                    &guid[4], &guid[5], &guid[6], &guid[7]) != 8)
362                 goto invalid;
363
364         ng = (u8 *) &nguid;
365
366         for (i = 0; i < 8; i++) {
367                 if (guid[i] > 0xff)
368                         goto invalid;
369                 ng[i] = guid[i];
370         }
371
372         dd->ipath_guid = nguid;
373         dd->ipath_nguid = 1;
374
375         ret = strlen(buf);
376         goto bail;
377
378 invalid:
379         ipath_dev_err(dd, "attempt to set invalid GUID\n");
380         ret = -EINVAL;
381
382 bail:
383         return ret;
384 }
385
386 static ssize_t show_nguid(struct device *dev,
387                           struct device_attribute *attr,
388                           char *buf)
389 {
390         struct ipath_devdata *dd = dev_get_drvdata(dev);
391
392         return scnprintf(buf, PAGE_SIZE, "%u\n", dd->ipath_nguid);
393 }
394
395 static ssize_t show_serial(struct device *dev,
396                            struct device_attribute *attr,
397                            char *buf)
398 {
399         struct ipath_devdata *dd = dev_get_drvdata(dev);
400
401         buf[sizeof dd->ipath_serial] = '\0';
402         memcpy(buf, dd->ipath_serial, sizeof dd->ipath_serial);
403         strcat(buf, "\n");
404         return strlen(buf);
405 }
406
407 static ssize_t show_unit(struct device *dev,
408                          struct device_attribute *attr,
409                          char *buf)
410 {
411         struct ipath_devdata *dd = dev_get_drvdata(dev);
412
413         return scnprintf(buf, PAGE_SIZE, "%u\n", dd->ipath_unit);
414 }
415
416 #define DEVICE_COUNTER(name, attr) \
417         static ssize_t show_counter_##name(struct device *dev, \
418                                            struct device_attribute *attr, \
419                                            char *buf) \
420         { \
421                 struct ipath_devdata *dd = dev_get_drvdata(dev); \
422                 return scnprintf(\
423                         buf, PAGE_SIZE, "%llu\n", (unsigned long long) \
424                         ipath_snap_cntr( \
425                                 dd, offsetof(struct infinipath_counters, \
426                                              attr) / sizeof(u64)));     \
427         } \
428         static DEVICE_ATTR(name, S_IRUGO, show_counter_##name, NULL);
429
430 DEVICE_COUNTER(ib_link_downeds, IBLinkDownedCnt);
431 DEVICE_COUNTER(ib_link_err_recoveries, IBLinkErrRecoveryCnt);
432 DEVICE_COUNTER(ib_status_changes, IBStatusChangeCnt);
433 DEVICE_COUNTER(ib_symbol_errs, IBSymbolErrCnt);
434 DEVICE_COUNTER(lb_flow_stalls, LBFlowStallCnt);
435 DEVICE_COUNTER(lb_ints, LBIntCnt);
436 DEVICE_COUNTER(rx_bad_formats, RxBadFormatCnt);
437 DEVICE_COUNTER(rx_buf_ovfls, RxBufOvflCnt);
438 DEVICE_COUNTER(rx_data_pkts, RxDataPktCnt);
439 DEVICE_COUNTER(rx_dropped_pkts, RxDroppedPktCnt);
440 DEVICE_COUNTER(rx_dwords, RxDwordCnt);
441 DEVICE_COUNTER(rx_ebps, RxEBPCnt);
442 DEVICE_COUNTER(rx_flow_ctrl_errs, RxFlowCtrlErrCnt);
443 DEVICE_COUNTER(rx_flow_pkts, RxFlowPktCnt);
444 DEVICE_COUNTER(rx_icrc_errs, RxICRCErrCnt);
445 DEVICE_COUNTER(rx_len_errs, RxLenErrCnt);
446 DEVICE_COUNTER(rx_link_problems, RxLinkProblemCnt);
447 DEVICE_COUNTER(rx_lpcrc_errs, RxLPCRCErrCnt);
448 DEVICE_COUNTER(rx_max_min_len_errs, RxMaxMinLenErrCnt);
449 DEVICE_COUNTER(rx_p0_hdr_egr_ovfls, RxP0HdrEgrOvflCnt);
450 DEVICE_COUNTER(rx_p1_hdr_egr_ovfls, RxP1HdrEgrOvflCnt);
451 DEVICE_COUNTER(rx_p2_hdr_egr_ovfls, RxP2HdrEgrOvflCnt);
452 DEVICE_COUNTER(rx_p3_hdr_egr_ovfls, RxP3HdrEgrOvflCnt);
453 DEVICE_COUNTER(rx_p4_hdr_egr_ovfls, RxP4HdrEgrOvflCnt);
454 DEVICE_COUNTER(rx_p5_hdr_egr_ovfls, RxP5HdrEgrOvflCnt);
455 DEVICE_COUNTER(rx_p6_hdr_egr_ovfls, RxP6HdrEgrOvflCnt);
456 DEVICE_COUNTER(rx_p7_hdr_egr_ovfls, RxP7HdrEgrOvflCnt);
457 DEVICE_COUNTER(rx_p8_hdr_egr_ovfls, RxP8HdrEgrOvflCnt);
458 DEVICE_COUNTER(rx_pkey_mismatches, RxPKeyMismatchCnt);
459 DEVICE_COUNTER(rx_tid_full_errs, RxTIDFullErrCnt);
460 DEVICE_COUNTER(rx_tid_valid_errs, RxTIDValidErrCnt);
461 DEVICE_COUNTER(rx_vcrc_errs, RxVCRCErrCnt);
462 DEVICE_COUNTER(tx_data_pkts, TxDataPktCnt);
463 DEVICE_COUNTER(tx_dropped_pkts, TxDroppedPktCnt);
464 DEVICE_COUNTER(tx_dwords, TxDwordCnt);
465 DEVICE_COUNTER(tx_flow_pkts, TxFlowPktCnt);
466 DEVICE_COUNTER(tx_flow_stalls, TxFlowStallCnt);
467 DEVICE_COUNTER(tx_len_errs, TxLenErrCnt);
468 DEVICE_COUNTER(tx_max_min_len_errs, TxMaxMinLenErrCnt);
469 DEVICE_COUNTER(tx_underruns, TxUnderrunCnt);
470 DEVICE_COUNTER(tx_unsup_vl_errs, TxUnsupVLErrCnt);
471
472 static struct attribute *dev_counter_attributes[] = {
473         &dev_attr_ib_link_downeds.attr,
474         &dev_attr_ib_link_err_recoveries.attr,
475         &dev_attr_ib_status_changes.attr,
476         &dev_attr_ib_symbol_errs.attr,
477         &dev_attr_lb_flow_stalls.attr,
478         &dev_attr_lb_ints.attr,
479         &dev_attr_rx_bad_formats.attr,
480         &dev_attr_rx_buf_ovfls.attr,
481         &dev_attr_rx_data_pkts.attr,
482         &dev_attr_rx_dropped_pkts.attr,
483         &dev_attr_rx_dwords.attr,
484         &dev_attr_rx_ebps.attr,
485         &dev_attr_rx_flow_ctrl_errs.attr,
486         &dev_attr_rx_flow_pkts.attr,
487         &dev_attr_rx_icrc_errs.attr,
488         &dev_attr_rx_len_errs.attr,
489         &dev_attr_rx_link_problems.attr,
490         &dev_attr_rx_lpcrc_errs.attr,
491         &dev_attr_rx_max_min_len_errs.attr,
492         &dev_attr_rx_p0_hdr_egr_ovfls.attr,
493         &dev_attr_rx_p1_hdr_egr_ovfls.attr,
494         &dev_attr_rx_p2_hdr_egr_ovfls.attr,
495         &dev_attr_rx_p3_hdr_egr_ovfls.attr,
496         &dev_attr_rx_p4_hdr_egr_ovfls.attr,
497         &dev_attr_rx_p5_hdr_egr_ovfls.attr,
498         &dev_attr_rx_p6_hdr_egr_ovfls.attr,
499         &dev_attr_rx_p7_hdr_egr_ovfls.attr,
500         &dev_attr_rx_p8_hdr_egr_ovfls.attr,
501         &dev_attr_rx_pkey_mismatches.attr,
502         &dev_attr_rx_tid_full_errs.attr,
503         &dev_attr_rx_tid_valid_errs.attr,
504         &dev_attr_rx_vcrc_errs.attr,
505         &dev_attr_tx_data_pkts.attr,
506         &dev_attr_tx_dropped_pkts.attr,
507         &dev_attr_tx_dwords.attr,
508         &dev_attr_tx_flow_pkts.attr,
509         &dev_attr_tx_flow_stalls.attr,
510         &dev_attr_tx_len_errs.attr,
511         &dev_attr_tx_max_min_len_errs.attr,
512         &dev_attr_tx_underruns.attr,
513         &dev_attr_tx_unsup_vl_errs.attr,
514         NULL
515 };
516
517 static struct attribute_group dev_counter_attr_group = {
518         .name = "counters",
519         .attrs = dev_counter_attributes
520 };
521
522 static ssize_t store_reset(struct device *dev,
523                          struct device_attribute *attr,
524                           const char *buf,
525                           size_t count)
526 {
527         struct ipath_devdata *dd = dev_get_drvdata(dev);
528         int ret;
529
530         if (count < 5 || memcmp(buf, "reset", 5)) {
531                 ret = -EINVAL;
532                 goto bail;
533         }
534
535         if (dd->ipath_flags & IPATH_DISABLED) {
536                 /*
537                  * post-reset init would re-enable interrupts, etc.
538                  * so don't allow reset on disabled devices.  Not
539                  * perfect error, but about the best choice.
540                  */
541                 dev_info(dev,"Unit %d is disabled, can't reset\n",
542                          dd->ipath_unit);
543                 ret = -EINVAL;
544         }
545         ret = ipath_reset_device(dd->ipath_unit);
546 bail:
547         return ret<0 ? ret : count;
548 }
549
550 static ssize_t store_link_state(struct device *dev,
551                          struct device_attribute *attr,
552                           const char *buf,
553                           size_t count)
554 {
555         struct ipath_devdata *dd = dev_get_drvdata(dev);
556         int ret, r;
557         u16 state;
558
559         ret = ipath_parse_ushort(buf, &state);
560         if (ret < 0)
561                 goto invalid;
562
563         r = ipath_layer_set_linkstate(dd, state);
564         if (r < 0) {
565                 ret = r;
566                 goto bail;
567         }
568
569         goto bail;
570 invalid:
571         ipath_dev_err(dd, "attempt to set invalid link state\n");
572 bail:
573         return ret;
574 }
575
576 static ssize_t show_mtu(struct device *dev,
577                          struct device_attribute *attr,
578                          char *buf)
579 {
580         struct ipath_devdata *dd = dev_get_drvdata(dev);
581         return scnprintf(buf, PAGE_SIZE, "%u\n", dd->ipath_ibmtu);
582 }
583
584 static ssize_t store_mtu(struct device *dev,
585                          struct device_attribute *attr,
586                           const char *buf,
587                           size_t count)
588 {
589         struct ipath_devdata *dd = dev_get_drvdata(dev);
590         ssize_t ret;
591         u16 mtu = 0;
592         int r;
593
594         ret = ipath_parse_ushort(buf, &mtu);
595         if (ret < 0)
596                 goto invalid;
597
598         r = ipath_layer_set_mtu(dd, mtu);
599         if (r < 0)
600                 ret = r;
601
602         goto bail;
603 invalid:
604         ipath_dev_err(dd, "attempt to set invalid MTU\n");
605 bail:
606         return ret;
607 }
608
609 static ssize_t show_enabled(struct device *dev,
610                          struct device_attribute *attr,
611                          char *buf)
612 {
613         struct ipath_devdata *dd = dev_get_drvdata(dev);
614         return scnprintf(buf, PAGE_SIZE, "%u\n",
615                          (dd->ipath_flags & IPATH_DISABLED) ? 0 : 1);
616 }
617
618 static ssize_t store_enabled(struct device *dev,
619                          struct device_attribute *attr,
620                           const char *buf,
621                           size_t count)
622 {
623         struct ipath_devdata *dd = dev_get_drvdata(dev);
624         ssize_t ret;
625         u16 enable = 0;
626
627         ret = ipath_parse_ushort(buf, &enable);
628         if (ret < 0) {
629                 ipath_dev_err(dd, "attempt to use non-numeric on enable\n");
630                 goto bail;
631         }
632
633         if (enable) {
634                 if (!(dd->ipath_flags & IPATH_DISABLED))
635                         goto bail;
636
637                 dev_info(dev, "Enabling unit %d\n", dd->ipath_unit);
638                 /* same as post-reset */
639                 ret = ipath_init_chip(dd, 1);
640                 if (ret)
641                         ipath_dev_err(dd, "Failed to enable unit %d\n",
642                                       dd->ipath_unit);
643                 else {
644                         dd->ipath_flags &= ~IPATH_DISABLED;
645                         *dd->ipath_statusp &= ~IPATH_STATUS_ADMIN_DISABLED;
646                 }
647         }
648         else if (!(dd->ipath_flags & IPATH_DISABLED)) {
649                 dev_info(dev, "Disabling unit %d\n", dd->ipath_unit);
650                 ipath_shutdown_device(dd);
651                 dd->ipath_flags |= IPATH_DISABLED;
652                 *dd->ipath_statusp |= IPATH_STATUS_ADMIN_DISABLED;
653         }
654
655 bail:
656         return ret;
657 }
658
659 static DRIVER_ATTR(num_units, S_IRUGO, show_num_units, NULL);
660 static DRIVER_ATTR(version, S_IRUGO, show_version, NULL);
661
662 static struct attribute *driver_attributes[] = {
663         &driver_attr_num_units.attr,
664         &driver_attr_version.attr,
665         NULL
666 };
667
668 static struct attribute_group driver_attr_group = {
669         .attrs = driver_attributes
670 };
671
672 static DEVICE_ATTR(guid, S_IWUSR | S_IRUGO, show_guid, store_guid);
673 static DEVICE_ATTR(lid, S_IWUSR | S_IRUGO, show_lid, store_lid);
674 static DEVICE_ATTR(link_state, S_IWUSR, NULL, store_link_state);
675 static DEVICE_ATTR(mlid, S_IWUSR | S_IRUGO, show_mlid, store_mlid);
676 static DEVICE_ATTR(mtu, S_IWUSR | S_IRUGO, show_mtu, store_mtu);
677 static DEVICE_ATTR(enabled, S_IWUSR | S_IRUGO, show_enabled, store_enabled);
678 static DEVICE_ATTR(nguid, S_IRUGO, show_nguid, NULL);
679 static DEVICE_ATTR(reset, S_IWUSR, NULL, store_reset);
680 static DEVICE_ATTR(serial, S_IRUGO, show_serial, NULL);
681 static DEVICE_ATTR(status, S_IRUGO, show_status, NULL);
682 static DEVICE_ATTR(status_str, S_IRUGO, show_status_str, NULL);
683 static DEVICE_ATTR(boardversion, S_IRUGO, show_boardversion, NULL);
684 static DEVICE_ATTR(unit, S_IRUGO, show_unit, NULL);
685
686 static struct attribute *dev_attributes[] = {
687         &dev_attr_guid.attr,
688         &dev_attr_lid.attr,
689         &dev_attr_link_state.attr,
690         &dev_attr_mlid.attr,
691         &dev_attr_mtu.attr,
692         &dev_attr_nguid.attr,
693         &dev_attr_serial.attr,
694         &dev_attr_status.attr,
695         &dev_attr_status_str.attr,
696         &dev_attr_boardversion.attr,
697         &dev_attr_unit.attr,
698         &dev_attr_enabled.attr,
699         NULL
700 };
701
702 static struct attribute_group dev_attr_group = {
703         .attrs = dev_attributes
704 };
705
706 /**
707  * ipath_expose_reset - create a device reset file
708  * @dev: the device structure
709  *
710  * Only expose a file that lets us reset the device after someone
711  * enters diag mode.  A device reset is quite likely to crash the
712  * machine entirely, so we don't want to normally make it
713  * available.
714  *
715  * Called with ipath_mutex held.
716  */
717 int ipath_expose_reset(struct device *dev)
718 {
719         static int exposed;
720         int ret;
721
722         if (!exposed) {
723                 ret = device_create_file(dev, &dev_attr_reset);
724                 exposed = 1;
725         }
726         else
727                 ret = 0;
728
729         return ret;
730 }
731
732 int ipath_driver_create_group(struct device_driver *drv)
733 {
734         int ret;
735
736         ret = sysfs_create_group(&drv->kobj, &driver_attr_group);
737         if (ret)
738                 goto bail;
739
740         ret = sysfs_create_group(&drv->kobj, &driver_stat_attr_group);
741         if (ret)
742                 sysfs_remove_group(&drv->kobj, &driver_attr_group);
743
744 bail:
745         return ret;
746 }
747
748 void ipath_driver_remove_group(struct device_driver *drv)
749 {
750         sysfs_remove_group(&drv->kobj, &driver_stat_attr_group);
751         sysfs_remove_group(&drv->kobj, &driver_attr_group);
752 }
753
754 int ipath_device_create_group(struct device *dev, struct ipath_devdata *dd)
755 {
756         int ret;
757         char unit[5];
758
759         ret = sysfs_create_group(&dev->kobj, &dev_attr_group);
760         if (ret)
761                 goto bail;
762
763         ret = sysfs_create_group(&dev->kobj, &dev_counter_attr_group);
764         if (ret)
765                 goto bail_attrs;
766
767         snprintf(unit, sizeof(unit), "%02d", dd->ipath_unit);
768         ret = sysfs_create_link(&dev->driver->kobj, &dev->kobj, unit);
769         if (ret == 0)
770                 goto bail;
771
772         sysfs_remove_group(&dev->kobj, &dev_counter_attr_group);
773 bail_attrs:
774         sysfs_remove_group(&dev->kobj, &dev_attr_group);
775 bail:
776         return ret;
777 }
778
779 void ipath_device_remove_group(struct device *dev, struct ipath_devdata *dd)
780 {
781         char unit[5];
782
783         snprintf(unit, sizeof(unit), "%02d", dd->ipath_unit);
784         sysfs_remove_link(&dev->driver->kobj, unit);
785
786         sysfs_remove_group(&dev->kobj, &dev_counter_attr_group);
787         sysfs_remove_group(&dev->kobj, &dev_attr_group);
788
789         device_remove_file(dev, &dev_attr_reset);
790 }