?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Merge tag 'trace-printf-v6.13' of git://git.kernel.org/pub/scm/linux/kernel/git/trace...
[drm/drm-misc.git] / drivers / ntb / test / ntb_tool.c
blob641cb7e05a47b27783ce8594be2d8e520939e4d9
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
1467 static int tool_init_ntb(struct tool_ctx *tc)
1468 {
1469 return ntb_set_ctx(tc->ntb, tc, &tool_ops);
1470 }
1471
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
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
1600 static void tool_clear_dbgfs(struct tool_ctx *tc)
1601 {
1602 debugfs_remove_recursive(tc->dbgfs_dir);
1603 }
1604
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
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
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
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);
Kernel DRM miscellaneous fixes and cross-tree changes