projects / GitHub / mt8127 / android_kernel_alcatel_ttab.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
[PATCH] IB: User MAD ABI changes to support RMPP
[GitHub/mt8127/android_kernel_alcatel_ttab.git] / drivers / infiniband / core / user_mad.c
CommitLineData
1da177e4
LT		 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
53MODULE_AUTHOR("Roland Dreier");
54MODULE_DESCRIPTION("InfiniBand userspace MAD packet access");
55MODULE_LICENSE("Dual BSD/GPL");
56
57enum {
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
65struct 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
80struct ib_umad_device {
81 int start_port, end_port;
82 struct kref ref;
83 struct ib_umad_port port[0];
84};
85
86struct 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
96struct 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
103static const dev_t base_dev = MKDEV(IB_UMAD_MAJOR, IB_UMAD_MINOR_BASE);
104static spinlock_t map_lock;
105static DECLARE_BITMAP(dev_map, IB_UMAD_MAX_PORTS * 2);
106
107static void ib_umad_add_one(struct ib_device *device);
108static void ib_umad_remove_one(struct ib_device *device);
109
110static 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
134static 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
157static 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
191out:
192 ib_free_recv_mad(mad_recv_wc);
193}
194
195static 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
234static 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;
f75b7a52 325 wr.wr.ud.retries = 0;
1da177e4
LT		 326
327 wr.wr_id = (unsigned long) packet;
328
329 ret = ib_post_send_mad(agent, &wr, &bad_wr);
330 if (ret) {
331 dma_unmap_single(agent->device->dma_device,
332 pci_unmap_addr(packet, mapping),
333 sizeof packet->mad.data,
334 DMA_TO_DEVICE);
335 goto err_up;
336 }
337
338 up_read(&file->agent_mutex);
339
340 return sizeof packet->mad;
341
342err_up:
343 up_read(&file->agent_mutex);
344
345err:
346 kfree(packet);
347 return ret;
348}
349
350static unsigned int ib_umad_poll(struct file *filp, struct poll_table_struct *wait)
351{
352 struct ib_umad_file *file = filp->private_data;
353
354 /* we will always be able to post a MAD send */
355 unsigned int mask = POLLOUT | POLLWRNORM;
356
357 poll_wait(filp, &file->recv_wait, wait);
358
359 if (!list_empty(&file->recv_list))
360 mask |= POLLIN | POLLRDNORM;
361
362 return mask;
363}
364
365static int ib_umad_reg_agent(struct ib_umad_file *file, unsigned long arg)
366{
367 struct ib_user_mad_reg_req ureq;
368 struct ib_mad_reg_req req;
369 struct ib_mad_agent *agent;
370 int agent_id;
371 int ret;
372
373 down_write(&file->agent_mutex);
374
375 if (copy_from_user(&ureq, (void __user *) arg, sizeof ureq)) {
376 ret = -EFAULT;
377 goto out;
378 }
379
380 if (ureq.qpn != 0 && ureq.qpn != 1) {
381 ret = -EINVAL;
382 goto out;
383 }
384
385 for (agent_id = 0; agent_id < IB_UMAD_MAX_AGENTS; ++agent_id)
386 if (!file->agent[agent_id])
387 goto found;
388
389 ret = -ENOMEM;
390 goto out;
391
392found:
0df3bb13
RD		 393 if (ureq.mgmt_class) {
394 req.mgmt_class = ureq.mgmt_class;
395 req.mgmt_class_version = ureq.mgmt_class_version;
396 memcpy(req.method_mask, ureq.method_mask, sizeof req.method_mask);
397 memcpy(req.oui, ureq.oui, sizeof req.oui);
398 }
1da177e4
LT		 399
400 agent = ib_register_mad_agent(file->port->ib_dev, file->port->port_num,
401 ureq.qpn ? IB_QPT_GSI : IB_QPT_SMI,
0df3bb13
RD		 402 ureq.mgmt_class ? &req : NULL,
403 0, send_handler, recv_handler, file);
1da177e4
LT		 404 if (IS_ERR(agent)) {
405 ret = PTR_ERR(agent);
406 goto out;
407 }
408
409 file->agent[agent_id] = agent;
410
411 file->mr[agent_id] = ib_get_dma_mr(agent->qp->pd, IB_ACCESS_LOCAL_WRITE);
412 if (IS_ERR(file->mr[agent_id])) {
413 ret = -ENOMEM;
414 goto err;
415 }
416
417 if (put_user(agent_id,
418 (u32 __user *) (arg + offsetof(struct ib_user_mad_reg_req, id)))) {
419 ret = -EFAULT;
420 goto err_mr;
421 }
422
423 ret = 0;
424 goto out;
425
426err_mr:
427 ib_dereg_mr(file->mr[agent_id]);
428
429err:
430 file->agent[agent_id] = NULL;
431 ib_unregister_mad_agent(agent);
432
433out:
434 up_write(&file->agent_mutex);
435 return ret;
436}
437
438static int ib_umad_unreg_agent(struct ib_umad_file *file, unsigned long arg)
439{
440 u32 id;
441 int ret = 0;
442
443 down_write(&file->agent_mutex);
444
445 if (get_user(id, (u32 __user *) arg)) {
446 ret = -EFAULT;
447 goto out;
448 }
449
450 if (id < 0 || id >= IB_UMAD_MAX_AGENTS || !file->agent[id]) {
451 ret = -EINVAL;
452 goto out;
453 }
454
455 ib_dereg_mr(file->mr[id]);
456 ib_unregister_mad_agent(file->agent[id]);
457 file->agent[id] = NULL;
458
459out:
460 up_write(&file->agent_mutex);
461 return ret;
462}
463
464static long ib_umad_ioctl(struct file *filp,
465 unsigned int cmd, unsigned long arg)
466{
467 switch (cmd) {
468 case IB_USER_MAD_REGISTER_AGENT:
469 return ib_umad_reg_agent(filp->private_data, arg);
470 case IB_USER_MAD_UNREGISTER_AGENT:
471 return ib_umad_unreg_agent(filp->private_data, arg);
472 default:
473 return -ENOIOCTLCMD;
474 }
475}
476
477static int ib_umad_open(struct inode *inode, struct file *filp)
478{
479 struct ib_umad_port *port =
480 container_of(inode->i_cdev, struct ib_umad_port, dev);
481 struct ib_umad_file *file;
482
483 file = kmalloc(sizeof *file, GFP_KERNEL);
484 if (!file)
485 return -ENOMEM;
486
487 memset(file, 0, sizeof *file);
488
489 spin_lock_init(&file->recv_lock);
490 init_rwsem(&file->agent_mutex);
491 INIT_LIST_HEAD(&file->recv_list);
492 init_waitqueue_head(&file->recv_wait);
493
494 file->port = port;
495 filp->private_data = file;
496
497 return 0;
498}
499
500static int ib_umad_close(struct inode *inode, struct file *filp)
501{
502 struct ib_umad_file *file = filp->private_data;
561e148e 503 struct ib_umad_packet *packet, *tmp;
1da177e4
LT		 504 int i;
505
506 for (i = 0; i < IB_UMAD_MAX_AGENTS; ++i)
507 if (file->agent[i]) {
508 ib_dereg_mr(file->mr[i]);
509 ib_unregister_mad_agent(file->agent[i]);
510 }
511
561e148e
RD		 512 list_for_each_entry_safe(packet, tmp, &file->recv_list, list)
513 kfree(packet);
514
1da177e4
LT		 515 kfree(file);
516
517 return 0;
518}
519
520static struct file_operations umad_fops = {
521 .owner = THIS_MODULE,
522 .read = ib_umad_read,
523 .write = ib_umad_write,
524 .poll = ib_umad_poll,
525 .unlocked_ioctl = ib_umad_ioctl,
526 .compat_ioctl = ib_umad_ioctl,
527 .open = ib_umad_open,
528 .release = ib_umad_close
529};
530
531static int ib_umad_sm_open(struct inode *inode, struct file *filp)
532{
533 struct ib_umad_port *port =
534 container_of(inode->i_cdev, struct ib_umad_port, sm_dev);
535 struct ib_port_modify props = {
536 .set_port_cap_mask = IB_PORT_SM
537 };
538 int ret;
539
540 if (filp->f_flags & O_NONBLOCK) {
541 if (down_trylock(&port->sm_sem))
542 return -EAGAIN;
543 } else {
544 if (down_interruptible(&port->sm_sem))
545 return -ERESTARTSYS;
546 }
547
548 ret = ib_modify_port(port->ib_dev, port->port_num, 0, &props);
549 if (ret) {
550 up(&port->sm_sem);
551 return ret;
552 }
553
554 filp->private_data = port;
555
556 return 0;
557}
558
559static int ib_umad_sm_close(struct inode *inode, struct file *filp)
560{
561 struct ib_umad_port *port = filp->private_data;
562 struct ib_port_modify props = {
563 .clr_port_cap_mask = IB_PORT_SM
564 };
565 int ret;
566
567 ret = ib_modify_port(port->ib_dev, port->port_num, 0, &props);
568 up(&port->sm_sem);
569
570 return ret;
571}
572
573static struct file_operations umad_sm_fops = {
574 .owner = THIS_MODULE,
575 .open = ib_umad_sm_open,
576 .release = ib_umad_sm_close
577};
578
579static struct ib_client umad_client = {
580 .name = "umad",
581 .add = ib_umad_add_one,
582 .remove = ib_umad_remove_one
583};
584
585static ssize_t show_dev(struct class_device *class_dev, char *buf)
586{
587 struct ib_umad_port *port = class_get_devdata(class_dev);
588
589 if (class_dev == &port->class_dev)
590 return print_dev_t(buf, port->dev.dev);
591 else
592 return print_dev_t(buf, port->sm_dev.dev);
593}
594static CLASS_DEVICE_ATTR(dev, S_IRUGO, show_dev, NULL);
595
596static ssize_t show_ibdev(struct class_device *class_dev, char *buf)
597{
598 struct ib_umad_port *port = class_get_devdata(class_dev);
599
600 return sprintf(buf, "%s\n", port->ib_dev->name);
601}
602static CLASS_DEVICE_ATTR(ibdev, S_IRUGO, show_ibdev, NULL);
603
604static ssize_t show_port(struct class_device *class_dev, char *buf)
605{
606 struct ib_umad_port *port = class_get_devdata(class_dev);
607
608 return sprintf(buf, "%d\n", port->port_num);
609}
610static CLASS_DEVICE_ATTR(port, S_IRUGO, show_port, NULL);
611
612static void ib_umad_release_dev(struct kref *ref)
613{
614 struct ib_umad_device *dev =
615 container_of(ref, struct ib_umad_device, ref);
616
617 kfree(dev);
618}
619
620static void ib_umad_release_port(struct class_device *class_dev)
621{
622 struct ib_umad_port *port = class_get_devdata(class_dev);
623
624 if (class_dev == &port->class_dev) {
625 cdev_del(&port->dev);
626 clear_bit(port->devnum, dev_map);
627 } else {
628 cdev_del(&port->sm_dev);
629 clear_bit(port->sm_devnum, dev_map);
630 }
631
632 kref_put(&port->umad_dev->ref, ib_umad_release_dev);
633}
634
635static struct class umad_class = {
636 .name = "infiniband_mad",
637 .release = ib_umad_release_port
638};
639
640static ssize_t show_abi_version(struct class *class, char *buf)
641{
642 return sprintf(buf, "%d\n", IB_USER_MAD_ABI_VERSION);
643}
644static CLASS_ATTR(abi_version, S_IRUGO, show_abi_version, NULL);
645
646static int ib_umad_init_port(struct ib_device *device, int port_num,
647 struct ib_umad_port *port)
648{
649 spin_lock(&map_lock);
650 port->devnum = find_first_zero_bit(dev_map, IB_UMAD_MAX_PORTS);
651 if (port->devnum >= IB_UMAD_MAX_PORTS) {
652 spin_unlock(&map_lock);
653 return -1;
654 }
655 port->sm_devnum = find_next_zero_bit(dev_map, IB_UMAD_MAX_PORTS * 2, IB_UMAD_MAX_PORTS);
656 if (port->sm_devnum >= IB_UMAD_MAX_PORTS * 2) {
657 spin_unlock(&map_lock);
658 return -1;
659 }
660 set_bit(port->devnum, dev_map);
661 set_bit(port->sm_devnum, dev_map);
662 spin_unlock(&map_lock);
663
664 port->ib_dev = device;
665 port->port_num = port_num;
666 init_MUTEX(&port->sm_sem);
667
668 cdev_init(&port->dev, &umad_fops);
669 port->dev.owner = THIS_MODULE;
670 kobject_set_name(&port->dev.kobj, "umad%d", port->devnum);
671 if (cdev_add(&port->dev, base_dev + port->devnum, 1))
672 return -1;
673
674 port->class_dev.class = &umad_class;
675 port->class_dev.dev = device->dma_device;
676
677 snprintf(port->class_dev.class_id, BUS_ID_SIZE, "umad%d", port->devnum);
678
679 if (class_device_register(&port->class_dev))
680 goto err_cdev;
681
682 class_set_devdata(&port->class_dev, port);
683 kref_get(&port->umad_dev->ref);
684
685 if (class_device_create_file(&port->class_dev, &class_device_attr_dev))
686 goto err_class;
687 if (class_device_create_file(&port->class_dev, &class_device_attr_ibdev))
688 goto err_class;
689 if (class_device_create_file(&port->class_dev, &class_device_attr_port))
690 goto err_class;
691
692 cdev_init(&port->sm_dev, &umad_sm_fops);
693 port->sm_dev.owner = THIS_MODULE;
694 kobject_set_name(&port->dev.kobj, "issm%d", port->sm_devnum - IB_UMAD_MAX_PORTS);
695 if (cdev_add(&port->sm_dev, base_dev + port->sm_devnum, 1))
696 return -1;
697
698 port->sm_class_dev.class = &umad_class;
699 port->sm_class_dev.dev = device->dma_device;
700
701 snprintf(port->sm_class_dev.class_id, BUS_ID_SIZE, "issm%d", port->sm_devnum - IB_UMAD_MAX_PORTS);
702
703 if (class_device_register(&port->sm_class_dev))
704 goto err_sm_cdev;
705
706 class_set_devdata(&port->sm_class_dev, port);
707 kref_get(&port->umad_dev->ref);
708
709 if (class_device_create_file(&port->sm_class_dev, &class_device_attr_dev))
710 goto err_sm_class;
711 if (class_device_create_file(&port->sm_class_dev, &class_device_attr_ibdev))
712 goto err_sm_class;
713 if (class_device_create_file(&port->sm_class_dev, &class_device_attr_port))
714 goto err_sm_class;
715
716 return 0;
717
718err_sm_class:
719 class_device_unregister(&port->sm_class_dev);
720
721err_sm_cdev:
722 cdev_del(&port->sm_dev);
723
724err_class:
725 class_device_unregister(&port->class_dev);
726
727err_cdev:
728 cdev_del(&port->dev);
729 clear_bit(port->devnum, dev_map);
730
731 return -1;
732}
733
734static void ib_umad_add_one(struct ib_device *device)
735{
736 struct ib_umad_device *umad_dev;
737 int s, e, i;
738
739 if (device->node_type == IB_NODE_SWITCH)
740 s = e = 0;
741 else {
742 s = 1;
743 e = device->phys_port_cnt;
744 }
745
746 umad_dev = kmalloc(sizeof *umad_dev +
747 (e - s + 1) * sizeof (struct ib_umad_port),
748 GFP_KERNEL);
749 if (!umad_dev)
750 return;
751
752 memset(umad_dev, 0, sizeof *umad_dev +
753 (e - s + 1) * sizeof (struct ib_umad_port));
754
755 kref_init(&umad_dev->ref);
756
757 umad_dev->start_port = s;
758 umad_dev->end_port = e;
759
760 for (i = s; i <= e; ++i) {
761 umad_dev->port[i - s].umad_dev = umad_dev;
762
763 if (ib_umad_init_port(device, i, &umad_dev->port[i - s]))
764 goto err;
765 }
766
767 ib_set_client_data(device, &umad_client, umad_dev);
768
769 return;
770
771err:
772 while (--i >= s) {
773 class_device_unregister(&umad_dev->port[i - s].class_dev);
774 class_device_unregister(&umad_dev->port[i - s].sm_class_dev);
775 }
776
777 kref_put(&umad_dev->ref, ib_umad_release_dev);
778}
779
780static void ib_umad_remove_one(struct ib_device *device)
781{
782 struct ib_umad_device *umad_dev = ib_get_client_data(device, &umad_client);
783 int i;
784
785 if (!umad_dev)
786 return;
787
788 for (i = 0; i <= umad_dev->end_port - umad_dev->start_port; ++i) {
789 class_device_unregister(&umad_dev->port[i].class_dev);
790 class_device_unregister(&umad_dev->port[i].sm_class_dev);
791 }
792
793 kref_put(&umad_dev->ref, ib_umad_release_dev);
794}
795
796static int __init ib_umad_init(void)
797{
798 int ret;
799
800 spin_lock_init(&map_lock);
801
802 ret = register_chrdev_region(base_dev, IB_UMAD_MAX_PORTS * 2,
803 "infiniband_mad");
804 if (ret) {
805 printk(KERN_ERR "user_mad: couldn't register device number\n");
806 goto out;
807 }
808
809 ret = class_register(&umad_class);
810 if (ret) {
811 printk(KERN_ERR "user_mad: couldn't create class infiniband_mad\n");
812 goto out_chrdev;
813 }
814
815 ret = class_create_file(&umad_class, &class_attr_abi_version);
816 if (ret) {
817 printk(KERN_ERR "user_mad: couldn't create abi_version attribute\n");
818 goto out_class;
819 }
820
821 ret = ib_register_client(&umad_client);
822 if (ret) {
823 printk(KERN_ERR "user_mad: couldn't register ib_umad client\n");
824 goto out_class;
825 }
826
827 return 0;
828
829out_class:
830 class_unregister(&umad_class);
831
832out_chrdev:
833 unregister_chrdev_region(base_dev, IB_UMAD_MAX_PORTS * 2);
834
835out:
836 return ret;
837}
838
839static void __exit ib_umad_cleanup(void)
840{
841 ib_unregister_client(&umad_client);
842 class_unregister(&umad_class);
843 unregister_chrdev_region(base_dev, IB_UMAD_MAX_PORTS * 2);
844}
845
846module_init(ib_umad_init);
847module_exit(ib_umad_cleanup);
kernel source for telekom puls (alcatel/mediatek)