Merge tag 'pstore-v4.8-rc1' of git://git.kernel.org/pub/scm/linux/kernel/git/kees...
[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  * # Set the doorbell mask
63  * root@self# echo 's 1' > $DBG_DIR/mask
64  *
65  * # Ring the doorbell from the peer
66  * root@peer# echo 's 1' > $DBG_DIR/peer_db
67  *
68  * # Clear the doorbell mask
69  * root@self# echo 'c 1' > $DBG_DIR/mask
70  *
71  * Observe debugging output in dmesg or your console.  You should see a
72  * doorbell event triggered by clearing the mask.  If not, this may indicate an
73  * issue with the hardware that needs to be worked around in the driver.
74  *
75  * Eg: read and write scratchpad registers
76  *
77  * root@peer# echo '0 0x01010101 1 0x7f7f7f7f' > $DBG_DIR/peer_spad
78  *
79  * root@self# cat $DBG_DIR/spad
80  *
81  * Observe that spad 0 and 1 have the values set by the peer.
82  */
83
84 #include <linux/init.h>
85 #include <linux/kernel.h>
86 #include <linux/module.h>
87
88 #include <linux/debugfs.h>
89 #include <linux/dma-mapping.h>
90 #include <linux/pci.h>
91 #include <linux/slab.h>
92
93 #include <linux/ntb.h>
94
95 #define DRIVER_NAME                     "ntb_tool"
96 #define DRIVER_DESCRIPTION              "PCIe NTB Debugging Tool"
97
98 #define DRIVER_LICENSE                  "Dual BSD/GPL"
99 #define DRIVER_VERSION                  "1.0"
100 #define DRIVER_RELDATE                  "22 April 2015"
101 #define DRIVER_AUTHOR                   "Allen Hubbe <Allen.Hubbe@emc.com>"
102
103 MODULE_LICENSE(DRIVER_LICENSE);
104 MODULE_VERSION(DRIVER_VERSION);
105 MODULE_AUTHOR(DRIVER_AUTHOR);
106 MODULE_DESCRIPTION(DRIVER_DESCRIPTION);
107
108 static struct dentry *tool_dbgfs;
109
110 struct tool_ctx {
111         struct ntb_dev *ntb;
112         struct dentry *dbgfs;
113 };
114
115 #define SPAD_FNAME_SIZE 0x10
116 #define INT_PTR(x) ((void *)(unsigned long)x)
117 #define PTR_INT(x) ((int)(unsigned long)x)
118
119 #define TOOL_FOPS_RDWR(__name, __read, __write) \
120         const struct file_operations __name = { \
121                 .owner = THIS_MODULE,           \
122                 .open = simple_open,            \
123                 .read = __read,                 \
124                 .write = __write,               \
125         }
126
127 static void tool_link_event(void *ctx)
128 {
129         struct tool_ctx *tc = ctx;
130         enum ntb_speed speed;
131         enum ntb_width width;
132         int up;
133
134         up = ntb_link_is_up(tc->ntb, &speed, &width);
135
136         dev_dbg(&tc->ntb->dev, "link is %s speed %d width %d\n",
137                 up ? "up" : "down", speed, width);
138 }
139
140 static void tool_db_event(void *ctx, int vec)
141 {
142         struct tool_ctx *tc = ctx;
143         u64 db_bits, db_mask;
144
145         db_mask = ntb_db_vector_mask(tc->ntb, vec);
146         db_bits = ntb_db_read(tc->ntb);
147
148         dev_dbg(&tc->ntb->dev, "doorbell vec %d mask %#llx bits %#llx\n",
149                 vec, db_mask, db_bits);
150 }
151
152 static const struct ntb_ctx_ops tool_ops = {
153         .link_event = tool_link_event,
154         .db_event = tool_db_event,
155 };
156
157 static ssize_t tool_dbfn_read(struct tool_ctx *tc, char __user *ubuf,
158                               size_t size, loff_t *offp,
159                               u64 (*db_read_fn)(struct ntb_dev *))
160 {
161         size_t buf_size;
162         char *buf;
163         ssize_t pos, rc;
164
165         if (!db_read_fn)
166                 return -EINVAL;
167
168         buf_size = min_t(size_t, size, 0x20);
169
170         buf = kmalloc(buf_size, GFP_KERNEL);
171         if (!buf)
172                 return -ENOMEM;
173
174         pos = scnprintf(buf, buf_size, "%#llx\n",
175                         db_read_fn(tc->ntb));
176
177         rc = simple_read_from_buffer(ubuf, size, offp, buf, pos);
178
179         kfree(buf);
180
181         return rc;
182 }
183
184 static ssize_t tool_dbfn_write(struct tool_ctx *tc,
185                                const char __user *ubuf,
186                                size_t size, loff_t *offp,
187                                int (*db_set_fn)(struct ntb_dev *, u64),
188                                int (*db_clear_fn)(struct ntb_dev *, u64))
189 {
190         u64 db_bits;
191         char *buf, cmd;
192         ssize_t rc;
193         int n;
194
195         buf = kmalloc(size + 1, GFP_KERNEL);
196         if (!buf)
197                 return -ENOMEM;
198
199         rc = simple_write_to_buffer(buf, size, offp, ubuf, size);
200         if (rc < 0) {
201                 kfree(buf);
202                 return rc;
203         }
204
205         buf[size] = 0;
206
207         n = sscanf(buf, "%c %lli", &cmd, &db_bits);
208
209         kfree(buf);
210
211         if (n != 2) {
212                 rc = -EINVAL;
213         } else if (cmd == 's') {
214                 if (!db_set_fn)
215                         rc = -EINVAL;
216                 else
217                         rc = db_set_fn(tc->ntb, db_bits);
218         } else if (cmd == 'c') {
219                 if (!db_clear_fn)
220                         rc = -EINVAL;
221                 else
222                         rc = db_clear_fn(tc->ntb, db_bits);
223         } else {
224                 rc = -EINVAL;
225         }
226
227         return rc ? : size;
228 }
229
230 static ssize_t tool_spadfn_read(struct tool_ctx *tc, char __user *ubuf,
231                                 size_t size, loff_t *offp,
232                                 u32 (*spad_read_fn)(struct ntb_dev *, int))
233 {
234         size_t buf_size;
235         char *buf;
236         ssize_t pos, rc;
237         int i, spad_count;
238
239         if (!spad_read_fn)
240                 return -EINVAL;
241
242         buf_size = min_t(size_t, size, 0x100);
243
244         buf = kmalloc(buf_size, GFP_KERNEL);
245         if (!buf)
246                 return -ENOMEM;
247
248         pos = 0;
249
250         spad_count = ntb_spad_count(tc->ntb);
251         for (i = 0; i < spad_count; ++i) {
252                 pos += scnprintf(buf + pos, buf_size - pos, "%d\t%#x\n",
253                                  i, spad_read_fn(tc->ntb, i));
254         }
255
256         rc = simple_read_from_buffer(ubuf, size, offp, buf, pos);
257
258         kfree(buf);
259
260         return rc;
261 }
262
263 static ssize_t tool_spadfn_write(struct tool_ctx *tc,
264                                  const char __user *ubuf,
265                                  size_t size, loff_t *offp,
266                                  int (*spad_write_fn)(struct ntb_dev *,
267                                                       int, u32))
268 {
269         int spad_idx;
270         u32 spad_val;
271         char *buf;
272         int pos, n;
273         ssize_t rc;
274
275         if (!spad_write_fn) {
276                 dev_dbg(&tc->ntb->dev, "no spad write fn\n");
277                 return -EINVAL;
278         }
279
280         buf = kmalloc(size + 1, GFP_KERNEL);
281         if (!buf)
282                 return -ENOMEM;
283
284         rc = simple_write_to_buffer(buf, size, offp, ubuf, size);
285         if (rc < 0) {
286                 kfree(buf);
287                 return rc;
288         }
289
290         buf[size] = 0;
291
292         n = sscanf(buf, "%d %i%n", &spad_idx, &spad_val, &pos);
293         while (n == 2) {
294                 rc = spad_write_fn(tc->ntb, spad_idx, spad_val);
295                 if (rc)
296                         break;
297
298                 n = sscanf(buf + pos, "%d %i%n", &spad_idx, &spad_val, &pos);
299         }
300
301         if (n < 0)
302                 rc = n;
303
304         kfree(buf);
305
306         return rc ? : size;
307 }
308
309 static ssize_t tool_db_read(struct file *filep, char __user *ubuf,
310                             size_t size, loff_t *offp)
311 {
312         struct tool_ctx *tc = filep->private_data;
313
314         return tool_dbfn_read(tc, ubuf, size, offp,
315                               tc->ntb->ops->db_read);
316 }
317
318 static ssize_t tool_db_write(struct file *filep, const char __user *ubuf,
319                              size_t size, loff_t *offp)
320 {
321         struct tool_ctx *tc = filep->private_data;
322
323         return tool_dbfn_write(tc, ubuf, size, offp,
324                                tc->ntb->ops->db_set,
325                                tc->ntb->ops->db_clear);
326 }
327
328 static TOOL_FOPS_RDWR(tool_db_fops,
329                       tool_db_read,
330                       tool_db_write);
331
332 static ssize_t tool_mask_read(struct file *filep, char __user *ubuf,
333                               size_t size, loff_t *offp)
334 {
335         struct tool_ctx *tc = filep->private_data;
336
337         return tool_dbfn_read(tc, ubuf, size, offp,
338                               tc->ntb->ops->db_read_mask);
339 }
340
341 static ssize_t tool_mask_write(struct file *filep, const char __user *ubuf,
342                                size_t size, loff_t *offp)
343 {
344         struct tool_ctx *tc = filep->private_data;
345
346         return tool_dbfn_write(tc, ubuf, size, offp,
347                                tc->ntb->ops->db_set_mask,
348                                tc->ntb->ops->db_clear_mask);
349 }
350
351 static TOOL_FOPS_RDWR(tool_mask_fops,
352                       tool_mask_read,
353                       tool_mask_write);
354
355 static ssize_t tool_peer_db_read(struct file *filep, char __user *ubuf,
356                                  size_t size, loff_t *offp)
357 {
358         struct tool_ctx *tc = filep->private_data;
359
360         return tool_dbfn_read(tc, ubuf, size, offp,
361                               tc->ntb->ops->peer_db_read);
362 }
363
364 static ssize_t tool_peer_db_write(struct file *filep, const char __user *ubuf,
365                                   size_t size, loff_t *offp)
366 {
367         struct tool_ctx *tc = filep->private_data;
368
369         return tool_dbfn_write(tc, ubuf, size, offp,
370                                tc->ntb->ops->peer_db_set,
371                                tc->ntb->ops->peer_db_clear);
372 }
373
374 static TOOL_FOPS_RDWR(tool_peer_db_fops,
375                       tool_peer_db_read,
376                       tool_peer_db_write);
377
378 static ssize_t tool_peer_mask_read(struct file *filep, char __user *ubuf,
379                                    size_t size, loff_t *offp)
380 {
381         struct tool_ctx *tc = filep->private_data;
382
383         return tool_dbfn_read(tc, ubuf, size, offp,
384                               tc->ntb->ops->peer_db_read_mask);
385 }
386
387 static ssize_t tool_peer_mask_write(struct file *filep, const char __user *ubuf,
388                                     size_t size, loff_t *offp)
389 {
390         struct tool_ctx *tc = filep->private_data;
391
392         return tool_dbfn_write(tc, ubuf, size, offp,
393                                tc->ntb->ops->peer_db_set_mask,
394                                tc->ntb->ops->peer_db_clear_mask);
395 }
396
397 static TOOL_FOPS_RDWR(tool_peer_mask_fops,
398                       tool_peer_mask_read,
399                       tool_peer_mask_write);
400
401 static ssize_t tool_spad_read(struct file *filep, char __user *ubuf,
402                               size_t size, loff_t *offp)
403 {
404         struct tool_ctx *tc = filep->private_data;
405
406         return tool_spadfn_read(tc, ubuf, size, offp,
407                                 tc->ntb->ops->spad_read);
408 }
409
410 static ssize_t tool_spad_write(struct file *filep, const char __user *ubuf,
411                                size_t size, loff_t *offp)
412 {
413         struct tool_ctx *tc = filep->private_data;
414
415         return tool_spadfn_write(tc, ubuf, size, offp,
416                                  tc->ntb->ops->spad_write);
417 }
418
419 static TOOL_FOPS_RDWR(tool_spad_fops,
420                       tool_spad_read,
421                       tool_spad_write);
422
423 static ssize_t tool_peer_spad_read(struct file *filep, char __user *ubuf,
424                                    size_t size, loff_t *offp)
425 {
426         struct tool_ctx *tc = filep->private_data;
427
428         return tool_spadfn_read(tc, ubuf, size, offp,
429                                 tc->ntb->ops->peer_spad_read);
430 }
431
432 static ssize_t tool_peer_spad_write(struct file *filep, const char __user *ubuf,
433                                     size_t size, loff_t *offp)
434 {
435         struct tool_ctx *tc = filep->private_data;
436
437         return tool_spadfn_write(tc, ubuf, size, offp,
438                                  tc->ntb->ops->peer_spad_write);
439 }
440
441 static TOOL_FOPS_RDWR(tool_peer_spad_fops,
442                       tool_peer_spad_read,
443                       tool_peer_spad_write);
444
445 static void tool_setup_dbgfs(struct tool_ctx *tc)
446 {
447         /* This modules is useless without dbgfs... */
448         if (!tool_dbgfs) {
449                 tc->dbgfs = NULL;
450                 return;
451         }
452
453         tc->dbgfs = debugfs_create_dir(dev_name(&tc->ntb->dev),
454                                        tool_dbgfs);
455         if (!tc->dbgfs)
456                 return;
457
458         debugfs_create_file("db", S_IRUSR | S_IWUSR, tc->dbgfs,
459                             tc, &tool_db_fops);
460
461         debugfs_create_file("mask", S_IRUSR | S_IWUSR, tc->dbgfs,
462                             tc, &tool_mask_fops);
463
464         debugfs_create_file("peer_db", S_IRUSR | S_IWUSR, tc->dbgfs,
465                             tc, &tool_peer_db_fops);
466
467         debugfs_create_file("peer_mask", S_IRUSR | S_IWUSR, tc->dbgfs,
468                             tc, &tool_peer_mask_fops);
469
470         debugfs_create_file("spad", S_IRUSR | S_IWUSR, tc->dbgfs,
471                             tc, &tool_spad_fops);
472
473         debugfs_create_file("peer_spad", S_IRUSR | S_IWUSR, tc->dbgfs,
474                             tc, &tool_peer_spad_fops);
475 }
476
477 static int tool_probe(struct ntb_client *self, struct ntb_dev *ntb)
478 {
479         struct tool_ctx *tc;
480         int rc;
481
482         if (ntb_db_is_unsafe(ntb))
483                 dev_dbg(&ntb->dev, "doorbell is unsafe\n");
484
485         if (ntb_spad_is_unsafe(ntb))
486                 dev_dbg(&ntb->dev, "scratchpad is unsafe\n");
487
488         tc = kmalloc(sizeof(*tc), GFP_KERNEL);
489         if (!tc) {
490                 rc = -ENOMEM;
491                 goto err_tc;
492         }
493
494         tc->ntb = ntb;
495
496         tool_setup_dbgfs(tc);
497
498         rc = ntb_set_ctx(ntb, tc, &tool_ops);
499         if (rc)
500                 goto err_ctx;
501
502         ntb_link_enable(ntb, NTB_SPEED_AUTO, NTB_WIDTH_AUTO);
503         ntb_link_event(ntb);
504
505         return 0;
506
507 err_ctx:
508         debugfs_remove_recursive(tc->dbgfs);
509         kfree(tc);
510 err_tc:
511         return rc;
512 }
513
514 static void tool_remove(struct ntb_client *self, struct ntb_dev *ntb)
515 {
516         struct tool_ctx *tc = ntb->ctx;
517
518         ntb_clear_ctx(ntb);
519         ntb_link_disable(ntb);
520
521         debugfs_remove_recursive(tc->dbgfs);
522         kfree(tc);
523 }
524
525 static struct ntb_client tool_client = {
526         .ops = {
527                 .probe = tool_probe,
528                 .remove = tool_remove,
529         },
530 };
531
532 static int __init tool_init(void)
533 {
534         int rc;
535
536         if (debugfs_initialized())
537                 tool_dbgfs = debugfs_create_dir(KBUILD_MODNAME, NULL);
538
539         rc = ntb_register_client(&tool_client);
540         if (rc)
541                 goto err_client;
542
543         return 0;
544
545 err_client:
546         debugfs_remove_recursive(tool_dbgfs);
547         return rc;
548 }
549 module_init(tool_init);
550
551 static void __exit tool_exit(void)
552 {
553         ntb_unregister_client(&tool_client);
554         debugfs_remove_recursive(tool_dbgfs);
555 }
556 module_exit(tool_exit);