add stmac read mac form eeprom

hc

2023-12-09 b22da3d8526a935aa31e086e63f60ff3246cb61c

 kernel/drivers/rknpu/rknpu_mem.c
..
..
@@ -15,7 +15,8 @@
15
15
 #include "rknpu_ioctl.h"
16
16
 #include "rknpu_mem.h"
17
17
 
18
-int rknpu_mem_create_ioctl(struct rknpu_device *rknpu_dev, unsigned long data)
18
+int rknpu_mem_create_ioctl(struct rknpu_device *rknpu_dev, unsigned long data,
19
+			   struct file *file)
19
20
 {
20
21
 	struct rknpu_mem_create args;
21
22
 	int ret = -EINVAL;
..
..
@@ -27,6 +28,7 @@
27
28
 	struct page **pages;
28
29
 	struct page *page;
29
30
 	struct rknpu_mem_object *rknpu_obj = NULL;
31
+	struct rknpu_session *session = NULL;
30
32
 	int i, fd;
31
33
 	unsigned int length, page_count;
32
34
 
..
..
@@ -65,6 +67,8 @@
65
67
 						  O_CLOEXEC | O_RDWR, 0x0,
66
68
 						  dev_name(rknpu_dev->dev));
67
69
 		if (IS_ERR(dmabuf)) {
70
+			LOG_ERROR("dmabuf alloc failed, args.size = %llu\n",
71
+				  args.size);
68
72
 			ret = PTR_ERR(dmabuf);
69
73
 			goto err_free_obj;
70
74
 		}
..
..
@@ -74,6 +78,7 @@
74
78
 
75
79
 		fd = dma_buf_fd(dmabuf, O_CLOEXEC | O_RDWR);
76
80
 		if (fd < 0) {
81
+			LOG_ERROR("dmabuf fd get failed\n");
77
82
 			ret = -EFAULT;
78
83
 			goto err_free_dma_buf;
79
84
 		}
..
..
@@ -81,12 +86,14 @@
81
86
 
82
87
 	attachment = dma_buf_attach(dmabuf, rknpu_dev->dev);
83
88
 	if (IS_ERR(attachment)) {
89
+		LOG_ERROR("dma_buf_attach failed\n");
84
90
 		ret = PTR_ERR(attachment);
85
91
 		goto err_free_dma_buf;
86
92
 	}
87
93
 
88
94
 	table = dma_buf_map_attachment(attachment, DMA_BIDIRECTIONAL);
89
95
 	if (IS_ERR(table)) {
96
+		LOG_ERROR("dma_buf_attach failed\n");
90
97
 		dma_buf_detach(dmabuf, attachment);
91
98
 		ret = PTR_ERR(table);
92
99
 		goto err_free_dma_buf;
..
..
@@ -103,6 +110,7 @@
103
110
 	page_count = length >> PAGE_SHIFT;
104
111
 	pages = kmalloc_array(page_count, sizeof(struct page), GFP_KERNEL);
105
112
 	if (!pages) {
113
+		LOG_ERROR("alloc pages failed\n");
106
114
 		ret = -ENOMEM;
107
115
 		goto err_detach_dma_buf;
108
116
 	}
..
..
@@ -112,6 +120,7 @@
112
120
 
113
121
 	rknpu_obj->kv_addr = vmap(pages, page_count, VM_MAP, PAGE_KERNEL);
114
122
 	if (!rknpu_obj->kv_addr) {
123
+		LOG_ERROR("vmap pages addr failed\n");
115
124
 		ret = -ENOMEM;
116
125
 		goto err_free_pages;
117
126
 	}
..
..
@@ -141,6 +150,18 @@
141
150
 	dma_buf_unmap_attachment(attachment, table, DMA_BIDIRECTIONAL);
142
151
 	dma_buf_detach(dmabuf, attachment);
143
152
 
153
+	spin_lock(&rknpu_dev->lock);
154
+
155
+	session = file->private_data;
156
+	if (!session) {
157
+		spin_unlock(&rknpu_dev->lock);
158
+		ret = -EFAULT;
159
+		goto err_unmap_kv_addr;
160
+	}
161
+	list_add_tail(&rknpu_obj->head, &session->list);
162
+
163
+	spin_unlock(&rknpu_dev->lock);
164
+
144
165
 	return 0;
145
166
 
146
167
 err_unmap_kv_addr:
..
..
@@ -166,11 +187,12 @@
166
187
 	return ret;
167
188
 }
168
189
 
169
-int rknpu_mem_destroy_ioctl(struct rknpu_device *rknpu_dev, unsigned long data)
190
+int rknpu_mem_destroy_ioctl(struct rknpu_device *rknpu_dev, unsigned long data,
191
+			    struct file *file)
170
192
 {
171
-	struct rknpu_mem_object *rknpu_obj = NULL;
193
+	struct rknpu_mem_object *rknpu_obj, *entry, *q;
194
+	struct rknpu_session *session = NULL;
172
195
 	struct rknpu_mem_destroy args;
173
-	struct dma_buf *dmabuf;
174
196
 	int ret = -EFAULT;
175
197
 
176
198
 	if (unlikely(copy_from_user(&args, (struct rknpu_mem_destroy *)data,
..
..
@@ -188,21 +210,82 @@
188
210
 	}
189
211
 
190
212
 	rknpu_obj = (struct rknpu_mem_object *)(uintptr_t)args.obj_addr;
191
-	dmabuf = rknpu_obj->dmabuf;
192
213
 	LOG_DEBUG(
193
214
 		"free args.handle: %d, rknpu_obj: %#llx, rknpu_obj->dma_addr: %#llx\n",
194
215
 		args.handle, (__u64)(uintptr_t)rknpu_obj,
195
216
 		(__u64)rknpu_obj->dma_addr);
196
217
 
197
-	vunmap(rknpu_obj->kv_addr);
198
-	rknpu_obj->kv_addr = NULL;
218
+	spin_lock(&rknpu_dev->lock);
219
+	session = file->private_data;
220
+	if (!session) {
221
+		spin_unlock(&rknpu_dev->lock);
222
+		ret = -EFAULT;
223
+		return ret;
224
+	}
225
+	list_for_each_entry_safe(entry, q, &session->list, head) {
226
+		if (entry == rknpu_obj) {
227
+			list_del(&entry->head);
228
+			break;
229
+		}
230
+	}
231
+	spin_unlock(&rknpu_dev->lock);
199
232
 
200
-	if (!rknpu_obj->owner)
201
-		dma_buf_put(dmabuf);
233
+	if (rknpu_obj == entry) {
234
+		vunmap(rknpu_obj->kv_addr);
235
+		rknpu_obj->kv_addr = NULL;
202
236
 
203
-	kfree(rknpu_obj);
237
+		if (!rknpu_obj->owner)
238
+			dma_buf_put(rknpu_obj->dmabuf);
239
+
240
+		kfree(rknpu_obj);
241
+	}
204
242
 
205
243
 	return 0;
244
+}
245
+
246
+/*
247
+ * begin cpu access => for_cpu = true
248
+ * end cpu access => for_cpu = false
249
+ */
250
+static void __maybe_unused rknpu_dma_buf_sync(
251
+	struct rknpu_device *rknpu_dev, struct rknpu_mem_object *rknpu_obj,
252
+	u32 offset, u32 length, enum dma_data_direction dir, bool for_cpu)
253
+{
254
+	struct device *dev = rknpu_dev->dev;
255
+	struct sg_table *sgt = rknpu_obj->sgt;
256
+	struct scatterlist *sg = sgt->sgl;
257
+	dma_addr_t sg_dma_addr = sg_dma_address(sg);
258
+	unsigned int len = 0;
259
+	int i;
260
+
261
+	for_each_sgtable_sg(sgt, sg, i) {
262
+		unsigned int sg_offset, sg_left, size = 0;
263
+
264
+		len += sg->length;
265
+		if (len <= offset) {
266
+			sg_dma_addr += sg->length;
267
+			continue;
268
+		}
269
+
270
+		sg_left = len - offset;
271
+		sg_offset = sg->length - sg_left;
272
+
273
+		size = (length < sg_left) ? length : sg_left;
274
+
275
+		if (for_cpu)
276
+			dma_sync_single_range_for_cpu(dev, sg_dma_addr,
277
+						      sg_offset, size, dir);
278
+		else
279
+			dma_sync_single_range_for_device(dev, sg_dma_addr,
280
+							 sg_offset, size, dir);
281
+
282
+		offset += size;
283
+		length -= size;
284
+		sg_dma_addr += sg->length;
285
+
286
+		if (length == 0)
287
+			break;
288
+	}
206
289
 }
207
290
 
208
291
 int rknpu_mem_sync_ioctl(struct rknpu_device *rknpu_dev, unsigned long data)
..
..
@@ -229,6 +312,16 @@
229
312
 	rknpu_obj = (struct rknpu_mem_object *)(uintptr_t)args.obj_addr;
230
313
 	dmabuf = rknpu_obj->dmabuf;
231
314
 
315
+#ifndef CONFIG_DMABUF_PARTIAL
316
+	if (args.flags & RKNPU_MEM_SYNC_TO_DEVICE) {
317
+		rknpu_dma_buf_sync(rknpu_dev, rknpu_obj, args.offset, args.size,
318
+				   DMA_TO_DEVICE, false);
319
+	}
320
+	if (args.flags & RKNPU_MEM_SYNC_FROM_DEVICE) {
321
+		rknpu_dma_buf_sync(rknpu_dev, rknpu_obj, args.offset, args.size,
322
+				   DMA_FROM_DEVICE, true);
323
+	}
324
+#else
232
325
 	if (args.flags & RKNPU_MEM_SYNC_TO_DEVICE) {
233
326
 		dmabuf->ops->end_cpu_access_partial(dmabuf, DMA_TO_DEVICE,
234
327
 						    args.offset, args.size);
..
..
@@ -237,6 +330,7 @@
237
330
 		dmabuf->ops->begin_cpu_access_partial(dmabuf, DMA_FROM_DEVICE,
238
331
 						      args.offset, args.size);
239
332
 	}
333
+#endif
240
334
 
241
335
 	return 0;
242
336
 }