2 * Copyright (c) 2004, 2005 Topspin Communications. All rights reserved.
3 * Copyright (c) 2005 Mellanox Technologies Ltd. All rights reserved.
4 * Copyright (c) 2005 Sun Microsystems, Inc. All rights reserved.
6 * This software is available to you under a choice of one of two
7 * licenses. You may choose to be licensed under the terms of the GNU
8 * General Public License (GPL) Version 2, available from the file
9 * COPYING in the main directory of this source tree, or the
10 * OpenIB.org BSD license below:
12 * Redistribution and use in source and binary forms, with or
13 * without modification, are permitted provided that the following
16 * - Redistributions of source code must retain the above
17 * copyright notice, this list of conditions and the following
20 * - Redistributions in binary form must reproduce the above
21 * copyright notice, this list of conditions and the following
22 * disclaimer in the documentation and/or other materials
23 * provided with the distribution.
25 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
26 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
27 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
28 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
29 * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
30 * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
31 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
34 * $Id: sysfs.c 1349 2004-12-16 21:09:43Z roland $
37 #include "core_priv.h"
39 #include <rdma/ib_mad.h>
43 struct ib_device
*ibdev
;
44 struct attribute_group gid_group
;
45 struct attribute_group pkey_group
;
49 struct port_attribute
{
50 struct attribute attr
;
51 ssize_t (*show
)(struct ib_port
*, struct port_attribute
*, char *buf
);
52 ssize_t (*store
)(struct ib_port
*, struct port_attribute
*,
53 const char *buf
, size_t count
);
56 #define PORT_ATTR(_name, _mode, _show, _store) \
57 struct port_attribute port_attr_##_name = __ATTR(_name, _mode, _show, _store)
59 #define PORT_ATTR_RO(_name) \
60 struct port_attribute port_attr_##_name = __ATTR_RO(_name)
62 struct port_table_attribute
{
63 struct port_attribute attr
;
68 static ssize_t
port_attr_show(struct kobject
*kobj
,
69 struct attribute
*attr
, char *buf
)
71 struct port_attribute
*port_attr
=
72 container_of(attr
, struct port_attribute
, attr
);
73 struct ib_port
*p
= container_of(kobj
, struct ib_port
, kobj
);
78 return port_attr
->show(p
, port_attr
, buf
);
81 static struct sysfs_ops port_sysfs_ops
= {
82 .show
= port_attr_show
85 static ssize_t
state_show(struct ib_port
*p
, struct port_attribute
*unused
,
88 struct ib_port_attr attr
;
91 static const char *state_name
[] = {
92 [IB_PORT_NOP
] = "NOP",
93 [IB_PORT_DOWN
] = "DOWN",
94 [IB_PORT_INIT
] = "INIT",
95 [IB_PORT_ARMED
] = "ARMED",
96 [IB_PORT_ACTIVE
] = "ACTIVE",
97 [IB_PORT_ACTIVE_DEFER
] = "ACTIVE_DEFER"
100 ret
= ib_query_port(p
->ibdev
, p
->port_num
, &attr
);
104 return sprintf(buf
, "%d: %s\n", attr
.state
,
105 attr
.state
>= 0 && attr
.state
<= ARRAY_SIZE(state_name
) ?
106 state_name
[attr
.state
] : "UNKNOWN");
109 static ssize_t
lid_show(struct ib_port
*p
, struct port_attribute
*unused
,
112 struct ib_port_attr attr
;
115 ret
= ib_query_port(p
->ibdev
, p
->port_num
, &attr
);
119 return sprintf(buf
, "0x%x\n", attr
.lid
);
122 static ssize_t
lid_mask_count_show(struct ib_port
*p
,
123 struct port_attribute
*unused
,
126 struct ib_port_attr attr
;
129 ret
= ib_query_port(p
->ibdev
, p
->port_num
, &attr
);
133 return sprintf(buf
, "%d\n", attr
.lmc
);
136 static ssize_t
sm_lid_show(struct ib_port
*p
, struct port_attribute
*unused
,
139 struct ib_port_attr attr
;
142 ret
= ib_query_port(p
->ibdev
, p
->port_num
, &attr
);
146 return sprintf(buf
, "0x%x\n", attr
.sm_lid
);
149 static ssize_t
sm_sl_show(struct ib_port
*p
, struct port_attribute
*unused
,
152 struct ib_port_attr attr
;
155 ret
= ib_query_port(p
->ibdev
, p
->port_num
, &attr
);
159 return sprintf(buf
, "%d\n", attr
.sm_sl
);
162 static ssize_t
cap_mask_show(struct ib_port
*p
, struct port_attribute
*unused
,
165 struct ib_port_attr attr
;
168 ret
= ib_query_port(p
->ibdev
, p
->port_num
, &attr
);
172 return sprintf(buf
, "0x%08x\n", attr
.port_cap_flags
);
175 static ssize_t
rate_show(struct ib_port
*p
, struct port_attribute
*unused
,
178 struct ib_port_attr attr
;
183 ret
= ib_query_port(p
->ibdev
, p
->port_num
, &attr
);
187 switch (attr
.active_speed
) {
188 case 2: speed
= " DDR"; break;
189 case 4: speed
= " QDR"; break;
192 rate
= 25 * ib_width_enum_to_int(attr
.active_width
) * attr
.active_speed
;
196 return sprintf(buf
, "%d%s Gb/sec (%dX%s)\n",
197 rate
/ 10, rate
% 10 ? ".5" : "",
198 ib_width_enum_to_int(attr
.active_width
), speed
);
201 static ssize_t
phys_state_show(struct ib_port
*p
, struct port_attribute
*unused
,
204 struct ib_port_attr attr
;
208 ret
= ib_query_port(p
->ibdev
, p
->port_num
, &attr
);
212 switch (attr
.phys_state
) {
213 case 1: return sprintf(buf
, "1: Sleep\n");
214 case 2: return sprintf(buf
, "2: Polling\n");
215 case 3: return sprintf(buf
, "3: Disabled\n");
216 case 4: return sprintf(buf
, "4: PortConfigurationTraining\n");
217 case 5: return sprintf(buf
, "5: LinkUp\n");
218 case 6: return sprintf(buf
, "6: LinkErrorRecovery\n");
219 case 7: return sprintf(buf
, "7: Phy Test\n");
220 default: return sprintf(buf
, "%d: <unknown>\n", attr
.phys_state
);
224 static PORT_ATTR_RO(state
);
225 static PORT_ATTR_RO(lid
);
226 static PORT_ATTR_RO(lid_mask_count
);
227 static PORT_ATTR_RO(sm_lid
);
228 static PORT_ATTR_RO(sm_sl
);
229 static PORT_ATTR_RO(cap_mask
);
230 static PORT_ATTR_RO(rate
);
231 static PORT_ATTR_RO(phys_state
);
233 static struct attribute
*port_default_attrs
[] = {
234 &port_attr_state
.attr
,
236 &port_attr_lid_mask_count
.attr
,
237 &port_attr_sm_lid
.attr
,
238 &port_attr_sm_sl
.attr
,
239 &port_attr_cap_mask
.attr
,
240 &port_attr_rate
.attr
,
241 &port_attr_phys_state
.attr
,
245 static ssize_t
show_port_gid(struct ib_port
*p
, struct port_attribute
*attr
,
248 struct port_table_attribute
*tab_attr
=
249 container_of(attr
, struct port_table_attribute
, attr
);
253 ret
= ib_query_gid(p
->ibdev
, p
->port_num
, tab_attr
->index
, &gid
);
257 return sprintf(buf
, "%04x:%04x:%04x:%04x:%04x:%04x:%04x:%04x\n",
258 be16_to_cpu(((__be16
*) gid
.raw
)[0]),
259 be16_to_cpu(((__be16
*) gid
.raw
)[1]),
260 be16_to_cpu(((__be16
*) gid
.raw
)[2]),
261 be16_to_cpu(((__be16
*) gid
.raw
)[3]),
262 be16_to_cpu(((__be16
*) gid
.raw
)[4]),
263 be16_to_cpu(((__be16
*) gid
.raw
)[5]),
264 be16_to_cpu(((__be16
*) gid
.raw
)[6]),
265 be16_to_cpu(((__be16
*) gid
.raw
)[7]));
268 static ssize_t
show_port_pkey(struct ib_port
*p
, struct port_attribute
*attr
,
271 struct port_table_attribute
*tab_attr
=
272 container_of(attr
, struct port_table_attribute
, attr
);
276 ret
= ib_query_pkey(p
->ibdev
, p
->port_num
, tab_attr
->index
, &pkey
);
280 return sprintf(buf
, "0x%04x\n", pkey
);
283 #define PORT_PMA_ATTR(_name, _counter, _width, _offset) \
284 struct port_table_attribute port_pma_attr_##_name = { \
285 .attr = __ATTR(_name, S_IRUGO, show_pma_counter, NULL), \
286 .index = (_offset) | ((_width) << 16) | ((_counter) << 24) \
289 static ssize_t
show_pma_counter(struct ib_port
*p
, struct port_attribute
*attr
,
292 struct port_table_attribute
*tab_attr
=
293 container_of(attr
, struct port_table_attribute
, attr
);
294 int offset
= tab_attr
->index
& 0xffff;
295 int width
= (tab_attr
->index
>> 16) & 0xff;
296 struct ib_mad
*in_mad
= NULL
;
297 struct ib_mad
*out_mad
= NULL
;
300 if (!p
->ibdev
->process_mad
)
301 return sprintf(buf
, "N/A (no PMA)\n");
303 in_mad
= kmalloc(sizeof *in_mad
, GFP_KERNEL
);
304 out_mad
= kmalloc(sizeof *in_mad
, GFP_KERNEL
);
305 if (!in_mad
|| !out_mad
) {
310 memset(in_mad
, 0, sizeof *in_mad
);
311 in_mad
->mad_hdr
.base_version
= 1;
312 in_mad
->mad_hdr
.mgmt_class
= IB_MGMT_CLASS_PERF_MGMT
;
313 in_mad
->mad_hdr
.class_version
= 1;
314 in_mad
->mad_hdr
.method
= IB_MGMT_METHOD_GET
;
315 in_mad
->mad_hdr
.attr_id
= cpu_to_be16(0x12); /* PortCounters */
317 in_mad
->data
[41] = p
->port_num
; /* PortSelect field */
319 if ((p
->ibdev
->process_mad(p
->ibdev
, IB_MAD_IGNORE_MKEY
,
320 p
->port_num
, NULL
, NULL
, in_mad
, out_mad
) &
321 (IB_MAD_RESULT_SUCCESS
| IB_MAD_RESULT_REPLY
)) !=
322 (IB_MAD_RESULT_SUCCESS
| IB_MAD_RESULT_REPLY
)) {
329 ret
= sprintf(buf
, "%u\n", (out_mad
->data
[40 + offset
/ 8] >>
330 (offset
% 4)) & 0xf);
333 ret
= sprintf(buf
, "%u\n", out_mad
->data
[40 + offset
/ 8]);
336 ret
= sprintf(buf
, "%u\n",
337 be16_to_cpup((__be16
*)(out_mad
->data
+ 40 + offset
/ 8)));
340 ret
= sprintf(buf
, "%u\n",
341 be32_to_cpup((__be32
*)(out_mad
->data
+ 40 + offset
/ 8)));
354 static PORT_PMA_ATTR(symbol_error
, 0, 16, 32);
355 static PORT_PMA_ATTR(link_error_recovery
, 1, 8, 48);
356 static PORT_PMA_ATTR(link_downed
, 2, 8, 56);
357 static PORT_PMA_ATTR(port_rcv_errors
, 3, 16, 64);
358 static PORT_PMA_ATTR(port_rcv_remote_physical_errors
, 4, 16, 80);
359 static PORT_PMA_ATTR(port_rcv_switch_relay_errors
, 5, 16, 96);
360 static PORT_PMA_ATTR(port_xmit_discards
, 6, 16, 112);
361 static PORT_PMA_ATTR(port_xmit_constraint_errors
, 7, 8, 128);
362 static PORT_PMA_ATTR(port_rcv_constraint_errors
, 8, 8, 136);
363 static PORT_PMA_ATTR(local_link_integrity_errors
, 9, 4, 152);
364 static PORT_PMA_ATTR(excessive_buffer_overrun_errors
, 10, 4, 156);
365 static PORT_PMA_ATTR(VL15_dropped
, 11, 16, 176);
366 static PORT_PMA_ATTR(port_xmit_data
, 12, 32, 192);
367 static PORT_PMA_ATTR(port_rcv_data
, 13, 32, 224);
368 static PORT_PMA_ATTR(port_xmit_packets
, 14, 32, 256);
369 static PORT_PMA_ATTR(port_rcv_packets
, 15, 32, 288);
371 static struct attribute
*pma_attrs
[] = {
372 &port_pma_attr_symbol_error
.attr
.attr
,
373 &port_pma_attr_link_error_recovery
.attr
.attr
,
374 &port_pma_attr_link_downed
.attr
.attr
,
375 &port_pma_attr_port_rcv_errors
.attr
.attr
,
376 &port_pma_attr_port_rcv_remote_physical_errors
.attr
.attr
,
377 &port_pma_attr_port_rcv_switch_relay_errors
.attr
.attr
,
378 &port_pma_attr_port_xmit_discards
.attr
.attr
,
379 &port_pma_attr_port_xmit_constraint_errors
.attr
.attr
,
380 &port_pma_attr_port_rcv_constraint_errors
.attr
.attr
,
381 &port_pma_attr_local_link_integrity_errors
.attr
.attr
,
382 &port_pma_attr_excessive_buffer_overrun_errors
.attr
.attr
,
383 &port_pma_attr_VL15_dropped
.attr
.attr
,
384 &port_pma_attr_port_xmit_data
.attr
.attr
,
385 &port_pma_attr_port_rcv_data
.attr
.attr
,
386 &port_pma_attr_port_xmit_packets
.attr
.attr
,
387 &port_pma_attr_port_rcv_packets
.attr
.attr
,
391 static struct attribute_group pma_group
= {
396 static void ib_port_release(struct kobject
*kobj
)
398 struct ib_port
*p
= container_of(kobj
, struct ib_port
, kobj
);
402 for (i
= 0; (a
= p
->gid_group
.attrs
[i
]); ++i
)
405 kfree(p
->gid_group
.attrs
);
407 for (i
= 0; (a
= p
->pkey_group
.attrs
[i
]); ++i
)
410 kfree(p
->pkey_group
.attrs
);
415 static struct kobj_type port_type
= {
416 .release
= ib_port_release
,
417 .sysfs_ops
= &port_sysfs_ops
,
418 .default_attrs
= port_default_attrs
421 static void ib_device_release(struct class_device
*cdev
)
423 struct ib_device
*dev
= container_of(cdev
, struct ib_device
, class_dev
);
428 static int ib_device_hotplug(struct class_device
*cdev
, char **envp
,
429 int num_envp
, char *buf
, int size
)
431 struct ib_device
*dev
= container_of(cdev
, struct ib_device
, class_dev
);
434 if (add_hotplug_env_var(envp
, num_envp
, &i
, buf
, size
, &len
,
435 "NAME=%s", dev
->name
))
439 * It might be nice to pass the node GUID to hotplug, but
440 * right now the only way to get it is to query the device
441 * provider, and this can crash during device removal because
442 * we are will be running after driver removal has started.
443 * We could add a node_guid field to struct ib_device, or we
444 * could just let the hotplug script read the node GUID from
445 * sysfs when devices are added.
452 static struct attribute
**
453 alloc_group_attrs(ssize_t (*show
)(struct ib_port
*,
454 struct port_attribute
*, char *buf
),
457 struct attribute
**tab_attr
;
458 struct port_table_attribute
*element
;
461 tab_attr
= kcalloc(1 + len
, sizeof(struct attribute
*), GFP_KERNEL
);
465 for (i
= 0; i
< len
; i
++) {
466 element
= kcalloc(1, sizeof(struct port_table_attribute
),
471 if (snprintf(element
->name
, sizeof(element
->name
),
472 "%d", i
) >= sizeof(element
->name
))
475 element
->attr
.attr
.name
= element
->name
;
476 element
->attr
.attr
.mode
= S_IRUGO
;
477 element
->attr
.attr
.owner
= THIS_MODULE
;
478 element
->attr
.show
= show
;
481 tab_attr
[i
] = &element
->attr
.attr
;
493 static int add_port(struct ib_device
*device
, int port_num
)
496 struct ib_port_attr attr
;
500 ret
= ib_query_port(device
, port_num
, &attr
);
504 p
= kmalloc(sizeof *p
, GFP_KERNEL
);
507 memset(p
, 0, sizeof *p
);
510 p
->port_num
= port_num
;
511 p
->kobj
.ktype
= &port_type
;
513 p
->kobj
.parent
= kobject_get(&device
->ports_parent
);
514 if (!p
->kobj
.parent
) {
519 ret
= kobject_set_name(&p
->kobj
, "%d", port_num
);
523 ret
= kobject_register(&p
->kobj
);
527 ret
= sysfs_create_group(&p
->kobj
, &pma_group
);
531 p
->gid_group
.name
= "gids";
532 p
->gid_group
.attrs
= alloc_group_attrs(show_port_gid
, attr
.gid_tbl_len
);
533 if (!p
->gid_group
.attrs
)
536 ret
= sysfs_create_group(&p
->kobj
, &p
->gid_group
);
540 p
->pkey_group
.name
= "pkeys";
541 p
->pkey_group
.attrs
= alloc_group_attrs(show_port_pkey
,
543 if (!p
->pkey_group
.attrs
)
546 ret
= sysfs_create_group(&p
->kobj
, &p
->pkey_group
);
550 list_add_tail(&p
->kobj
.entry
, &device
->port_list
);
555 for (i
= 0; i
< attr
.pkey_tbl_len
; ++i
)
556 kfree(p
->pkey_group
.attrs
[i
]);
558 kfree(p
->pkey_group
.attrs
);
561 sysfs_remove_group(&p
->kobj
, &p
->gid_group
);
564 for (i
= 0; i
< attr
.gid_tbl_len
; ++i
)
565 kfree(p
->gid_group
.attrs
[i
]);
567 kfree(p
->gid_group
.attrs
);
570 sysfs_remove_group(&p
->kobj
, &pma_group
);
573 kobject_put(&device
->ports_parent
);
580 static ssize_t
show_node_type(struct class_device
*cdev
, char *buf
)
582 struct ib_device
*dev
= container_of(cdev
, struct ib_device
, class_dev
);
584 switch (dev
->node_type
) {
585 case IB_NODE_CA
: return sprintf(buf
, "%d: CA\n", dev
->node_type
);
586 case IB_NODE_SWITCH
: return sprintf(buf
, "%d: switch\n", dev
->node_type
);
587 case IB_NODE_ROUTER
: return sprintf(buf
, "%d: router\n", dev
->node_type
);
588 default: return sprintf(buf
, "%d: <unknown>\n", dev
->node_type
);
592 static ssize_t
show_sys_image_guid(struct class_device
*cdev
, char *buf
)
594 struct ib_device
*dev
= container_of(cdev
, struct ib_device
, class_dev
);
595 struct ib_device_attr attr
;
598 ret
= ib_query_device(dev
, &attr
);
602 return sprintf(buf
, "%04x:%04x:%04x:%04x\n",
603 be16_to_cpu(((__be16
*) &attr
.sys_image_guid
)[0]),
604 be16_to_cpu(((__be16
*) &attr
.sys_image_guid
)[1]),
605 be16_to_cpu(((__be16
*) &attr
.sys_image_guid
)[2]),
606 be16_to_cpu(((__be16
*) &attr
.sys_image_guid
)[3]));
609 static ssize_t
show_node_guid(struct class_device
*cdev
, char *buf
)
611 struct ib_device
*dev
= container_of(cdev
, struct ib_device
, class_dev
);
612 struct ib_device_attr attr
;
615 ret
= ib_query_device(dev
, &attr
);
619 return sprintf(buf
, "%04x:%04x:%04x:%04x\n",
620 be16_to_cpu(((__be16
*) &attr
.node_guid
)[0]),
621 be16_to_cpu(((__be16
*) &attr
.node_guid
)[1]),
622 be16_to_cpu(((__be16
*) &attr
.node_guid
)[2]),
623 be16_to_cpu(((__be16
*) &attr
.node_guid
)[3]));
626 static CLASS_DEVICE_ATTR(node_type
, S_IRUGO
, show_node_type
, NULL
);
627 static CLASS_DEVICE_ATTR(sys_image_guid
, S_IRUGO
, show_sys_image_guid
, NULL
);
628 static CLASS_DEVICE_ATTR(node_guid
, S_IRUGO
, show_node_guid
, NULL
);
630 static struct class_device_attribute
*ib_class_attributes
[] = {
631 &class_device_attr_node_type
,
632 &class_device_attr_sys_image_guid
,
633 &class_device_attr_node_guid
636 static struct class ib_class
= {
637 .name
= "infiniband",
638 .release
= ib_device_release
,
639 .hotplug
= ib_device_hotplug
,
642 int ib_device_register_sysfs(struct ib_device
*device
)
644 struct class_device
*class_dev
= &device
->class_dev
;
648 class_dev
->class = &ib_class
;
649 class_dev
->class_data
= device
;
650 strlcpy(class_dev
->class_id
, device
->name
, BUS_ID_SIZE
);
652 INIT_LIST_HEAD(&device
->port_list
);
654 ret
= class_device_register(class_dev
);
658 for (i
= 0; i
< ARRAY_SIZE(ib_class_attributes
); ++i
) {
659 ret
= class_device_create_file(class_dev
, ib_class_attributes
[i
]);
664 device
->ports_parent
.parent
= kobject_get(&class_dev
->kobj
);
665 if (!device
->ports_parent
.parent
) {
669 ret
= kobject_set_name(&device
->ports_parent
, "ports");
672 ret
= kobject_register(&device
->ports_parent
);
676 if (device
->node_type
== IB_NODE_SWITCH
) {
677 ret
= add_port(device
, 0);
683 for (i
= 1; i
<= device
->phys_port_cnt
; ++i
) {
684 ret
= add_port(device
, i
);
694 struct kobject
*p
, *t
;
695 struct ib_port
*port
;
697 list_for_each_entry_safe(p
, t
, &device
->port_list
, entry
) {
699 port
= container_of(p
, struct ib_port
, kobj
);
700 sysfs_remove_group(p
, &pma_group
);
701 sysfs_remove_group(p
, &port
->pkey_group
);
702 sysfs_remove_group(p
, &port
->gid_group
);
703 kobject_unregister(p
);
707 kobject_put(&class_dev
->kobj
);
710 class_device_unregister(class_dev
);
716 void ib_device_unregister_sysfs(struct ib_device
*device
)
718 struct kobject
*p
, *t
;
719 struct ib_port
*port
;
721 list_for_each_entry_safe(p
, t
, &device
->port_list
, entry
) {
723 port
= container_of(p
, struct ib_port
, kobj
);
724 sysfs_remove_group(p
, &pma_group
);
725 sysfs_remove_group(p
, &port
->pkey_group
);
726 sysfs_remove_group(p
, &port
->gid_group
);
727 kobject_unregister(p
);
730 kobject_unregister(&device
->ports_parent
);
731 class_device_unregister(&device
->class_dev
);
734 int ib_sysfs_setup(void)
736 return class_register(&ib_class
);
739 void ib_sysfs_cleanup(void)
741 class_unregister(&ib_class
);