2 * Copyright (c) 2004 Topspin Communications. All rights reserved.
3 * Copyright (c) 2005 Voltaire, Inc. 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: user_mad.c 2814 2005-07-06 19:14:09Z halr $
37 #include <linux/module.h>
38 #include <linux/init.h>
39 #include <linux/device.h>
40 #include <linux/err.h>
42 #include <linux/cdev.h>
43 #include <linux/pci.h>
44 #include <linux/dma-mapping.h>
45 #include <linux/poll.h>
46 #include <linux/rwsem.h>
47 #include <linux/kref.h>
49 #include <asm/uaccess.h>
50 #include <asm/semaphore.h>
52 #include <rdma/ib_mad.h>
53 #include <rdma/ib_user_mad.h>
55 MODULE_AUTHOR("Roland Dreier");
56 MODULE_DESCRIPTION("InfiniBand userspace MAD packet access");
57 MODULE_LICENSE("Dual BSD/GPL");
60 IB_UMAD_MAX_PORTS
= 64,
61 IB_UMAD_MAX_AGENTS
= 32,
64 IB_UMAD_MINOR_BASE
= 0
70 struct class_device class_dev
;
74 struct class_device sm_class_dev
;
75 struct semaphore sm_sem
;
77 struct ib_device
*ib_dev
;
78 struct ib_umad_device
*umad_dev
;
82 struct ib_umad_device
{
83 int start_port
, end_port
;
85 struct ib_umad_port port
[0];
89 struct ib_umad_port
*port
;
91 struct list_head recv_list
;
92 wait_queue_head_t recv_wait
;
93 struct rw_semaphore agent_mutex
;
94 struct ib_mad_agent
*agent
[IB_UMAD_MAX_AGENTS
];
95 struct ib_mr
*mr
[IB_UMAD_MAX_AGENTS
];
98 struct ib_umad_packet
{
100 struct ib_mad_send_buf
*msg
;
101 struct list_head list
;
103 DECLARE_PCI_UNMAP_ADDR(mapping
)
104 struct ib_user_mad mad
;
107 static const dev_t base_dev
= MKDEV(IB_UMAD_MAJOR
, IB_UMAD_MINOR_BASE
);
108 static spinlock_t map_lock
;
109 static DECLARE_BITMAP(dev_map
, IB_UMAD_MAX_PORTS
* 2);
111 static void ib_umad_add_one(struct ib_device
*device
);
112 static void ib_umad_remove_one(struct ib_device
*device
);
114 static int queue_packet(struct ib_umad_file
*file
,
115 struct ib_mad_agent
*agent
,
116 struct ib_umad_packet
*packet
)
120 down_read(&file
->agent_mutex
);
121 for (packet
->mad
.hdr
.id
= 0;
122 packet
->mad
.hdr
.id
< IB_UMAD_MAX_AGENTS
;
123 packet
->mad
.hdr
.id
++)
124 if (agent
== file
->agent
[packet
->mad
.hdr
.id
]) {
125 spin_lock_irq(&file
->recv_lock
);
126 list_add_tail(&packet
->list
, &file
->recv_list
);
127 spin_unlock_irq(&file
->recv_lock
);
128 wake_up_interruptible(&file
->recv_wait
);
133 up_read(&file
->agent_mutex
);
138 static void send_handler(struct ib_mad_agent
*agent
,
139 struct ib_mad_send_wc
*send_wc
)
141 struct ib_umad_file
*file
= agent
->context
;
142 struct ib_umad_packet
*timeout
, *packet
=
143 (void *) (unsigned long) send_wc
->wr_id
;
145 ib_destroy_ah(packet
->msg
->send_wr
.wr
.ud
.ah
);
146 ib_free_send_mad(packet
->msg
);
148 if (send_wc
->status
== IB_WC_RESP_TIMEOUT_ERR
) {
149 timeout
= kmalloc(sizeof *timeout
+ sizeof (struct ib_mad_hdr
),
154 memset(timeout
, 0, sizeof *timeout
+ sizeof (struct ib_mad_hdr
));
156 timeout
->length
= sizeof (struct ib_mad_hdr
);
157 timeout
->mad
.hdr
.id
= packet
->mad
.hdr
.id
;
158 timeout
->mad
.hdr
.status
= ETIMEDOUT
;
159 memcpy(timeout
->mad
.data
, packet
->mad
.data
,
160 sizeof (struct ib_mad_hdr
));
162 if (!queue_packet(file
, agent
, timeout
))
169 static void recv_handler(struct ib_mad_agent
*agent
,
170 struct ib_mad_recv_wc
*mad_recv_wc
)
172 struct ib_umad_file
*file
= agent
->context
;
173 struct ib_umad_packet
*packet
;
176 if (mad_recv_wc
->wc
->status
!= IB_WC_SUCCESS
)
179 length
= mad_recv_wc
->mad_len
;
180 packet
= kmalloc(sizeof *packet
+ length
, GFP_KERNEL
);
184 memset(packet
, 0, sizeof *packet
+ length
);
185 packet
->length
= length
;
187 ib_coalesce_recv_mad(mad_recv_wc
, packet
->mad
.data
);
189 packet
->mad
.hdr
.status
= 0;
190 packet
->mad
.hdr
.length
= length
+ sizeof (struct ib_user_mad
);
191 packet
->mad
.hdr
.qpn
= cpu_to_be32(mad_recv_wc
->wc
->src_qp
);
192 packet
->mad
.hdr
.lid
= cpu_to_be16(mad_recv_wc
->wc
->slid
);
193 packet
->mad
.hdr
.sl
= mad_recv_wc
->wc
->sl
;
194 packet
->mad
.hdr
.path_bits
= mad_recv_wc
->wc
->dlid_path_bits
;
195 packet
->mad
.hdr
.grh_present
= !!(mad_recv_wc
->wc
->wc_flags
& IB_WC_GRH
);
196 if (packet
->mad
.hdr
.grh_present
) {
198 packet
->mad
.hdr
.gid_index
= 0;
199 packet
->mad
.hdr
.hop_limit
= 0;
200 packet
->mad
.hdr
.traffic_class
= 0;
201 memset(packet
->mad
.hdr
.gid
, 0, 16);
202 packet
->mad
.hdr
.flow_label
= 0;
205 if (queue_packet(file
, agent
, packet
))
209 ib_free_recv_mad(mad_recv_wc
);
212 static ssize_t
ib_umad_read(struct file
*filp
, char __user
*buf
,
213 size_t count
, loff_t
*pos
)
215 struct ib_umad_file
*file
= filp
->private_data
;
216 struct ib_umad_packet
*packet
;
219 if (count
< sizeof (struct ib_user_mad
) + sizeof (struct ib_mad
))
222 spin_lock_irq(&file
->recv_lock
);
224 while (list_empty(&file
->recv_list
)) {
225 spin_unlock_irq(&file
->recv_lock
);
227 if (filp
->f_flags
& O_NONBLOCK
)
230 if (wait_event_interruptible(file
->recv_wait
,
231 !list_empty(&file
->recv_list
)))
234 spin_lock_irq(&file
->recv_lock
);
237 packet
= list_entry(file
->recv_list
.next
, struct ib_umad_packet
, list
);
238 list_del(&packet
->list
);
240 spin_unlock_irq(&file
->recv_lock
);
242 if (count
< packet
->length
+ sizeof (struct ib_user_mad
)) {
243 /* Return length needed (and first RMPP segment) if too small */
244 if (copy_to_user(buf
, &packet
->mad
,
245 sizeof (struct ib_user_mad
) + sizeof (struct ib_mad
)))
249 } else if (copy_to_user(buf
, &packet
->mad
,
250 packet
->length
+ sizeof (struct ib_user_mad
)))
253 ret
= packet
->length
+ sizeof (struct ib_user_mad
);
256 spin_lock_irq(&file
->recv_lock
);
257 list_add(&packet
->list
, &file
->recv_list
);
258 spin_unlock_irq(&file
->recv_lock
);
264 static ssize_t
ib_umad_write(struct file
*filp
, const char __user
*buf
,
265 size_t count
, loff_t
*pos
)
267 struct ib_umad_file
*file
= filp
->private_data
;
268 struct ib_umad_packet
*packet
;
269 struct ib_mad_agent
*agent
;
270 struct ib_ah_attr ah_attr
;
271 struct ib_send_wr
*bad_wr
;
272 struct ib_rmpp_mad
*rmpp_mad
;
275 int ret
, length
, hdr_len
, data_len
, rmpp_hdr_size
;
278 if (count
< sizeof (struct ib_user_mad
))
281 length
= count
- sizeof (struct ib_user_mad
);
282 packet
= kmalloc(sizeof *packet
+ sizeof(struct ib_mad_hdr
) +
283 sizeof(struct ib_rmpp_hdr
), GFP_KERNEL
);
287 if (copy_from_user(&packet
->mad
, buf
,
288 sizeof (struct ib_user_mad
) +
289 sizeof(struct ib_mad_hdr
) +
290 sizeof(struct ib_rmpp_hdr
))) {
295 if (packet
->mad
.hdr
.id
< 0 ||
296 packet
->mad
.hdr
.id
>= IB_UMAD_MAX_AGENTS
) {
301 packet
->length
= length
;
303 down_read(&file
->agent_mutex
);
305 agent
= file
->agent
[packet
->mad
.hdr
.id
];
311 memset(&ah_attr
, 0, sizeof ah_attr
);
312 ah_attr
.dlid
= be16_to_cpu(packet
->mad
.hdr
.lid
);
313 ah_attr
.sl
= packet
->mad
.hdr
.sl
;
314 ah_attr
.src_path_bits
= packet
->mad
.hdr
.path_bits
;
315 ah_attr
.port_num
= file
->port
->port_num
;
316 if (packet
->mad
.hdr
.grh_present
) {
317 ah_attr
.ah_flags
= IB_AH_GRH
;
318 memcpy(ah_attr
.grh
.dgid
.raw
, packet
->mad
.hdr
.gid
, 16);
319 ah_attr
.grh
.flow_label
= be32_to_cpu(packet
->mad
.hdr
.flow_label
);
320 ah_attr
.grh
.hop_limit
= packet
->mad
.hdr
.hop_limit
;
321 ah_attr
.grh
.traffic_class
= packet
->mad
.hdr
.traffic_class
;
324 packet
->ah
= ib_create_ah(agent
->qp
->pd
, &ah_attr
);
325 if (IS_ERR(packet
->ah
)) {
326 ret
= PTR_ERR(packet
->ah
);
330 rmpp_mad
= (struct ib_rmpp_mad
*) packet
->mad
.data
;
331 if (ib_get_rmpp_flags(&rmpp_mad
->rmpp_hdr
) & IB_MGMT_RMPP_FLAG_ACTIVE
) {
333 if (!agent
->rmpp_version
) {
338 /* Validate that the management class can support RMPP */
339 if (rmpp_mad
->mad_hdr
.mgmt_class
== IB_MGMT_CLASS_SUBN_ADM
) {
340 hdr_len
= offsetof(struct ib_sa_mad
, data
);
341 data_len
= length
- hdr_len
;
342 } else if ((rmpp_mad
->mad_hdr
.mgmt_class
>= IB_MGMT_CLASS_VENDOR_RANGE2_START
) &&
343 (rmpp_mad
->mad_hdr
.mgmt_class
<= IB_MGMT_CLASS_VENDOR_RANGE2_END
)) {
344 hdr_len
= offsetof(struct ib_vendor_mad
, data
);
345 data_len
= length
- hdr_len
;
352 if (length
> sizeof(struct ib_mad
)) {
356 hdr_len
= offsetof(struct ib_mad
, data
);
357 data_len
= length
- hdr_len
;
360 packet
->msg
= ib_create_send_mad(agent
,
361 be32_to_cpu(packet
->mad
.hdr
.qpn
),
362 0, packet
->ah
, rmpp_active
,
365 if (IS_ERR(packet
->msg
)) {
366 ret
= PTR_ERR(packet
->msg
);
370 packet
->msg
->send_wr
.wr
.ud
.timeout_ms
= packet
->mad
.hdr
.timeout_ms
;
371 packet
->msg
->send_wr
.wr
.ud
.retries
= packet
->mad
.hdr
.retries
;
373 /* Override send WR WRID initialized in ib_create_send_mad */
374 packet
->msg
->send_wr
.wr_id
= (unsigned long) packet
;
377 /* Copy message from user into send buffer */
378 if (copy_from_user(packet
->msg
->mad
,
379 buf
+ sizeof(struct ib_user_mad
), length
)) {
384 rmpp_hdr_size
= sizeof(struct ib_mad_hdr
) +
385 sizeof(struct ib_rmpp_hdr
);
387 /* Only copy MAD headers (RMPP header in place) */
388 memcpy(packet
->msg
->mad
, packet
->mad
.data
,
389 sizeof(struct ib_mad_hdr
));
391 /* Now, copy rest of message from user into send buffer */
392 if (copy_from_user(((struct ib_rmpp_mad
*) packet
->msg
->mad
)->data
,
393 buf
+ sizeof (struct ib_user_mad
) + rmpp_hdr_size
,
394 length
- rmpp_hdr_size
)) {
401 * If userspace is generating a request that will generate a
402 * response, we need to make sure the high-order part of the
403 * transaction ID matches the agent being used to send the
406 method
= packet
->msg
->mad
->mad_hdr
.method
;
408 if (!(method
& IB_MGMT_METHOD_RESP
) &&
409 method
!= IB_MGMT_METHOD_TRAP_REPRESS
&&
410 method
!= IB_MGMT_METHOD_SEND
) {
411 tid
= &packet
->msg
->mad
->mad_hdr
.tid
;
412 *tid
= cpu_to_be64(((u64
) agent
->hi_tid
) << 32 |
413 (be64_to_cpup(tid
) & 0xffffffff));
416 ret
= ib_post_send_mad(agent
, &packet
->msg
->send_wr
, &bad_wr
);
420 up_read(&file
->agent_mutex
);
422 return sizeof (struct ib_user_mad_hdr
) + packet
->length
;
425 ib_free_send_mad(packet
->msg
);
428 ib_destroy_ah(packet
->ah
);
431 up_read(&file
->agent_mutex
);
438 static unsigned int ib_umad_poll(struct file
*filp
, struct poll_table_struct
*wait
)
440 struct ib_umad_file
*file
= filp
->private_data
;
442 /* we will always be able to post a MAD send */
443 unsigned int mask
= POLLOUT
| POLLWRNORM
;
445 poll_wait(filp
, &file
->recv_wait
, wait
);
447 if (!list_empty(&file
->recv_list
))
448 mask
|= POLLIN
| POLLRDNORM
;
453 static int ib_umad_reg_agent(struct ib_umad_file
*file
, unsigned long arg
)
455 struct ib_user_mad_reg_req ureq
;
456 struct ib_mad_reg_req req
;
457 struct ib_mad_agent
*agent
;
461 down_write(&file
->agent_mutex
);
463 if (copy_from_user(&ureq
, (void __user
*) arg
, sizeof ureq
)) {
468 if (ureq
.qpn
!= 0 && ureq
.qpn
!= 1) {
473 for (agent_id
= 0; agent_id
< IB_UMAD_MAX_AGENTS
; ++agent_id
)
474 if (!file
->agent
[agent_id
])
481 if (ureq
.mgmt_class
) {
482 req
.mgmt_class
= ureq
.mgmt_class
;
483 req
.mgmt_class_version
= ureq
.mgmt_class_version
;
484 memcpy(req
.method_mask
, ureq
.method_mask
, sizeof req
.method_mask
);
485 memcpy(req
.oui
, ureq
.oui
, sizeof req
.oui
);
488 agent
= ib_register_mad_agent(file
->port
->ib_dev
, file
->port
->port_num
,
489 ureq
.qpn
? IB_QPT_GSI
: IB_QPT_SMI
,
490 ureq
.mgmt_class
? &req
: NULL
,
492 send_handler
, recv_handler
, file
);
494 ret
= PTR_ERR(agent
);
498 file
->agent
[agent_id
] = agent
;
500 file
->mr
[agent_id
] = ib_get_dma_mr(agent
->qp
->pd
, IB_ACCESS_LOCAL_WRITE
);
501 if (IS_ERR(file
->mr
[agent_id
])) {
506 if (put_user(agent_id
,
507 (u32 __user
*) (arg
+ offsetof(struct ib_user_mad_reg_req
, id
)))) {
516 ib_dereg_mr(file
->mr
[agent_id
]);
519 file
->agent
[agent_id
] = NULL
;
520 ib_unregister_mad_agent(agent
);
523 up_write(&file
->agent_mutex
);
527 static int ib_umad_unreg_agent(struct ib_umad_file
*file
, unsigned long arg
)
532 down_write(&file
->agent_mutex
);
534 if (get_user(id
, (u32 __user
*) arg
)) {
539 if (id
< 0 || id
>= IB_UMAD_MAX_AGENTS
|| !file
->agent
[id
]) {
544 ib_dereg_mr(file
->mr
[id
]);
545 ib_unregister_mad_agent(file
->agent
[id
]);
546 file
->agent
[id
] = NULL
;
549 up_write(&file
->agent_mutex
);
553 static long ib_umad_ioctl(struct file
*filp
, unsigned int cmd
,
557 case IB_USER_MAD_REGISTER_AGENT
:
558 return ib_umad_reg_agent(filp
->private_data
, arg
);
559 case IB_USER_MAD_UNREGISTER_AGENT
:
560 return ib_umad_unreg_agent(filp
->private_data
, arg
);
566 static int ib_umad_open(struct inode
*inode
, struct file
*filp
)
568 struct ib_umad_port
*port
=
569 container_of(inode
->i_cdev
, struct ib_umad_port
, dev
);
570 struct ib_umad_file
*file
;
572 file
= kmalloc(sizeof *file
, GFP_KERNEL
);
576 memset(file
, 0, sizeof *file
);
578 spin_lock_init(&file
->recv_lock
);
579 init_rwsem(&file
->agent_mutex
);
580 INIT_LIST_HEAD(&file
->recv_list
);
581 init_waitqueue_head(&file
->recv_wait
);
584 filp
->private_data
= file
;
589 static int ib_umad_close(struct inode
*inode
, struct file
*filp
)
591 struct ib_umad_file
*file
= filp
->private_data
;
592 struct ib_umad_packet
*packet
, *tmp
;
595 for (i
= 0; i
< IB_UMAD_MAX_AGENTS
; ++i
)
596 if (file
->agent
[i
]) {
597 ib_dereg_mr(file
->mr
[i
]);
598 ib_unregister_mad_agent(file
->agent
[i
]);
601 list_for_each_entry_safe(packet
, tmp
, &file
->recv_list
, list
)
609 static struct file_operations umad_fops
= {
610 .owner
= THIS_MODULE
,
611 .read
= ib_umad_read
,
612 .write
= ib_umad_write
,
613 .poll
= ib_umad_poll
,
614 .unlocked_ioctl
= ib_umad_ioctl
,
615 .compat_ioctl
= ib_umad_ioctl
,
616 .open
= ib_umad_open
,
617 .release
= ib_umad_close
620 static int ib_umad_sm_open(struct inode
*inode
, struct file
*filp
)
622 struct ib_umad_port
*port
=
623 container_of(inode
->i_cdev
, struct ib_umad_port
, sm_dev
);
624 struct ib_port_modify props
= {
625 .set_port_cap_mask
= IB_PORT_SM
629 if (filp
->f_flags
& O_NONBLOCK
) {
630 if (down_trylock(&port
->sm_sem
))
633 if (down_interruptible(&port
->sm_sem
))
637 ret
= ib_modify_port(port
->ib_dev
, port
->port_num
, 0, &props
);
643 filp
->private_data
= port
;
648 static int ib_umad_sm_close(struct inode
*inode
, struct file
*filp
)
650 struct ib_umad_port
*port
= filp
->private_data
;
651 struct ib_port_modify props
= {
652 .clr_port_cap_mask
= IB_PORT_SM
656 ret
= ib_modify_port(port
->ib_dev
, port
->port_num
, 0, &props
);
662 static struct file_operations umad_sm_fops
= {
663 .owner
= THIS_MODULE
,
664 .open
= ib_umad_sm_open
,
665 .release
= ib_umad_sm_close
668 static struct ib_client umad_client
= {
670 .add
= ib_umad_add_one
,
671 .remove
= ib_umad_remove_one
674 static ssize_t
show_dev(struct class_device
*class_dev
, char *buf
)
676 struct ib_umad_port
*port
= class_get_devdata(class_dev
);
678 if (class_dev
== &port
->class_dev
)
679 return print_dev_t(buf
, port
->dev
.dev
);
681 return print_dev_t(buf
, port
->sm_dev
.dev
);
683 static CLASS_DEVICE_ATTR(dev
, S_IRUGO
, show_dev
, NULL
);
685 static ssize_t
show_ibdev(struct class_device
*class_dev
, char *buf
)
687 struct ib_umad_port
*port
= class_get_devdata(class_dev
);
689 return sprintf(buf
, "%s\n", port
->ib_dev
->name
);
691 static CLASS_DEVICE_ATTR(ibdev
, S_IRUGO
, show_ibdev
, NULL
);
693 static ssize_t
show_port(struct class_device
*class_dev
, char *buf
)
695 struct ib_umad_port
*port
= class_get_devdata(class_dev
);
697 return sprintf(buf
, "%d\n", port
->port_num
);
699 static CLASS_DEVICE_ATTR(port
, S_IRUGO
, show_port
, NULL
);
701 static void ib_umad_release_dev(struct kref
*ref
)
703 struct ib_umad_device
*dev
=
704 container_of(ref
, struct ib_umad_device
, ref
);
709 static void ib_umad_release_port(struct class_device
*class_dev
)
711 struct ib_umad_port
*port
= class_get_devdata(class_dev
);
713 if (class_dev
== &port
->class_dev
) {
714 cdev_del(&port
->dev
);
715 clear_bit(port
->devnum
, dev_map
);
717 cdev_del(&port
->sm_dev
);
718 clear_bit(port
->sm_devnum
, dev_map
);
721 kref_put(&port
->umad_dev
->ref
, ib_umad_release_dev
);
724 static struct class umad_class
= {
725 .name
= "infiniband_mad",
726 .release
= ib_umad_release_port
729 static ssize_t
show_abi_version(struct class *class, char *buf
)
731 return sprintf(buf
, "%d\n", IB_USER_MAD_ABI_VERSION
);
733 static CLASS_ATTR(abi_version
, S_IRUGO
, show_abi_version
, NULL
);
735 static int ib_umad_init_port(struct ib_device
*device
, int port_num
,
736 struct ib_umad_port
*port
)
738 spin_lock(&map_lock
);
739 port
->devnum
= find_first_zero_bit(dev_map
, IB_UMAD_MAX_PORTS
);
740 if (port
->devnum
>= IB_UMAD_MAX_PORTS
) {
741 spin_unlock(&map_lock
);
744 port
->sm_devnum
= find_next_zero_bit(dev_map
, IB_UMAD_MAX_PORTS
* 2, IB_UMAD_MAX_PORTS
);
745 if (port
->sm_devnum
>= IB_UMAD_MAX_PORTS
* 2) {
746 spin_unlock(&map_lock
);
749 set_bit(port
->devnum
, dev_map
);
750 set_bit(port
->sm_devnum
, dev_map
);
751 spin_unlock(&map_lock
);
753 port
->ib_dev
= device
;
754 port
->port_num
= port_num
;
755 init_MUTEX(&port
->sm_sem
);
757 cdev_init(&port
->dev
, &umad_fops
);
758 port
->dev
.owner
= THIS_MODULE
;
759 kobject_set_name(&port
->dev
.kobj
, "umad%d", port
->devnum
);
760 if (cdev_add(&port
->dev
, base_dev
+ port
->devnum
, 1))
763 port
->class_dev
.class = &umad_class
;
764 port
->class_dev
.dev
= device
->dma_device
;
766 snprintf(port
->class_dev
.class_id
, BUS_ID_SIZE
, "umad%d", port
->devnum
);
768 if (class_device_register(&port
->class_dev
))
771 class_set_devdata(&port
->class_dev
, port
);
772 kref_get(&port
->umad_dev
->ref
);
774 if (class_device_create_file(&port
->class_dev
, &class_device_attr_dev
))
776 if (class_device_create_file(&port
->class_dev
, &class_device_attr_ibdev
))
778 if (class_device_create_file(&port
->class_dev
, &class_device_attr_port
))
781 cdev_init(&port
->sm_dev
, &umad_sm_fops
);
782 port
->sm_dev
.owner
= THIS_MODULE
;
783 kobject_set_name(&port
->dev
.kobj
, "issm%d", port
->sm_devnum
- IB_UMAD_MAX_PORTS
);
784 if (cdev_add(&port
->sm_dev
, base_dev
+ port
->sm_devnum
, 1))
787 port
->sm_class_dev
.class = &umad_class
;
788 port
->sm_class_dev
.dev
= device
->dma_device
;
790 snprintf(port
->sm_class_dev
.class_id
, BUS_ID_SIZE
, "issm%d", port
->sm_devnum
- IB_UMAD_MAX_PORTS
);
792 if (class_device_register(&port
->sm_class_dev
))
795 class_set_devdata(&port
->sm_class_dev
, port
);
796 kref_get(&port
->umad_dev
->ref
);
798 if (class_device_create_file(&port
->sm_class_dev
, &class_device_attr_dev
))
800 if (class_device_create_file(&port
->sm_class_dev
, &class_device_attr_ibdev
))
802 if (class_device_create_file(&port
->sm_class_dev
, &class_device_attr_port
))
808 class_device_unregister(&port
->sm_class_dev
);
811 cdev_del(&port
->sm_dev
);
814 class_device_unregister(&port
->class_dev
);
817 cdev_del(&port
->dev
);
818 clear_bit(port
->devnum
, dev_map
);
823 static void ib_umad_add_one(struct ib_device
*device
)
825 struct ib_umad_device
*umad_dev
;
828 if (device
->node_type
== IB_NODE_SWITCH
)
832 e
= device
->phys_port_cnt
;
835 umad_dev
= kmalloc(sizeof *umad_dev
+
836 (e
- s
+ 1) * sizeof (struct ib_umad_port
),
841 memset(umad_dev
, 0, sizeof *umad_dev
+
842 (e
- s
+ 1) * sizeof (struct ib_umad_port
));
844 kref_init(&umad_dev
->ref
);
846 umad_dev
->start_port
= s
;
847 umad_dev
->end_port
= e
;
849 for (i
= s
; i
<= e
; ++i
) {
850 umad_dev
->port
[i
- s
].umad_dev
= umad_dev
;
852 if (ib_umad_init_port(device
, i
, &umad_dev
->port
[i
- s
]))
856 ib_set_client_data(device
, &umad_client
, umad_dev
);
862 class_device_unregister(&umad_dev
->port
[i
- s
].class_dev
);
863 class_device_unregister(&umad_dev
->port
[i
- s
].sm_class_dev
);
866 kref_put(&umad_dev
->ref
, ib_umad_release_dev
);
869 static void ib_umad_remove_one(struct ib_device
*device
)
871 struct ib_umad_device
*umad_dev
= ib_get_client_data(device
, &umad_client
);
877 for (i
= 0; i
<= umad_dev
->end_port
- umad_dev
->start_port
; ++i
) {
878 class_device_unregister(&umad_dev
->port
[i
].class_dev
);
879 class_device_unregister(&umad_dev
->port
[i
].sm_class_dev
);
882 kref_put(&umad_dev
->ref
, ib_umad_release_dev
);
885 static int __init
ib_umad_init(void)
889 spin_lock_init(&map_lock
);
891 ret
= register_chrdev_region(base_dev
, IB_UMAD_MAX_PORTS
* 2,
894 printk(KERN_ERR
"user_mad: couldn't register device number\n");
898 ret
= class_register(&umad_class
);
900 printk(KERN_ERR
"user_mad: couldn't create class infiniband_mad\n");
904 ret
= class_create_file(&umad_class
, &class_attr_abi_version
);
906 printk(KERN_ERR
"user_mad: couldn't create abi_version attribute\n");
910 ret
= ib_register_client(&umad_client
);
912 printk(KERN_ERR
"user_mad: couldn't register ib_umad client\n");
919 class_unregister(&umad_class
);
922 unregister_chrdev_region(base_dev
, IB_UMAD_MAX_PORTS
* 2);
928 static void __exit
ib_umad_cleanup(void)
930 ib_unregister_client(&umad_client
);
931 class_unregister(&umad_class
);
932 unregister_chrdev_region(base_dev
, IB_UMAD_MAX_PORTS
* 2);
935 module_init(ib_umad_init
);
936 module_exit(ib_umad_cleanup
);