?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
[TG3]: Set minimal hw interrupt mitigation.
[linux-2.6/verdex.git] / drivers / infiniband / core / user_mad.c
blob56b9c2fa2ecccbf99399a6015a1e6f1ee3f7e650
1 /*
2 * Copyright (c) 2004 Topspin Communications. 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 * $Id: user_mad.c 1389 2004-12-27 22:56:47Z roland $
33 */
34
35 #include <linux/module.h>
36 #include <linux/init.h>
37 #include <linux/device.h>
38 #include <linux/err.h>
39 #include <linux/fs.h>
40 #include <linux/cdev.h>
41 #include <linux/pci.h>
42 #include <linux/dma-mapping.h>
43 #include <linux/poll.h>
44 #include <linux/rwsem.h>
45 #include <linux/kref.h>
46
47 #include <asm/uaccess.h>
48 #include <asm/semaphore.h>
49
50 #include <ib_mad.h>
51 #include <ib_user_mad.h>
52
53 MODULE_AUTHOR("Roland Dreier");
54 MODULE_DESCRIPTION("InfiniBand userspace MAD packet access");
55 MODULE_LICENSE("Dual BSD/GPL");
56
57 enum {
58 IB_UMAD_MAX_PORTS = 64,
59 IB_UMAD_MAX_AGENTS = 32,
60
61 IB_UMAD_MAJOR = 231,
62 IB_UMAD_MINOR_BASE = 0
63 };
64
65 struct ib_umad_port {
66 int devnum;
67 struct cdev dev;
68 struct class_device class_dev;
69
70 int sm_devnum;
71 struct cdev sm_dev;
72 struct class_device sm_class_dev;
73 struct semaphore sm_sem;
74
75 struct ib_device *ib_dev;
76 struct ib_umad_device *umad_dev;
77 u8 port_num;
78 };
79
80 struct ib_umad_device {
81 int start_port, end_port;
82 struct kref ref;
83 struct ib_umad_port port[0];
84 };
85
86 struct ib_umad_file {
87 struct ib_umad_port *port;
88 spinlock_t recv_lock;
89 struct list_head recv_list;
90 wait_queue_head_t recv_wait;
91 struct rw_semaphore agent_mutex;
92 struct ib_mad_agent *agent[IB_UMAD_MAX_AGENTS];
93 struct ib_mr *mr[IB_UMAD_MAX_AGENTS];
94 };
95
96 struct ib_umad_packet {
97 struct ib_user_mad mad;
98 struct ib_ah *ah;
99 struct list_head list;
100 DECLARE_PCI_UNMAP_ADDR(mapping)
101 };
102
103 static const dev_t base_dev = MKDEV(IB_UMAD_MAJOR, IB_UMAD_MINOR_BASE);
104 static spinlock_t map_lock;
105 static DECLARE_BITMAP(dev_map, IB_UMAD_MAX_PORTS * 2);
106
107 static void ib_umad_add_one(struct ib_device *device);
108 static void ib_umad_remove_one(struct ib_device *device);
109
110 static int queue_packet(struct ib_umad_file *file,
111 struct ib_mad_agent *agent,
112 struct ib_umad_packet *packet)
113 {
114 int ret = 1;
115
116 down_read(&file->agent_mutex);
117 for (packet->mad.id = 0;
118 packet->mad.id < IB_UMAD_MAX_AGENTS;
119 packet->mad.id++)
120 if (agent == file->agent[packet->mad.id]) {
121 spin_lock_irq(&file->recv_lock);
122 list_add_tail(&packet->list, &file->recv_list);
123 spin_unlock_irq(&file->recv_lock);
124 wake_up_interruptible(&file->recv_wait);
125 ret = 0;
126 break;
127 }
128
129 up_read(&file->agent_mutex);
130
131 return ret;
132 }
133
134 static void send_handler(struct ib_mad_agent *agent,
135 struct ib_mad_send_wc *send_wc)
136 {
137 struct ib_umad_file *file = agent->context;
138 struct ib_umad_packet *packet =
139 (void *) (unsigned long) send_wc->wr_id;
140
141 dma_unmap_single(agent->device->dma_device,
142 pci_unmap_addr(packet, mapping),
143 sizeof packet->mad.data,
144 DMA_TO_DEVICE);
145 ib_destroy_ah(packet->ah);
146
147 if (send_wc->status == IB_WC_RESP_TIMEOUT_ERR) {
148 packet->mad.status = ETIMEDOUT;
149
150 if (!queue_packet(file, agent, packet))
151 return;
152 }
153
154 kfree(packet);
155 }
156
157 static void recv_handler(struct ib_mad_agent *agent,
158 struct ib_mad_recv_wc *mad_recv_wc)
159 {
160 struct ib_umad_file *file = agent->context;
161 struct ib_umad_packet *packet;
162
163 if (mad_recv_wc->wc->status != IB_WC_SUCCESS)
164 goto out;
165
166 packet = kmalloc(sizeof *packet, GFP_KERNEL);
167 if (!packet)
168 goto out;
169
170 memset(packet, 0, sizeof *packet);
171
172 memcpy(packet->mad.data, mad_recv_wc->recv_buf.mad, sizeof packet->mad.data);
173 packet->mad.status = 0;
174 packet->mad.qpn = cpu_to_be32(mad_recv_wc->wc->src_qp);
175 packet->mad.lid = cpu_to_be16(mad_recv_wc->wc->slid);
176 packet->mad.sl = mad_recv_wc->wc->sl;
177 packet->mad.path_bits = mad_recv_wc->wc->dlid_path_bits;
178 packet->mad.grh_present = !!(mad_recv_wc->wc->wc_flags & IB_WC_GRH);
179 if (packet->mad.grh_present) {
180 /* XXX parse GRH */
181 packet->mad.gid_index = 0;
182 packet->mad.hop_limit = 0;
183 packet->mad.traffic_class = 0;
184 memset(packet->mad.gid, 0, 16);
185 packet->mad.flow_label = 0;
186 }
187
188 if (queue_packet(file, agent, packet))
189 kfree(packet);
190
191 out:
192 ib_free_recv_mad(mad_recv_wc);
193 }
194
195 static ssize_t ib_umad_read(struct file *filp, char __user *buf,
196 size_t count, loff_t *pos)
197 {
198 struct ib_umad_file *file = filp->private_data;
199 struct ib_umad_packet *packet;
200 ssize_t ret;
201
202 if (count < sizeof (struct ib_user_mad))
203 return -EINVAL;
204
205 spin_lock_irq(&file->recv_lock);
206
207 while (list_empty(&file->recv_list)) {
208 spin_unlock_irq(&file->recv_lock);
209
210 if (filp->f_flags & O_NONBLOCK)
211 return -EAGAIN;
212
213 if (wait_event_interruptible(file->recv_wait,
214 !list_empty(&file->recv_list)))
215 return -ERESTARTSYS;
216
217 spin_lock_irq(&file->recv_lock);
218 }
219
220 packet = list_entry(file->recv_list.next, struct ib_umad_packet, list);
221 list_del(&packet->list);
222
223 spin_unlock_irq(&file->recv_lock);
224
225 if (copy_to_user(buf, &packet->mad, sizeof packet->mad))
226 ret = -EFAULT;
227 else
228 ret = sizeof packet->mad;
229
230 kfree(packet);
231 return ret;
232 }
233
234 static ssize_t ib_umad_write(struct file *filp, const char __user *buf,
235 size_t count, loff_t *pos)
236 {
237 struct ib_umad_file *file = filp->private_data;
238 struct ib_umad_packet *packet;
239 struct ib_mad_agent *agent;
240 struct ib_ah_attr ah_attr;
241 struct ib_sge gather_list;
242 struct ib_send_wr *bad_wr, wr = {
243 .opcode = IB_WR_SEND,
244 .sg_list = &gather_list,
245 .num_sge = 1,
246 .send_flags = IB_SEND_SIGNALED,
247 };
248 u8 method;
249 u64 *tid;
250 int ret;
251
252 if (count < sizeof (struct ib_user_mad))
253 return -EINVAL;
254
255 packet = kmalloc(sizeof *packet, GFP_KERNEL);
256 if (!packet)
257 return -ENOMEM;
258
259 if (copy_from_user(&packet->mad, buf, sizeof packet->mad)) {
260 kfree(packet);
261 return -EFAULT;
262 }
263
264 if (packet->mad.id < 0 || packet->mad.id >= IB_UMAD_MAX_AGENTS) {
265 ret = -EINVAL;
266 goto err;
267 }
268
269 down_read(&file->agent_mutex);
270
271 agent = file->agent[packet->mad.id];
272 if (!agent) {
273 ret = -EINVAL;
274 goto err_up;
275 }
276
277 /*
278 * If userspace is generating a request that will generate a
279 * response, we need to make sure the high-order part of the
280 * transaction ID matches the agent being used to send the
281 * MAD.
282 */
283 method = ((struct ib_mad_hdr *) packet->mad.data)->method;
284
285 if (!(method & IB_MGMT_METHOD_RESP) &&
286 method != IB_MGMT_METHOD_TRAP_REPRESS &&
287 method != IB_MGMT_METHOD_SEND) {
288 tid = &((struct ib_mad_hdr *) packet->mad.data)->tid;
289 *tid = cpu_to_be64(((u64) agent->hi_tid) << 32 |
290 (be64_to_cpup(tid) & 0xffffffff));
291 }
292
293 memset(&ah_attr, 0, sizeof ah_attr);
294 ah_attr.dlid = be16_to_cpu(packet->mad.lid);
295 ah_attr.sl = packet->mad.sl;
296 ah_attr.src_path_bits = packet->mad.path_bits;
297 ah_attr.port_num = file->port->port_num;
298 if (packet->mad.grh_present) {
299 ah_attr.ah_flags = IB_AH_GRH;
300 memcpy(ah_attr.grh.dgid.raw, packet->mad.gid, 16);
301 ah_attr.grh.flow_label = packet->mad.flow_label;
302 ah_attr.grh.hop_limit = packet->mad.hop_limit;
303 ah_attr.grh.traffic_class = packet->mad.traffic_class;
304 }
305
306 packet->ah = ib_create_ah(agent->qp->pd, &ah_attr);
307 if (IS_ERR(packet->ah)) {
308 ret = PTR_ERR(packet->ah);
309 goto err_up;
310 }
311
312 gather_list.addr = dma_map_single(agent->device->dma_device,
313 packet->mad.data,
314 sizeof packet->mad.data,
315 DMA_TO_DEVICE);
316 gather_list.length = sizeof packet->mad.data;
317 gather_list.lkey = file->mr[packet->mad.id]->lkey;
318 pci_unmap_addr_set(packet, mapping, gather_list.addr);
319
320 wr.wr.ud.mad_hdr = (struct ib_mad_hdr *) packet->mad.data;
321 wr.wr.ud.ah = packet->ah;
322 wr.wr.ud.remote_qpn = be32_to_cpu(packet->mad.qpn);
323 wr.wr.ud.remote_qkey = be32_to_cpu(packet->mad.qkey);
324 wr.wr.ud.timeout_ms = packet->mad.timeout_ms;
325
326 wr.wr_id = (unsigned long) packet;
327
328 ret = ib_post_send_mad(agent, &wr, &bad_wr);
329 if (ret) {
330 dma_unmap_single(agent->device->dma_device,
331 pci_unmap_addr(packet, mapping),
332 sizeof packet->mad.data,
333 DMA_TO_DEVICE);
334 goto err_up;
335 }
336
337 up_read(&file->agent_mutex);
338
339 return sizeof packet->mad;
340
341 err_up:
342 up_read(&file->agent_mutex);
343
344 err:
345 kfree(packet);
346 return ret;
347 }
348
349 static unsigned int ib_umad_poll(struct file *filp, struct poll_table_struct *wait)
350 {
351 struct ib_umad_file *file = filp->private_data;
352
353 /* we will always be able to post a MAD send */
354 unsigned int mask = POLLOUT | POLLWRNORM;
355
356 poll_wait(filp, &file->recv_wait, wait);
357
358 if (!list_empty(&file->recv_list))
359 mask |= POLLIN | POLLRDNORM;
360
361 return mask;
362 }
363
364 static int ib_umad_reg_agent(struct ib_umad_file *file, unsigned long arg)
365 {
366 struct ib_user_mad_reg_req ureq;
367 struct ib_mad_reg_req req;
368 struct ib_mad_agent *agent;
369 int agent_id;
370 int ret;
371
372 down_write(&file->agent_mutex);
373
374 if (copy_from_user(&ureq, (void __user *) arg, sizeof ureq)) {
375 ret = -EFAULT;
376 goto out;
377 }
378
379 if (ureq.qpn != 0 && ureq.qpn != 1) {
380 ret = -EINVAL;
381 goto out;
382 }
383
384 for (agent_id = 0; agent_id < IB_UMAD_MAX_AGENTS; ++agent_id)
385 if (!file->agent[agent_id])
386 goto found;
387
388 ret = -ENOMEM;
389 goto out;
390
391 found:
392 if (ureq.mgmt_class) {
393 req.mgmt_class = ureq.mgmt_class;
394 req.mgmt_class_version = ureq.mgmt_class_version;
395 memcpy(req.method_mask, ureq.method_mask, sizeof req.method_mask);
396 memcpy(req.oui, ureq.oui, sizeof req.oui);
397 }
398
399 agent = ib_register_mad_agent(file->port->ib_dev, file->port->port_num,
400 ureq.qpn ? IB_QPT_GSI : IB_QPT_SMI,
401 ureq.mgmt_class ? &req : NULL,
402 0, send_handler, recv_handler, file);
403 if (IS_ERR(agent)) {
404 ret = PTR_ERR(agent);
405 goto out;
406 }
407
408 file->agent[agent_id] = agent;
409
410 file->mr[agent_id] = ib_get_dma_mr(agent->qp->pd, IB_ACCESS_LOCAL_WRITE);
411 if (IS_ERR(file->mr[agent_id])) {
412 ret = -ENOMEM;
413 goto err;
414 }
415
416 if (put_user(agent_id,
417 (u32 __user *) (arg + offsetof(struct ib_user_mad_reg_req, id)))) {
418 ret = -EFAULT;
419 goto err_mr;
420 }
421
422 ret = 0;
423 goto out;
424
425 err_mr:
426 ib_dereg_mr(file->mr[agent_id]);
427
428 err:
429 file->agent[agent_id] = NULL;
430 ib_unregister_mad_agent(agent);
431
432 out:
433 up_write(&file->agent_mutex);
434 return ret;
435 }
436
437 static int ib_umad_unreg_agent(struct ib_umad_file *file, unsigned long arg)
438 {
439 u32 id;
440 int ret = 0;
441
442 down_write(&file->agent_mutex);
443
444 if (get_user(id, (u32 __user *) arg)) {
445 ret = -EFAULT;
446 goto out;
447 }
448
449 if (id < 0 || id >= IB_UMAD_MAX_AGENTS || !file->agent[id]) {
450 ret = -EINVAL;
451 goto out;
452 }
453
454 ib_dereg_mr(file->mr[id]);
455 ib_unregister_mad_agent(file->agent[id]);
456 file->agent[id] = NULL;
457
458 out:
459 up_write(&file->agent_mutex);
460 return ret;
461 }
462
463 static long ib_umad_ioctl(struct file *filp,
464 unsigned int cmd, unsigned long arg)
465 {
466 switch (cmd) {
467 case IB_USER_MAD_REGISTER_AGENT:
468 return ib_umad_reg_agent(filp->private_data, arg);
469 case IB_USER_MAD_UNREGISTER_AGENT:
470 return ib_umad_unreg_agent(filp->private_data, arg);
471 default:
472 return -ENOIOCTLCMD;
473 }
474 }
475
476 static int ib_umad_open(struct inode *inode, struct file *filp)
477 {
478 struct ib_umad_port *port =
479 container_of(inode->i_cdev, struct ib_umad_port, dev);
480 struct ib_umad_file *file;
481
482 file = kmalloc(sizeof *file, GFP_KERNEL);
483 if (!file)
484 return -ENOMEM;
485
486 memset(file, 0, sizeof *file);
487
488 spin_lock_init(&file->recv_lock);
489 init_rwsem(&file->agent_mutex);
490 INIT_LIST_HEAD(&file->recv_list);
491 init_waitqueue_head(&file->recv_wait);
492
493 file->port = port;
494 filp->private_data = file;
495
496 return 0;
497 }
498
499 static int ib_umad_close(struct inode *inode, struct file *filp)
500 {
501 struct ib_umad_file *file = filp->private_data;
502 int i;
503
504 for (i = 0; i < IB_UMAD_MAX_AGENTS; ++i)
505 if (file->agent[i]) {
506 ib_dereg_mr(file->mr[i]);
507 ib_unregister_mad_agent(file->agent[i]);
508 }
509
510 kfree(file);
511
512 return 0;
513 }
514
515 static struct file_operations umad_fops = {
516 .owner = THIS_MODULE,
517 .read = ib_umad_read,
518 .write = ib_umad_write,
519 .poll = ib_umad_poll,
520 .unlocked_ioctl = ib_umad_ioctl,
521 .compat_ioctl = ib_umad_ioctl,
522 .open = ib_umad_open,
523 .release = ib_umad_close
524 };
525
526 static int ib_umad_sm_open(struct inode *inode, struct file *filp)
527 {
528 struct ib_umad_port *port =
529 container_of(inode->i_cdev, struct ib_umad_port, sm_dev);
530 struct ib_port_modify props = {
531 .set_port_cap_mask = IB_PORT_SM
532 };
533 int ret;
534
535 if (filp->f_flags & O_NONBLOCK) {
536 if (down_trylock(&port->sm_sem))
537 return -EAGAIN;
538 } else {
539 if (down_interruptible(&port->sm_sem))
540 return -ERESTARTSYS;
541 }
542
543 ret = ib_modify_port(port->ib_dev, port->port_num, 0, &props);
544 if (ret) {
545 up(&port->sm_sem);
546 return ret;
547 }
548
549 filp->private_data = port;
550
551 return 0;
552 }
553
554 static int ib_umad_sm_close(struct inode *inode, struct file *filp)
555 {
556 struct ib_umad_port *port = filp->private_data;
557 struct ib_port_modify props = {
558 .clr_port_cap_mask = IB_PORT_SM
559 };
560 int ret;
561
562 ret = ib_modify_port(port->ib_dev, port->port_num, 0, &props);
563 up(&port->sm_sem);
564
565 return ret;
566 }
567
568 static struct file_operations umad_sm_fops = {
569 .owner = THIS_MODULE,
570 .open = ib_umad_sm_open,
571 .release = ib_umad_sm_close
572 };
573
574 static struct ib_client umad_client = {
575 .name = "umad",
576 .add = ib_umad_add_one,
577 .remove = ib_umad_remove_one
578 };
579
580 static ssize_t show_dev(struct class_device *class_dev, char *buf)
581 {
582 struct ib_umad_port *port = class_get_devdata(class_dev);
583
584 if (class_dev == &port->class_dev)
585 return print_dev_t(buf, port->dev.dev);
586 else
587 return print_dev_t(buf, port->sm_dev.dev);
588 }
589 static CLASS_DEVICE_ATTR(dev, S_IRUGO, show_dev, NULL);
590
591 static ssize_t show_ibdev(struct class_device *class_dev, char *buf)
592 {
593 struct ib_umad_port *port = class_get_devdata(class_dev);
594
595 return sprintf(buf, "%s\n", port->ib_dev->name);
596 }
597 static CLASS_DEVICE_ATTR(ibdev, S_IRUGO, show_ibdev, NULL);
598
599 static ssize_t show_port(struct class_device *class_dev, char *buf)
600 {
601 struct ib_umad_port *port = class_get_devdata(class_dev);
602
603 return sprintf(buf, "%d\n", port->port_num);
604 }
605 static CLASS_DEVICE_ATTR(port, S_IRUGO, show_port, NULL);
606
607 static void ib_umad_release_dev(struct kref *ref)
608 {
609 struct ib_umad_device *dev =
610 container_of(ref, struct ib_umad_device, ref);
611
612 kfree(dev);
613 }
614
615 static void ib_umad_release_port(struct class_device *class_dev)
616 {
617 struct ib_umad_port *port = class_get_devdata(class_dev);
618
619 if (class_dev == &port->class_dev) {
620 cdev_del(&port->dev);
621 clear_bit(port->devnum, dev_map);
622 } else {
623 cdev_del(&port->sm_dev);
624 clear_bit(port->sm_devnum, dev_map);
625 }
626
627 kref_put(&port->umad_dev->ref, ib_umad_release_dev);
628 }
629
630 static struct class umad_class = {
631 .name = "infiniband_mad",
632 .release = ib_umad_release_port
633 };
634
635 static ssize_t show_abi_version(struct class *class, char *buf)
636 {
637 return sprintf(buf, "%d\n", IB_USER_MAD_ABI_VERSION);
638 }
639 static CLASS_ATTR(abi_version, S_IRUGO, show_abi_version, NULL);
640
641 static int ib_umad_init_port(struct ib_device *device, int port_num,
642 struct ib_umad_port *port)
643 {
644 spin_lock(&map_lock);
645 port->devnum = find_first_zero_bit(dev_map, IB_UMAD_MAX_PORTS);
646 if (port->devnum >= IB_UMAD_MAX_PORTS) {
647 spin_unlock(&map_lock);
648 return -1;
649 }
650 port->sm_devnum = find_next_zero_bit(dev_map, IB_UMAD_MAX_PORTS * 2, IB_UMAD_MAX_PORTS);
651 if (port->sm_devnum >= IB_UMAD_MAX_PORTS * 2) {
652 spin_unlock(&map_lock);
653 return -1;
654 }
655 set_bit(port->devnum, dev_map);
656 set_bit(port->sm_devnum, dev_map);
657 spin_unlock(&map_lock);
658
659 port->ib_dev = device;
660 port->port_num = port_num;
661 init_MUTEX(&port->sm_sem);
662
663 cdev_init(&port->dev, &umad_fops);
664 port->dev.owner = THIS_MODULE;
665 kobject_set_name(&port->dev.kobj, "umad%d", port->devnum);
666 if (cdev_add(&port->dev, base_dev + port->devnum, 1))
667 return -1;
668
669 port->class_dev.class = &umad_class;
670 port->class_dev.dev = device->dma_device;
671
672 snprintf(port->class_dev.class_id, BUS_ID_SIZE, "umad%d", port->devnum);
673
674 if (class_device_register(&port->class_dev))
675 goto err_cdev;
676
677 class_set_devdata(&port->class_dev, port);
678 kref_get(&port->umad_dev->ref);
679
680 if (class_device_create_file(&port->class_dev, &class_device_attr_dev))
681 goto err_class;
682 if (class_device_create_file(&port->class_dev, &class_device_attr_ibdev))
683 goto err_class;
684 if (class_device_create_file(&port->class_dev, &class_device_attr_port))
685 goto err_class;
686
687 cdev_init(&port->sm_dev, &umad_sm_fops);
688 port->sm_dev.owner = THIS_MODULE;
689 kobject_set_name(&port->dev.kobj, "issm%d", port->sm_devnum - IB_UMAD_MAX_PORTS);
690 if (cdev_add(&port->sm_dev, base_dev + port->sm_devnum, 1))
691 return -1;
692
693 port->sm_class_dev.class = &umad_class;
694 port->sm_class_dev.dev = device->dma_device;
695
696 snprintf(port->sm_class_dev.class_id, BUS_ID_SIZE, "issm%d", port->sm_devnum - IB_UMAD_MAX_PORTS);
697
698 if (class_device_register(&port->sm_class_dev))
699 goto err_sm_cdev;
700
701 class_set_devdata(&port->sm_class_dev, port);
702 kref_get(&port->umad_dev->ref);
703
704 if (class_device_create_file(&port->sm_class_dev, &class_device_attr_dev))
705 goto err_sm_class;
706 if (class_device_create_file(&port->sm_class_dev, &class_device_attr_ibdev))
707 goto err_sm_class;
708 if (class_device_create_file(&port->sm_class_dev, &class_device_attr_port))
709 goto err_sm_class;
710
711 return 0;
712
713 err_sm_class:
714 class_device_unregister(&port->sm_class_dev);
715
716 err_sm_cdev:
717 cdev_del(&port->sm_dev);
718
719 err_class:
720 class_device_unregister(&port->class_dev);
721
722 err_cdev:
723 cdev_del(&port->dev);
724 clear_bit(port->devnum, dev_map);
725
726 return -1;
727 }
728
729 static void ib_umad_add_one(struct ib_device *device)
730 {
731 struct ib_umad_device *umad_dev;
732 int s, e, i;
733
734 if (device->node_type == IB_NODE_SWITCH)
735 s = e = 0;
736 else {
737 s = 1;
738 e = device->phys_port_cnt;
739 }
740
741 umad_dev = kmalloc(sizeof *umad_dev +
742 (e - s + 1) * sizeof (struct ib_umad_port),
743 GFP_KERNEL);
744 if (!umad_dev)
745 return;
746
747 memset(umad_dev, 0, sizeof *umad_dev +
748 (e - s + 1) * sizeof (struct ib_umad_port));
749
750 kref_init(&umad_dev->ref);
751
752 umad_dev->start_port = s;
753 umad_dev->end_port = e;
754
755 for (i = s; i <= e; ++i) {
756 umad_dev->port[i - s].umad_dev = umad_dev;
757
758 if (ib_umad_init_port(device, i, &umad_dev->port[i - s]))
759 goto err;
760 }
761
762 ib_set_client_data(device, &umad_client, umad_dev);
763
764 return;
765
766 err:
767 while (--i >= s) {
768 class_device_unregister(&umad_dev->port[i - s].class_dev);
769 class_device_unregister(&umad_dev->port[i - s].sm_class_dev);
770 }
771
772 kref_put(&umad_dev->ref, ib_umad_release_dev);
773 }
774
775 static void ib_umad_remove_one(struct ib_device *device)
776 {
777 struct ib_umad_device *umad_dev = ib_get_client_data(device, &umad_client);
778 int i;
779
780 if (!umad_dev)
781 return;
782
783 for (i = 0; i <= umad_dev->end_port - umad_dev->start_port; ++i) {
784 class_device_unregister(&umad_dev->port[i].class_dev);
785 class_device_unregister(&umad_dev->port[i].sm_class_dev);
786 }
787
788 kref_put(&umad_dev->ref, ib_umad_release_dev);
789 }
790
791 static int __init ib_umad_init(void)
792 {
793 int ret;
794
795 spin_lock_init(&map_lock);
796
797 ret = register_chrdev_region(base_dev, IB_UMAD_MAX_PORTS * 2,
798 "infiniband_mad");
799 if (ret) {
800 printk(KERN_ERR "user_mad: couldn't register device number\n");
801 goto out;
802 }
803
804 ret = class_register(&umad_class);
805 if (ret) {
806 printk(KERN_ERR "user_mad: couldn't create class infiniband_mad\n");
807 goto out_chrdev;
808 }
809
810 ret = class_create_file(&umad_class, &class_attr_abi_version);
811 if (ret) {
812 printk(KERN_ERR "user_mad: couldn't create abi_version attribute\n");
813 goto out_class;
814 }
815
816 ret = ib_register_client(&umad_client);
817 if (ret) {
818 printk(KERN_ERR "user_mad: couldn't register ib_umad client\n");
819 goto out_class;
820 }
821
822 return 0;
823
824 out_class:
825 class_unregister(&umad_class);
826
827 out_chrdev:
828 unregister_chrdev_region(base_dev, IB_UMAD_MAX_PORTS * 2);
829
830 out:
831 return ret;
832 }
833
834 static void __exit ib_umad_cleanup(void)
835 {
836 ib_unregister_client(&umad_client);
837 class_unregister(&umad_class);
838 unregister_chrdev_region(base_dev, IB_UMAD_MAX_PORTS * 2);
839 }
840
841 module_init(ib_umad_init);
842 module_exit(ib_umad_cleanup);
Verdex Pro support