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, *buf_ptr;
 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         buf_ptr = buf;
 292         n = sscanf(buf_ptr, "%d %i%n", &spad_idx, &spad_val, &pos);
 293         while (n == 2) {
 294                 buf_ptr += pos;
 295                 rc = spad_write_fn(tc->ntb, spad_idx, spad_val);
 296                 if (rc)
 297                         break;
 298
 299                 n = sscanf(buf_ptr, "%d %i%n", &spad_idx, &spad_val, &pos);
 300         }
 301
 302         if (n < 0)
 303                 rc = n;
 304
 305         kfree(buf);
 306
 307         return rc ? : size;
 308 }
 309
 310 static ssize_t tool_db_read(struct file *filep, char __user *ubuf,
 311                             size_t size, loff_t *offp)
 312 {
 313         struct tool_ctx *tc = filep->private_data;
 314
 315         return tool_dbfn_read(tc, ubuf, size, offp,
 316                               tc->ntb->ops->db_read);
 317 }
 318
 319 static ssize_t tool_db_write(struct file *filep, const char __user *ubuf,
 320                              size_t size, loff_t *offp)
 321 {
 322         struct tool_ctx *tc = filep->private_data;
 323
 324         return tool_dbfn_write(tc, ubuf, size, offp,
 325                                tc->ntb->ops->db_set,
 326                                tc->ntb->ops->db_clear);
 327 }
 328
 329 static TOOL_FOPS_RDWR(tool_db_fops,
 330                       tool_db_read,
 331                       tool_db_write);
 332
 333 static ssize_t tool_mask_read(struct file *filep, char __user *ubuf,
 334                               size_t size, loff_t *offp)
 335 {
 336         struct tool_ctx *tc = filep->private_data;
 337
 338         return tool_dbfn_read(tc, ubuf, size, offp,
 339                               tc->ntb->ops->db_read_mask);
 340 }
 341
 342 static ssize_t tool_mask_write(struct file *filep, const char __user *ubuf,
 343                                size_t size, loff_t *offp)
 344 {
 345         struct tool_ctx *tc = filep->private_data;
 346
 347         return tool_dbfn_write(tc, ubuf, size, offp,
 348                                tc->ntb->ops->db_set_mask,
 349                                tc->ntb->ops->db_clear_mask);
 350 }
 351
 352 static TOOL_FOPS_RDWR(tool_mask_fops,
 353                       tool_mask_read,
 354                       tool_mask_write);
 355
 356 static ssize_t tool_peer_db_read(struct file *filep, char __user *ubuf,
 357                                  size_t size, loff_t *offp)
 358 {
 359         struct tool_ctx *tc = filep->private_data;
 360
 361         return tool_dbfn_read(tc, ubuf, size, offp,
 362                               tc->ntb->ops->peer_db_read);
 363 }
 364
 365 static ssize_t tool_peer_db_write(struct file *filep, const char __user *ubuf,
 366                                   size_t size, loff_t *offp)
 367 {
 368         struct tool_ctx *tc = filep->private_data;
 369
 370         return tool_dbfn_write(tc, ubuf, size, offp,
 371                                tc->ntb->ops->peer_db_set,
 372                                tc->ntb->ops->peer_db_clear);
 373 }
 374
 375 static TOOL_FOPS_RDWR(tool_peer_db_fops,
 376                       tool_peer_db_read,
 377                       tool_peer_db_write);
 378
 379 static ssize_t tool_peer_mask_read(struct file *filep, char __user *ubuf,
 380                                    size_t size, loff_t *offp)
 381 {
 382         struct tool_ctx *tc = filep->private_data;
 383
 384         return tool_dbfn_read(tc, ubuf, size, offp,
 385                               tc->ntb->ops->peer_db_read_mask);
 386 }
 387
 388 static ssize_t tool_peer_mask_write(struct file *filep, const char __user *ubuf,
 389                                     size_t size, loff_t *offp)
 390 {
 391         struct tool_ctx *tc = filep->private_data;
 392
 393         return tool_dbfn_write(tc, ubuf, size, offp,
 394                                tc->ntb->ops->peer_db_set_mask,
 395                                tc->ntb->ops->peer_db_clear_mask);
 396 }
 397
 398 static TOOL_FOPS_RDWR(tool_peer_mask_fops,
 399                       tool_peer_mask_read,
 400                       tool_peer_mask_write);
 401
 402 static ssize_t tool_spad_read(struct file *filep, char __user *ubuf,
 403                               size_t size, loff_t *offp)
 404 {
 405         struct tool_ctx *tc = filep->private_data;
 406
 407         return tool_spadfn_read(tc, ubuf, size, offp,
 408                                 tc->ntb->ops->spad_read);
 409 }
 410
 411 static ssize_t tool_spad_write(struct file *filep, const char __user *ubuf,
 412                                size_t size, loff_t *offp)
 413 {
 414         struct tool_ctx *tc = filep->private_data;
 415
 416         return tool_spadfn_write(tc, ubuf, size, offp,
 417                                  tc->ntb->ops->spad_write);
 418 }
 419
 420 static TOOL_FOPS_RDWR(tool_spad_fops,
 421                       tool_spad_read,
 422                       tool_spad_write);
 423
 424 static ssize_t tool_peer_spad_read(struct file *filep, char __user *ubuf,
 425                                    size_t size, loff_t *offp)
 426 {
 427         struct tool_ctx *tc = filep->private_data;
 428
 429         return tool_spadfn_read(tc, ubuf, size, offp,
 430                                 tc->ntb->ops->peer_spad_read);
 431 }
 432
 433 static ssize_t tool_peer_spad_write(struct file *filep, const char __user *ubuf,
 434                                     size_t size, loff_t *offp)
 435 {
 436         struct tool_ctx *tc = filep->private_data;
 437
 438         return tool_spadfn_write(tc, ubuf, size, offp,
 439                                  tc->ntb->ops->peer_spad_write);
 440 }
 441
 442 static TOOL_FOPS_RDWR(tool_peer_spad_fops,
 443                       tool_peer_spad_read,
 444                       tool_peer_spad_write);
 445
 446 static void tool_setup_dbgfs(struct tool_ctx *tc)
 447 {
 448         /* This modules is useless without dbgfs... */
 449         if (!tool_dbgfs) {
 450                 tc->dbgfs = NULL;
 451                 return;
 452         }
 453
 454         tc->dbgfs = debugfs_create_dir(dev_name(&tc->ntb->dev),
 455                                        tool_dbgfs);
 456         if (!tc->dbgfs)
 457                 return;
 458
 459         debugfs_create_file("db", S_IRUSR | S_IWUSR, tc->dbgfs,
 460                             tc, &tool_db_fops);
 461
 462         debugfs_create_file("mask", S_IRUSR | S_IWUSR, tc->dbgfs,
 463                             tc, &tool_mask_fops);
 464
 465         debugfs_create_file("peer_db", S_IRUSR | S_IWUSR, tc->dbgfs,
 466                             tc, &tool_peer_db_fops);
 467
 468         debugfs_create_file("peer_mask", S_IRUSR | S_IWUSR, tc->dbgfs,
 469                             tc, &tool_peer_mask_fops);
 470
 471         debugfs_create_file("spad", S_IRUSR | S_IWUSR, tc->dbgfs,
 472                             tc, &tool_spad_fops);
 473
 474         debugfs_create_file("peer_spad", S_IRUSR | S_IWUSR, tc->dbgfs,
 475                             tc, &tool_peer_spad_fops);
 476 }
 477
 478 static int tool_probe(struct ntb_client *self, struct ntb_dev *ntb)
 479 {
 480         struct tool_ctx *tc;
 481         int rc;
 482
 483         if (ntb_db_is_unsafe(ntb))
 484                 dev_dbg(&ntb->dev, "doorbell is unsafe\n");
 485
 486         if (ntb_spad_is_unsafe(ntb))
 487                 dev_dbg(&ntb->dev, "scratchpad is unsafe\n");
 488
 489         tc = kmalloc(sizeof(*tc), GFP_KERNEL);
 490         if (!tc) {
 491                 rc = -ENOMEM;
 492                 goto err_tc;
 493         }
 494
 495         tc->ntb = ntb;
 496
 497         tool_setup_dbgfs(tc);
 498
 499         rc = ntb_set_ctx(ntb, tc, &tool_ops);
 500         if (rc)
 501                 goto err_ctx;
 502
 503         ntb_link_enable(ntb, NTB_SPEED_AUTO, NTB_WIDTH_AUTO);
 504         ntb_link_event(ntb);
 505
 506         return 0;
 507
 508 err_ctx:
 509         debugfs_remove_recursive(tc->dbgfs);
 510         kfree(tc);
 511 err_tc:
 512         return rc;
 513 }
 514
 515 static void tool_remove(struct ntb_client *self, struct ntb_dev *ntb)
 516 {
 517         struct tool_ctx *tc = ntb->ctx;
 518
 519         ntb_clear_ctx(ntb);
 520         ntb_link_disable(ntb);
 521
 522         debugfs_remove_recursive(tc->dbgfs);
 523         kfree(tc);
 524 }
 525
 526 static struct ntb_client tool_client = {
 527         .ops = {
 528                 .probe = tool_probe,
 529                 .remove = tool_remove,
 530         },
 531 };
 532
 533 static int __init tool_init(void)
 534 {
 535         int rc;
 536
 537         if (debugfs_initialized())
 538                 tool_dbgfs = debugfs_create_dir(KBUILD_MODNAME, NULL);
 539
 540         rc = ntb_register_client(&tool_client);
 541         if (rc)
 542                 goto err_client;
 543
 544         return 0;
 545
 546 err_client:
 547         debugfs_remove_recursive(tool_dbgfs);
 548         return rc;
 549 }
 550 module_init(tool_init);
 551
 552 static void __exit tool_exit(void)
 553 {
 554         ntb_unregister_client(&tool_client);
 555         debugfs_remove_recursive(tool_dbgfs);
 556 }
 557 module_exit(tool_exit);