xref: /linux/drivers/ntb/test/ntb_tool.c (revision 03c11eb3b16dc0058589751dfd91f254be2be613)
1 /*
2  * This file is provided under a dual BSD/GPLv2 license.  When using or
3  *   redistributing this file, you may do so under either license.
4  *
5  *   GPL LICENSE SUMMARY
6  *
7  *   Copyright (C) 2015 EMC Corporation. All Rights Reserved.
8  *   Copyright (C) 2017 T-Platforms All Rights Reserved.
9  *
10  *   This program is free software; you can redistribute it and/or modify
11  *   it under the terms of version 2 of the GNU General Public License as
12  *   published by the Free Software Foundation.
13  *
14  *   This program is distributed in the hope that it will be useful, but
15  *   WITHOUT ANY WARRANTY; without even the implied warranty of
16  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
17  *   General Public License for more details.
18  *
19  *   BSD LICENSE
20  *
21  *   Copyright (C) 2015 EMC Corporation. All Rights Reserved.
22  *   Copyright (C) 2017 T-Platforms All Rights Reserved.
23  *
24  *   Redistribution and use in source and binary forms, with or without
25  *   modification, are permitted provided that the following conditions
26  *   are met:
27  *
28  *     * Redistributions of source code must retain the above copyright
29  *       notice, this list of conditions and the following disclaimer.
30  *     * Redistributions in binary form must reproduce the above copy
31  *       notice, this list of conditions and the following disclaimer in
32  *       the documentation and/or other materials provided with the
33  *       distribution.
34  *     * Neither the name of Intel Corporation nor the names of its
35  *       contributors may be used to endorse or promote products derived
36  *       from this software without specific prior written permission.
37  *
38  *   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
39  *   "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
40  *   LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
41  *   A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
42  *   OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
43  *   SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
44  *   LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
45  *   DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
46  *   THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
47  *   (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
48  *   OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
49  *
50  * PCIe NTB Debugging Tool Linux driver
51  */
52 
53 /*
54  * How to use this tool, by example.
55  *
56  * Assuming $DBG_DIR is something like:
57  * '/sys/kernel/debug/ntb_tool/0000:00:03.0'
58  * Suppose aside from local device there is at least one remote device
59  * connected to NTB with index 0.
60  *-----------------------------------------------------------------------------
61  * Eg: check local/peer device information.
62  *
63  * # Get local device port number
64  * root@self# cat $DBG_DIR/port
65  *
66  * # Check local device functionality
67  * root@self# ls $DBG_DIR
68  * db            msg1          msg_sts     peer4/        port
69  * db_event      msg2          peer0/      peer5/        spad0
70  * db_mask       msg3          peer1/      peer_db       spad1
71  * link          msg_event     peer2/      peer_db_mask  spad2
72  * msg0          msg_mask      peer3/      peer_spad     spad3
73  * # As one can see it supports:
74  * # 1) four inbound message registers
75  * # 2) four inbound scratchpads
76  * # 3) up to six peer devices
77  *
78  * # Check peer device port number
79  * root@self# cat $DBG_DIR/peer0/port
80  *
81  * # Check peer device(s) functionality to be used
82  * root@self# ls $DBG_DIR/peer0
83  * link             mw_trans0       mw_trans6        port
84  * link_event       mw_trans1       mw_trans7        spad0
85  * msg0             mw_trans2       peer_mw_trans0   spad1
86  * msg1             mw_trans3       peer_mw_trans1   spad2
87  * msg2             mw_trans4       peer_mw_trans2   spad3
88  * msg3             mw_trans5       peer_mw_trans3
89  * # As one can see we got:
90  * # 1) four outbound message registers
91  * # 2) four outbound scratchpads
92  * # 3) eight inbound memory windows
93  * # 4) four outbound memory windows
94  *-----------------------------------------------------------------------------
95  * Eg: NTB link tests
96  *
97  * # Set local link up/down
98  * root@self# echo Y > $DBG_DIR/link
99  * root@self# echo N > $DBG_DIR/link
100  *
101  * # Check if link with peer device is up/down:
102  * root@self# cat $DBG_DIR/peer0/link
103  *
104  * # Block until the link is up/down
105  * root@self# echo Y > $DBG_DIR/peer0/link_event
106  * root@self# echo N > $DBG_DIR/peer0/link_event
107  *-----------------------------------------------------------------------------
108  * Eg: Doorbell registers tests (some functionality might be absent)
109  *
110  * # Set/clear/get local doorbell
111  * root@self# echo 's 1' > $DBG_DIR/db
112  * root@self# echo 'c 1' > $DBG_DIR/db
113  * root@self# cat  $DBG_DIR/db
114  *
115  * # Set/clear/get local doorbell mask
116  * root@self# echo 's 1' > $DBG_DIR/db_mask
117  * root@self# echo 'c 1' > $DBG_DIR/db_mask
118  * root@self# cat $DBG_DIR/db_mask
119  *
120  * # Ring/clear/get peer doorbell
121  * root@peer# echo 's 1' > $DBG_DIR/peer_db
122  * root@peer# echo 'c 1' > $DBG_DIR/peer_db
123  * root@peer# cat $DBG_DIR/peer_db
124  *
125  * # Set/clear/get peer doorbell mask
126  * root@self# echo 's 1' > $DBG_DIR/peer_db_mask
127  * root@self# echo 'c 1' > $DBG_DIR/peer_db_mask
128  * root@self# cat $DBG_DIR/peer_db_mask
129  *
130  * # Block until local doorbell is set with specified value
131  * root@self# echo 1 > $DBG_DIR/db_event
132  *-----------------------------------------------------------------------------
133  * Eg: Message registers tests (functionality might be absent)
134  *
135  * # Set/clear/get in/out message registers status
136  * root@self# echo 's 1' > $DBG_DIR/msg_sts
137  * root@self# echo 'c 1' > $DBG_DIR/msg_sts
138  * root@self# cat $DBG_DIR/msg_sts
139  *
140  * # Set/clear in/out message registers mask
141  * root@self# echo 's 1' > $DBG_DIR/msg_mask
142  * root@self# echo 'c 1' > $DBG_DIR/msg_mask
143  *
144  * # Get inbound message register #0 value and source of port index
145  * root@self# cat  $DBG_DIR/msg0
146  *
147  * # Send some data to peer over outbound message register #0
148  * root@self# echo 0x01020304 > $DBG_DIR/peer0/msg0
149  *-----------------------------------------------------------------------------
150  * Eg: Scratchpad registers tests (functionality might be absent)
151  *
152  * # Write/read to/from local scratchpad register #0
153  * root@peer# echo 0x01020304 > $DBG_DIR/spad0
154  * root@peer# cat $DBG_DIR/spad0
155  *
156  * # Write/read to/from peer scratchpad register #0
157  * root@peer# echo 0x01020304 > $DBG_DIR/peer0/spad0
158  * root@peer# cat $DBG_DIR/peer0/spad0
159  *-----------------------------------------------------------------------------
160  * Eg: Memory windows tests
161  *
162  * # Create inbound memory window buffer of specified size/get its base address
163  * root@peer# echo 16384 > $DBG_DIR/peer0/mw_trans0
164  * root@peer# cat $DBG_DIR/peer0/mw_trans0
165  *
166  * # Write/read data to/from inbound memory window
167  * root@peer# echo Hello > $DBG_DIR/peer0/mw0
168  * root@peer# head -c 7 $DBG_DIR/peer0/mw0
169  *
170  * # Map outbound memory window/check it settings (on peer device)
171  * root@peer# echo 0xADD0BA5E:16384 > $DBG_DIR/peer0/peer_mw_trans0
172  * root@peer# cat $DBG_DIR/peer0/peer_mw_trans0
173  *
174  * # Write/read data to/from outbound memory window (on peer device)
175  * root@peer# echo olleH > $DBG_DIR/peer0/peer_mw0
176  * root@peer# head -c 7 $DBG_DIR/peer0/peer_mw0
177  */
178 
179 #include <linux/init.h>
180 #include <linux/kernel.h>
181 #include <linux/module.h>
182 
183 #include <linux/debugfs.h>
184 #include <linux/dma-mapping.h>
185 #include <linux/pci.h>
186 #include <linux/slab.h>
187 #include <linux/uaccess.h>
188 
189 #include <linux/ntb.h>
190 
191 #define DRIVER_NAME		"ntb_tool"
192 #define DRIVER_VERSION		"2.0"
193 
194 MODULE_LICENSE("Dual BSD/GPL");
195 MODULE_VERSION(DRIVER_VERSION);
196 MODULE_AUTHOR("Allen Hubbe <Allen.Hubbe@emc.com>");
197 MODULE_DESCRIPTION("PCIe NTB Debugging Tool");
198 
199 /*
200  * Inbound and outbound memory windows descriptor. Union members selection
201  * depends on the MW type the structure describes. mm_base/dma_base are the
202  * virtual and DMA address of an inbound MW. io_base/tr_base are the MMIO
203  * mapped virtual and xlat addresses of an outbound MW respectively.
204  */
205 struct tool_mw {
206 	int widx;
207 	int pidx;
208 	struct tool_ctx *tc;
209 	union {
210 		u8 *mm_base;
211 		u8 __iomem *io_base;
212 	};
213 	union {
214 		dma_addr_t dma_base;
215 		u64 tr_base;
216 	};
217 	resource_size_t size;
218 	struct dentry *dbgfs_file;
219 };
220 
221 /*
222  * Wrapper structure is used to distinguish the outbound MW peers reference
223  * within the corresponding DebugFS directory IO operation.
224  */
225 struct tool_mw_wrap {
226 	int pidx;
227 	struct tool_mw *mw;
228 };
229 
230 struct tool_msg {
231 	int midx;
232 	int pidx;
233 	struct tool_ctx *tc;
234 };
235 
236 struct tool_spad {
237 	int sidx;
238 	int pidx;
239 	struct tool_ctx *tc;
240 };
241 
242 struct tool_peer {
243 	int pidx;
244 	struct tool_ctx *tc;
245 	int inmw_cnt;
246 	struct tool_mw *inmws;
247 	int outmw_cnt;
248 	struct tool_mw_wrap *outmws;
249 	int outmsg_cnt;
250 	struct tool_msg *outmsgs;
251 	int outspad_cnt;
252 	struct tool_spad *outspads;
253 	struct dentry *dbgfs_dir;
254 };
255 
256 struct tool_ctx {
257 	struct ntb_dev *ntb;
258 	wait_queue_head_t link_wq;
259 	wait_queue_head_t db_wq;
260 	wait_queue_head_t msg_wq;
261 	int outmw_cnt;
262 	struct tool_mw *outmws;
263 	int peer_cnt;
264 	struct tool_peer *peers;
265 	int inmsg_cnt;
266 	struct tool_msg *inmsgs;
267 	int inspad_cnt;
268 	struct tool_spad *inspads;
269 	struct dentry *dbgfs_dir;
270 };
271 
272 #define TOOL_FOPS_RDWR(__name, __read, __write) \
273 	const struct file_operations __name = {	\
274 		.owner = THIS_MODULE,		\
275 		.open = simple_open,		\
276 		.read = __read,			\
277 		.write = __write,		\
278 	}
279 
280 #define TOOL_BUF_LEN 32
281 
282 static struct dentry *tool_dbgfs_topdir;
283 
284 /*==============================================================================
285  *                               NTB events handlers
286  *==============================================================================
287  */
288 
tool_link_event(void * ctx)289 static void tool_link_event(void *ctx)
290 {
291 	struct tool_ctx *tc = ctx;
292 	enum ntb_speed speed;
293 	enum ntb_width width;
294 	int up;
295 
296 	up = ntb_link_is_up(tc->ntb, &speed, &width);
297 
298 	dev_dbg(&tc->ntb->dev, "link is %s speed %d width %d\n",
299 		up ? "up" : "down", speed, width);
300 
301 	wake_up(&tc->link_wq);
302 }
303 
tool_db_event(void * ctx,int vec)304 static void tool_db_event(void *ctx, int vec)
305 {
306 	struct tool_ctx *tc = ctx;
307 	u64 db_bits, db_mask;
308 
309 	db_mask = ntb_db_vector_mask(tc->ntb, vec);
310 	db_bits = ntb_db_read(tc->ntb);
311 
312 	dev_dbg(&tc->ntb->dev, "doorbell vec %d mask %#llx bits %#llx\n",
313 		vec, db_mask, db_bits);
314 
315 	wake_up(&tc->db_wq);
316 }
317 
tool_msg_event(void * ctx)318 static void tool_msg_event(void *ctx)
319 {
320 	struct tool_ctx *tc = ctx;
321 	u64 msg_sts;
322 
323 	msg_sts = ntb_msg_read_sts(tc->ntb);
324 
325 	dev_dbg(&tc->ntb->dev, "message bits %#llx\n", msg_sts);
326 
327 	wake_up(&tc->msg_wq);
328 }
329 
330 static const struct ntb_ctx_ops tool_ops = {
331 	.link_event = tool_link_event,
332 	.db_event = tool_db_event,
333 	.msg_event = tool_msg_event
334 };
335 
336 /*==============================================================================
337  *                        Common read/write methods
338  *==============================================================================
339  */
340 
tool_fn_read(struct tool_ctx * tc,char __user * ubuf,size_t size,loff_t * offp,u64 (* fn_read)(struct ntb_dev *))341 static ssize_t tool_fn_read(struct tool_ctx *tc, char __user *ubuf,
342 			    size_t size, loff_t *offp,
343 			    u64 (*fn_read)(struct ntb_dev *))
344 {
345 	size_t buf_size;
346 	char buf[TOOL_BUF_LEN];
347 	ssize_t pos;
348 
349 	if (!fn_read)
350 		return -EINVAL;
351 
352 	buf_size = min(size, sizeof(buf));
353 
354 	pos = scnprintf(buf, buf_size, "%#llx\n", fn_read(tc->ntb));
355 
356 	return simple_read_from_buffer(ubuf, size, offp, buf, pos);
357 }
358 
tool_fn_write(struct tool_ctx * tc,const char __user * ubuf,size_t size,loff_t * offp,int (* fn_set)(struct ntb_dev *,u64),int (* fn_clear)(struct ntb_dev *,u64))359 static ssize_t tool_fn_write(struct tool_ctx *tc,
360 			     const char __user *ubuf,
361 			     size_t size, loff_t *offp,
362 			     int (*fn_set)(struct ntb_dev *, u64),
363 			     int (*fn_clear)(struct ntb_dev *, u64))
364 {
365 	char *buf, cmd;
366 	ssize_t ret;
367 	u64 bits;
368 	int n;
369 
370 	if (*offp)
371 		return 0;
372 
373 	buf = memdup_user_nul(ubuf, size);
374 	if (IS_ERR(buf))
375 		return PTR_ERR(buf);
376 
377 	n = sscanf(buf, "%c %lli", &cmd, &bits);
378 
379 	kfree(buf);
380 
381 	if (n != 2) {
382 		ret = -EINVAL;
383 	} else if (cmd == 's') {
384 		if (!fn_set)
385 			ret = -EINVAL;
386 		else
387 			ret = fn_set(tc->ntb, bits);
388 	} else if (cmd == 'c') {
389 		if (!fn_clear)
390 			ret = -EINVAL;
391 		else
392 			ret = fn_clear(tc->ntb, bits);
393 	} else {
394 		ret = -EINVAL;
395 	}
396 
397 	return ret ? : size;
398 }
399 
400 /*==============================================================================
401  *                            Port read/write methods
402  *==============================================================================
403  */
404 
tool_port_read(struct file * filep,char __user * ubuf,size_t size,loff_t * offp)405 static ssize_t tool_port_read(struct file *filep, char __user *ubuf,
406 			      size_t size, loff_t *offp)
407 {
408 	struct tool_ctx *tc = filep->private_data;
409 	char buf[TOOL_BUF_LEN];
410 	int pos;
411 
412 	pos = scnprintf(buf, sizeof(buf), "%d\n", ntb_port_number(tc->ntb));
413 
414 	return simple_read_from_buffer(ubuf, size, offp, buf, pos);
415 }
416 
417 static TOOL_FOPS_RDWR(tool_port_fops,
418 		      tool_port_read,
419 		      NULL);
420 
tool_peer_port_read(struct file * filep,char __user * ubuf,size_t size,loff_t * offp)421 static ssize_t tool_peer_port_read(struct file *filep, char __user *ubuf,
422 				   size_t size, loff_t *offp)
423 {
424 	struct tool_peer *peer = filep->private_data;
425 	struct tool_ctx *tc = peer->tc;
426 	char buf[TOOL_BUF_LEN];
427 	int pos;
428 
429 	pos = scnprintf(buf, sizeof(buf), "%d\n",
430 		ntb_peer_port_number(tc->ntb, peer->pidx));
431 
432 	return simple_read_from_buffer(ubuf, size, offp, buf, pos);
433 }
434 
435 static TOOL_FOPS_RDWR(tool_peer_port_fops,
436 		      tool_peer_port_read,
437 		      NULL);
438 
tool_init_peers(struct tool_ctx * tc)439 static int tool_init_peers(struct tool_ctx *tc)
440 {
441 	int pidx;
442 
443 	tc->peer_cnt = ntb_peer_port_count(tc->ntb);
444 	tc->peers = devm_kcalloc(&tc->ntb->dev, tc->peer_cnt,
445 				 sizeof(*tc->peers), GFP_KERNEL);
446 	if (tc->peers == NULL)
447 		return -ENOMEM;
448 
449 	for (pidx = 0; pidx < tc->peer_cnt; pidx++) {
450 		tc->peers[pidx].pidx = pidx;
451 		tc->peers[pidx].tc = tc;
452 	}
453 
454 	return 0;
455 }
456 
457 /*==============================================================================
458  *                       Link state read/write methods
459  *==============================================================================
460  */
461 
tool_link_write(struct file * filep,const char __user * ubuf,size_t size,loff_t * offp)462 static ssize_t tool_link_write(struct file *filep, const char __user *ubuf,
463 			       size_t size, loff_t *offp)
464 {
465 	struct tool_ctx *tc = filep->private_data;
466 	bool val;
467 	int ret;
468 
469 	ret = kstrtobool_from_user(ubuf, size, &val);
470 	if (ret)
471 		return ret;
472 
473 	if (val)
474 		ret = ntb_link_enable(tc->ntb, NTB_SPEED_AUTO, NTB_WIDTH_AUTO);
475 	else
476 		ret = ntb_link_disable(tc->ntb);
477 
478 	if (ret)
479 		return ret;
480 
481 	return size;
482 }
483 
484 static TOOL_FOPS_RDWR(tool_link_fops,
485 		      NULL,
486 		      tool_link_write);
487 
tool_peer_link_read(struct file * filep,char __user * ubuf,size_t size,loff_t * offp)488 static ssize_t tool_peer_link_read(struct file *filep, char __user *ubuf,
489 				   size_t size, loff_t *offp)
490 {
491 	struct tool_peer *peer = filep->private_data;
492 	struct tool_ctx *tc = peer->tc;
493 	char buf[3];
494 
495 	if (ntb_link_is_up(tc->ntb, NULL, NULL) & BIT(peer->pidx))
496 		buf[0] = 'Y';
497 	else
498 		buf[0] = 'N';
499 	buf[1] = '\n';
500 	buf[2] = '\0';
501 
502 	return simple_read_from_buffer(ubuf, size, offp, buf, 2);
503 }
504 
505 static TOOL_FOPS_RDWR(tool_peer_link_fops,
506 		      tool_peer_link_read,
507 		      NULL);
508 
tool_peer_link_event_write(struct file * filep,const char __user * ubuf,size_t size,loff_t * offp)509 static ssize_t tool_peer_link_event_write(struct file *filep,
510 					  const char __user *ubuf,
511 					  size_t size, loff_t *offp)
512 {
513 	struct tool_peer *peer = filep->private_data;
514 	struct tool_ctx *tc = peer->tc;
515 	u64 link_msk;
516 	bool val;
517 	int ret;
518 
519 	ret = kstrtobool_from_user(ubuf, size, &val);
520 	if (ret)
521 		return ret;
522 
523 	link_msk = BIT_ULL_MASK(peer->pidx);
524 
525 	if (wait_event_interruptible(tc->link_wq,
526 		!!(ntb_link_is_up(tc->ntb, NULL, NULL) & link_msk) == val))
527 		return -ERESTART;
528 
529 	return size;
530 }
531 
532 static TOOL_FOPS_RDWR(tool_peer_link_event_fops,
533 		      NULL,
534 		      tool_peer_link_event_write);
535 
536 /*==============================================================================
537  *                  Memory windows read/write/setting methods
538  *==============================================================================
539  */
540 
tool_mw_read(struct file * filep,char __user * ubuf,size_t size,loff_t * offp)541 static ssize_t tool_mw_read(struct file *filep, char __user *ubuf,
542 			    size_t size, loff_t *offp)
543 {
544 	struct tool_mw *inmw = filep->private_data;
545 
546 	if (inmw->mm_base == NULL)
547 		return -ENXIO;
548 
549 	return simple_read_from_buffer(ubuf, size, offp,
550 				       inmw->mm_base, inmw->size);
551 }
552 
tool_mw_write(struct file * filep,const char __user * ubuf,size_t size,loff_t * offp)553 static ssize_t tool_mw_write(struct file *filep, const char __user *ubuf,
554 			     size_t size, loff_t *offp)
555 {
556 	struct tool_mw *inmw = filep->private_data;
557 
558 	if (inmw->mm_base == NULL)
559 		return -ENXIO;
560 
561 	return simple_write_to_buffer(inmw->mm_base, inmw->size, offp,
562 				      ubuf, size);
563 }
564 
565 static TOOL_FOPS_RDWR(tool_mw_fops,
566 		      tool_mw_read,
567 		      tool_mw_write);
568 
tool_setup_mw(struct tool_ctx * tc,int pidx,int widx,size_t req_size)569 static int tool_setup_mw(struct tool_ctx *tc, int pidx, int widx,
570 			 size_t req_size)
571 {
572 	resource_size_t size, addr_align, size_align;
573 	struct tool_mw *inmw = &tc->peers[pidx].inmws[widx];
574 	char buf[TOOL_BUF_LEN];
575 	int ret;
576 
577 	if (inmw->mm_base != NULL)
578 		return 0;
579 
580 	ret = ntb_mw_get_align(tc->ntb, pidx, widx, &addr_align,
581 				&size_align, &size);
582 	if (ret)
583 		return ret;
584 
585 	inmw->size = min_t(resource_size_t, req_size, size);
586 	inmw->size = round_up(inmw->size, addr_align);
587 	inmw->size = round_up(inmw->size, size_align);
588 	inmw->mm_base = dma_alloc_coherent(&tc->ntb->pdev->dev, inmw->size,
589 					   &inmw->dma_base, GFP_KERNEL);
590 	if (!inmw->mm_base)
591 		return -ENOMEM;
592 
593 	if (!IS_ALIGNED(inmw->dma_base, addr_align)) {
594 		ret = -ENOMEM;
595 		goto err_free_dma;
596 	}
597 
598 	ret = ntb_mw_set_trans(tc->ntb, pidx, widx, inmw->dma_base, inmw->size);
599 	if (ret)
600 		goto err_free_dma;
601 
602 	snprintf(buf, sizeof(buf), "mw%d", widx);
603 	inmw->dbgfs_file = debugfs_create_file(buf, 0600,
604 					       tc->peers[pidx].dbgfs_dir, inmw,
605 					       &tool_mw_fops);
606 
607 	return 0;
608 
609 err_free_dma:
610 	dma_free_coherent(&tc->ntb->pdev->dev, inmw->size, inmw->mm_base,
611 			  inmw->dma_base);
612 	inmw->mm_base = NULL;
613 	inmw->dma_base = 0;
614 	inmw->size = 0;
615 
616 	return ret;
617 }
618 
tool_free_mw(struct tool_ctx * tc,int pidx,int widx)619 static void tool_free_mw(struct tool_ctx *tc, int pidx, int widx)
620 {
621 	struct tool_mw *inmw = &tc->peers[pidx].inmws[widx];
622 
623 	debugfs_remove(inmw->dbgfs_file);
624 
625 	if (inmw->mm_base != NULL) {
626 		ntb_mw_clear_trans(tc->ntb, pidx, widx);
627 		dma_free_coherent(&tc->ntb->pdev->dev, inmw->size,
628 				  inmw->mm_base, inmw->dma_base);
629 	}
630 
631 	inmw->mm_base = NULL;
632 	inmw->dma_base = 0;
633 	inmw->size = 0;
634 	inmw->dbgfs_file = NULL;
635 }
636 
tool_mw_trans_read(struct file * filep,char __user * ubuf,size_t size,loff_t * offp)637 static ssize_t tool_mw_trans_read(struct file *filep, char __user *ubuf,
638 				  size_t size, loff_t *offp)
639 {
640 	struct tool_mw *inmw = filep->private_data;
641 	resource_size_t addr_align;
642 	resource_size_t size_align;
643 	resource_size_t size_max;
644 	ssize_t ret, off = 0;
645 	size_t buf_size;
646 	char *buf;
647 
648 	buf_size = min_t(size_t, size, 512);
649 
650 	buf = kmalloc(buf_size, GFP_KERNEL);
651 	if (!buf)
652 		return -ENOMEM;
653 
654 	ret = ntb_mw_get_align(inmw->tc->ntb, inmw->pidx, inmw->widx,
655 			       &addr_align, &size_align, &size_max);
656 	if (ret)
657 		goto err;
658 
659 	off += scnprintf(buf + off, buf_size - off,
660 			 "Inbound MW     \t%d\n",
661 			 inmw->widx);
662 
663 	off += scnprintf(buf + off, buf_size - off,
664 			 "Port           \t%d (%d)\n",
665 			 ntb_peer_port_number(inmw->tc->ntb, inmw->pidx),
666 			 inmw->pidx);
667 
668 	off += scnprintf(buf + off, buf_size - off,
669 			 "Window Address \t0x%pK\n", inmw->mm_base);
670 
671 	off += scnprintf(buf + off, buf_size - off,
672 			 "DMA Address    \t%pad\n",
673 			 &inmw->dma_base);
674 
675 	off += scnprintf(buf + off, buf_size - off,
676 			 "Window Size    \t%pap\n",
677 			 &inmw->size);
678 
679 	off += scnprintf(buf + off, buf_size - off,
680 			 "Alignment      \t%pap\n",
681 			 &addr_align);
682 
683 	off += scnprintf(buf + off, buf_size - off,
684 			 "Size Alignment \t%pap\n",
685 			 &size_align);
686 
687 	off += scnprintf(buf + off, buf_size - off,
688 			 "Size Max       \t%pap\n",
689 			 &size_max);
690 
691 	ret = simple_read_from_buffer(ubuf, size, offp, buf, off);
692 
693 err:
694 	kfree(buf);
695 
696 	return ret;
697 }
698 
tool_mw_trans_write(struct file * filep,const char __user * ubuf,size_t size,loff_t * offp)699 static ssize_t tool_mw_trans_write(struct file *filep, const char __user *ubuf,
700 				   size_t size, loff_t *offp)
701 {
702 	struct tool_mw *inmw = filep->private_data;
703 	unsigned int val;
704 	int ret;
705 
706 	ret = kstrtouint_from_user(ubuf, size, 0, &val);
707 	if (ret)
708 		return ret;
709 
710 	tool_free_mw(inmw->tc, inmw->pidx, inmw->widx);
711 	if (val) {
712 		ret = tool_setup_mw(inmw->tc, inmw->pidx, inmw->widx, val);
713 		if (ret)
714 			return ret;
715 	}
716 
717 	return size;
718 }
719 
720 static TOOL_FOPS_RDWR(tool_mw_trans_fops,
721 		      tool_mw_trans_read,
722 		      tool_mw_trans_write);
723 
tool_peer_mw_read(struct file * filep,char __user * ubuf,size_t size,loff_t * offp)724 static ssize_t tool_peer_mw_read(struct file *filep, char __user *ubuf,
725 				 size_t size, loff_t *offp)
726 {
727 	struct tool_mw *outmw = filep->private_data;
728 	loff_t pos = *offp;
729 	ssize_t ret;
730 	void *buf;
731 
732 	if (outmw->io_base == NULL)
733 		return -EIO;
734 
735 	if (pos >= outmw->size || !size)
736 		return 0;
737 
738 	if (size > outmw->size - pos)
739 		size = outmw->size - pos;
740 
741 	buf = kmalloc(size, GFP_KERNEL);
742 	if (!buf)
743 		return -ENOMEM;
744 
745 	memcpy_fromio(buf, outmw->io_base + pos, size);
746 	ret = copy_to_user(ubuf, buf, size);
747 	if (ret == size) {
748 		ret = -EFAULT;
749 		goto err_free;
750 	}
751 
752 	size -= ret;
753 	*offp = pos + size;
754 	ret = size;
755 
756 err_free:
757 	kfree(buf);
758 
759 	return ret;
760 }
761 
tool_peer_mw_write(struct file * filep,const char __user * ubuf,size_t size,loff_t * offp)762 static ssize_t tool_peer_mw_write(struct file *filep, const char __user *ubuf,
763 				  size_t size, loff_t *offp)
764 {
765 	struct tool_mw *outmw = filep->private_data;
766 	ssize_t ret;
767 	loff_t pos = *offp;
768 	void *buf;
769 
770 	if (outmw->io_base == NULL)
771 		return -EIO;
772 
773 	if (pos >= outmw->size || !size)
774 		return 0;
775 	if (size > outmw->size - pos)
776 		size = outmw->size - pos;
777 
778 	buf = kmalloc(size, GFP_KERNEL);
779 	if (!buf)
780 		return -ENOMEM;
781 
782 	ret = copy_from_user(buf, ubuf, size);
783 	if (ret == size) {
784 		ret = -EFAULT;
785 		goto err_free;
786 	}
787 
788 	size -= ret;
789 	*offp = pos + size;
790 	ret = size;
791 
792 	memcpy_toio(outmw->io_base + pos, buf, size);
793 
794 err_free:
795 	kfree(buf);
796 
797 	return ret;
798 }
799 
800 static TOOL_FOPS_RDWR(tool_peer_mw_fops,
801 		      tool_peer_mw_read,
802 		      tool_peer_mw_write);
803 
tool_setup_peer_mw(struct tool_ctx * tc,int pidx,int widx,u64 req_addr,size_t req_size)804 static int tool_setup_peer_mw(struct tool_ctx *tc, int pidx, int widx,
805 			      u64 req_addr, size_t req_size)
806 {
807 	struct tool_mw *outmw = &tc->outmws[widx];
808 	resource_size_t map_size;
809 	phys_addr_t map_base;
810 	char buf[TOOL_BUF_LEN];
811 	int ret;
812 
813 	if (outmw->io_base != NULL)
814 		return 0;
815 
816 	ret = ntb_peer_mw_get_addr(tc->ntb, widx, &map_base, &map_size);
817 	if (ret)
818 		return ret;
819 
820 	ret = ntb_peer_mw_set_trans(tc->ntb, pidx, widx, req_addr, req_size);
821 	if (ret)
822 		return ret;
823 
824 	outmw->io_base = ioremap_wc(map_base, map_size);
825 	if (outmw->io_base == NULL) {
826 		ret = -EFAULT;
827 		goto err_clear_trans;
828 	}
829 
830 	outmw->tr_base = req_addr;
831 	outmw->size = req_size;
832 	outmw->pidx = pidx;
833 
834 	snprintf(buf, sizeof(buf), "peer_mw%d", widx);
835 	outmw->dbgfs_file = debugfs_create_file(buf, 0600,
836 					       tc->peers[pidx].dbgfs_dir, outmw,
837 					       &tool_peer_mw_fops);
838 
839 	return 0;
840 
841 err_clear_trans:
842 	ntb_peer_mw_clear_trans(tc->ntb, pidx, widx);
843 
844 	return ret;
845 }
846 
tool_free_peer_mw(struct tool_ctx * tc,int widx)847 static void tool_free_peer_mw(struct tool_ctx *tc, int widx)
848 {
849 	struct tool_mw *outmw = &tc->outmws[widx];
850 
851 	debugfs_remove(outmw->dbgfs_file);
852 
853 	if (outmw->io_base != NULL) {
854 		iounmap(tc->outmws[widx].io_base);
855 		ntb_peer_mw_clear_trans(tc->ntb, outmw->pidx, widx);
856 	}
857 
858 	outmw->io_base = NULL;
859 	outmw->tr_base = 0;
860 	outmw->size = 0;
861 	outmw->pidx = -1;
862 	outmw->dbgfs_file = NULL;
863 }
864 
tool_peer_mw_trans_read(struct file * filep,char __user * ubuf,size_t size,loff_t * offp)865 static ssize_t tool_peer_mw_trans_read(struct file *filep, char __user *ubuf,
866 					size_t size, loff_t *offp)
867 {
868 	struct tool_mw_wrap *outmw_wrap = filep->private_data;
869 	struct tool_mw *outmw = outmw_wrap->mw;
870 	resource_size_t map_size;
871 	phys_addr_t map_base;
872 	ssize_t off = 0;
873 	size_t buf_size;
874 	char *buf;
875 	int ret;
876 
877 	ret = ntb_peer_mw_get_addr(outmw->tc->ntb, outmw->widx,
878 				  &map_base, &map_size);
879 	if (ret)
880 		return ret;
881 
882 	buf_size = min_t(size_t, size, 512);
883 
884 	buf = kmalloc(buf_size, GFP_KERNEL);
885 	if (!buf)
886 		return -ENOMEM;
887 
888 	off += scnprintf(buf + off, buf_size - off,
889 			 "Outbound MW:        \t%d\n", outmw->widx);
890 
891 	if (outmw->io_base != NULL) {
892 		off += scnprintf(buf + off, buf_size - off,
893 			"Port attached       \t%d (%d)\n",
894 			ntb_peer_port_number(outmw->tc->ntb, outmw->pidx),
895 			outmw->pidx);
896 	} else {
897 		off += scnprintf(buf + off, buf_size - off,
898 				 "Port attached       \t-1 (-1)\n");
899 	}
900 
901 	off += scnprintf(buf + off, buf_size - off,
902 			 "Virtual address     \t0x%pK\n", outmw->io_base);
903 
904 	off += scnprintf(buf + off, buf_size - off,
905 			 "Phys Address        \t%pap\n", &map_base);
906 
907 	off += scnprintf(buf + off, buf_size - off,
908 			 "Mapping Size        \t%pap\n", &map_size);
909 
910 	off += scnprintf(buf + off, buf_size - off,
911 			 "Translation Address \t0x%016llx\n", outmw->tr_base);
912 
913 	off += scnprintf(buf + off, buf_size - off,
914 			 "Window Size         \t%pap\n", &outmw->size);
915 
916 	ret = simple_read_from_buffer(ubuf, size, offp, buf, off);
917 	kfree(buf);
918 
919 	return ret;
920 }
921 
tool_peer_mw_trans_write(struct file * filep,const char __user * ubuf,size_t size,loff_t * offp)922 static ssize_t tool_peer_mw_trans_write(struct file *filep,
923 					const char __user *ubuf,
924 					size_t size, loff_t *offp)
925 {
926 	struct tool_mw_wrap *outmw_wrap = filep->private_data;
927 	struct tool_mw *outmw = outmw_wrap->mw;
928 	size_t buf_size, wsize;
929 	char buf[TOOL_BUF_LEN];
930 	int ret, n;
931 	u64 addr;
932 
933 	buf_size = min(size, (sizeof(buf) - 1));
934 	if (copy_from_user(buf, ubuf, buf_size))
935 		return -EFAULT;
936 
937 	buf[buf_size] = '\0';
938 
939 	n = sscanf(buf, "%lli:%zi", &addr, &wsize);
940 	if (n != 2)
941 		return -EINVAL;
942 
943 	tool_free_peer_mw(outmw->tc, outmw->widx);
944 	if (wsize) {
945 		ret = tool_setup_peer_mw(outmw->tc, outmw_wrap->pidx,
946 					 outmw->widx, addr, wsize);
947 		if (ret)
948 			return ret;
949 	}
950 
951 	return size;
952 }
953 
954 static TOOL_FOPS_RDWR(tool_peer_mw_trans_fops,
955 		      tool_peer_mw_trans_read,
956 		      tool_peer_mw_trans_write);
957 
tool_init_mws(struct tool_ctx * tc)958 static int tool_init_mws(struct tool_ctx *tc)
959 {
960 	int widx, pidx;
961 
962 	/* Initialize outbound memory windows */
963 	tc->outmw_cnt = ntb_peer_mw_count(tc->ntb);
964 	tc->outmws = devm_kcalloc(&tc->ntb->dev, tc->outmw_cnt,
965 				  sizeof(*tc->outmws), GFP_KERNEL);
966 	if (tc->outmws == NULL)
967 		return -ENOMEM;
968 
969 	for (widx = 0; widx < tc->outmw_cnt; widx++) {
970 		tc->outmws[widx].widx = widx;
971 		tc->outmws[widx].pidx = -1;
972 		tc->outmws[widx].tc = tc;
973 	}
974 
975 	/* Initialize inbound memory windows and outbound MWs wrapper */
976 	for (pidx = 0; pidx < tc->peer_cnt; pidx++) {
977 		tc->peers[pidx].inmw_cnt = ntb_mw_count(tc->ntb, pidx);
978 		tc->peers[pidx].inmws =
979 			devm_kcalloc(&tc->ntb->dev, tc->peers[pidx].inmw_cnt,
980 				    sizeof(*tc->peers[pidx].inmws), GFP_KERNEL);
981 		if (tc->peers[pidx].inmws == NULL)
982 			return -ENOMEM;
983 
984 		for (widx = 0; widx < tc->peers[pidx].inmw_cnt; widx++) {
985 			tc->peers[pidx].inmws[widx].widx = widx;
986 			tc->peers[pidx].inmws[widx].pidx = pidx;
987 			tc->peers[pidx].inmws[widx].tc = tc;
988 		}
989 
990 		tc->peers[pidx].outmw_cnt = ntb_peer_mw_count(tc->ntb);
991 		tc->peers[pidx].outmws =
992 			devm_kcalloc(&tc->ntb->dev, tc->peers[pidx].outmw_cnt,
993 				   sizeof(*tc->peers[pidx].outmws), GFP_KERNEL);
994 		if (tc->peers[pidx].outmws == NULL)
995 			return -ENOMEM;
996 
997 		for (widx = 0; widx < tc->peers[pidx].outmw_cnt; widx++) {
998 			tc->peers[pidx].outmws[widx].pidx = pidx;
999 			tc->peers[pidx].outmws[widx].mw = &tc->outmws[widx];
1000 		}
1001 	}
1002 
1003 	return 0;
1004 }
1005 
tool_clear_mws(struct tool_ctx * tc)1006 static void tool_clear_mws(struct tool_ctx *tc)
1007 {
1008 	int widx, pidx;
1009 
1010 	/* Free outbound memory windows */
1011 	for (widx = 0; widx < tc->outmw_cnt; widx++)
1012 		tool_free_peer_mw(tc, widx);
1013 
1014 	/* Free outbound memory windows */
1015 	for (pidx = 0; pidx < tc->peer_cnt; pidx++)
1016 		for (widx = 0; widx < tc->peers[pidx].inmw_cnt; widx++)
1017 			tool_free_mw(tc, pidx, widx);
1018 }
1019 
1020 /*==============================================================================
1021  *                       Doorbell read/write methods
1022  *==============================================================================
1023  */
1024 
tool_db_read(struct file * filep,char __user * ubuf,size_t size,loff_t * offp)1025 static ssize_t tool_db_read(struct file *filep, char __user *ubuf,
1026 			    size_t size, loff_t *offp)
1027 {
1028 	struct tool_ctx *tc = filep->private_data;
1029 
1030 	return tool_fn_read(tc, ubuf, size, offp, tc->ntb->ops->db_read);
1031 }
1032 
tool_db_write(struct file * filep,const char __user * ubuf,size_t size,loff_t * offp)1033 static ssize_t tool_db_write(struct file *filep, const char __user *ubuf,
1034 			     size_t size, loff_t *offp)
1035 {
1036 	struct tool_ctx *tc = filep->private_data;
1037 
1038 	return tool_fn_write(tc, ubuf, size, offp, tc->ntb->ops->db_set,
1039 			     tc->ntb->ops->db_clear);
1040 }
1041 
1042 static TOOL_FOPS_RDWR(tool_db_fops,
1043 		      tool_db_read,
1044 		      tool_db_write);
1045 
tool_db_valid_mask_read(struct file * filep,char __user * ubuf,size_t size,loff_t * offp)1046 static ssize_t tool_db_valid_mask_read(struct file *filep, char __user *ubuf,
1047 				       size_t size, loff_t *offp)
1048 {
1049 	struct tool_ctx *tc = filep->private_data;
1050 
1051 	return tool_fn_read(tc, ubuf, size, offp, tc->ntb->ops->db_valid_mask);
1052 }
1053 
1054 static TOOL_FOPS_RDWR(tool_db_valid_mask_fops,
1055 		      tool_db_valid_mask_read,
1056 		      NULL);
1057 
tool_db_mask_read(struct file * filep,char __user * ubuf,size_t size,loff_t * offp)1058 static ssize_t tool_db_mask_read(struct file *filep, char __user *ubuf,
1059 				 size_t size, loff_t *offp)
1060 {
1061 	struct tool_ctx *tc = filep->private_data;
1062 
1063 	return tool_fn_read(tc, ubuf, size, offp, tc->ntb->ops->db_read_mask);
1064 }
1065 
tool_db_mask_write(struct file * filep,const char __user * ubuf,size_t size,loff_t * offp)1066 static ssize_t tool_db_mask_write(struct file *filep, const char __user *ubuf,
1067 			       size_t size, loff_t *offp)
1068 {
1069 	struct tool_ctx *tc = filep->private_data;
1070 
1071 	return tool_fn_write(tc, ubuf, size, offp, tc->ntb->ops->db_set_mask,
1072 			     tc->ntb->ops->db_clear_mask);
1073 }
1074 
1075 static TOOL_FOPS_RDWR(tool_db_mask_fops,
1076 		      tool_db_mask_read,
1077 		      tool_db_mask_write);
1078 
tool_peer_db_read(struct file * filep,char __user * ubuf,size_t size,loff_t * offp)1079 static ssize_t tool_peer_db_read(struct file *filep, char __user *ubuf,
1080 				 size_t size, loff_t *offp)
1081 {
1082 	struct tool_ctx *tc = filep->private_data;
1083 
1084 	return tool_fn_read(tc, ubuf, size, offp, tc->ntb->ops->peer_db_read);
1085 }
1086 
tool_peer_db_write(struct file * filep,const char __user * ubuf,size_t size,loff_t * offp)1087 static ssize_t tool_peer_db_write(struct file *filep, const char __user *ubuf,
1088 				  size_t size, loff_t *offp)
1089 {
1090 	struct tool_ctx *tc = filep->private_data;
1091 
1092 	return tool_fn_write(tc, ubuf, size, offp, tc->ntb->ops->peer_db_set,
1093 			     tc->ntb->ops->peer_db_clear);
1094 }
1095 
1096 static TOOL_FOPS_RDWR(tool_peer_db_fops,
1097 		      tool_peer_db_read,
1098 		      tool_peer_db_write);
1099 
tool_peer_db_mask_read(struct file * filep,char __user * ubuf,size_t size,loff_t * offp)1100 static ssize_t tool_peer_db_mask_read(struct file *filep, char __user *ubuf,
1101 				   size_t size, loff_t *offp)
1102 {
1103 	struct tool_ctx *tc = filep->private_data;
1104 
1105 	return tool_fn_read(tc, ubuf, size, offp,
1106 			    tc->ntb->ops->peer_db_read_mask);
1107 }
1108 
tool_peer_db_mask_write(struct file * filep,const char __user * ubuf,size_t size,loff_t * offp)1109 static ssize_t tool_peer_db_mask_write(struct file *filep,
1110 				       const char __user *ubuf,
1111 				       size_t size, loff_t *offp)
1112 {
1113 	struct tool_ctx *tc = filep->private_data;
1114 
1115 	return tool_fn_write(tc, ubuf, size, offp,
1116 			     tc->ntb->ops->peer_db_set_mask,
1117 			     tc->ntb->ops->peer_db_clear_mask);
1118 }
1119 
1120 static TOOL_FOPS_RDWR(tool_peer_db_mask_fops,
1121 		      tool_peer_db_mask_read,
1122 		      tool_peer_db_mask_write);
1123 
tool_db_event_write(struct file * filep,const char __user * ubuf,size_t size,loff_t * offp)1124 static ssize_t tool_db_event_write(struct file *filep,
1125 				   const char __user *ubuf,
1126 				   size_t size, loff_t *offp)
1127 {
1128 	struct tool_ctx *tc = filep->private_data;
1129 	u64 val;
1130 	int ret;
1131 
1132 	ret = kstrtou64_from_user(ubuf, size, 0, &val);
1133 	if (ret)
1134 		return ret;
1135 
1136 	if (wait_event_interruptible(tc->db_wq, ntb_db_read(tc->ntb) == val))
1137 		return -ERESTART;
1138 
1139 	return size;
1140 }
1141 
1142 static TOOL_FOPS_RDWR(tool_db_event_fops,
1143 		      NULL,
1144 		      tool_db_event_write);
1145 
1146 /*==============================================================================
1147  *                       Scratchpads read/write methods
1148  *==============================================================================
1149  */
1150 
tool_spad_read(struct file * filep,char __user * ubuf,size_t size,loff_t * offp)1151 static ssize_t tool_spad_read(struct file *filep, char __user *ubuf,
1152 			      size_t size, loff_t *offp)
1153 {
1154 	struct tool_spad *spad = filep->private_data;
1155 	char buf[TOOL_BUF_LEN];
1156 	ssize_t pos;
1157 
1158 	if (!spad->tc->ntb->ops->spad_read)
1159 		return -EINVAL;
1160 
1161 	pos = scnprintf(buf, sizeof(buf), "%#x\n",
1162 		ntb_spad_read(spad->tc->ntb, spad->sidx));
1163 
1164 	return simple_read_from_buffer(ubuf, size, offp, buf, pos);
1165 }
1166 
tool_spad_write(struct file * filep,const char __user * ubuf,size_t size,loff_t * offp)1167 static ssize_t tool_spad_write(struct file *filep, const char __user *ubuf,
1168 			       size_t size, loff_t *offp)
1169 {
1170 	struct tool_spad *spad = filep->private_data;
1171 	u32 val;
1172 	int ret;
1173 
1174 	if (!spad->tc->ntb->ops->spad_write) {
1175 		dev_dbg(&spad->tc->ntb->dev, "no spad write fn\n");
1176 		return -EINVAL;
1177 	}
1178 
1179 	ret = kstrtou32_from_user(ubuf, size, 0, &val);
1180 	if (ret)
1181 		return ret;
1182 
1183 	ret = ntb_spad_write(spad->tc->ntb, spad->sidx, val);
1184 
1185 	return ret ?: size;
1186 }
1187 
1188 static TOOL_FOPS_RDWR(tool_spad_fops,
1189 		      tool_spad_read,
1190 		      tool_spad_write);
1191 
tool_peer_spad_read(struct file * filep,char __user * ubuf,size_t size,loff_t * offp)1192 static ssize_t tool_peer_spad_read(struct file *filep, char __user *ubuf,
1193 				   size_t size, loff_t *offp)
1194 {
1195 	struct tool_spad *spad = filep->private_data;
1196 	char buf[TOOL_BUF_LEN];
1197 	ssize_t pos;
1198 
1199 	if (!spad->tc->ntb->ops->peer_spad_read)
1200 		return -EINVAL;
1201 
1202 	pos = scnprintf(buf, sizeof(buf), "%#x\n",
1203 		ntb_peer_spad_read(spad->tc->ntb, spad->pidx, spad->sidx));
1204 
1205 	return simple_read_from_buffer(ubuf, size, offp, buf, pos);
1206 }
1207 
tool_peer_spad_write(struct file * filep,const char __user * ubuf,size_t size,loff_t * offp)1208 static ssize_t tool_peer_spad_write(struct file *filep, const char __user *ubuf,
1209 				    size_t size, loff_t *offp)
1210 {
1211 	struct tool_spad *spad = filep->private_data;
1212 	u32 val;
1213 	int ret;
1214 
1215 	if (!spad->tc->ntb->ops->peer_spad_write) {
1216 		dev_dbg(&spad->tc->ntb->dev, "no spad write fn\n");
1217 		return -EINVAL;
1218 	}
1219 
1220 	ret = kstrtou32_from_user(ubuf, size, 0, &val);
1221 	if (ret)
1222 		return ret;
1223 
1224 	ret = ntb_peer_spad_write(spad->tc->ntb, spad->pidx, spad->sidx, val);
1225 
1226 	return ret ?: size;
1227 }
1228 
1229 static TOOL_FOPS_RDWR(tool_peer_spad_fops,
1230 		      tool_peer_spad_read,
1231 		      tool_peer_spad_write);
1232 
tool_init_spads(struct tool_ctx * tc)1233 static int tool_init_spads(struct tool_ctx *tc)
1234 {
1235 	int sidx, pidx;
1236 
1237 	/* Initialize inbound scratchpad structures */
1238 	tc->inspad_cnt = ntb_spad_count(tc->ntb);
1239 	tc->inspads = devm_kcalloc(&tc->ntb->dev, tc->inspad_cnt,
1240 				   sizeof(*tc->inspads), GFP_KERNEL);
1241 	if (tc->inspads == NULL)
1242 		return -ENOMEM;
1243 
1244 	for (sidx = 0; sidx < tc->inspad_cnt; sidx++) {
1245 		tc->inspads[sidx].sidx = sidx;
1246 		tc->inspads[sidx].pidx = -1;
1247 		tc->inspads[sidx].tc = tc;
1248 	}
1249 
1250 	/* Initialize outbound scratchpad structures */
1251 	for (pidx = 0; pidx < tc->peer_cnt; pidx++) {
1252 		tc->peers[pidx].outspad_cnt = ntb_spad_count(tc->ntb);
1253 		tc->peers[pidx].outspads =
1254 			devm_kcalloc(&tc->ntb->dev, tc->peers[pidx].outspad_cnt,
1255 				sizeof(*tc->peers[pidx].outspads), GFP_KERNEL);
1256 		if (tc->peers[pidx].outspads == NULL)
1257 			return -ENOMEM;
1258 
1259 		for (sidx = 0; sidx < tc->peers[pidx].outspad_cnt; sidx++) {
1260 			tc->peers[pidx].outspads[sidx].sidx = sidx;
1261 			tc->peers[pidx].outspads[sidx].pidx = pidx;
1262 			tc->peers[pidx].outspads[sidx].tc = tc;
1263 		}
1264 	}
1265 
1266 	return 0;
1267 }
1268 
1269 /*==============================================================================
1270  *                       Messages read/write methods
1271  *==============================================================================
1272  */
1273 
tool_inmsg_read(struct file * filep,char __user * ubuf,size_t size,loff_t * offp)1274 static ssize_t tool_inmsg_read(struct file *filep, char __user *ubuf,
1275 			       size_t size, loff_t *offp)
1276 {
1277 	struct tool_msg *msg = filep->private_data;
1278 	char buf[TOOL_BUF_LEN];
1279 	ssize_t pos;
1280 	u32 data;
1281 	int pidx;
1282 
1283 	data = ntb_msg_read(msg->tc->ntb, &pidx, msg->midx);
1284 
1285 	pos = scnprintf(buf, sizeof(buf), "0x%08x<-%d\n", data, pidx);
1286 
1287 	return simple_read_from_buffer(ubuf, size, offp, buf, pos);
1288 }
1289 
1290 static TOOL_FOPS_RDWR(tool_inmsg_fops,
1291 		      tool_inmsg_read,
1292 		      NULL);
1293 
tool_outmsg_write(struct file * filep,const char __user * ubuf,size_t size,loff_t * offp)1294 static ssize_t tool_outmsg_write(struct file *filep,
1295 				 const char __user *ubuf,
1296 				 size_t size, loff_t *offp)
1297 {
1298 	struct tool_msg *msg = filep->private_data;
1299 	u32 val;
1300 	int ret;
1301 
1302 	ret = kstrtou32_from_user(ubuf, size, 0, &val);
1303 	if (ret)
1304 		return ret;
1305 
1306 	ret = ntb_peer_msg_write(msg->tc->ntb, msg->pidx, msg->midx, val);
1307 
1308 	return ret ? : size;
1309 }
1310 
1311 static TOOL_FOPS_RDWR(tool_outmsg_fops,
1312 		      NULL,
1313 		      tool_outmsg_write);
1314 
tool_msg_sts_read(struct file * filep,char __user * ubuf,size_t size,loff_t * offp)1315 static ssize_t tool_msg_sts_read(struct file *filep, char __user *ubuf,
1316 				 size_t size, loff_t *offp)
1317 {
1318 	struct tool_ctx *tc = filep->private_data;
1319 
1320 	return tool_fn_read(tc, ubuf, size, offp, tc->ntb->ops->msg_read_sts);
1321 }
1322 
tool_msg_sts_write(struct file * filep,const char __user * ubuf,size_t size,loff_t * offp)1323 static ssize_t tool_msg_sts_write(struct file *filep, const char __user *ubuf,
1324 				  size_t size, loff_t *offp)
1325 {
1326 	struct tool_ctx *tc = filep->private_data;
1327 
1328 	return tool_fn_write(tc, ubuf, size, offp, NULL,
1329 			     tc->ntb->ops->msg_clear_sts);
1330 }
1331 
1332 static TOOL_FOPS_RDWR(tool_msg_sts_fops,
1333 		      tool_msg_sts_read,
1334 		      tool_msg_sts_write);
1335 
tool_msg_inbits_read(struct file * filep,char __user * ubuf,size_t size,loff_t * offp)1336 static ssize_t tool_msg_inbits_read(struct file *filep, char __user *ubuf,
1337 				    size_t size, loff_t *offp)
1338 {
1339 	struct tool_ctx *tc = filep->private_data;
1340 
1341 	return tool_fn_read(tc, ubuf, size, offp, tc->ntb->ops->msg_inbits);
1342 }
1343 
1344 static TOOL_FOPS_RDWR(tool_msg_inbits_fops,
1345 		      tool_msg_inbits_read,
1346 		      NULL);
1347 
tool_msg_outbits_read(struct file * filep,char __user * ubuf,size_t size,loff_t * offp)1348 static ssize_t tool_msg_outbits_read(struct file *filep, char __user *ubuf,
1349 				     size_t size, loff_t *offp)
1350 {
1351 	struct tool_ctx *tc = filep->private_data;
1352 
1353 	return tool_fn_read(tc, ubuf, size, offp, tc->ntb->ops->msg_outbits);
1354 }
1355 
1356 static TOOL_FOPS_RDWR(tool_msg_outbits_fops,
1357 		      tool_msg_outbits_read,
1358 		      NULL);
1359 
tool_msg_mask_write(struct file * filep,const char __user * ubuf,size_t size,loff_t * offp)1360 static ssize_t tool_msg_mask_write(struct file *filep, const char __user *ubuf,
1361 				   size_t size, loff_t *offp)
1362 {
1363 	struct tool_ctx *tc = filep->private_data;
1364 
1365 	return tool_fn_write(tc, ubuf, size, offp,
1366 			     tc->ntb->ops->msg_set_mask,
1367 			     tc->ntb->ops->msg_clear_mask);
1368 }
1369 
1370 static TOOL_FOPS_RDWR(tool_msg_mask_fops,
1371 		      NULL,
1372 		      tool_msg_mask_write);
1373 
tool_msg_event_write(struct file * filep,const char __user * ubuf,size_t size,loff_t * offp)1374 static ssize_t tool_msg_event_write(struct file *filep,
1375 				    const char __user *ubuf,
1376 				    size_t size, loff_t *offp)
1377 {
1378 	struct tool_ctx *tc = filep->private_data;
1379 	u64 val;
1380 	int ret;
1381 
1382 	ret = kstrtou64_from_user(ubuf, size, 0, &val);
1383 	if (ret)
1384 		return ret;
1385 
1386 	if (wait_event_interruptible(tc->msg_wq,
1387 		ntb_msg_read_sts(tc->ntb) == val))
1388 		return -ERESTART;
1389 
1390 	return size;
1391 }
1392 
1393 static TOOL_FOPS_RDWR(tool_msg_event_fops,
1394 		      NULL,
1395 		      tool_msg_event_write);
1396 
tool_init_msgs(struct tool_ctx * tc)1397 static int tool_init_msgs(struct tool_ctx *tc)
1398 {
1399 	int midx, pidx;
1400 
1401 	/* Initialize inbound message structures */
1402 	tc->inmsg_cnt = ntb_msg_count(tc->ntb);
1403 	tc->inmsgs = devm_kcalloc(&tc->ntb->dev, tc->inmsg_cnt,
1404 				   sizeof(*tc->inmsgs), GFP_KERNEL);
1405 	if (tc->inmsgs == NULL)
1406 		return -ENOMEM;
1407 
1408 	for (midx = 0; midx < tc->inmsg_cnt; midx++) {
1409 		tc->inmsgs[midx].midx = midx;
1410 		tc->inmsgs[midx].pidx = -1;
1411 		tc->inmsgs[midx].tc = tc;
1412 	}
1413 
1414 	/* Initialize outbound message structures */
1415 	for (pidx = 0; pidx < tc->peer_cnt; pidx++) {
1416 		tc->peers[pidx].outmsg_cnt = ntb_msg_count(tc->ntb);
1417 		tc->peers[pidx].outmsgs =
1418 			devm_kcalloc(&tc->ntb->dev, tc->peers[pidx].outmsg_cnt,
1419 				sizeof(*tc->peers[pidx].outmsgs), GFP_KERNEL);
1420 		if (tc->peers[pidx].outmsgs == NULL)
1421 			return -ENOMEM;
1422 
1423 		for (midx = 0; midx < tc->peers[pidx].outmsg_cnt; midx++) {
1424 			tc->peers[pidx].outmsgs[midx].midx = midx;
1425 			tc->peers[pidx].outmsgs[midx].pidx = pidx;
1426 			tc->peers[pidx].outmsgs[midx].tc = tc;
1427 		}
1428 	}
1429 
1430 	return 0;
1431 }
1432 
1433 /*==============================================================================
1434  *                          Initialization methods
1435  *==============================================================================
1436  */
1437 
tool_create_data(struct ntb_dev * ntb)1438 static struct tool_ctx *tool_create_data(struct ntb_dev *ntb)
1439 {
1440 	struct tool_ctx *tc;
1441 
1442 	tc = devm_kzalloc(&ntb->dev, sizeof(*tc), GFP_KERNEL);
1443 	if (tc == NULL)
1444 		return ERR_PTR(-ENOMEM);
1445 
1446 	tc->ntb = ntb;
1447 	init_waitqueue_head(&tc->link_wq);
1448 	init_waitqueue_head(&tc->db_wq);
1449 	init_waitqueue_head(&tc->msg_wq);
1450 
1451 	if (ntb_db_is_unsafe(ntb))
1452 		dev_dbg(&ntb->dev, "doorbell is unsafe\n");
1453 
1454 	if (ntb_spad_is_unsafe(ntb))
1455 		dev_dbg(&ntb->dev, "scratchpad is unsafe\n");
1456 
1457 	return tc;
1458 }
1459 
tool_clear_data(struct tool_ctx * tc)1460 static void tool_clear_data(struct tool_ctx *tc)
1461 {
1462 	wake_up(&tc->link_wq);
1463 	wake_up(&tc->db_wq);
1464 	wake_up(&tc->msg_wq);
1465 }
1466 
tool_init_ntb(struct tool_ctx * tc)1467 static int tool_init_ntb(struct tool_ctx *tc)
1468 {
1469 	return ntb_set_ctx(tc->ntb, tc, &tool_ops);
1470 }
1471 
tool_clear_ntb(struct tool_ctx * tc)1472 static void tool_clear_ntb(struct tool_ctx *tc)
1473 {
1474 	ntb_clear_ctx(tc->ntb);
1475 	ntb_link_disable(tc->ntb);
1476 }
1477 
tool_setup_dbgfs(struct tool_ctx * tc)1478 static void tool_setup_dbgfs(struct tool_ctx *tc)
1479 {
1480 	int pidx, widx, sidx, midx;
1481 	char buf[TOOL_BUF_LEN];
1482 
1483 	/* This modules is useless without dbgfs... */
1484 	if (!tool_dbgfs_topdir) {
1485 		tc->dbgfs_dir = NULL;
1486 		return;
1487 	}
1488 
1489 	tc->dbgfs_dir = debugfs_create_dir(dev_name(&tc->ntb->dev),
1490 					   tool_dbgfs_topdir);
1491 
1492 	debugfs_create_file("port", 0600, tc->dbgfs_dir,
1493 			    tc, &tool_port_fops);
1494 
1495 	debugfs_create_file("link", 0600, tc->dbgfs_dir,
1496 			    tc, &tool_link_fops);
1497 
1498 	debugfs_create_file("db", 0600, tc->dbgfs_dir,
1499 			    tc, &tool_db_fops);
1500 
1501 	debugfs_create_file("db_valid_mask", 0600, tc->dbgfs_dir,
1502 			    tc, &tool_db_valid_mask_fops);
1503 
1504 	debugfs_create_file("db_mask", 0600, tc->dbgfs_dir,
1505 			    tc, &tool_db_mask_fops);
1506 
1507 	debugfs_create_file("db_event", 0600, tc->dbgfs_dir,
1508 			    tc, &tool_db_event_fops);
1509 
1510 	debugfs_create_file("peer_db", 0600, tc->dbgfs_dir,
1511 			    tc, &tool_peer_db_fops);
1512 
1513 	debugfs_create_file("peer_db_mask", 0600, tc->dbgfs_dir,
1514 			    tc, &tool_peer_db_mask_fops);
1515 
1516 	if (tc->inspad_cnt != 0) {
1517 		for (sidx = 0; sidx < tc->inspad_cnt; sidx++) {
1518 			snprintf(buf, sizeof(buf), "spad%d", sidx);
1519 
1520 			debugfs_create_file(buf, 0600, tc->dbgfs_dir,
1521 					   &tc->inspads[sidx], &tool_spad_fops);
1522 		}
1523 	}
1524 
1525 	if (tc->inmsg_cnt != 0) {
1526 		for (midx = 0; midx < tc->inmsg_cnt; midx++) {
1527 			snprintf(buf, sizeof(buf), "msg%d", midx);
1528 			debugfs_create_file(buf, 0600, tc->dbgfs_dir,
1529 					   &tc->inmsgs[midx], &tool_inmsg_fops);
1530 		}
1531 
1532 		debugfs_create_file("msg_sts", 0600, tc->dbgfs_dir,
1533 				    tc, &tool_msg_sts_fops);
1534 
1535 		debugfs_create_file("msg_inbits", 0600, tc->dbgfs_dir,
1536 				    tc, &tool_msg_inbits_fops);
1537 
1538 		debugfs_create_file("msg_outbits", 0600, tc->dbgfs_dir,
1539 				    tc, &tool_msg_outbits_fops);
1540 
1541 		debugfs_create_file("msg_mask", 0600, tc->dbgfs_dir,
1542 				    tc, &tool_msg_mask_fops);
1543 
1544 		debugfs_create_file("msg_event", 0600, tc->dbgfs_dir,
1545 				    tc, &tool_msg_event_fops);
1546 	}
1547 
1548 	for (pidx = 0; pidx < tc->peer_cnt; pidx++) {
1549 		snprintf(buf, sizeof(buf), "peer%d", pidx);
1550 		tc->peers[pidx].dbgfs_dir =
1551 			debugfs_create_dir(buf, tc->dbgfs_dir);
1552 
1553 		debugfs_create_file("port", 0600,
1554 				    tc->peers[pidx].dbgfs_dir,
1555 				    &tc->peers[pidx], &tool_peer_port_fops);
1556 
1557 		debugfs_create_file("link", 0200,
1558 				    tc->peers[pidx].dbgfs_dir,
1559 				    &tc->peers[pidx], &tool_peer_link_fops);
1560 
1561 		debugfs_create_file("link_event", 0200,
1562 				  tc->peers[pidx].dbgfs_dir,
1563 				  &tc->peers[pidx], &tool_peer_link_event_fops);
1564 
1565 		for (widx = 0; widx < tc->peers[pidx].inmw_cnt; widx++) {
1566 			snprintf(buf, sizeof(buf), "mw_trans%d", widx);
1567 			debugfs_create_file(buf, 0600,
1568 					    tc->peers[pidx].dbgfs_dir,
1569 					    &tc->peers[pidx].inmws[widx],
1570 					    &tool_mw_trans_fops);
1571 		}
1572 
1573 		for (widx = 0; widx < tc->peers[pidx].outmw_cnt; widx++) {
1574 			snprintf(buf, sizeof(buf), "peer_mw_trans%d", widx);
1575 			debugfs_create_file(buf, 0600,
1576 					    tc->peers[pidx].dbgfs_dir,
1577 					    &tc->peers[pidx].outmws[widx],
1578 					    &tool_peer_mw_trans_fops);
1579 		}
1580 
1581 		for (sidx = 0; sidx < tc->peers[pidx].outspad_cnt; sidx++) {
1582 			snprintf(buf, sizeof(buf), "spad%d", sidx);
1583 
1584 			debugfs_create_file(buf, 0600,
1585 					    tc->peers[pidx].dbgfs_dir,
1586 					    &tc->peers[pidx].outspads[sidx],
1587 					    &tool_peer_spad_fops);
1588 		}
1589 
1590 		for (midx = 0; midx < tc->peers[pidx].outmsg_cnt; midx++) {
1591 			snprintf(buf, sizeof(buf), "msg%d", midx);
1592 			debugfs_create_file(buf, 0600,
1593 					    tc->peers[pidx].dbgfs_dir,
1594 					    &tc->peers[pidx].outmsgs[midx],
1595 					    &tool_outmsg_fops);
1596 		}
1597 	}
1598 }
1599 
tool_clear_dbgfs(struct tool_ctx * tc)1600 static void tool_clear_dbgfs(struct tool_ctx *tc)
1601 {
1602 	debugfs_remove_recursive(tc->dbgfs_dir);
1603 }
1604 
tool_probe(struct ntb_client * self,struct ntb_dev * ntb)1605 static int tool_probe(struct ntb_client *self, struct ntb_dev *ntb)
1606 {
1607 	struct tool_ctx *tc;
1608 	int ret;
1609 
1610 	tc = tool_create_data(ntb);
1611 	if (IS_ERR(tc))
1612 		return PTR_ERR(tc);
1613 
1614 	ret = tool_init_peers(tc);
1615 	if (ret != 0)
1616 		goto err_clear_data;
1617 
1618 	ret = tool_init_mws(tc);
1619 	if (ret != 0)
1620 		goto err_clear_data;
1621 
1622 	ret = tool_init_spads(tc);
1623 	if (ret != 0)
1624 		goto err_clear_mws;
1625 
1626 	ret = tool_init_msgs(tc);
1627 	if (ret != 0)
1628 		goto err_clear_mws;
1629 
1630 	ret = tool_init_ntb(tc);
1631 	if (ret != 0)
1632 		goto err_clear_mws;
1633 
1634 	tool_setup_dbgfs(tc);
1635 
1636 	return 0;
1637 
1638 err_clear_mws:
1639 	tool_clear_mws(tc);
1640 
1641 err_clear_data:
1642 	tool_clear_data(tc);
1643 
1644 	return ret;
1645 }
1646 
tool_remove(struct ntb_client * self,struct ntb_dev * ntb)1647 static void tool_remove(struct ntb_client *self, struct ntb_dev *ntb)
1648 {
1649 	struct tool_ctx *tc = ntb->ctx;
1650 
1651 	tool_clear_dbgfs(tc);
1652 
1653 	tool_clear_ntb(tc);
1654 
1655 	tool_clear_mws(tc);
1656 
1657 	tool_clear_data(tc);
1658 }
1659 
1660 static struct ntb_client tool_client = {
1661 	.ops = {
1662 		.probe = tool_probe,
1663 		.remove = tool_remove,
1664 	}
1665 };
1666 
tool_init(void)1667 static int __init tool_init(void)
1668 {
1669 	int ret;
1670 
1671 	if (debugfs_initialized())
1672 		tool_dbgfs_topdir = debugfs_create_dir(KBUILD_MODNAME, NULL);
1673 
1674 	ret = ntb_register_client(&tool_client);
1675 	if (ret)
1676 		debugfs_remove_recursive(tool_dbgfs_topdir);
1677 
1678 	return ret;
1679 }
1680 module_init(tool_init);
1681 
tool_exit(void)1682 static void __exit tool_exit(void)
1683 {
1684 	ntb_unregister_client(&tool_client);
1685 	debugfs_remove_recursive(tool_dbgfs_topdir);
1686 }
1687 module_exit(tool_exit);
1688