Merge tag 'ntb-4.8' of git://github.com/jonmason/ntb
[sfrench/cifs-2.6.git] / drivers / ntb / test / ntb_tool.c
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  *
9  *   This program is free software; you can redistribute it and/or modify
10  *   it under the terms of version 2 of the GNU General Public License as
11  *   published by the Free Software Foundation.
12  *
13  *   This program is distributed in the hope that it will be useful, but
14  *   WITHOUT ANY WARRANTY; without even the implied warranty of
15  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
16  *   General Public License for more details.
17  *
18  *   BSD LICENSE
19  *
20  *   Copyright (C) 2015 EMC Corporation. All Rights Reserved.
21  *
22  *   Redistribution and use in source and binary forms, with or without
23  *   modification, are permitted provided that the following conditions
24  *   are met:
25  *
26  *     * Redistributions of source code must retain the above copyright
27  *       notice, this list of conditions and the following disclaimer.
28  *     * Redistributions in binary form must reproduce the above copy
29  *       notice, this list of conditions and the following disclaimer in
30  *       the documentation and/or other materials provided with the
31  *       distribution.
32  *     * Neither the name of Intel Corporation nor the names of its
33  *       contributors may be used to endorse or promote products derived
34  *       from this software without specific prior written permission.
35  *
36  *   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
37  *   "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
38  *   LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
39  *   A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
40  *   OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
41  *   SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
42  *   LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
43  *   DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
44  *   THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
45  *   (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
46  *   OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
47  *
48  * PCIe NTB Debugging Tool Linux driver
49  *
50  * Contact Information:
51  * Allen Hubbe <Allen.Hubbe@emc.com>
52  */
53
54 /*
55  * How to use this tool, by example.
56  *
57  * Assuming $DBG_DIR is something like:
58  * '/sys/kernel/debug/ntb_tool/0000:00:03.0'
59  *
60  * Eg: check if clearing the doorbell mask generates an interrupt.
61  *
62  * # Check the link status
63  * root@self# cat $DBG_DIR/link
64  *
65  * # Block until the link is up
66  * root@self# echo Y > $DBG_DIR/link_event
67  *
68  * # Set the doorbell mask
69  * root@self# echo 's 1' > $DBG_DIR/mask
70  *
71  * # Ring the doorbell from the peer
72  * root@peer# echo 's 1' > $DBG_DIR/peer_db
73  *
74  * # Clear the doorbell mask
75  * root@self# echo 'c 1' > $DBG_DIR/mask
76  *
77  * Observe debugging output in dmesg or your console.  You should see a
78  * doorbell event triggered by clearing the mask.  If not, this may indicate an
79  * issue with the hardware that needs to be worked around in the driver.
80  *
81  * Eg: read and write scratchpad registers
82  *
83  * root@peer# echo '0 0x01010101 1 0x7f7f7f7f' > $DBG_DIR/peer_spad
84  *
85  * root@self# cat $DBG_DIR/spad
86  *
87  * Observe that spad 0 and 1 have the values set by the peer.
88  *
89  * # Check the memory window translation info
90  * cat $DBG_DIR/peer_trans0
91  *
92  * # Setup a 16k memory window buffer
93  * echo 16384 > $DBG_DIR/peer_trans0
94  *
95  */
96
97 #include <linux/init.h>
98 #include <linux/kernel.h>
99 #include <linux/module.h>
100
101 #include <linux/debugfs.h>
102 #include <linux/dma-mapping.h>
103 #include <linux/pci.h>
104 #include <linux/slab.h>
105 #include <linux/uaccess.h>
106
107 #include <linux/ntb.h>
108
109 #define DRIVER_NAME                     "ntb_tool"
110 #define DRIVER_DESCRIPTION              "PCIe NTB Debugging Tool"
111
112 #define DRIVER_LICENSE                  "Dual BSD/GPL"
113 #define DRIVER_VERSION                  "1.0"
114 #define DRIVER_RELDATE                  "22 April 2015"
115 #define DRIVER_AUTHOR                   "Allen Hubbe <Allen.Hubbe@emc.com>"
116
117 MODULE_LICENSE(DRIVER_LICENSE);
118 MODULE_VERSION(DRIVER_VERSION);
119 MODULE_AUTHOR(DRIVER_AUTHOR);
120 MODULE_DESCRIPTION(DRIVER_DESCRIPTION);
121
122 #define MAX_MWS 16
123
124 static struct dentry *tool_dbgfs;
125
126 struct tool_mw {
127         int idx;
128         struct tool_ctx *tc;
129         resource_size_t win_size;
130         resource_size_t size;
131         u8 __iomem *local;
132         u8 *peer;
133         dma_addr_t peer_dma;
134         struct dentry *peer_dbg_file;
135 };
136
137 struct tool_ctx {
138         struct ntb_dev *ntb;
139         struct dentry *dbgfs;
140         wait_queue_head_t link_wq;
141         int mw_count;
142         struct tool_mw mws[MAX_MWS];
143 };
144
145 #define SPAD_FNAME_SIZE 0x10
146 #define INT_PTR(x) ((void *)(unsigned long)x)
147 #define PTR_INT(x) ((int)(unsigned long)x)
148
149 #define TOOL_FOPS_RDWR(__name, __read, __write) \
150         const struct file_operations __name = { \
151                 .owner = THIS_MODULE,           \
152                 .open = simple_open,            \
153                 .read = __read,                 \
154                 .write = __write,               \
155         }
156
157 static void tool_link_event(void *ctx)
158 {
159         struct tool_ctx *tc = ctx;
160         enum ntb_speed speed;
161         enum ntb_width width;
162         int up;
163
164         up = ntb_link_is_up(tc->ntb, &speed, &width);
165
166         dev_dbg(&tc->ntb->dev, "link is %s speed %d width %d\n",
167                 up ? "up" : "down", speed, width);
168
169         wake_up(&tc->link_wq);
170 }
171
172 static void tool_db_event(void *ctx, int vec)
173 {
174         struct tool_ctx *tc = ctx;
175         u64 db_bits, db_mask;
176
177         db_mask = ntb_db_vector_mask(tc->ntb, vec);
178         db_bits = ntb_db_read(tc->ntb);
179
180         dev_dbg(&tc->ntb->dev, "doorbell vec %d mask %#llx bits %#llx\n",
181                 vec, db_mask, db_bits);
182 }
183
184 static const struct ntb_ctx_ops tool_ops = {
185         .link_event = tool_link_event,
186         .db_event = tool_db_event,
187 };
188
189 static ssize_t tool_dbfn_read(struct tool_ctx *tc, char __user *ubuf,
190                               size_t size, loff_t *offp,
191                               u64 (*db_read_fn)(struct ntb_dev *))
192 {
193         size_t buf_size;
194         char *buf;
195         ssize_t pos, rc;
196
197         if (!db_read_fn)
198                 return -EINVAL;
199
200         buf_size = min_t(size_t, size, 0x20);
201
202         buf = kmalloc(buf_size, GFP_KERNEL);
203         if (!buf)
204                 return -ENOMEM;
205
206         pos = scnprintf(buf, buf_size, "%#llx\n",
207                         db_read_fn(tc->ntb));
208
209         rc = simple_read_from_buffer(ubuf, size, offp, buf, pos);
210
211         kfree(buf);
212
213         return rc;
214 }
215
216 static ssize_t tool_dbfn_write(struct tool_ctx *tc,
217                                const char __user *ubuf,
218                                size_t size, loff_t *offp,
219                                int (*db_set_fn)(struct ntb_dev *, u64),
220                                int (*db_clear_fn)(struct ntb_dev *, u64))
221 {
222         u64 db_bits;
223         char *buf, cmd;
224         ssize_t rc;
225         int n;
226
227         buf = kmalloc(size + 1, GFP_KERNEL);
228         if (!buf)
229                 return -ENOMEM;
230
231         rc = simple_write_to_buffer(buf, size, offp, ubuf, size);
232         if (rc < 0) {
233                 kfree(buf);
234                 return rc;
235         }
236
237         buf[size] = 0;
238
239         n = sscanf(buf, "%c %lli", &cmd, &db_bits);
240
241         kfree(buf);
242
243         if (n != 2) {
244                 rc = -EINVAL;
245         } else if (cmd == 's') {
246                 if (!db_set_fn)
247                         rc = -EINVAL;
248                 else
249                         rc = db_set_fn(tc->ntb, db_bits);
250         } else if (cmd == 'c') {
251                 if (!db_clear_fn)
252                         rc = -EINVAL;
253                 else
254                         rc = db_clear_fn(tc->ntb, db_bits);
255         } else {
256                 rc = -EINVAL;
257         }
258
259         return rc ? : size;
260 }
261
262 static ssize_t tool_spadfn_read(struct tool_ctx *tc, char __user *ubuf,
263                                 size_t size, loff_t *offp,
264                                 u32 (*spad_read_fn)(struct ntb_dev *, int))
265 {
266         size_t buf_size;
267         char *buf;
268         ssize_t pos, rc;
269         int i, spad_count;
270
271         if (!spad_read_fn)
272                 return -EINVAL;
273
274         spad_count = ntb_spad_count(tc->ntb);
275
276         /*
277          * We multiply the number of spads by 15 to get the buffer size
278          * this is from 3 for the %d, 10 for the largest hex value
279          * (0x00000000) and 2 for the tab and line feed.
280          */
281         buf_size = min_t(size_t, size, spad_count * 15);
282
283         buf = kmalloc(buf_size, GFP_KERNEL);
284         if (!buf)
285                 return -ENOMEM;
286
287         pos = 0;
288
289         for (i = 0; i < spad_count; ++i) {
290                 pos += scnprintf(buf + pos, buf_size - pos, "%d\t%#x\n",
291                                  i, spad_read_fn(tc->ntb, i));
292         }
293
294         rc = simple_read_from_buffer(ubuf, size, offp, buf, pos);
295
296         kfree(buf);
297
298         return rc;
299 }
300
301 static ssize_t tool_spadfn_write(struct tool_ctx *tc,
302                                  const char __user *ubuf,
303                                  size_t size, loff_t *offp,
304                                  int (*spad_write_fn)(struct ntb_dev *,
305                                                       int, u32))
306 {
307         int spad_idx;
308         u32 spad_val;
309         char *buf, *buf_ptr;
310         int pos, n;
311         ssize_t rc;
312
313         if (!spad_write_fn) {
314                 dev_dbg(&tc->ntb->dev, "no spad write fn\n");
315                 return -EINVAL;
316         }
317
318         buf = kmalloc(size + 1, GFP_KERNEL);
319         if (!buf)
320                 return -ENOMEM;
321
322         rc = simple_write_to_buffer(buf, size, offp, ubuf, size);
323         if (rc < 0) {
324                 kfree(buf);
325                 return rc;
326         }
327
328         buf[size] = 0;
329         buf_ptr = buf;
330         n = sscanf(buf_ptr, "%d %i%n", &spad_idx, &spad_val, &pos);
331         while (n == 2) {
332                 buf_ptr += pos;
333                 rc = spad_write_fn(tc->ntb, spad_idx, spad_val);
334                 if (rc)
335                         break;
336
337                 n = sscanf(buf_ptr, "%d %i%n", &spad_idx, &spad_val, &pos);
338         }
339
340         if (n < 0)
341                 rc = n;
342
343         kfree(buf);
344
345         return rc ? : size;
346 }
347
348 static ssize_t tool_db_read(struct file *filep, char __user *ubuf,
349                             size_t size, loff_t *offp)
350 {
351         struct tool_ctx *tc = filep->private_data;
352
353         return tool_dbfn_read(tc, ubuf, size, offp,
354                               tc->ntb->ops->db_read);
355 }
356
357 static ssize_t tool_db_write(struct file *filep, const char __user *ubuf,
358                              size_t size, loff_t *offp)
359 {
360         struct tool_ctx *tc = filep->private_data;
361
362         return tool_dbfn_write(tc, ubuf, size, offp,
363                                tc->ntb->ops->db_set,
364                                tc->ntb->ops->db_clear);
365 }
366
367 static TOOL_FOPS_RDWR(tool_db_fops,
368                       tool_db_read,
369                       tool_db_write);
370
371 static ssize_t tool_mask_read(struct file *filep, char __user *ubuf,
372                               size_t size, loff_t *offp)
373 {
374         struct tool_ctx *tc = filep->private_data;
375
376         return tool_dbfn_read(tc, ubuf, size, offp,
377                               tc->ntb->ops->db_read_mask);
378 }
379
380 static ssize_t tool_mask_write(struct file *filep, const char __user *ubuf,
381                                size_t size, loff_t *offp)
382 {
383         struct tool_ctx *tc = filep->private_data;
384
385         return tool_dbfn_write(tc, ubuf, size, offp,
386                                tc->ntb->ops->db_set_mask,
387                                tc->ntb->ops->db_clear_mask);
388 }
389
390 static TOOL_FOPS_RDWR(tool_mask_fops,
391                       tool_mask_read,
392                       tool_mask_write);
393
394 static ssize_t tool_peer_db_read(struct file *filep, char __user *ubuf,
395                                  size_t size, loff_t *offp)
396 {
397         struct tool_ctx *tc = filep->private_data;
398
399         return tool_dbfn_read(tc, ubuf, size, offp,
400                               tc->ntb->ops->peer_db_read);
401 }
402
403 static ssize_t tool_peer_db_write(struct file *filep, const char __user *ubuf,
404                                   size_t size, loff_t *offp)
405 {
406         struct tool_ctx *tc = filep->private_data;
407
408         return tool_dbfn_write(tc, ubuf, size, offp,
409                                tc->ntb->ops->peer_db_set,
410                                tc->ntb->ops->peer_db_clear);
411 }
412
413 static TOOL_FOPS_RDWR(tool_peer_db_fops,
414                       tool_peer_db_read,
415                       tool_peer_db_write);
416
417 static ssize_t tool_peer_mask_read(struct file *filep, char __user *ubuf,
418                                    size_t size, loff_t *offp)
419 {
420         struct tool_ctx *tc = filep->private_data;
421
422         return tool_dbfn_read(tc, ubuf, size, offp,
423                               tc->ntb->ops->peer_db_read_mask);
424 }
425
426 static ssize_t tool_peer_mask_write(struct file *filep, const char __user *ubuf,
427                                     size_t size, loff_t *offp)
428 {
429         struct tool_ctx *tc = filep->private_data;
430
431         return tool_dbfn_write(tc, ubuf, size, offp,
432                                tc->ntb->ops->peer_db_set_mask,
433                                tc->ntb->ops->peer_db_clear_mask);
434 }
435
436 static TOOL_FOPS_RDWR(tool_peer_mask_fops,
437                       tool_peer_mask_read,
438                       tool_peer_mask_write);
439
440 static ssize_t tool_spad_read(struct file *filep, char __user *ubuf,
441                               size_t size, loff_t *offp)
442 {
443         struct tool_ctx *tc = filep->private_data;
444
445         return tool_spadfn_read(tc, ubuf, size, offp,
446                                 tc->ntb->ops->spad_read);
447 }
448
449 static ssize_t tool_spad_write(struct file *filep, const char __user *ubuf,
450                                size_t size, loff_t *offp)
451 {
452         struct tool_ctx *tc = filep->private_data;
453
454         return tool_spadfn_write(tc, ubuf, size, offp,
455                                  tc->ntb->ops->spad_write);
456 }
457
458 static TOOL_FOPS_RDWR(tool_spad_fops,
459                       tool_spad_read,
460                       tool_spad_write);
461
462 static ssize_t tool_peer_spad_read(struct file *filep, char __user *ubuf,
463                                    size_t size, loff_t *offp)
464 {
465         struct tool_ctx *tc = filep->private_data;
466
467         return tool_spadfn_read(tc, ubuf, size, offp,
468                                 tc->ntb->ops->peer_spad_read);
469 }
470
471 static ssize_t tool_peer_spad_write(struct file *filep, const char __user *ubuf,
472                                     size_t size, loff_t *offp)
473 {
474         struct tool_ctx *tc = filep->private_data;
475
476         return tool_spadfn_write(tc, ubuf, size, offp,
477                                  tc->ntb->ops->peer_spad_write);
478 }
479
480 static TOOL_FOPS_RDWR(tool_peer_spad_fops,
481                       tool_peer_spad_read,
482                       tool_peer_spad_write);
483
484 static ssize_t tool_link_read(struct file *filep, char __user *ubuf,
485                               size_t size, loff_t *offp)
486 {
487         struct tool_ctx *tc = filep->private_data;
488         char buf[3];
489
490         buf[0] = ntb_link_is_up(tc->ntb, NULL, NULL) ? 'Y' : 'N';
491         buf[1] = '\n';
492         buf[2] = '\0';
493
494         return simple_read_from_buffer(ubuf, size, offp, buf, 2);
495 }
496
497 static ssize_t tool_link_write(struct file *filep, const char __user *ubuf,
498                                size_t size, loff_t *offp)
499 {
500         struct tool_ctx *tc = filep->private_data;
501         char buf[32];
502         size_t buf_size;
503         bool val;
504         int rc;
505
506         buf_size = min(size, (sizeof(buf) - 1));
507         if (copy_from_user(buf, ubuf, buf_size))
508                 return -EFAULT;
509
510         buf[buf_size] = '\0';
511
512         rc = strtobool(buf, &val);
513         if (rc)
514                 return rc;
515
516         if (val)
517                 rc = ntb_link_enable(tc->ntb, NTB_SPEED_AUTO, NTB_WIDTH_AUTO);
518         else
519                 rc = ntb_link_disable(tc->ntb);
520
521         if (rc)
522                 return rc;
523
524         return size;
525 }
526
527 static TOOL_FOPS_RDWR(tool_link_fops,
528                       tool_link_read,
529                       tool_link_write);
530
531 static ssize_t tool_link_event_write(struct file *filep,
532                                      const char __user *ubuf,
533                                      size_t size, loff_t *offp)
534 {
535         struct tool_ctx *tc = filep->private_data;
536         char buf[32];
537         size_t buf_size;
538         bool val;
539         int rc;
540
541         buf_size = min(size, (sizeof(buf) - 1));
542         if (copy_from_user(buf, ubuf, buf_size))
543                 return -EFAULT;
544
545         buf[buf_size] = '\0';
546
547         rc = strtobool(buf, &val);
548         if (rc)
549                 return rc;
550
551         if (wait_event_interruptible(tc->link_wq,
552                 ntb_link_is_up(tc->ntb, NULL, NULL) == val))
553                 return -ERESTART;
554
555         return size;
556 }
557
558 static TOOL_FOPS_RDWR(tool_link_event_fops,
559                       NULL,
560                       tool_link_event_write);
561
562 static ssize_t tool_mw_read(struct file *filep, char __user *ubuf,
563                             size_t size, loff_t *offp)
564 {
565         struct tool_mw *mw = filep->private_data;
566         ssize_t rc;
567         loff_t pos = *offp;
568         void *buf;
569
570         if (mw->local == NULL)
571                 return -EIO;
572         if (pos < 0)
573                 return -EINVAL;
574         if (pos >= mw->win_size || !size)
575                 return 0;
576         if (size > mw->win_size - pos)
577                 size = mw->win_size - pos;
578
579         buf = kmalloc(size, GFP_KERNEL);
580         if (!buf)
581                 return -ENOMEM;
582
583         memcpy_fromio(buf, mw->local + pos, size);
584         rc = copy_to_user(ubuf, buf, size);
585         if (rc == size) {
586                 rc = -EFAULT;
587                 goto err_free;
588         }
589
590         size -= rc;
591         *offp = pos + size;
592         rc = size;
593
594 err_free:
595         kfree(buf);
596
597         return rc;
598 }
599
600 static ssize_t tool_mw_write(struct file *filep, const char __user *ubuf,
601                              size_t size, loff_t *offp)
602 {
603         struct tool_mw *mw = filep->private_data;
604         ssize_t rc;
605         loff_t pos = *offp;
606         void *buf;
607
608         if (pos < 0)
609                 return -EINVAL;
610         if (pos >= mw->win_size || !size)
611                 return 0;
612         if (size > mw->win_size - pos)
613                 size = mw->win_size - pos;
614
615         buf = kmalloc(size, GFP_KERNEL);
616         if (!buf)
617                 return -ENOMEM;
618
619         rc = copy_from_user(buf, ubuf, size);
620         if (rc == size) {
621                 rc = -EFAULT;
622                 goto err_free;
623         }
624
625         size -= rc;
626         *offp = pos + size;
627         rc = size;
628
629         memcpy_toio(mw->local + pos, buf, size);
630
631 err_free:
632         kfree(buf);
633
634         return rc;
635 }
636
637 static TOOL_FOPS_RDWR(tool_mw_fops,
638                       tool_mw_read,
639                       tool_mw_write);
640
641 static ssize_t tool_peer_mw_read(struct file *filep, char __user *ubuf,
642                                  size_t size, loff_t *offp)
643 {
644         struct tool_mw *mw = filep->private_data;
645
646         if (!mw->peer)
647                 return -ENXIO;
648
649         return simple_read_from_buffer(ubuf, size, offp, mw->peer, mw->size);
650 }
651
652 static ssize_t tool_peer_mw_write(struct file *filep, const char __user *ubuf,
653                                   size_t size, loff_t *offp)
654 {
655         struct tool_mw *mw = filep->private_data;
656
657         if (!mw->peer)
658                 return -ENXIO;
659
660         return simple_write_to_buffer(mw->peer, mw->size, offp, ubuf, size);
661 }
662
663 static TOOL_FOPS_RDWR(tool_peer_mw_fops,
664                       tool_peer_mw_read,
665                       tool_peer_mw_write);
666
667 static int tool_setup_mw(struct tool_ctx *tc, int idx, size_t req_size)
668 {
669         int rc;
670         struct tool_mw *mw = &tc->mws[idx];
671         phys_addr_t base;
672         resource_size_t size, align, align_size;
673         char buf[16];
674
675         if (mw->peer)
676                 return 0;
677
678         rc = ntb_mw_get_range(tc->ntb, idx, &base, &size, &align,
679                               &align_size);
680         if (rc)
681                 return rc;
682
683         mw->size = min_t(resource_size_t, req_size, size);
684         mw->size = round_up(mw->size, align);
685         mw->size = round_up(mw->size, align_size);
686         mw->peer = dma_alloc_coherent(&tc->ntb->pdev->dev, mw->size,
687                                       &mw->peer_dma, GFP_KERNEL);
688
689         if (!mw->peer)
690                 return -ENOMEM;
691
692         rc = ntb_mw_set_trans(tc->ntb, idx, mw->peer_dma, mw->size);
693         if (rc)
694                 goto err_free_dma;
695
696         snprintf(buf, sizeof(buf), "peer_mw%d", idx);
697         mw->peer_dbg_file = debugfs_create_file(buf, S_IRUSR | S_IWUSR,
698                                                 mw->tc->dbgfs, mw,
699                                                 &tool_peer_mw_fops);
700
701         return 0;
702
703 err_free_dma:
704         dma_free_coherent(&tc->ntb->pdev->dev, mw->size,
705                           mw->peer,
706                           mw->peer_dma);
707         mw->peer = NULL;
708         mw->peer_dma = 0;
709         mw->size = 0;
710
711         return rc;
712 }
713
714 static void tool_free_mw(struct tool_ctx *tc, int idx)
715 {
716         struct tool_mw *mw = &tc->mws[idx];
717
718         if (mw->peer) {
719                 ntb_mw_clear_trans(tc->ntb, idx);
720                 dma_free_coherent(&tc->ntb->pdev->dev, mw->size,
721                                   mw->peer,
722                                   mw->peer_dma);
723         }
724
725         mw->peer = NULL;
726         mw->peer_dma = 0;
727
728         debugfs_remove(mw->peer_dbg_file);
729
730         mw->peer_dbg_file = NULL;
731 }
732
733 static ssize_t tool_peer_mw_trans_read(struct file *filep,
734                                        char __user *ubuf,
735                                        size_t size, loff_t *offp)
736 {
737         struct tool_mw *mw = filep->private_data;
738
739         char *buf;
740         size_t buf_size;
741         ssize_t ret, off = 0;
742
743         phys_addr_t base;
744         resource_size_t mw_size;
745         resource_size_t align;
746         resource_size_t align_size;
747
748         buf_size = min_t(size_t, size, 512);
749
750         buf = kmalloc(buf_size, GFP_KERNEL);
751         if (!buf)
752                 return -ENOMEM;
753
754         ntb_mw_get_range(mw->tc->ntb, mw->idx,
755                          &base, &mw_size, &align, &align_size);
756
757         off += scnprintf(buf + off, buf_size - off,
758                          "Peer MW %d Information:\n", mw->idx);
759
760         off += scnprintf(buf + off, buf_size - off,
761                          "Physical Address      \t%pa[p]\n",
762                          &base);
763
764         off += scnprintf(buf + off, buf_size - off,
765                          "Window Size           \t%lld\n",
766                          (unsigned long long)mw_size);
767
768         off += scnprintf(buf + off, buf_size - off,
769                          "Alignment             \t%lld\n",
770                          (unsigned long long)align);
771
772         off += scnprintf(buf + off, buf_size - off,
773                          "Size Alignment        \t%lld\n",
774                          (unsigned long long)align_size);
775
776         off += scnprintf(buf + off, buf_size - off,
777                          "Ready                 \t%c\n",
778                          (mw->peer) ? 'Y' : 'N');
779
780         off += scnprintf(buf + off, buf_size - off,
781                          "Allocated Size       \t%zd\n",
782                          (mw->peer) ? (size_t)mw->size : 0);
783
784         ret = simple_read_from_buffer(ubuf, size, offp, buf, off);
785         kfree(buf);
786         return ret;
787 }
788
789 static ssize_t tool_peer_mw_trans_write(struct file *filep,
790                                         const char __user *ubuf,
791                                         size_t size, loff_t *offp)
792 {
793         struct tool_mw *mw = filep->private_data;
794
795         char buf[32];
796         size_t buf_size;
797         unsigned long long val;
798         int rc;
799
800         buf_size = min(size, (sizeof(buf) - 1));
801         if (copy_from_user(buf, ubuf, buf_size))
802                 return -EFAULT;
803
804         buf[buf_size] = '\0';
805
806         rc = kstrtoull(buf, 0, &val);
807         if (rc)
808                 return rc;
809
810         tool_free_mw(mw->tc, mw->idx);
811         if (val)
812                 rc = tool_setup_mw(mw->tc, mw->idx, val);
813
814         if (rc)
815                 return rc;
816
817         return size;
818 }
819
820 static TOOL_FOPS_RDWR(tool_peer_mw_trans_fops,
821                       tool_peer_mw_trans_read,
822                       tool_peer_mw_trans_write);
823
824 static int tool_init_mw(struct tool_ctx *tc, int idx)
825 {
826         struct tool_mw *mw = &tc->mws[idx];
827         phys_addr_t base;
828         int rc;
829
830         rc = ntb_mw_get_range(tc->ntb, idx, &base, &mw->win_size,
831                               NULL, NULL);
832         if (rc)
833                 return rc;
834
835         mw->tc = tc;
836         mw->idx = idx;
837         mw->local = ioremap_wc(base, mw->win_size);
838         if (!mw->local)
839                 return -EFAULT;
840
841         return 0;
842 }
843
844 static void tool_free_mws(struct tool_ctx *tc)
845 {
846         int i;
847
848         for (i = 0; i < tc->mw_count; i++) {
849                 tool_free_mw(tc, i);
850
851                 if (tc->mws[i].local)
852                         iounmap(tc->mws[i].local);
853
854                 tc->mws[i].local = NULL;
855         }
856 }
857
858 static void tool_setup_dbgfs(struct tool_ctx *tc)
859 {
860         int i;
861
862         /* This modules is useless without dbgfs... */
863         if (!tool_dbgfs) {
864                 tc->dbgfs = NULL;
865                 return;
866         }
867
868         tc->dbgfs = debugfs_create_dir(dev_name(&tc->ntb->dev),
869                                        tool_dbgfs);
870         if (!tc->dbgfs)
871                 return;
872
873         debugfs_create_file("db", S_IRUSR | S_IWUSR, tc->dbgfs,
874                             tc, &tool_db_fops);
875
876         debugfs_create_file("mask", S_IRUSR | S_IWUSR, tc->dbgfs,
877                             tc, &tool_mask_fops);
878
879         debugfs_create_file("peer_db", S_IRUSR | S_IWUSR, tc->dbgfs,
880                             tc, &tool_peer_db_fops);
881
882         debugfs_create_file("peer_mask", S_IRUSR | S_IWUSR, tc->dbgfs,
883                             tc, &tool_peer_mask_fops);
884
885         debugfs_create_file("spad", S_IRUSR | S_IWUSR, tc->dbgfs,
886                             tc, &tool_spad_fops);
887
888         debugfs_create_file("peer_spad", S_IRUSR | S_IWUSR, tc->dbgfs,
889                             tc, &tool_peer_spad_fops);
890
891         debugfs_create_file("link", S_IRUSR | S_IWUSR, tc->dbgfs,
892                             tc, &tool_link_fops);
893
894         debugfs_create_file("link_event", S_IWUSR, tc->dbgfs,
895                             tc, &tool_link_event_fops);
896
897         for (i = 0; i < tc->mw_count; i++) {
898                 char buf[30];
899
900                 snprintf(buf, sizeof(buf), "mw%d", i);
901                 debugfs_create_file(buf, S_IRUSR | S_IWUSR, tc->dbgfs,
902                                     &tc->mws[i], &tool_mw_fops);
903
904                 snprintf(buf, sizeof(buf), "peer_trans%d", i);
905                 debugfs_create_file(buf, S_IRUSR | S_IWUSR, tc->dbgfs,
906                                     &tc->mws[i], &tool_peer_mw_trans_fops);
907         }
908 }
909
910 static int tool_probe(struct ntb_client *self, struct ntb_dev *ntb)
911 {
912         struct tool_ctx *tc;
913         int rc;
914         int i;
915
916         if (ntb_db_is_unsafe(ntb))
917                 dev_dbg(&ntb->dev, "doorbell is unsafe\n");
918
919         if (ntb_spad_is_unsafe(ntb))
920                 dev_dbg(&ntb->dev, "scratchpad is unsafe\n");
921
922         tc = kzalloc(sizeof(*tc), GFP_KERNEL);
923         if (!tc) {
924                 rc = -ENOMEM;
925                 goto err_tc;
926         }
927
928         tc->ntb = ntb;
929         init_waitqueue_head(&tc->link_wq);
930
931         tc->mw_count = min(ntb_mw_count(tc->ntb), MAX_MWS);
932         for (i = 0; i < tc->mw_count; i++) {
933                 rc = tool_init_mw(tc, i);
934                 if (rc)
935                         goto err_ctx;
936         }
937
938         tool_setup_dbgfs(tc);
939
940         rc = ntb_set_ctx(ntb, tc, &tool_ops);
941         if (rc)
942                 goto err_ctx;
943
944         ntb_link_enable(ntb, NTB_SPEED_AUTO, NTB_WIDTH_AUTO);
945         ntb_link_event(ntb);
946
947         return 0;
948
949 err_ctx:
950         tool_free_mws(tc);
951         debugfs_remove_recursive(tc->dbgfs);
952         kfree(tc);
953 err_tc:
954         return rc;
955 }
956
957 static void tool_remove(struct ntb_client *self, struct ntb_dev *ntb)
958 {
959         struct tool_ctx *tc = ntb->ctx;
960
961         tool_free_mws(tc);
962
963         ntb_clear_ctx(ntb);
964         ntb_link_disable(ntb);
965
966         debugfs_remove_recursive(tc->dbgfs);
967         kfree(tc);
968 }
969
970 static struct ntb_client tool_client = {
971         .ops = {
972                 .probe = tool_probe,
973                 .remove = tool_remove,
974         },
975 };
976
977 static int __init tool_init(void)
978 {
979         int rc;
980
981         if (debugfs_initialized())
982                 tool_dbgfs = debugfs_create_dir(KBUILD_MODNAME, NULL);
983
984         rc = ntb_register_client(&tool_client);
985         if (rc)
986                 goto err_client;
987
988         return 0;
989
990 err_client:
991         debugfs_remove_recursive(tool_dbgfs);
992         return rc;
993 }
994 module_init(tool_init);
995
996 static void __exit tool_exit(void)
997 {
998         ntb_unregister_client(&tool_client);
999         debugfs_remove_recursive(tool_dbgfs);
1000 }
1001 module_exit(tool_exit);