Linux kernel mirror (for testing)
git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel
os
linux
Merge tag 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/dledford/rdma
Pull rdma fixes from Doug Ledford:
"This has been a slow -rc cycle for the RDMA subsystem. We really
haven't had a lot of rc fixes come in. This pull request is the first
of this entire rc cycle and it has all of the suitable fixes so far
and it's still only about 20 patches. The fix for the minor breakage
cause by the dma mapping patchset is in here, as well as a couple
other potential oops fixes, but the rest is more minor.
Summary:
- fix for dma_ops change in this kernel, resolving the s390, powerpc,
and IOMMU operation
- a few other oops fixes
- the rest are all minor fixes"
* tag 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/dledford/rdma:
IB/qib: fix false-postive maybe-uninitialized warning
RDMA/iser: Fix possible mr leak on device removal event
IB/device: Convert ib-comp-wq to be CPU-bound
IB/cq: Don't process more than the given budget
IB/rxe: increment msn only when completing a request
uapi: fix rdma/mlx5-abi.h userspace compilation errors
IB/core: Restore I/O MMU, s390 and powerpc support
IB/rxe: Update documentation link
RDMA/ocrdma: fix a type issue in ocrdma_put_pd_num()
IB/rxe: double free on error
RDMA/vmw_pvrdma: Activate device on ethernet link up
RDMA/vmw_pvrdma: Dont hardcode QP header page
RDMA/vmw_pvrdma: Cleanup unused variables
infiniband: Fix alignment of mmap cookies to support VIPT caching
IB/core: Protect against self-requeue of a cq work item
i40iw: Receive netdev events post INET_NOTIFIER state
+110
-69
+8
-2
drivers/infiniband/core/cq.c
+8
-2
drivers/infiniband/core/cq.c
···
29
29
{
30
30
int i, n, completed = 0;
31
31
32
-
while ((n = ib_poll_cq(cq, IB_POLL_BATCH, cq->wc)) > 0) {
32
+
/*
33
+
* budget might be (-1) if the caller does not
34
+
* want to bound this call, thus we need unsigned
35
+
* minimum here.
36
+
*/
37
+
while ((n = ib_poll_cq(cq, min_t(u32, IB_POLL_BATCH,
38
+
budget - completed), cq->wc)) > 0) {
33
39
for (i = 0; i < n; i++) {
34
40
struct ib_wc *wc = &cq->wc[i];
35
41
···
202
196
irq_poll_disable(&cq->iop);
203
197
break;
204
198
case IB_POLL_WORKQUEUE:
205
-
flush_work(&cq->work);
199
+
cancel_work_sync(&cq->work);
206
200
break;
207
201
default:
208
202
WARN_ON_ONCE(1);
+21
-8
drivers/infiniband/core/device.c
+21
-8
drivers/infiniband/core/device.c
···
336
336
struct device *parent = device->dev.parent;
337
337
338
338
WARN_ON_ONCE(!parent);
339
-
if (!device->dev.dma_ops)
340
-
device->dev.dma_ops = parent->dma_ops;
341
-
if (!device->dev.dma_mask)
342
-
device->dev.dma_mask = parent->dma_mask;
343
-
if (!device->dev.coherent_dma_mask)
344
-
device->dev.coherent_dma_mask = parent->coherent_dma_mask;
339
+
WARN_ON_ONCE(device->dma_device);
340
+
if (device->dev.dma_ops) {
341
+
/*
342
+
* The caller provided custom DMA operations. Copy the
343
+
* DMA-related fields that are used by e.g. dma_alloc_coherent()
344
+
* into device->dev.
345
+
*/
346
+
device->dma_device = &device->dev;
347
+
if (!device->dev.dma_mask)
348
+
device->dev.dma_mask = parent->dma_mask;
349
+
if (!device->dev.coherent_dma_mask)
350
+
device->dev.coherent_dma_mask =
351
+
parent->coherent_dma_mask;
352
+
} else {
353
+
/*
354
+
* The caller did not provide custom DMA operations. Use the
355
+
* DMA mapping operations of the parent device.
356
+
*/
357
+
device->dma_device = parent;
358
+
}
345
359
346
360
mutex_lock(&device_mutex);
347
361
···
1029
1015
return -ENOMEM;
1030
1016
1031
1017
ib_comp_wq = alloc_workqueue("ib-comp-wq",
1032
-
WQ_UNBOUND | WQ_HIGHPRI | WQ_MEM_RECLAIM,
1033
-
WQ_UNBOUND_MAX_ACTIVE);
1018
+
WQ_HIGHPRI | WQ_MEM_RECLAIM | WQ_SYSFS, 0);
1034
1019
if (!ib_comp_wq) {
1035
1020
ret = -ENOMEM;
1036
1021
goto err;
+8
drivers/infiniband/hw/i40iw/i40iw_utils.c
+8
drivers/infiniband/hw/i40iw/i40iw_utils.c
···
160
160
return NOTIFY_DONE;
161
161
162
162
iwdev = &hdl->device;
163
+
if (iwdev->init_state < INET_NOTIFIER)
164
+
return NOTIFY_DONE;
165
+
163
166
netdev = iwdev->ldev->netdev;
164
167
upper_dev = netdev_master_upper_dev_get(netdev);
165
168
if (netdev != event_netdev)
···
217
214
return NOTIFY_DONE;
218
215
219
216
iwdev = &hdl->device;
217
+
if (iwdev->init_state < INET_NOTIFIER)
218
+
return NOTIFY_DONE;
219
+
220
220
netdev = iwdev->ldev->netdev;
221
221
if (netdev != event_netdev)
222
222
return NOTIFY_DONE;
···
266
260
if (!iwhdl)
267
261
return NOTIFY_DONE;
268
262
iwdev = &iwhdl->device;
263
+
if (iwdev->init_state < INET_NOTIFIER)
264
+
return NOTIFY_DONE;
269
265
p = (__be32 *)neigh->primary_key;
270
266
i40iw_copy_ip_ntohl(local_ipaddr, p);
271
267
if (neigh->nud_state & NUD_VALID) {
+1
-1
drivers/infiniband/hw/ocrdma/ocrdma_verbs.c
+1
-1
drivers/infiniband/hw/ocrdma/ocrdma_verbs.c
+1
-1
drivers/infiniband/hw/qib/qib_iba7322.c
+1
-1
drivers/infiniband/hw/qib/qib_iba7322.c
+3
drivers/infiniband/hw/vmw_pvrdma/pvrdma.h
+3
drivers/infiniband/hw/vmw_pvrdma/pvrdma.h
+1
-1
drivers/infiniband/hw/vmw_pvrdma/pvrdma_dev_api.h
+1
-1
drivers/infiniband/hw/vmw_pvrdma/pvrdma_dev_api.h
+13
-4
drivers/infiniband/hw/vmw_pvrdma/pvrdma_main.c
+13
-4
drivers/infiniband/hw/vmw_pvrdma/pvrdma_main.c
···
56
56
#include "pvrdma.h"
57
57
58
58
#define DRV_NAME "vmw_pvrdma"
59
-
#define DRV_VERSION "1.0.0.0-k"
59
+
#define DRV_VERSION "1.0.1.0-k"
60
60
61
61
static DEFINE_MUTEX(pvrdma_device_list_lock);
62
62
static LIST_HEAD(pvrdma_device_list);
···
660
660
pvrdma_dispatch_event(dev, 1, IB_EVENT_PORT_ERR);
661
661
break;
662
662
case NETDEV_UP:
663
-
pvrdma_dispatch_event(dev, 1, IB_EVENT_PORT_ACTIVE);
663
+
pvrdma_write_reg(dev, PVRDMA_REG_CTL,
664
+
PVRDMA_DEVICE_CTL_UNQUIESCE);
665
+
666
+
mb();
667
+
668
+
if (pvrdma_read_reg(dev, PVRDMA_REG_ERR))
669
+
dev_err(&dev->pdev->dev,
670
+
"failed to activate device during link up\n");
671
+
else
672
+
pvrdma_dispatch_event(dev, 1, IB_EVENT_PORT_ACTIVE);
664
673
break;
665
674
default:
666
675
dev_dbg(&dev->pdev->dev, "ignore netdevice event %ld on %s\n",
···
867
858
dev->dsr->resp_slot_dma = (u64)slot_dma;
868
859
869
860
/* Async event ring */
870
-
dev->dsr->async_ring_pages.num_pages = 4;
861
+
dev->dsr->async_ring_pages.num_pages = PVRDMA_NUM_RING_PAGES;
871
862
ret = pvrdma_page_dir_init(dev, &dev->async_pdir,
872
863
dev->dsr->async_ring_pages.num_pages, true);
873
864
if (ret)
···
876
867
dev->dsr->async_ring_pages.pdir_dma = dev->async_pdir.dir_dma;
877
868
878
869
/* CQ notification ring */
879
-
dev->dsr->cq_ring_pages.num_pages = 4;
870
+
dev->dsr->cq_ring_pages.num_pages = PVRDMA_NUM_RING_PAGES;
880
871
ret = pvrdma_page_dir_init(dev, &dev->cq_pdir,
881
872
dev->dsr->cq_ring_pages.num_pages, true);
882
873
if (ret)
+18
-24
drivers/infiniband/hw/vmw_pvrdma/pvrdma_qp.c
+18
-24
drivers/infiniband/hw/vmw_pvrdma/pvrdma_qp.c
···
170
170
sizeof(struct pvrdma_sge) *
171
171
qp->sq.max_sg);
172
172
/* Note: one extra page for the header. */
173
-
qp->npages_send = 1 + (qp->sq.wqe_cnt * qp->sq.wqe_size +
174
-
PAGE_SIZE - 1) / PAGE_SIZE;
173
+
qp->npages_send = PVRDMA_QP_NUM_HEADER_PAGES +
174
+
(qp->sq.wqe_cnt * qp->sq.wqe_size + PAGE_SIZE - 1) /
175
+
PAGE_SIZE;
175
176
176
177
return 0;
177
178
}
···
289
288
qp->npages = qp->npages_send + qp->npages_recv;
290
289
291
290
/* Skip header page. */
292
-
qp->sq.offset = PAGE_SIZE;
291
+
qp->sq.offset = PVRDMA_QP_NUM_HEADER_PAGES * PAGE_SIZE;
293
292
294
293
/* Recv queue pages are after send pages. */
295
294
qp->rq.offset = qp->npages_send * PAGE_SIZE;
···
342
341
cmd->qp_type = ib_qp_type_to_pvrdma(init_attr->qp_type);
343
342
cmd->access_flags = IB_ACCESS_LOCAL_WRITE;
344
343
cmd->total_chunks = qp->npages;
345
-
cmd->send_chunks = qp->npages_send - 1;
344
+
cmd->send_chunks = qp->npages_send - PVRDMA_QP_NUM_HEADER_PAGES;
346
345
cmd->pdir_dma = qp->pdir.dir_dma;
347
346
348
347
dev_dbg(&dev->pdev->dev, "create queuepair with %d, %d, %d, %d\n",
···
555
554
return ret;
556
555
}
557
556
558
-
static inline void *get_sq_wqe(struct pvrdma_qp *qp, int n)
557
+
static inline void *get_sq_wqe(struct pvrdma_qp *qp, unsigned int n)
559
558
{
560
559
return pvrdma_page_dir_get_ptr(&qp->pdir,
561
560
qp->sq.offset + n * qp->sq.wqe_size);
562
561
}
563
562
564
-
static inline void *get_rq_wqe(struct pvrdma_qp *qp, int n)
563
+
static inline void *get_rq_wqe(struct pvrdma_qp *qp, unsigned int n)
565
564
{
566
565
return pvrdma_page_dir_get_ptr(&qp->pdir,
567
566
qp->rq.offset + n * qp->rq.wqe_size);
···
599
598
unsigned long flags;
600
599
struct pvrdma_sq_wqe_hdr *wqe_hdr;
601
600
struct pvrdma_sge *sge;
602
-
int i, index;
603
-
int nreq;
604
-
int ret;
601
+
int i, ret;
605
602
606
603
/*
607
604
* In states lower than RTS, we can fail immediately. In other states,
···
612
613
613
614
spin_lock_irqsave(&qp->sq.lock, flags);
614
615
615
-
index = pvrdma_idx(&qp->sq.ring->prod_tail, qp->sq.wqe_cnt);
616
-
for (nreq = 0; wr; nreq++, wr = wr->next) {
617
-
unsigned int tail;
616
+
while (wr) {
617
+
unsigned int tail = 0;
618
618
619
619
if (unlikely(!pvrdma_idx_ring_has_space(
620
620
qp->sq.ring, qp->sq.wqe_cnt, &tail))) {
···
678
680
}
679
681
}
680
682
681
-
wqe_hdr = (struct pvrdma_sq_wqe_hdr *)get_sq_wqe(qp, index);
683
+
wqe_hdr = (struct pvrdma_sq_wqe_hdr *)get_sq_wqe(qp, tail);
682
684
memset(wqe_hdr, 0, sizeof(*wqe_hdr));
683
685
wqe_hdr->wr_id = wr->wr_id;
684
686
wqe_hdr->num_sge = wr->num_sge;
···
769
771
/* Make sure wqe is written before index update */
770
772
smp_wmb();
771
773
772
-
index++;
773
-
if (unlikely(index >= qp->sq.wqe_cnt))
774
-
index = 0;
775
774
/* Update shared sq ring */
776
775
pvrdma_idx_ring_inc(&qp->sq.ring->prod_tail,
777
776
qp->sq.wqe_cnt);
777
+
778
+
wr = wr->next;
778
779
}
779
780
780
781
ret = 0;
···
803
806
struct pvrdma_qp *qp = to_vqp(ibqp);
804
807
struct pvrdma_rq_wqe_hdr *wqe_hdr;
805
808
struct pvrdma_sge *sge;
806
-
int index, nreq;
807
809
int ret = 0;
808
810
int i;
809
811
···
817
821
818
822
spin_lock_irqsave(&qp->rq.lock, flags);
819
823
820
-
index = pvrdma_idx(&qp->rq.ring->prod_tail, qp->rq.wqe_cnt);
821
-
for (nreq = 0; wr; nreq++, wr = wr->next) {
822
-
unsigned int tail;
824
+
while (wr) {
825
+
unsigned int tail = 0;
823
826
824
827
if (unlikely(wr->num_sge > qp->rq.max_sg ||
825
828
wr->num_sge < 0)) {
···
838
843
goto out;
839
844
}
840
845
841
-
wqe_hdr = (struct pvrdma_rq_wqe_hdr *)get_rq_wqe(qp, index);
846
+
wqe_hdr = (struct pvrdma_rq_wqe_hdr *)get_rq_wqe(qp, tail);
842
847
wqe_hdr->wr_id = wr->wr_id;
843
848
wqe_hdr->num_sge = wr->num_sge;
844
849
wqe_hdr->total_len = 0;
···
854
859
/* Make sure wqe is written before index update */
855
860
smp_wmb();
856
861
857
-
index++;
858
-
if (unlikely(index >= qp->rq.wqe_cnt))
859
-
index = 0;
860
862
/* Update shared rq ring */
861
863
pvrdma_idx_ring_inc(&qp->rq.ring->prod_tail,
862
864
qp->rq.wqe_cnt);
865
+
866
+
wr = wr->next;
863
867
}
864
868
865
869
spin_unlock_irqrestore(&qp->rq.lock, flags);
+2
-2
drivers/infiniband/sw/rdmavt/mmap.c
+2
-2
drivers/infiniband/sw/rdmavt/mmap.c
···
170
170
171
171
spin_lock_irq(&rdi->mmap_offset_lock);
172
172
if (rdi->mmap_offset == 0)
173
-
rdi->mmap_offset = PAGE_SIZE;
173
+
rdi->mmap_offset = ALIGN(PAGE_SIZE, SHMLBA);
174
174
ip->offset = rdi->mmap_offset;
175
-
rdi->mmap_offset += size;
175
+
rdi->mmap_offset += ALIGN(size, SHMLBA);
176
176
spin_unlock_irq(&rdi->mmap_offset_lock);
177
177
178
178
INIT_LIST_HEAD(&ip->pending_mmaps);
+1
-1
drivers/infiniband/sw/rxe/Kconfig
+1
-1
drivers/infiniband/sw/rxe/Kconfig
+2
-2
drivers/infiniband/sw/rxe/rxe_mmap.c
+2
-2
drivers/infiniband/sw/rxe/rxe_mmap.c
···
156
156
spin_lock_bh(&rxe->mmap_offset_lock);
157
157
158
158
if (rxe->mmap_offset == 0)
159
-
rxe->mmap_offset = PAGE_SIZE;
159
+
rxe->mmap_offset = ALIGN(PAGE_SIZE, SHMLBA);
160
160
161
161
ip->info.offset = rxe->mmap_offset;
162
-
rxe->mmap_offset += size;
162
+
rxe->mmap_offset += ALIGN(size, SHMLBA);
163
163
164
164
spin_unlock_bh(&rxe->mmap_offset_lock);
165
165
+1
-1
drivers/infiniband/sw/rxe/rxe_req.c
+1
-1
drivers/infiniband/sw/rxe/rxe_req.c
···
729
729
ret = rxe_xmit_packet(to_rdev(qp->ibqp.device), qp, &pkt, skb);
730
730
if (ret) {
731
731
qp->need_req_skb = 1;
732
-
kfree_skb(skb);
733
732
734
733
rollback_state(wqe, qp, &rollback_wqe, rollback_psn);
735
734
736
735
if (ret == -EAGAIN) {
736
+
kfree_skb(skb);
737
737
rxe_run_task(&qp->req.task, 1);
738
738
goto exit;
739
739
}
+4
-5
drivers/infiniband/sw/rxe/rxe_resp.c
+4
-5
drivers/infiniband/sw/rxe/rxe_resp.c
···
813
813
WARN_ON_ONCE(1);
814
814
}
815
815
816
-
/* We successfully processed this new request. */
817
-
qp->resp.msn++;
818
-
819
816
/* next expected psn, read handles this separately */
820
817
qp->resp.psn = (pkt->psn + 1) & BTH_PSN_MASK;
821
818
822
819
qp->resp.opcode = pkt->opcode;
823
820
qp->resp.status = IB_WC_SUCCESS;
824
821
825
-
if (pkt->mask & RXE_COMP_MASK)
822
+
if (pkt->mask & RXE_COMP_MASK) {
823
+
/* We successfully processed this new request. */
824
+
qp->resp.msn++;
826
825
return RESPST_COMPLETE;
827
-
else if (qp_type(qp) == IB_QPT_RC)
826
+
} else if (qp_type(qp) == IB_QPT_RC)
828
827
return RESPST_ACKNOWLEDGE;
829
828
else
830
829
return RESPST_CLEANUP;
+2
drivers/infiniband/ulp/iser/iscsi_iser.h
+2
drivers/infiniband/ulp/iser/iscsi_iser.h
···
430
430
struct list_head list;
431
431
struct iser_reg_resources rsc;
432
432
struct iser_pi_context *pi_ctx;
433
+
struct list_head all_list;
433
434
};
434
435
435
436
/**
···
444
443
struct list_head list;
445
444
spinlock_t lock;
446
445
int size;
446
+
struct list_head all_list;
447
447
};
448
448
449
449
/**
+5
-3
drivers/infiniband/ulp/iser/iser_verbs.c
+5
-3
drivers/infiniband/ulp/iser/iser_verbs.c
···
362
362
int i, ret;
363
363
364
364
INIT_LIST_HEAD(&fr_pool->list);
365
+
INIT_LIST_HEAD(&fr_pool->all_list);
365
366
spin_lock_init(&fr_pool->lock);
366
367
fr_pool->size = 0;
367
368
for (i = 0; i < cmds_max; i++) {
···
374
373
}
375
374
376
375
list_add_tail(&desc->list, &fr_pool->list);
376
+
list_add_tail(&desc->all_list, &fr_pool->all_list);
377
377
fr_pool->size++;
378
378
}
379
379
···
394
392
struct iser_fr_desc *desc, *tmp;
395
393
int i = 0;
396
394
397
-
if (list_empty(&fr_pool->list))
395
+
if (list_empty(&fr_pool->all_list))
398
396
return;
399
397
400
398
iser_info("freeing conn %p fr pool\n", ib_conn);
401
399
402
-
list_for_each_entry_safe(desc, tmp, &fr_pool->list, list) {
403
-
list_del(&desc->list);
400
+
list_for_each_entry_safe(desc, tmp, &fr_pool->all_list, all_list) {
401
+
list_del(&desc->all_list);
404
402
iser_free_reg_res(&desc->rsc);
405
403
if (desc->pi_ctx)
406
404
iser_free_pi_ctx(desc->pi_ctx);
+17
-13
include/rdma/ib_verbs.h
+17
-13
include/rdma/ib_verbs.h
···
1863
1863
};
1864
1864
1865
1865
struct ib_device {
1866
+
/* Do not access @dma_device directly from ULP nor from HW drivers. */
1867
+
struct device *dma_device;
1868
+
1866
1869
char name[IB_DEVICE_NAME_MAX];
1867
1870
1868
1871
struct list_head event_handler_list;
···
3010
3007
*/
3011
3008
static inline int ib_dma_mapping_error(struct ib_device *dev, u64 dma_addr)
3012
3009
{
3013
-
return dma_mapping_error(&dev->dev, dma_addr);
3010
+
return dma_mapping_error(dev->dma_device, dma_addr);
3014
3011
}
3015
3012
3016
3013
/**
···
3024
3021
void *cpu_addr, size_t size,
3025
3022
enum dma_data_direction direction)
3026
3023
{
3027
-
return dma_map_single(&dev->dev, cpu_addr, size, direction);
3024
+
return dma_map_single(dev->dma_device, cpu_addr, size, direction);
3028
3025
}
3029
3026
3030
3027
/**
···
3038
3035
u64 addr, size_t size,
3039
3036
enum dma_data_direction direction)
3040
3037
{
3041
-
dma_unmap_single(&dev->dev, addr, size, direction);
3038
+
dma_unmap_single(dev->dma_device, addr, size, direction);
3042
3039
}
3043
3040
3044
3041
/**
···
3055
3052
size_t size,
3056
3053
enum dma_data_direction direction)
3057
3054
{
3058
-
return dma_map_page(&dev->dev, page, offset, size, direction);
3055
+
return dma_map_page(dev->dma_device, page, offset, size, direction);
3059
3056
}
3060
3057
3061
3058
/**
···
3069
3066
u64 addr, size_t size,
3070
3067
enum dma_data_direction direction)
3071
3068
{
3072
-
dma_unmap_page(&dev->dev, addr, size, direction);
3069
+
dma_unmap_page(dev->dma_device, addr, size, direction);
3073
3070
}
3074
3071
3075
3072
/**
···
3083
3080
struct scatterlist *sg, int nents,
3084
3081
enum dma_data_direction direction)
3085
3082
{
3086
-
return dma_map_sg(&dev->dev, sg, nents, direction);
3083
+
return dma_map_sg(dev->dma_device, sg, nents, direction);
3087
3084
}
3088
3085
3089
3086
/**
···
3097
3094
struct scatterlist *sg, int nents,
3098
3095
enum dma_data_direction direction)
3099
3096
{
3100
-
dma_unmap_sg(&dev->dev, sg, nents, direction);
3097
+
dma_unmap_sg(dev->dma_device, sg, nents, direction);
3101
3098
}
3102
3099
3103
3100
static inline int ib_dma_map_sg_attrs(struct ib_device *dev,
···
3105
3102
enum dma_data_direction direction,
3106
3103
unsigned long dma_attrs)
3107
3104
{
3108
-
return dma_map_sg_attrs(&dev->dev, sg, nents, direction, dma_attrs);
3105
+
return dma_map_sg_attrs(dev->dma_device, sg, nents, direction,
3106
+
dma_attrs);
3109
3107
}
3110
3108
3111
3109
static inline void ib_dma_unmap_sg_attrs(struct ib_device *dev,
···
3114
3110
enum dma_data_direction direction,
3115
3111
unsigned long dma_attrs)
3116
3112
{
3117
-
dma_unmap_sg_attrs(&dev->dev, sg, nents, direction, dma_attrs);
3113
+
dma_unmap_sg_attrs(dev->dma_device, sg, nents, direction, dma_attrs);
3118
3114
}
3119
3115
/**
3120
3116
* ib_sg_dma_address - Return the DMA address from a scatter/gather entry
···
3156
3152
size_t size,
3157
3153
enum dma_data_direction dir)
3158
3154
{
3159
-
dma_sync_single_for_cpu(&dev->dev, addr, size, dir);
3155
+
dma_sync_single_for_cpu(dev->dma_device, addr, size, dir);
3160
3156
}
3161
3157
3162
3158
/**
···
3171
3167
size_t size,
3172
3168
enum dma_data_direction dir)
3173
3169
{
3174
-
dma_sync_single_for_device(&dev->dev, addr, size, dir);
3170
+
dma_sync_single_for_device(dev->dma_device, addr, size, dir);
3175
3171
}
3176
3172
3177
3173
/**
···
3186
3182
dma_addr_t *dma_handle,
3187
3183
gfp_t flag)
3188
3184
{
3189
-
return dma_alloc_coherent(&dev->dev, size, dma_handle, flag);
3185
+
return dma_alloc_coherent(dev->dma_device, size, dma_handle, flag);
3190
3186
}
3191
3187
3192
3188
/**
···
3200
3196
size_t size, void *cpu_addr,
3201
3197
dma_addr_t dma_handle)
3202
3198
{
3203
-
dma_free_coherent(&dev->dev, size, cpu_addr, dma_handle);
3199
+
dma_free_coherent(dev->dma_device, size, cpu_addr, dma_handle);
3204
3200
}
3205
3201
3206
3202
/**
+2
-1
include/uapi/rdma/mlx5-abi.h
+2
-1
include/uapi/rdma/mlx5-abi.h
···
34
34
#define MLX5_ABI_USER_H
35
35
36
36
#include <linux/types.h>
37
+
#include <linux/if_ether.h> /* For ETH_ALEN. */
37
38
38
39
enum {
39
40
MLX5_QP_FLAG_SIGNATURE = 1 << 0,
···
67
66
};
68
67
69
68
enum mlx5_lib_caps {
70
-
MLX5_LIB_CAP_4K_UAR = (u64)1 << 0,
69
+
MLX5_LIB_CAP_4K_UAR = (__u64)1 << 0,
71
70
};
72
71
73
72
struct mlx5_ib_alloc_ucontext_req_v2 {