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);