?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
x86: cpa self-test, WARN_ON()
[wrt350n-kernel.git] / drivers / infiniband / hw / amso1100 / c2_provider.c
blob7a6cece6ea9d1ba0060ee630b3ab7a5931f8f638
1 /*
2 * Copyright (c) 2005 Ammasso, Inc. All rights reserved.
3 * Copyright (c) 2005 Open Grid Computing, Inc. All rights reserved.
4 *
5 * This software is available to you under a choice of one of two
6 * licenses. You may choose to be licensed under the terms of the GNU
7 * General Public License (GPL) Version 2, available from the file
8 * COPYING in the main directory of this source tree, or the
9 * OpenIB.org BSD license below:
10 *
11 * Redistribution and use in source and binary forms, with or
12 * without modification, are permitted provided that the following
13 * conditions are met:
14 *
15 * - Redistributions of source code must retain the above
16 * copyright notice, this list of conditions and the following
17 * disclaimer.
18 *
19 * - Redistributions in binary form must reproduce the above
20 * copyright notice, this list of conditions and the following
21 * disclaimer in the documentation and/or other materials
22 * provided with the distribution.
23 *
24 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
25 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
26 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
27 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
28 * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
29 * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
30 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
31 * SOFTWARE.
32 *
33 */
34
35 #include <linux/module.h>
36 #include <linux/moduleparam.h>
37 #include <linux/pci.h>
38 #include <linux/netdevice.h>
39 #include <linux/etherdevice.h>
40 #include <linux/inetdevice.h>
41 #include <linux/delay.h>
42 #include <linux/ethtool.h>
43 #include <linux/mii.h>
44 #include <linux/if_vlan.h>
45 #include <linux/crc32.h>
46 #include <linux/in.h>
47 #include <linux/ip.h>
48 #include <linux/tcp.h>
49 #include <linux/init.h>
50 #include <linux/dma-mapping.h>
51 #include <linux/if_arp.h>
52 #include <linux/vmalloc.h>
53
54 #include <asm/io.h>
55 #include <asm/irq.h>
56 #include <asm/byteorder.h>
57
58 #include <rdma/ib_smi.h>
59 #include <rdma/ib_umem.h>
60 #include <rdma/ib_user_verbs.h>
61 #include "c2.h"
62 #include "c2_provider.h"
63 #include "c2_user.h"
64
65 static int c2_query_device(struct ib_device *ibdev,
66 struct ib_device_attr *props)
67 {
68 struct c2_dev *c2dev = to_c2dev(ibdev);
69
70 pr_debug("%s:%u\n", __FUNCTION__, __LINE__);
71
72 *props = c2dev->props;
73 return 0;
74 }
75
76 static int c2_query_port(struct ib_device *ibdev,
77 u8 port, struct ib_port_attr *props)
78 {
79 pr_debug("%s:%u\n", __FUNCTION__, __LINE__);
80
81 props->max_mtu = IB_MTU_4096;
82 props->lid = 0;
83 props->lmc = 0;
84 props->sm_lid = 0;
85 props->sm_sl = 0;
86 props->state = IB_PORT_ACTIVE;
87 props->phys_state = 0;
88 props->port_cap_flags =
89 IB_PORT_CM_SUP |
90 IB_PORT_REINIT_SUP |
91 IB_PORT_VENDOR_CLASS_SUP | IB_PORT_BOOT_MGMT_SUP;
92 props->gid_tbl_len = 1;
93 props->pkey_tbl_len = 1;
94 props->qkey_viol_cntr = 0;
95 props->active_width = 1;
96 props->active_speed = 1;
97
98 return 0;
99 }
100
101 static int c2_modify_port(struct ib_device *ibdev,
102 u8 port, int port_modify_mask,
103 struct ib_port_modify *props)
104 {
105 pr_debug("%s:%u\n", __FUNCTION__, __LINE__);
106 return 0;
107 }
108
109 static int c2_query_pkey(struct ib_device *ibdev,
110 u8 port, u16 index, u16 * pkey)
111 {
112 pr_debug("%s:%u\n", __FUNCTION__, __LINE__);
113 *pkey = 0;
114 return 0;
115 }
116
117 static int c2_query_gid(struct ib_device *ibdev, u8 port,
118 int index, union ib_gid *gid)
119 {
120 struct c2_dev *c2dev = to_c2dev(ibdev);
121
122 pr_debug("%s:%u\n", __FUNCTION__, __LINE__);
123 memset(&(gid->raw[0]), 0, sizeof(gid->raw));
124 memcpy(&(gid->raw[0]), c2dev->pseudo_netdev->dev_addr, 6);
125
126 return 0;
127 }
128
129 /* Allocate the user context data structure. This keeps track
130 * of all objects associated with a particular user-mode client.
131 */
132 static struct ib_ucontext *c2_alloc_ucontext(struct ib_device *ibdev,
133 struct ib_udata *udata)
134 {
135 struct c2_ucontext *context;
136
137 pr_debug("%s:%u\n", __FUNCTION__, __LINE__);
138 context = kmalloc(sizeof(*context), GFP_KERNEL);
139 if (!context)
140 return ERR_PTR(-ENOMEM);
141
142 return &context->ibucontext;
143 }
144
145 static int c2_dealloc_ucontext(struct ib_ucontext *context)
146 {
147 pr_debug("%s:%u\n", __FUNCTION__, __LINE__);
148 kfree(context);
149 return 0;
150 }
151
152 static int c2_mmap_uar(struct ib_ucontext *context, struct vm_area_struct *vma)
153 {
154 pr_debug("%s:%u\n", __FUNCTION__, __LINE__);
155 return -ENOSYS;
156 }
157
158 static struct ib_pd *c2_alloc_pd(struct ib_device *ibdev,
159 struct ib_ucontext *context,
160 struct ib_udata *udata)
161 {
162 struct c2_pd *pd;
163 int err;
164
165 pr_debug("%s:%u\n", __FUNCTION__, __LINE__);
166
167 pd = kmalloc(sizeof(*pd), GFP_KERNEL);
168 if (!pd)
169 return ERR_PTR(-ENOMEM);
170
171 err = c2_pd_alloc(to_c2dev(ibdev), !context, pd);
172 if (err) {
173 kfree(pd);
174 return ERR_PTR(err);
175 }
176
177 if (context) {
178 if (ib_copy_to_udata(udata, &pd->pd_id, sizeof(__u32))) {
179 c2_pd_free(to_c2dev(ibdev), pd);
180 kfree(pd);
181 return ERR_PTR(-EFAULT);
182 }
183 }
184
185 return &pd->ibpd;
186 }
187
188 static int c2_dealloc_pd(struct ib_pd *pd)
189 {
190 pr_debug("%s:%u\n", __FUNCTION__, __LINE__);
191 c2_pd_free(to_c2dev(pd->device), to_c2pd(pd));
192 kfree(pd);
193
194 return 0;
195 }
196
197 static struct ib_ah *c2_ah_create(struct ib_pd *pd, struct ib_ah_attr *ah_attr)
198 {
199 pr_debug("%s:%u\n", __FUNCTION__, __LINE__);
200 return ERR_PTR(-ENOSYS);
201 }
202
203 static int c2_ah_destroy(struct ib_ah *ah)
204 {
205 pr_debug("%s:%u\n", __FUNCTION__, __LINE__);
206 return -ENOSYS;
207 }
208
209 static void c2_add_ref(struct ib_qp *ibqp)
210 {
211 struct c2_qp *qp;
212 BUG_ON(!ibqp);
213 qp = to_c2qp(ibqp);
214 atomic_inc(&qp->refcount);
215 }
216
217 static void c2_rem_ref(struct ib_qp *ibqp)
218 {
219 struct c2_qp *qp;
220 BUG_ON(!ibqp);
221 qp = to_c2qp(ibqp);
222 if (atomic_dec_and_test(&qp->refcount))
223 wake_up(&qp->wait);
224 }
225
226 struct ib_qp *c2_get_qp(struct ib_device *device, int qpn)
227 {
228 struct c2_dev* c2dev = to_c2dev(device);
229 struct c2_qp *qp;
230
231 qp = c2_find_qpn(c2dev, qpn);
232 pr_debug("%s Returning QP=%p for QPN=%d, device=%p, refcount=%d\n",
233 __FUNCTION__, qp, qpn, device,
234 (qp?atomic_read(&qp->refcount):0));
235
236 return (qp?&qp->ibqp:NULL);
237 }
238
239 static struct ib_qp *c2_create_qp(struct ib_pd *pd,
240 struct ib_qp_init_attr *init_attr,
241 struct ib_udata *udata)
242 {
243 struct c2_qp *qp;
244 int err;
245
246 pr_debug("%s:%u\n", __FUNCTION__, __LINE__);
247
248 switch (init_attr->qp_type) {
249 case IB_QPT_RC:
250 qp = kzalloc(sizeof(*qp), GFP_KERNEL);
251 if (!qp) {
252 pr_debug("%s: Unable to allocate QP\n", __FUNCTION__);
253 return ERR_PTR(-ENOMEM);
254 }
255 spin_lock_init(&qp->lock);
256 if (pd->uobject) {
257 /* userspace specific */
258 }
259
260 err = c2_alloc_qp(to_c2dev(pd->device),
261 to_c2pd(pd), init_attr, qp);
262
263 if (err && pd->uobject) {
264 /* userspace specific */
265 }
266
267 break;
268 default:
269 pr_debug("%s: Invalid QP type: %d\n", __FUNCTION__,
270 init_attr->qp_type);
271 return ERR_PTR(-EINVAL);
272 break;
273 }
274
275 if (err) {
276 kfree(qp);
277 return ERR_PTR(err);
278 }
279
280 return &qp->ibqp;
281 }
282
283 static int c2_destroy_qp(struct ib_qp *ib_qp)
284 {
285 struct c2_qp *qp = to_c2qp(ib_qp);
286
287 pr_debug("%s:%u qp=%p,qp->state=%d\n",
288 __FUNCTION__, __LINE__,ib_qp,qp->state);
289 c2_free_qp(to_c2dev(ib_qp->device), qp);
290 kfree(qp);
291 return 0;
292 }
293
294 static struct ib_cq *c2_create_cq(struct ib_device *ibdev, int entries, int vector,
295 struct ib_ucontext *context,
296 struct ib_udata *udata)
297 {
298 struct c2_cq *cq;
299 int err;
300
301 cq = kmalloc(sizeof(*cq), GFP_KERNEL);
302 if (!cq) {
303 pr_debug("%s: Unable to allocate CQ\n", __FUNCTION__);
304 return ERR_PTR(-ENOMEM);
305 }
306
307 err = c2_init_cq(to_c2dev(ibdev), entries, NULL, cq);
308 if (err) {
309 pr_debug("%s: error initializing CQ\n", __FUNCTION__);
310 kfree(cq);
311 return ERR_PTR(err);
312 }
313
314 return &cq->ibcq;
315 }
316
317 static int c2_destroy_cq(struct ib_cq *ib_cq)
318 {
319 struct c2_cq *cq = to_c2cq(ib_cq);
320
321 pr_debug("%s:%u\n", __FUNCTION__, __LINE__);
322
323 c2_free_cq(to_c2dev(ib_cq->device), cq);
324 kfree(cq);
325
326 return 0;
327 }
328
329 static inline u32 c2_convert_access(int acc)
330 {
331 return (acc & IB_ACCESS_REMOTE_WRITE ? C2_ACF_REMOTE_WRITE : 0) |
332 (acc & IB_ACCESS_REMOTE_READ ? C2_ACF_REMOTE_READ : 0) |
333 (acc & IB_ACCESS_LOCAL_WRITE ? C2_ACF_LOCAL_WRITE : 0) |
334 C2_ACF_LOCAL_READ | C2_ACF_WINDOW_BIND;
335 }
336
337 static struct ib_mr *c2_reg_phys_mr(struct ib_pd *ib_pd,
338 struct ib_phys_buf *buffer_list,
339 int num_phys_buf, int acc, u64 * iova_start)
340 {
341 struct c2_mr *mr;
342 u64 *page_list;
343 u32 total_len;
344 int err, i, j, k, page_shift, pbl_depth;
345
346 pbl_depth = 0;
347 total_len = 0;
348
349 page_shift = PAGE_SHIFT;
350 /*
351 * If there is only 1 buffer we assume this could
352 * be a map of all phy mem...use a 32k page_shift.
353 */
354 if (num_phys_buf == 1)
355 page_shift += 3;
356
357 for (i = 0; i < num_phys_buf; i++) {
358
359 if (buffer_list[i].addr & ~PAGE_MASK) {
360 pr_debug("Unaligned Memory Buffer: 0x%x\n",
361 (unsigned int) buffer_list[i].addr);
362 return ERR_PTR(-EINVAL);
363 }
364
365 if (!buffer_list[i].size) {
366 pr_debug("Invalid Buffer Size\n");
367 return ERR_PTR(-EINVAL);
368 }
369
370 total_len += buffer_list[i].size;
371 pbl_depth += ALIGN(buffer_list[i].size,
372 (1 << page_shift)) >> page_shift;
373 }
374
375 page_list = vmalloc(sizeof(u64) * pbl_depth);
376 if (!page_list) {
377 pr_debug("couldn't vmalloc page_list of size %zd\n",
378 (sizeof(u64) * pbl_depth));
379 return ERR_PTR(-ENOMEM);
380 }
381
382 for (i = 0, j = 0; i < num_phys_buf; i++) {
383
384 int naddrs;
385
386 naddrs = ALIGN(buffer_list[i].size,
387 (1 << page_shift)) >> page_shift;
388 for (k = 0; k < naddrs; k++)
389 page_list[j++] = (buffer_list[i].addr +
390 (k << page_shift));
391 }
392
393 mr = kmalloc(sizeof(*mr), GFP_KERNEL);
394 if (!mr) {
395 vfree(page_list);
396 return ERR_PTR(-ENOMEM);
397 }
398
399 mr->pd = to_c2pd(ib_pd);
400 mr->umem = NULL;
401 pr_debug("%s - page shift %d, pbl_depth %d, total_len %u, "
402 "*iova_start %llx, first pa %llx, last pa %llx\n",
403 __FUNCTION__, page_shift, pbl_depth, total_len,
404 (unsigned long long) *iova_start,
405 (unsigned long long) page_list[0],
406 (unsigned long long) page_list[pbl_depth-1]);
407 err = c2_nsmr_register_phys_kern(to_c2dev(ib_pd->device), page_list,
408 (1 << page_shift), pbl_depth,
409 total_len, 0, iova_start,
410 c2_convert_access(acc), mr);
411 vfree(page_list);
412 if (err) {
413 kfree(mr);
414 return ERR_PTR(err);
415 }
416
417 return &mr->ibmr;
418 }
419
420 static struct ib_mr *c2_get_dma_mr(struct ib_pd *pd, int acc)
421 {
422 struct ib_phys_buf bl;
423 u64 kva = 0;
424
425 pr_debug("%s:%u\n", __FUNCTION__, __LINE__);
426
427 /* AMSO1100 limit */
428 bl.size = 0xffffffff;
429 bl.addr = 0;
430 return c2_reg_phys_mr(pd, &bl, 1, acc, &kva);
431 }
432
433 static struct ib_mr *c2_reg_user_mr(struct ib_pd *pd, u64 start, u64 length,
434 u64 virt, int acc, struct ib_udata *udata)
435 {
436 u64 *pages;
437 u64 kva = 0;
438 int shift, n, len;
439 int i, j, k;
440 int err = 0;
441 struct ib_umem_chunk *chunk;
442 struct c2_pd *c2pd = to_c2pd(pd);
443 struct c2_mr *c2mr;
444
445 pr_debug("%s:%u\n", __FUNCTION__, __LINE__);
446
447 c2mr = kmalloc(sizeof(*c2mr), GFP_KERNEL);
448 if (!c2mr)
449 return ERR_PTR(-ENOMEM);
450 c2mr->pd = c2pd;
451
452 c2mr->umem = ib_umem_get(pd->uobject->context, start, length, acc);
453 if (IS_ERR(c2mr->umem)) {
454 err = PTR_ERR(c2mr->umem);
455 kfree(c2mr);
456 return ERR_PTR(err);
457 }
458
459 shift = ffs(c2mr->umem->page_size) - 1;
460
461 n = 0;
462 list_for_each_entry(chunk, &c2mr->umem->chunk_list, list)
463 n += chunk->nents;
464
465 pages = kmalloc(n * sizeof(u64), GFP_KERNEL);
466 if (!pages) {
467 err = -ENOMEM;
468 goto err;
469 }
470
471 i = 0;
472 list_for_each_entry(chunk, &c2mr->umem->chunk_list, list) {
473 for (j = 0; j < chunk->nmap; ++j) {
474 len = sg_dma_len(&chunk->page_list[j]) >> shift;
475 for (k = 0; k < len; ++k) {
476 pages[i++] =
477 sg_dma_address(&chunk->page_list[j]) +
478 (c2mr->umem->page_size * k);
479 }
480 }
481 }
482
483 kva = virt;
484 err = c2_nsmr_register_phys_kern(to_c2dev(pd->device),
485 pages,
486 c2mr->umem->page_size,
487 i,
488 length,
489 c2mr->umem->offset,
490 &kva,
491 c2_convert_access(acc),
492 c2mr);
493 kfree(pages);
494 if (err)
495 goto err;
496 return &c2mr->ibmr;
497
498 err:
499 ib_umem_release(c2mr->umem);
500 kfree(c2mr);
501 return ERR_PTR(err);
502 }
503
504 static int c2_dereg_mr(struct ib_mr *ib_mr)
505 {
506 struct c2_mr *mr = to_c2mr(ib_mr);
507 int err;
508
509 pr_debug("%s:%u\n", __FUNCTION__, __LINE__);
510
511 err = c2_stag_dealloc(to_c2dev(ib_mr->device), ib_mr->lkey);
512 if (err)
513 pr_debug("c2_stag_dealloc failed: %d\n", err);
514 else {
515 if (mr->umem)
516 ib_umem_release(mr->umem);
517 kfree(mr);
518 }
519
520 return err;
521 }
522
523 static ssize_t show_rev(struct class_device *cdev, char *buf)
524 {
525 struct c2_dev *dev = container_of(cdev, struct c2_dev, ibdev.class_dev);
526 pr_debug("%s:%u\n", __FUNCTION__, __LINE__);
527 return sprintf(buf, "%x\n", dev->props.hw_ver);
528 }
529
530 static ssize_t show_fw_ver(struct class_device *cdev, char *buf)
531 {
532 struct c2_dev *dev = container_of(cdev, struct c2_dev, ibdev.class_dev);
533 pr_debug("%s:%u\n", __FUNCTION__, __LINE__);
534 return sprintf(buf, "%x.%x.%x\n",
535 (int) (dev->props.fw_ver >> 32),
536 (int) (dev->props.fw_ver >> 16) & 0xffff,
537 (int) (dev->props.fw_ver & 0xffff));
538 }
539
540 static ssize_t show_hca(struct class_device *cdev, char *buf)
541 {
542 pr_debug("%s:%u\n", __FUNCTION__, __LINE__);
543 return sprintf(buf, "AMSO1100\n");
544 }
545
546 static ssize_t show_board(struct class_device *cdev, char *buf)
547 {
548 pr_debug("%s:%u\n", __FUNCTION__, __LINE__);
549 return sprintf(buf, "%.*s\n", 32, "AMSO1100 Board ID");
550 }
551
552 static CLASS_DEVICE_ATTR(hw_rev, S_IRUGO, show_rev, NULL);
553 static CLASS_DEVICE_ATTR(fw_ver, S_IRUGO, show_fw_ver, NULL);
554 static CLASS_DEVICE_ATTR(hca_type, S_IRUGO, show_hca, NULL);
555 static CLASS_DEVICE_ATTR(board_id, S_IRUGO, show_board, NULL);
556
557 static struct class_device_attribute *c2_class_attributes[] = {
558 &class_device_attr_hw_rev,
559 &class_device_attr_fw_ver,
560 &class_device_attr_hca_type,
561 &class_device_attr_board_id
562 };
563
564 static int c2_modify_qp(struct ib_qp *ibqp, struct ib_qp_attr *attr,
565 int attr_mask, struct ib_udata *udata)
566 {
567 int err;
568
569 err =
570 c2_qp_modify(to_c2dev(ibqp->device), to_c2qp(ibqp), attr,
571 attr_mask);
572
573 return err;
574 }
575
576 static int c2_multicast_attach(struct ib_qp *ibqp, union ib_gid *gid, u16 lid)
577 {
578 pr_debug("%s:%u\n", __FUNCTION__, __LINE__);
579 return -ENOSYS;
580 }
581
582 static int c2_multicast_detach(struct ib_qp *ibqp, union ib_gid *gid, u16 lid)
583 {
584 pr_debug("%s:%u\n", __FUNCTION__, __LINE__);
585 return -ENOSYS;
586 }
587
588 static int c2_process_mad(struct ib_device *ibdev,
589 int mad_flags,
590 u8 port_num,
591 struct ib_wc *in_wc,
592 struct ib_grh *in_grh,
593 struct ib_mad *in_mad, struct ib_mad *out_mad)
594 {
595 pr_debug("%s:%u\n", __FUNCTION__, __LINE__);
596 return -ENOSYS;
597 }
598
599 static int c2_connect(struct iw_cm_id *cm_id, struct iw_cm_conn_param *iw_param)
600 {
601 pr_debug("%s:%u\n", __FUNCTION__, __LINE__);
602
603 /* Request a connection */
604 return c2_llp_connect(cm_id, iw_param);
605 }
606
607 static int c2_accept(struct iw_cm_id *cm_id, struct iw_cm_conn_param *iw_param)
608 {
609 pr_debug("%s:%u\n", __FUNCTION__, __LINE__);
610
611 /* Accept the new connection */
612 return c2_llp_accept(cm_id, iw_param);
613 }
614
615 static int c2_reject(struct iw_cm_id *cm_id, const void *pdata, u8 pdata_len)
616 {
617 int err;
618
619 pr_debug("%s:%u\n", __FUNCTION__, __LINE__);
620
621 err = c2_llp_reject(cm_id, pdata, pdata_len);
622 return err;
623 }
624
625 static int c2_service_create(struct iw_cm_id *cm_id, int backlog)
626 {
627 int err;
628
629 pr_debug("%s:%u\n", __FUNCTION__, __LINE__);
630 err = c2_llp_service_create(cm_id, backlog);
631 pr_debug("%s:%u err=%d\n",
632 __FUNCTION__, __LINE__,
633 err);
634 return err;
635 }
636
637 static int c2_service_destroy(struct iw_cm_id *cm_id)
638 {
639 int err;
640 pr_debug("%s:%u\n", __FUNCTION__, __LINE__);
641
642 err = c2_llp_service_destroy(cm_id);
643
644 return err;
645 }
646
647 static int c2_pseudo_up(struct net_device *netdev)
648 {
649 struct in_device *ind;
650 struct c2_dev *c2dev = netdev->priv;
651
652 ind = in_dev_get(netdev);
653 if (!ind)
654 return 0;
655
656 pr_debug("adding...\n");
657 for_ifa(ind) {
658 #ifdef DEBUG
659 u8 *ip = (u8 *) & ifa->ifa_address;
660
661 pr_debug("%s: %d.%d.%d.%d\n",
662 ifa->ifa_label, ip[0], ip[1], ip[2], ip[3]);
663 #endif
664 c2_add_addr(c2dev, ifa->ifa_address, ifa->ifa_mask);
665 }
666 endfor_ifa(ind);
667 in_dev_put(ind);
668
669 return 0;
670 }
671
672 static int c2_pseudo_down(struct net_device *netdev)
673 {
674 struct in_device *ind;
675 struct c2_dev *c2dev = netdev->priv;
676
677 ind = in_dev_get(netdev);
678 if (!ind)
679 return 0;
680
681 pr_debug("deleting...\n");
682 for_ifa(ind) {
683 #ifdef DEBUG
684 u8 *ip = (u8 *) & ifa->ifa_address;
685
686 pr_debug("%s: %d.%d.%d.%d\n",
687 ifa->ifa_label, ip[0], ip[1], ip[2], ip[3]);
688 #endif
689 c2_del_addr(c2dev, ifa->ifa_address, ifa->ifa_mask);
690 }
691 endfor_ifa(ind);
692 in_dev_put(ind);
693
694 return 0;
695 }
696
697 static int c2_pseudo_xmit_frame(struct sk_buff *skb, struct net_device *netdev)
698 {
699 kfree_skb(skb);
700 return NETDEV_TX_OK;
701 }
702
703 static int c2_pseudo_change_mtu(struct net_device *netdev, int new_mtu)
704 {
705 int ret = 0;
706
707 if (new_mtu < ETH_ZLEN || new_mtu > ETH_JUMBO_MTU)
708 return -EINVAL;
709
710 netdev->mtu = new_mtu;
711
712 /* TODO: Tell rnic about new rmda interface mtu */
713 return ret;
714 }
715
716 static void setup(struct net_device *netdev)
717 {
718 netdev->open = c2_pseudo_up;
719 netdev->stop = c2_pseudo_down;
720 netdev->hard_start_xmit = c2_pseudo_xmit_frame;
721 netdev->get_stats = NULL;
722 netdev->tx_timeout = NULL;
723 netdev->set_mac_address = NULL;
724 netdev->change_mtu = c2_pseudo_change_mtu;
725 netdev->watchdog_timeo = 0;
726 netdev->type = ARPHRD_ETHER;
727 netdev->mtu = 1500;
728 netdev->hard_header_len = ETH_HLEN;
729 netdev->addr_len = ETH_ALEN;
730 netdev->tx_queue_len = 0;
731 netdev->flags |= IFF_NOARP;
732 return;
733 }
734
735 static struct net_device *c2_pseudo_netdev_init(struct c2_dev *c2dev)
736 {
737 char name[IFNAMSIZ];
738 struct net_device *netdev;
739
740 /* change ethxxx to iwxxx */
741 strcpy(name, "iw");
742 strcat(name, &c2dev->netdev->name[3]);
743 netdev = alloc_netdev(sizeof(*netdev), name, setup);
744 if (!netdev) {
745 printk(KERN_ERR PFX "%s - etherdev alloc failed",
746 __FUNCTION__);
747 return NULL;
748 }
749
750 netdev->priv = c2dev;
751
752 SET_NETDEV_DEV(netdev, &c2dev->pcidev->dev);
753
754 memcpy_fromio(netdev->dev_addr, c2dev->kva + C2_REGS_RDMA_ENADDR, 6);
755
756 /* Print out the MAC address */
757 pr_debug("%s: MAC %02X:%02X:%02X:%02X:%02X:%02X\n",
758 netdev->name,
759 netdev->dev_addr[0], netdev->dev_addr[1], netdev->dev_addr[2],
760 netdev->dev_addr[3], netdev->dev_addr[4], netdev->dev_addr[5]);
761
762 #if 0
763 /* Disable network packets */
764 netif_stop_queue(netdev);
765 #endif
766 return netdev;
767 }
768
769 int c2_register_device(struct c2_dev *dev)
770 {
771 int ret = -ENOMEM;
772 int i;
773
774 /* Register pseudo network device */
775 dev->pseudo_netdev = c2_pseudo_netdev_init(dev);
776 if (!dev->pseudo_netdev)
777 goto out3;
778
779 ret = register_netdev(dev->pseudo_netdev);
780 if (ret)
781 goto out2;
782
783 pr_debug("%s:%u\n", __FUNCTION__, __LINE__);
784 strlcpy(dev->ibdev.name, "amso%d", IB_DEVICE_NAME_MAX);
785 dev->ibdev.owner = THIS_MODULE;
786 dev->ibdev.uverbs_cmd_mask =
787 (1ull << IB_USER_VERBS_CMD_GET_CONTEXT) |
788 (1ull << IB_USER_VERBS_CMD_QUERY_DEVICE) |
789 (1ull << IB_USER_VERBS_CMD_QUERY_PORT) |
790 (1ull << IB_USER_VERBS_CMD_ALLOC_PD) |
791 (1ull << IB_USER_VERBS_CMD_DEALLOC_PD) |
792 (1ull << IB_USER_VERBS_CMD_REG_MR) |
793 (1ull << IB_USER_VERBS_CMD_DEREG_MR) |
794 (1ull << IB_USER_VERBS_CMD_CREATE_COMP_CHANNEL) |
795 (1ull << IB_USER_VERBS_CMD_CREATE_CQ) |
796 (1ull << IB_USER_VERBS_CMD_DESTROY_CQ) |
797 (1ull << IB_USER_VERBS_CMD_REQ_NOTIFY_CQ) |
798 (1ull << IB_USER_VERBS_CMD_CREATE_QP) |
799 (1ull << IB_USER_VERBS_CMD_MODIFY_QP) |
800 (1ull << IB_USER_VERBS_CMD_POLL_CQ) |
801 (1ull << IB_USER_VERBS_CMD_DESTROY_QP) |
802 (1ull << IB_USER_VERBS_CMD_POST_SEND) |
803 (1ull << IB_USER_VERBS_CMD_POST_RECV);
804
805 dev->ibdev.node_type = RDMA_NODE_RNIC;
806 memset(&dev->ibdev.node_guid, 0, sizeof(dev->ibdev.node_guid));
807 memcpy(&dev->ibdev.node_guid, dev->pseudo_netdev->dev_addr, 6);
808 dev->ibdev.phys_port_cnt = 1;
809 dev->ibdev.num_comp_vectors = 1;
810 dev->ibdev.dma_device = &dev->pcidev->dev;
811 dev->ibdev.query_device = c2_query_device;
812 dev->ibdev.query_port = c2_query_port;
813 dev->ibdev.modify_port = c2_modify_port;
814 dev->ibdev.query_pkey = c2_query_pkey;
815 dev->ibdev.query_gid = c2_query_gid;
816 dev->ibdev.alloc_ucontext = c2_alloc_ucontext;
817 dev->ibdev.dealloc_ucontext = c2_dealloc_ucontext;
818 dev->ibdev.mmap = c2_mmap_uar;
819 dev->ibdev.alloc_pd = c2_alloc_pd;
820 dev->ibdev.dealloc_pd = c2_dealloc_pd;
821 dev->ibdev.create_ah = c2_ah_create;
822 dev->ibdev.destroy_ah = c2_ah_destroy;
823 dev->ibdev.create_qp = c2_create_qp;
824 dev->ibdev.modify_qp = c2_modify_qp;
825 dev->ibdev.destroy_qp = c2_destroy_qp;
826 dev->ibdev.create_cq = c2_create_cq;
827 dev->ibdev.destroy_cq = c2_destroy_cq;
828 dev->ibdev.poll_cq = c2_poll_cq;
829 dev->ibdev.get_dma_mr = c2_get_dma_mr;
830 dev->ibdev.reg_phys_mr = c2_reg_phys_mr;
831 dev->ibdev.reg_user_mr = c2_reg_user_mr;
832 dev->ibdev.dereg_mr = c2_dereg_mr;
833
834 dev->ibdev.alloc_fmr = NULL;
835 dev->ibdev.unmap_fmr = NULL;
836 dev->ibdev.dealloc_fmr = NULL;
837 dev->ibdev.map_phys_fmr = NULL;
838
839 dev->ibdev.attach_mcast = c2_multicast_attach;
840 dev->ibdev.detach_mcast = c2_multicast_detach;
841 dev->ibdev.process_mad = c2_process_mad;
842
843 dev->ibdev.req_notify_cq = c2_arm_cq;
844 dev->ibdev.post_send = c2_post_send;
845 dev->ibdev.post_recv = c2_post_receive;
846
847 dev->ibdev.iwcm = kmalloc(sizeof(*dev->ibdev.iwcm), GFP_KERNEL);
848 dev->ibdev.iwcm->add_ref = c2_add_ref;
849 dev->ibdev.iwcm->rem_ref = c2_rem_ref;
850 dev->ibdev.iwcm->get_qp = c2_get_qp;
851 dev->ibdev.iwcm->connect = c2_connect;
852 dev->ibdev.iwcm->accept = c2_accept;
853 dev->ibdev.iwcm->reject = c2_reject;
854 dev->ibdev.iwcm->create_listen = c2_service_create;
855 dev->ibdev.iwcm->destroy_listen = c2_service_destroy;
856
857 ret = ib_register_device(&dev->ibdev);
858 if (ret)
859 goto out1;
860
861 for (i = 0; i < ARRAY_SIZE(c2_class_attributes); ++i) {
862 ret = class_device_create_file(&dev->ibdev.class_dev,
863 c2_class_attributes[i]);
864 if (ret)
865 goto out0;
866 }
867 goto out3;
868
869 out0:
870 ib_unregister_device(&dev->ibdev);
871 out1:
872 unregister_netdev(dev->pseudo_netdev);
873 out2:
874 free_netdev(dev->pseudo_netdev);
875 out3:
876 pr_debug("%s:%u ret=%d\n", __FUNCTION__, __LINE__, ret);
877 return ret;
878 }
879
880 void c2_unregister_device(struct c2_dev *dev)
881 {
882 pr_debug("%s:%u\n", __FUNCTION__, __LINE__);
883 unregister_netdev(dev->pseudo_netdev);
884 free_netdev(dev->pseudo_netdev);
885 ib_unregister_device(&dev->ibdev);
886 }
WRT350N Kernel Patches