1 // SPDX-License-Identifier: GPL-2.0
2 /*
3  * DMA traffic test driver
4  *
5  * Copyright (C) 2020, Intel Corporation
6  * Authors: Isaac Hazan <isaac.hazan@intel.com>
7  *	    Mika Westerberg <mika.westerberg@linux.intel.com>
8  */
9 
10 #include <linux/completion.h>
11 #include <linux/debugfs.h>
12 #include <linux/module.h>
13 #include <linux/sizes.h>
14 #include <linux/thunderbolt.h>
15 
16 #define DMA_TEST_TX_RING_SIZE		64
17 #define DMA_TEST_RX_RING_SIZE		256
18 #define DMA_TEST_FRAME_SIZE		SZ_4K
19 #define DMA_TEST_DATA_PATTERN		0x0123456789abcdefLL
20 #define DMA_TEST_MAX_PACKETS		1000
21 
22 enum dma_test_frame_pdf {
23 	DMA_TEST_PDF_FRAME_START = 1,
24 	DMA_TEST_PDF_FRAME_END,
25 };
26 
27 struct dma_test_frame {
28 	struct dma_test *dma_test;
29 	void *data;
30 	struct ring_frame frame;
31 };
32 
33 enum dma_test_test_error {
34 	DMA_TEST_NO_ERROR,
35 	DMA_TEST_INTERRUPTED,
36 	DMA_TEST_BUFFER_ERROR,
37 	DMA_TEST_DMA_ERROR,
38 	DMA_TEST_CONFIG_ERROR,
39 	DMA_TEST_SPEED_ERROR,
40 	DMA_TEST_WIDTH_ERROR,
41 	DMA_TEST_BONDING_ERROR,
42 	DMA_TEST_PACKET_ERROR,
43 };
44 
45 static const char * const dma_test_error_names[] = {
46 	[DMA_TEST_NO_ERROR] = "no errors",
47 	[DMA_TEST_INTERRUPTED] = "interrupted by signal",
48 	[DMA_TEST_BUFFER_ERROR] = "no memory for packet buffers",
49 	[DMA_TEST_DMA_ERROR] = "DMA ring setup failed",
50 	[DMA_TEST_CONFIG_ERROR] = "configuration is not valid",
51 	[DMA_TEST_SPEED_ERROR] = "unexpected link speed",
52 	[DMA_TEST_WIDTH_ERROR] = "unexpected link width",
53 	[DMA_TEST_BONDING_ERROR] = "lane bonding configuration error",
54 	[DMA_TEST_PACKET_ERROR] = "packet check failed",
55 };
56 
57 enum dma_test_result {
58 	DMA_TEST_NOT_RUN,
59 	DMA_TEST_SUCCESS,
60 	DMA_TEST_FAIL,
61 };
62 
63 static const char * const dma_test_result_names[] = {
64 	[DMA_TEST_NOT_RUN] = "not run",
65 	[DMA_TEST_SUCCESS] = "success",
66 	[DMA_TEST_FAIL] = "failed",
67 };
68 
69 /**
70  * struct dma_test - DMA test device driver private data
71  * @svc: XDomain service the driver is bound to
72  * @xd: XDomain the service belongs to
73  * @rx_ring: Software ring holding RX frames
74  * @rx_hopid: HopID used for receiving frames
75  * @tx_ring: Software ring holding TX frames
76  * @tx_hopid: HopID used for sending fames
77  * @packets_to_send: Number of packets to send
78  * @packets_to_receive: Number of packets to receive
79  * @packets_sent: Actual number of packets sent
80  * @packets_received: Actual number of packets received
81  * @link_speed: Expected link speed (Gb/s), %0 to use whatever is negotiated
82  * @link_width: Expected link width (Gb/s), %0 to use whatever is negotiated
83  * @crc_errors: Number of CRC errors during the test run
84  * @buffer_overflow_errors: Number of buffer overflow errors during the test
85  *			    run
86  * @result: Result of the last run
87  * @error_code: Error code of the last run
88  * @complete: Used to wait for the Rx to complete
89  * @lock: Lock serializing access to this structure
90  * @debugfs_dir: dentry of this dma_test
91  */
92 struct dma_test {
93 	const struct tb_service *svc;
94 	struct tb_xdomain *xd;
95 	struct tb_ring *rx_ring;
96 	int rx_hopid;
97 	struct tb_ring *tx_ring;
98 	int tx_hopid;
99 	unsigned int packets_to_send;
100 	unsigned int packets_to_receive;
101 	unsigned int packets_sent;
102 	unsigned int packets_received;
103 	unsigned int link_speed;
104 	unsigned int link_width;
105 	unsigned int crc_errors;
106 	unsigned int buffer_overflow_errors;
107 	enum dma_test_result result;
108 	enum dma_test_test_error error_code;
109 	struct completion complete;
110 	struct mutex lock;
111 	struct dentry *debugfs_dir;
112 };
113 
114 /* DMA test property directory UUID: 3188cd10-6523-4a5a-a682-fdca07a248d8 */
115 static const uuid_t dma_test_dir_uuid =
116 	UUID_INIT(0x3188cd10, 0x6523, 0x4a5a,
117 		  0xa6, 0x82, 0xfd, 0xca, 0x07, 0xa2, 0x48, 0xd8);
118 
119 static struct tb_property_dir *dma_test_dir;
120 static void *dma_test_pattern;
121 
122 static void dma_test_free_rings(struct dma_test *dt)
123 {
124 	if (dt->rx_ring) {
125 		tb_xdomain_release_in_hopid(dt->xd, dt->rx_hopid);
126 		tb_ring_free(dt->rx_ring);
127 		dt->rx_ring = NULL;
128 	}
129 	if (dt->tx_ring) {
130 		tb_xdomain_release_out_hopid(dt->xd, dt->tx_hopid);
131 		tb_ring_free(dt->tx_ring);
132 		dt->tx_ring = NULL;
133 	}
134 }
135 
136 static int dma_test_start_rings(struct dma_test *dt)
137 {
138 	unsigned int flags = RING_FLAG_FRAME;
139 	struct tb_xdomain *xd = dt->xd;
140 	int ret, e2e_tx_hop = 0;
141 	struct tb_ring *ring;
142 
143 	/*
144 	 * If we are both sender and receiver (traffic goes over a
145 	 * special loopback dongle) enable E2E flow control. This avoids
146 	 * losing packets.
147 	 */
148 	if (dt->packets_to_send && dt->packets_to_receive)
149 		flags |= RING_FLAG_E2E;
150 
151 	if (dt->packets_to_send) {
152 		ring = tb_ring_alloc_tx(xd->tb->nhi, -1, DMA_TEST_TX_RING_SIZE,
153 					flags);
154 		if (!ring)
155 			return -ENOMEM;
156 
157 		dt->tx_ring = ring;
158 		e2e_tx_hop = ring->hop;
159 
160 		ret = tb_xdomain_alloc_out_hopid(xd, -1);
161 		if (ret < 0) {
162 			dma_test_free_rings(dt);
163 			return ret;
164 		}
165 
166 		dt->tx_hopid = ret;
167 	}
168 
169 	if (dt->packets_to_receive) {
170 		u16 sof_mask, eof_mask;
171 
172 		sof_mask = BIT(DMA_TEST_PDF_FRAME_START);
173 		eof_mask = BIT(DMA_TEST_PDF_FRAME_END);
174 
175 		ring = tb_ring_alloc_rx(xd->tb->nhi, -1, DMA_TEST_RX_RING_SIZE,
176 					flags, e2e_tx_hop, sof_mask, eof_mask,
177 					NULL, NULL);
178 		if (!ring) {
179 			dma_test_free_rings(dt);
180 			return -ENOMEM;
181 		}
182 
183 		dt->rx_ring = ring;
184 
185 		ret = tb_xdomain_alloc_in_hopid(xd, -1);
186 		if (ret < 0) {
187 			dma_test_free_rings(dt);
188 			return ret;
189 		}
190 
191 		dt->rx_hopid = ret;
192 	}
193 
194 	ret = tb_xdomain_enable_paths(dt->xd, dt->tx_hopid,
195 				      dt->tx_ring ? dt->tx_ring->hop : -1,
196 				      dt->rx_hopid,
197 				      dt->rx_ring ? dt->rx_ring->hop : -1);
198 	if (ret) {
199 		dma_test_free_rings(dt);
200 		return ret;
201 	}
202 
203 	if (dt->tx_ring)
204 		tb_ring_start(dt->tx_ring);
205 	if (dt->rx_ring)
206 		tb_ring_start(dt->rx_ring);
207 
208 	return 0;
209 }
210 
211 static void dma_test_stop_rings(struct dma_test *dt)
212 {
213 	int ret;
214 
215 	if (dt->rx_ring)
216 		tb_ring_stop(dt->rx_ring);
217 	if (dt->tx_ring)
218 		tb_ring_stop(dt->tx_ring);
219 
220 	ret = tb_xdomain_disable_paths(dt->xd, dt->tx_hopid,
221 				       dt->tx_ring ? dt->tx_ring->hop : -1,
222 				       dt->rx_hopid,
223 				       dt->rx_ring ? dt->rx_ring->hop : -1);
224 	if (ret)
225 		dev_warn(&dt->svc->dev, "failed to disable DMA paths\n");
226 
227 	dma_test_free_rings(dt);
228 }
229 
230 static void dma_test_rx_callback(struct tb_ring *ring, struct ring_frame *frame,
231 				 bool canceled)
232 {
233 	struct dma_test_frame *tf = container_of(frame, typeof(*tf), frame);
234 	struct dma_test *dt = tf->dma_test;
235 	struct device *dma_dev = tb_ring_dma_device(dt->rx_ring);
236 
237 	dma_unmap_single(dma_dev, tf->frame.buffer_phy, DMA_TEST_FRAME_SIZE,
238 			 DMA_FROM_DEVICE);
239 	kfree(tf->data);
240 
241 	if (canceled) {
242 		kfree(tf);
243 		return;
244 	}
245 
246 	dt->packets_received++;
247 	dev_dbg(&dt->svc->dev, "packet %u/%u received\n", dt->packets_received,
248 		dt->packets_to_receive);
249 
250 	if (tf->frame.flags & RING_DESC_CRC_ERROR)
251 		dt->crc_errors++;
252 	if (tf->frame.flags & RING_DESC_BUFFER_OVERRUN)
253 		dt->buffer_overflow_errors++;
254 
255 	kfree(tf);
256 
257 	if (dt->packets_received == dt->packets_to_receive)
258 		complete(&dt->complete);
259 }
260 
261 static int dma_test_submit_rx(struct dma_test *dt, size_t npackets)
262 {
263 	struct device *dma_dev = tb_ring_dma_device(dt->rx_ring);
264 	int i;
265 
266 	for (i = 0; i < npackets; i++) {
267 		struct dma_test_frame *tf;
268 		dma_addr_t dma_addr;
269 
270 		tf = kzalloc(sizeof(*tf), GFP_KERNEL);
271 		if (!tf)
272 			return -ENOMEM;
273 
274 		tf->data = kzalloc(DMA_TEST_FRAME_SIZE, GFP_KERNEL);
275 		if (!tf->data) {
276 			kfree(tf);
277 			return -ENOMEM;
278 		}
279 
280 		dma_addr = dma_map_single(dma_dev, tf->data, DMA_TEST_FRAME_SIZE,
281 					  DMA_FROM_DEVICE);
282 		if (dma_mapping_error(dma_dev, dma_addr)) {
283 			kfree(tf->data);
284 			kfree(tf);
285 			return -ENOMEM;
286 		}
287 
288 		tf->frame.buffer_phy = dma_addr;
289 		tf->frame.callback = dma_test_rx_callback;
290 		tf->dma_test = dt;
291 		INIT_LIST_HEAD(&tf->frame.list);
292 
293 		tb_ring_rx(dt->rx_ring, &tf->frame);
294 	}
295 
296 	return 0;
297 }
298 
299 static void dma_test_tx_callback(struct tb_ring *ring, struct ring_frame *frame,
300 				 bool canceled)
301 {
302 	struct dma_test_frame *tf = container_of(frame, typeof(*tf), frame);
303 	struct dma_test *dt = tf->dma_test;
304 	struct device *dma_dev = tb_ring_dma_device(dt->tx_ring);
305 
306 	dma_unmap_single(dma_dev, tf->frame.buffer_phy, DMA_TEST_FRAME_SIZE,
307 			 DMA_TO_DEVICE);
308 	kfree(tf->data);
309 	kfree(tf);
310 }
311 
312 static int dma_test_submit_tx(struct dma_test *dt, size_t npackets)
313 {
314 	struct device *dma_dev = tb_ring_dma_device(dt->tx_ring);
315 	int i;
316 
317 	for (i = 0; i < npackets; i++) {
318 		struct dma_test_frame *tf;
319 		dma_addr_t dma_addr;
320 
321 		tf = kzalloc(sizeof(*tf), GFP_KERNEL);
322 		if (!tf)
323 			return -ENOMEM;
324 
325 		tf->frame.size = 0; /* means 4096 */
326 		tf->dma_test = dt;
327 
328 		tf->data = kmemdup(dma_test_pattern, DMA_TEST_FRAME_SIZE, GFP_KERNEL);
329 		if (!tf->data) {
330 			kfree(tf);
331 			return -ENOMEM;
332 		}
333 
334 		dma_addr = dma_map_single(dma_dev, tf->data, DMA_TEST_FRAME_SIZE,
335 					  DMA_TO_DEVICE);
336 		if (dma_mapping_error(dma_dev, dma_addr)) {
337 			kfree(tf->data);
338 			kfree(tf);
339 			return -ENOMEM;
340 		}
341 
342 		tf->frame.buffer_phy = dma_addr;
343 		tf->frame.callback = dma_test_tx_callback;
344 		tf->frame.sof = DMA_TEST_PDF_FRAME_START;
345 		tf->frame.eof = DMA_TEST_PDF_FRAME_END;
346 		INIT_LIST_HEAD(&tf->frame.list);
347 
348 		dt->packets_sent++;
349 		dev_dbg(&dt->svc->dev, "packet %u/%u sent\n", dt->packets_sent,
350 			dt->packets_to_send);
351 
352 		tb_ring_tx(dt->tx_ring, &tf->frame);
353 	}
354 
355 	return 0;
356 }
357 
358 #define DMA_TEST_DEBUGFS_ATTR(__fops, __get, __validate, __set)	\
359 static int __fops ## _show(void *data, u64 *val)		\
360 {								\
361 	struct tb_service *svc = data;				\
362 	struct dma_test *dt = tb_service_get_drvdata(svc);	\
363 	int ret;						\
364 								\
365 	ret = mutex_lock_interruptible(&dt->lock);		\
366 	if (ret)						\
367 		return ret;					\
368 	__get(dt, val);						\
369 	mutex_unlock(&dt->lock);				\
370 	return 0;						\
371 }								\
372 static int __fops ## _store(void *data, u64 val)		\
373 {								\
374 	struct tb_service *svc = data;				\
375 	struct dma_test *dt = tb_service_get_drvdata(svc);	\
376 	int ret;						\
377 								\
378 	ret = __validate(val);					\
379 	if (ret)						\
380 		return ret;					\
381 	ret = mutex_lock_interruptible(&dt->lock);		\
382 	if (ret)						\
383 		return ret;					\
384 	__set(dt, val);						\
385 	mutex_unlock(&dt->lock);				\
386 	return 0;						\
387 }								\
388 DEFINE_DEBUGFS_ATTRIBUTE(__fops ## _fops, __fops ## _show,	\
389 			 __fops ## _store, "%llu\n")
390 
391 static void lanes_get(const struct dma_test *dt, u64 *val)
392 {
393 	*val = dt->link_width;
394 }
395 
396 static int lanes_validate(u64 val)
397 {
398 	return val > 2 ? -EINVAL : 0;
399 }
400 
401 static void lanes_set(struct dma_test *dt, u64 val)
402 {
403 	dt->link_width = val;
404 }
405 DMA_TEST_DEBUGFS_ATTR(lanes, lanes_get, lanes_validate, lanes_set);
406 
407 static void speed_get(const struct dma_test *dt, u64 *val)
408 {
409 	*val = dt->link_speed;
410 }
411 
412 static int speed_validate(u64 val)
413 {
414 	switch (val) {
415 	case 40:
416 	case 20:
417 	case 10:
418 	case 0:
419 		return 0;
420 	default:
421 		return -EINVAL;
422 	}
423 }
424 
425 static void speed_set(struct dma_test *dt, u64 val)
426 {
427 	dt->link_speed = val;
428 }
429 DMA_TEST_DEBUGFS_ATTR(speed, speed_get, speed_validate, speed_set);
430 
431 static void packets_to_receive_get(const struct dma_test *dt, u64 *val)
432 {
433 	*val = dt->packets_to_receive;
434 }
435 
436 static int packets_to_receive_validate(u64 val)
437 {
438 	return val > DMA_TEST_MAX_PACKETS ? -EINVAL : 0;
439 }
440 
441 static void packets_to_receive_set(struct dma_test *dt, u64 val)
442 {
443 	dt->packets_to_receive = val;
444 }
445 DMA_TEST_DEBUGFS_ATTR(packets_to_receive, packets_to_receive_get,
446 		      packets_to_receive_validate, packets_to_receive_set);
447 
448 static void packets_to_send_get(const struct dma_test *dt, u64 *val)
449 {
450 	*val = dt->packets_to_send;
451 }
452 
453 static int packets_to_send_validate(u64 val)
454 {
455 	return val > DMA_TEST_MAX_PACKETS ? -EINVAL : 0;
456 }
457 
458 static void packets_to_send_set(struct dma_test *dt, u64 val)
459 {
460 	dt->packets_to_send = val;
461 }
462 DMA_TEST_DEBUGFS_ATTR(packets_to_send, packets_to_send_get,
463 		      packets_to_send_validate, packets_to_send_set);
464 
465 static int dma_test_set_bonding(struct dma_test *dt)
466 {
467 	switch (dt->link_width) {
468 	case 2:
469 		return tb_xdomain_lane_bonding_enable(dt->xd);
470 	case 1:
471 		tb_xdomain_lane_bonding_disable(dt->xd);
472 		fallthrough;
473 	default:
474 		return 0;
475 	}
476 }
477 
478 static bool dma_test_validate_config(struct dma_test *dt)
479 {
480 	if (!dt->packets_to_send && !dt->packets_to_receive)
481 		return false;
482 	if (dt->packets_to_send && dt->packets_to_receive &&
483 	    dt->packets_to_send != dt->packets_to_receive)
484 		return false;
485 	return true;
486 }
487 
488 static void dma_test_check_errors(struct dma_test *dt, int ret)
489 {
490 	if (!dt->error_code) {
491 		if (dt->link_speed && dt->xd->link_speed != dt->link_speed) {
492 			dt->error_code = DMA_TEST_SPEED_ERROR;
493 		} else if (dt->link_width) {
494 			const struct tb_xdomain *xd = dt->xd;
495 
496 			if ((dt->link_width == 1 && xd->link_width != TB_LINK_WIDTH_SINGLE) ||
497 			    (dt->link_width == 2 && xd->link_width < TB_LINK_WIDTH_DUAL))
498 				dt->error_code = DMA_TEST_WIDTH_ERROR;
499 		} else if (dt->packets_to_send != dt->packets_sent ||
500 			 dt->packets_to_receive != dt->packets_received ||
501 			 dt->crc_errors || dt->buffer_overflow_errors) {
502 			dt->error_code = DMA_TEST_PACKET_ERROR;
503 		} else {
504 			return;
505 		}
506 	}
507 
508 	dt->result = DMA_TEST_FAIL;
509 }
510 
511 static int test_store(void *data, u64 val)
512 {
513 	struct tb_service *svc = data;
514 	struct dma_test *dt = tb_service_get_drvdata(svc);
515 	int ret;
516 
517 	if (val != 1)
518 		return -EINVAL;
519 
520 	ret = mutex_lock_interruptible(&dt->lock);
521 	if (ret)
522 		return ret;
523 
524 	dt->packets_sent = 0;
525 	dt->packets_received = 0;
526 	dt->crc_errors = 0;
527 	dt->buffer_overflow_errors = 0;
528 	dt->result = DMA_TEST_SUCCESS;
529 	dt->error_code = DMA_TEST_NO_ERROR;
530 
531 	dev_dbg(&svc->dev, "DMA test starting\n");
532 	if (dt->link_speed)
533 		dev_dbg(&svc->dev, "link_speed: %u Gb/s\n", dt->link_speed);
534 	if (dt->link_width)
535 		dev_dbg(&svc->dev, "link_width: %u\n", dt->link_width);
536 	dev_dbg(&svc->dev, "packets_to_send: %u\n", dt->packets_to_send);
537 	dev_dbg(&svc->dev, "packets_to_receive: %u\n", dt->packets_to_receive);
538 
539 	if (!dma_test_validate_config(dt)) {
540 		dev_err(&svc->dev, "invalid test configuration\n");
541 		dt->error_code = DMA_TEST_CONFIG_ERROR;
542 		goto out_unlock;
543 	}
544 
545 	ret = dma_test_set_bonding(dt);
546 	if (ret) {
547 		dev_err(&svc->dev, "failed to set lanes\n");
548 		dt->error_code = DMA_TEST_BONDING_ERROR;
549 		goto out_unlock;
550 	}
551 
552 	ret = dma_test_start_rings(dt);
553 	if (ret) {
554 		dev_err(&svc->dev, "failed to enable DMA rings\n");
555 		dt->error_code = DMA_TEST_DMA_ERROR;
556 		goto out_unlock;
557 	}
558 
559 	if (dt->packets_to_receive) {
560 		reinit_completion(&dt->complete);
561 		ret = dma_test_submit_rx(dt, dt->packets_to_receive);
562 		if (ret) {
563 			dev_err(&svc->dev, "failed to submit receive buffers\n");
564 			dt->error_code = DMA_TEST_BUFFER_ERROR;
565 			goto out_stop;
566 		}
567 	}
568 
569 	if (dt->packets_to_send) {
570 		ret = dma_test_submit_tx(dt, dt->packets_to_send);
571 		if (ret) {
572 			dev_err(&svc->dev, "failed to submit transmit buffers\n");
573 			dt->error_code = DMA_TEST_BUFFER_ERROR;
574 			goto out_stop;
575 		}
576 	}
577 
578 	if (dt->packets_to_receive) {
579 		ret = wait_for_completion_interruptible(&dt->complete);
580 		if (ret) {
581 			dt->error_code = DMA_TEST_INTERRUPTED;
582 			goto out_stop;
583 		}
584 	}
585 
586 out_stop:
587 	dma_test_stop_rings(dt);
588 out_unlock:
589 	dma_test_check_errors(dt, ret);
590 	mutex_unlock(&dt->lock);
591 
592 	dev_dbg(&svc->dev, "DMA test %s\n", dma_test_result_names[dt->result]);
593 	return ret;
594 }
595 DEFINE_DEBUGFS_ATTRIBUTE(test_fops, NULL, test_store, "%llu\n");
596 
597 static int status_show(struct seq_file *s, void *not_used)
598 {
599 	struct tb_service *svc = s->private;
600 	struct dma_test *dt = tb_service_get_drvdata(svc);
601 	int ret;
602 
603 	ret = mutex_lock_interruptible(&dt->lock);
604 	if (ret)
605 		return ret;
606 
607 	seq_printf(s, "result: %s\n", dma_test_result_names[dt->result]);
608 	if (dt->result == DMA_TEST_NOT_RUN)
609 		goto out_unlock;
610 
611 	seq_printf(s, "packets received: %u\n", dt->packets_received);
612 	seq_printf(s, "packets sent: %u\n", dt->packets_sent);
613 	seq_printf(s, "CRC errors: %u\n", dt->crc_errors);
614 	seq_printf(s, "buffer overflow errors: %u\n",
615 		   dt->buffer_overflow_errors);
616 	seq_printf(s, "error: %s\n", dma_test_error_names[dt->error_code]);
617 
618 out_unlock:
619 	mutex_unlock(&dt->lock);
620 	return 0;
621 }
622 DEFINE_SHOW_ATTRIBUTE(status);
623 
624 static void dma_test_debugfs_init(struct tb_service *svc)
625 {
626 	struct dma_test *dt = tb_service_get_drvdata(svc);
627 
628 	dt->debugfs_dir = debugfs_create_dir("dma_test", svc->debugfs_dir);
629 
630 	debugfs_create_file("lanes", 0600, dt->debugfs_dir, svc, &lanes_fops);
631 	debugfs_create_file("speed", 0600, dt->debugfs_dir, svc, &speed_fops);
632 	debugfs_create_file("packets_to_receive", 0600, dt->debugfs_dir, svc,
633 			    &packets_to_receive_fops);
634 	debugfs_create_file("packets_to_send", 0600, dt->debugfs_dir, svc,
635 			    &packets_to_send_fops);
636 	debugfs_create_file("status", 0400, dt->debugfs_dir, svc, &status_fops);
637 	debugfs_create_file("test", 0200, dt->debugfs_dir, svc, &test_fops);
638 }
639 
640 static int dma_test_probe(struct tb_service *svc, const struct tb_service_id *id)
641 {
642 	struct tb_xdomain *xd = tb_service_parent(svc);
643 	struct dma_test *dt;
644 
645 	dt = devm_kzalloc(&svc->dev, sizeof(*dt), GFP_KERNEL);
646 	if (!dt)
647 		return -ENOMEM;
648 
649 	dt->svc = svc;
650 	dt->xd = xd;
651 	mutex_init(&dt->lock);
652 	init_completion(&dt->complete);
653 
654 	tb_service_set_drvdata(svc, dt);
655 	dma_test_debugfs_init(svc);
656 
657 	return 0;
658 }
659 
660 static void dma_test_remove(struct tb_service *svc)
661 {
662 	struct dma_test *dt = tb_service_get_drvdata(svc);
663 
664 	mutex_lock(&dt->lock);
665 	debugfs_remove_recursive(dt->debugfs_dir);
666 	mutex_unlock(&dt->lock);
667 }
668 
669 static int __maybe_unused dma_test_suspend(struct device *dev)
670 {
671 	/*
672 	 * No need to do anything special here. If userspace is writing
673 	 * to the test attribute when suspend started, it comes out from
674 	 * wait_for_completion_interruptible() with -ERESTARTSYS and the
675 	 * DMA test fails tearing down the rings. Once userspace is
676 	 * thawed the kernel restarts the write syscall effectively
677 	 * re-running the test.
678 	 */
679 	return 0;
680 }
681 
682 static int __maybe_unused dma_test_resume(struct device *dev)
683 {
684 	return 0;
685 }
686 
687 static const struct dev_pm_ops dma_test_pm_ops = {
688 	SET_SYSTEM_SLEEP_PM_OPS(dma_test_suspend, dma_test_resume)
689 };
690 
691 static const struct tb_service_id dma_test_ids[] = {
692 	{ TB_SERVICE("dma_test", 1) },
693 	{ },
694 };
695 MODULE_DEVICE_TABLE(tbsvc, dma_test_ids);
696 
697 static struct tb_service_driver dma_test_driver = {
698 	.driver = {
699 		.owner = THIS_MODULE,
700 		.name = "thunderbolt_dma_test",
701 		.pm = &dma_test_pm_ops,
702 	},
703 	.probe = dma_test_probe,
704 	.remove = dma_test_remove,
705 	.id_table = dma_test_ids,
706 };
707 
708 static int __init dma_test_init(void)
709 {
710 	u64 data_value = DMA_TEST_DATA_PATTERN;
711 	int i, ret;
712 
713 	dma_test_pattern = kmalloc(DMA_TEST_FRAME_SIZE, GFP_KERNEL);
714 	if (!dma_test_pattern)
715 		return -ENOMEM;
716 
717 	for (i = 0; i <	DMA_TEST_FRAME_SIZE / sizeof(data_value); i++)
718 		((u32 *)dma_test_pattern)[i] = data_value++;
719 
720 	dma_test_dir = tb_property_create_dir(&dma_test_dir_uuid);
721 	if (!dma_test_dir) {
722 		ret = -ENOMEM;
723 		goto err_free_pattern;
724 	}
725 
726 	tb_property_add_immediate(dma_test_dir, "prtcid", 1);
727 	tb_property_add_immediate(dma_test_dir, "prtcvers", 1);
728 	tb_property_add_immediate(dma_test_dir, "prtcrevs", 0);
729 	tb_property_add_immediate(dma_test_dir, "prtcstns", 0);
730 
731 	ret = tb_register_property_dir("dma_test", dma_test_dir);
732 	if (ret)
733 		goto err_free_dir;
734 
735 	ret = tb_register_service_driver(&dma_test_driver);
736 	if (ret)
737 		goto err_unregister_dir;
738 
739 	return 0;
740 
741 err_unregister_dir:
742 	tb_unregister_property_dir("dma_test", dma_test_dir);
743 err_free_dir:
744 	tb_property_free_dir(dma_test_dir);
745 err_free_pattern:
746 	kfree(dma_test_pattern);
747 
748 	return ret;
749 }
750 module_init(dma_test_init);
751 
752 static void __exit dma_test_exit(void)
753 {
754 	tb_unregister_service_driver(&dma_test_driver);
755 	tb_unregister_property_dir("dma_test", dma_test_dir);
756 	tb_property_free_dir(dma_test_dir);
757 	kfree(dma_test_pattern);
758 }
759 module_exit(dma_test_exit);
760 
761 MODULE_AUTHOR("Isaac Hazan <isaac.hazan@intel.com>");
762 MODULE_AUTHOR("Mika Westerberg <mika.westerberg@linux.intel.com>");
763 MODULE_DESCRIPTION("Thunderbolt/USB4 DMA traffic test driver");
764 MODULE_LICENSE("GPL v2");
765