add dts config

hc

2023-12-06 08f87f769b595151be1afeff53e144f543faa614

 kernel/drivers/infiniband/hw/vmw_pvrdma/pvrdma_srq.c
..
..
@@ -90,56 +90,49 @@
90
90
 
91
91
 /**
92
92
  * pvrdma_create_srq - create shared receive queue
93
- * @pd: protection domain
93
+ * @ibsrq: the IB shared receive queue
94
94
  * @init_attr: shared receive queue attributes
95
95
  * @udata: user data
96
96
  *
97
- * @return: the ib_srq pointer on success, otherwise returns an errno.
97
+ * @return: 0 on success, otherwise returns an errno.
98
98
  */
99
-struct ib_srq *pvrdma_create_srq(struct ib_pd *pd,
100
-				 struct ib_srq_init_attr *init_attr,
101
-				 struct ib_udata *udata)
99
+int pvrdma_create_srq(struct ib_srq *ibsrq, struct ib_srq_init_attr *init_attr,
100
+		      struct ib_udata *udata)
102
101
 {
103
-	struct pvrdma_srq *srq = NULL;
104
-	struct pvrdma_dev *dev = to_vdev(pd->device);
102
+	struct pvrdma_srq *srq = to_vsrq(ibsrq);
103
+	struct pvrdma_dev *dev = to_vdev(ibsrq->device);
105
104
 	union pvrdma_cmd_req req;
106
105
 	union pvrdma_cmd_resp rsp;
107
106
 	struct pvrdma_cmd_create_srq *cmd = &req.create_srq;
108
107
 	struct pvrdma_cmd_create_srq_resp *resp = &rsp.create_srq_resp;
109
-	struct pvrdma_create_srq_resp srq_resp = {0};
108
+	struct pvrdma_create_srq_resp srq_resp = {};
110
109
 	struct pvrdma_create_srq ucmd;
111
110
 	unsigned long flags;
112
111
 	int ret;
113
112
 
114
-	if (!(pd->uobject && udata)) {
113
+	if (!udata) {
115
114
 		/* No support for kernel clients. */
116
115
 		dev_warn(&dev->pdev->dev,
117
116
 			 "no shared receive queue support for kernel client\n");
118
-		return ERR_PTR(-EOPNOTSUPP);
117
+		return -EOPNOTSUPP;
119
118
 	}
120
119
 
121
120
 	if (init_attr->srq_type != IB_SRQT_BASIC) {
122
121
 		dev_warn(&dev->pdev->dev,
123
122
 			 "shared receive queue type %d not supported\n",
124
123
 			 init_attr->srq_type);
125
-		return ERR_PTR(-EINVAL);
124
+		return -EINVAL;
126
125
 	}
127
126
 
128
127
 	if (init_attr->attr.max_wr  > dev->dsr->caps.max_srq_wr ||
129
128
 	    init_attr->attr.max_sge > dev->dsr->caps.max_srq_sge) {
130
129
 		dev_warn(&dev->pdev->dev,
131
130
 			 "shared receive queue size invalid\n");
132
-		return ERR_PTR(-EINVAL);
131
+		return -EINVAL;
133
132
 	}
134
133
 
135
134
 	if (!atomic_add_unless(&dev->num_srqs, 1, dev->dsr->caps.max_srq))
136
-		return ERR_PTR(-ENOMEM);
137
-
138
-	srq = kmalloc(sizeof(*srq), GFP_KERNEL);
139
-	if (!srq) {
140
-		ret = -ENOMEM;
141
-		goto err_srq;
142
-	}
135
+		return -ENOMEM;
143
136
 
144
137
 	spin_lock_init(&srq->lock);
145
138
 	refcount_set(&srq->refcnt, 1);
..
..
@@ -153,15 +146,13 @@
153
146
 		goto err_srq;
154
147
 	}
155
148
 
156
-	srq->umem = ib_umem_get(pd->uobject->context,
157
-				ucmd.buf_addr,
158
-				ucmd.buf_size, 0, 0);
149
+	srq->umem = ib_umem_get(ibsrq->device, ucmd.buf_addr, ucmd.buf_size, 0);
159
150
 	if (IS_ERR(srq->umem)) {
160
151
 		ret = PTR_ERR(srq->umem);
161
152
 		goto err_srq;
162
153
 	}
163
154
 
164
-	srq->npages = ib_umem_page_count(srq->umem);
155
+	srq->npages = ib_umem_num_dma_blocks(srq->umem, PAGE_SIZE);
165
156
 
166
157
 	if (srq->npages < 0 || srq->npages > PVRDMA_PAGE_DIR_MAX_PAGES) {
167
158
 		dev_warn(&dev->pdev->dev,
..
..
@@ -183,7 +174,7 @@
183
174
 	cmd->hdr.cmd = PVRDMA_CMD_CREATE_SRQ;
184
175
 	cmd->srq_type = init_attr->srq_type;
185
176
 	cmd->nchunks = srq->npages;
186
-	cmd->pd_handle = to_vpd(pd)->pd_handle;
177
+	cmd->pd_handle = to_vpd(ibsrq->pd)->pd_handle;
187
178
 	cmd->attrs.max_wr = init_attr->attr.max_wr;
188
179
 	cmd->attrs.max_sge = init_attr->attr.max_sge;
189
180
 	cmd->attrs.srq_limit = init_attr->attr.srq_limit;
..
..
@@ -206,21 +197,20 @@
206
197
 	/* Copy udata back. */
207
198
 	if (ib_copy_to_udata(udata, &srq_resp, sizeof(srq_resp))) {
208
199
 		dev_warn(&dev->pdev->dev, "failed to copy back udata\n");
209
-		pvrdma_destroy_srq(&srq->ibsrq);
210
-		return ERR_PTR(-EINVAL);
200
+		pvrdma_destroy_srq(&srq->ibsrq, udata);
201
+		return -EINVAL;
211
202
 	}
212
203
 
213
-	return &srq->ibsrq;
204
+	return 0;
214
205
 
215
206
 err_page_dir:
216
207
 	pvrdma_page_dir_cleanup(dev, &srq->pdir);
217
208
 err_umem:
218
209
 	ib_umem_release(srq->umem);
219
210
 err_srq:
220
-	kfree(srq);
221
211
 	atomic_dec(&dev->num_srqs);
222
212
 
223
-	return ERR_PTR(ret);
213
+	return ret;
224
214
 }
225
215
 
226
216
 static void pvrdma_free_srq(struct pvrdma_dev *dev, struct pvrdma_srq *srq)
..
..
@@ -240,18 +230,17 @@
240
230
 
241
231
 	pvrdma_page_dir_cleanup(dev, &srq->pdir);
242
232
 
243
-	kfree(srq);
244
-
245
233
 	atomic_dec(&dev->num_srqs);
246
234
 }
247
235
 
248
236
 /**
249
237
  * pvrdma_destroy_srq - destroy shared receive queue
250
238
  * @srq: the shared receive queue to destroy
239
+ * @udata: user data or null for kernel object
251
240
  *
252
241
  * @return: 0 for success.
253
242
  */
254
-int pvrdma_destroy_srq(struct ib_srq *srq)
243
+int pvrdma_destroy_srq(struct ib_srq *srq, struct ib_udata *udata)
255
244
 {
256
245
 	struct pvrdma_srq *vsrq = to_vsrq(srq);
257
246
 	union pvrdma_cmd_req req;
..
..
@@ -270,7 +259,6 @@
270
259
 			 ret);
271
260
 
272
261
 	pvrdma_free_srq(dev, vsrq);
273
-
274
262
 	return 0;
275
263
 }
276
264