drivers/thunderbolt/dma_test.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  * DMA traffic test driver
   4  *
   5  * Copyright (C) 2020, Intel Corporation
   6  * Authors: Isaac Hazan <isaac.hazan@intel.com>
   7  *          Mika Westerberg <mika.westerberg@linux.intel.com>
   8  */
   9
  10 #include <linux/completion.h>
  11 #include <linux/debugfs.h>
  12 #include <linux/module.h>
  13 #include <linux/sizes.h>
  14 #include <linux/thunderbolt.h>
  15
  16 #define DMA_TEST_TX_RING_SIZE           64
  17 #define DMA_TEST_RX_RING_SIZE           256
  18 #define DMA_TEST_FRAME_SIZE             SZ_4K
  19 #define DMA_TEST_DATA_PATTERN           0x0123456789abcdefLL
  20 #define DMA_TEST_MAX_PACKETS            1000
  21
  22 enum dma_test_frame_pdf {
  23         DMA_TEST_PDF_FRAME_START = 1,
  24         DMA_TEST_PDF_FRAME_END,
  25 };
  26
  27 struct dma_test_frame {
  28         struct dma_test *dma_test;
  29         void *data;
  30         struct ring_frame frame;
  31 };
  32
  33 enum dma_test_test_error {
  34         DMA_TEST_NO_ERROR,
  35         DMA_TEST_INTERRUPTED,
  36         DMA_TEST_BUFFER_ERROR,
  37         DMA_TEST_DMA_ERROR,
  38         DMA_TEST_CONFIG_ERROR,
  39         DMA_TEST_SPEED_ERROR,
  40         DMA_TEST_WIDTH_ERROR,
  41         DMA_TEST_BONDING_ERROR,
  42         DMA_TEST_PACKET_ERROR,
  43 };
  44
  45 static const char * const dma_test_error_names[] = {
  46         [DMA_TEST_NO_ERROR] = "no errors",
  47         [DMA_TEST_INTERRUPTED] = "interrupted by signal",
  48         [DMA_TEST_BUFFER_ERROR] = "no memory for packet buffers",
  49         [DMA_TEST_DMA_ERROR] = "DMA ring setup failed",
  50         [DMA_TEST_CONFIG_ERROR] = "configuration is not valid",
  51         [DMA_TEST_SPEED_ERROR] = "unexpected link speed",
  52         [DMA_TEST_WIDTH_ERROR] = "unexpected link width",
  53         [DMA_TEST_BONDING_ERROR] = "lane bonding configuration error",
  54         [DMA_TEST_PACKET_ERROR] = "packet check failed",
  55 };
  56
  57 enum dma_test_result {
  58         DMA_TEST_NOT_RUN,
  59         DMA_TEST_SUCCESS,
  60         DMA_TEST_FAIL,
  61 };
  62
  63 static const char * const dma_test_result_names[] = {
  64         [DMA_TEST_NOT_RUN] = "not run",
  65         [DMA_TEST_SUCCESS] = "success",
  66         [DMA_TEST_FAIL] = "failed",
  67 };
  68
  69 /**
  70  * struct dma_test - DMA test device driver private data
  71  * @svc: XDomain service the driver is bound to
  72  * @xd: XDomain the service belongs to
  73  * @rx_ring: Software ring holding RX frames
  74  * @rx_hopid: HopID used for receiving frames
  75  * @tx_ring: Software ring holding TX frames
  76  * @tx_hopid: HopID used for sending fames
  77  * @packets_to_send: Number of packets to send
  78  * @packets_to_receive: Number of packets to receive
  79  * @packets_sent: Actual number of packets sent
  80  * @packets_received: Actual number of packets received
  81  * @link_speed: Expected link speed (Gb/s), %0 to use whatever is negotiated
  82  * @link_width: Expected link width (Gb/s), %0 to use whatever is negotiated
  83  * @crc_errors: Number of CRC errors during the test run
  84  * @buffer_overflow_errors: Number of buffer overflow errors during the test
  85  *                          run
  86  * @result: Result of the last run
  87  * @error_code: Error code of the last run
  88  * @complete: Used to wait for the Rx to complete
  89  * @lock: Lock serializing access to this structure
  90  * @debugfs_dir: dentry of this dma_test
  91  */
  92 struct dma_test {
  93         const struct tb_service *svc;
  94         struct tb_xdomain *xd;
  95         struct tb_ring *rx_ring;
  96         int rx_hopid;
  97         struct tb_ring *tx_ring;
  98         int tx_hopid;
  99         unsigned int packets_to_send;
 100         unsigned int packets_to_receive;
 101         unsigned int packets_sent;
 102         unsigned int packets_received;
 103         unsigned int link_speed;
 104         unsigned int link_width;
 105         unsigned int crc_errors;
 106         unsigned int buffer_overflow_errors;
 107         enum dma_test_result result;
 108         enum dma_test_test_error error_code;
 109         struct completion complete;
 110         struct mutex lock;
 111         struct dentry *debugfs_dir;
 112 };
 113
 114 /* DMA test property directory UUID: 3188cd10-6523-4a5a-a682-fdca07a248d8 */
 115 static const uuid_t dma_test_dir_uuid =
 116         UUID_INIT(0x3188cd10, 0x6523, 0x4a5a,
 117                   0xa6, 0x82, 0xfd, 0xca, 0x07, 0xa2, 0x48, 0xd8);
 118
 119 static struct tb_property_dir *dma_test_dir;
 120 static void *dma_test_pattern;
 121
 122 static void dma_test_free_rings(struct dma_test *dt)
 123 {
 124         if (dt->rx_ring) {
 125                 tb_xdomain_release_in_hopid(dt->xd, dt->rx_hopid);
 126                 tb_ring_free(dt->rx_ring);
 127                 dt->rx_ring = NULL;
 128         }
 129         if (dt->tx_ring) {
 130                 tb_xdomain_release_out_hopid(dt->xd, dt->tx_hopid);
 131                 tb_ring_free(dt->tx_ring);
 132                 dt->tx_ring = NULL;
 133         }
 134 }
 135
 136 static int dma_test_start_rings(struct dma_test *dt)
 137 {
 138         unsigned int flags = RING_FLAG_FRAME;
 139         struct tb_xdomain *xd = dt->xd;
 140         int ret, e2e_tx_hop = 0;
 141         struct tb_ring *ring;
 142
 143         /*
 144          * If we are both sender and receiver (traffic goes over a
 145          * special loopback dongle) enable E2E flow control. This avoids
 146          * losing packets.
 147          */
 148         if (dt->packets_to_send && dt->packets_to_receive)
 149                 flags |= RING_FLAG_E2E;
 150
 151         if (dt->packets_to_send) {
 152                 ring = tb_ring_alloc_tx(xd->tb->nhi, -1, DMA_TEST_TX_RING_SIZE,
 153                                         flags);
 154                 if (!ring)
 155                         return -ENOMEM;
 156
 157                 dt->tx_ring = ring;
 158                 e2e_tx_hop = ring->hop;
 159
 160                 ret = tb_xdomain_alloc_out_hopid(xd, -1);
 161                 if (ret < 0) {
 162                         dma_test_free_rings(dt);
 163                         return ret;
 164                 }
 165
 166                 dt->tx_hopid = ret;
 167         }
 168
 169         if (dt->packets_to_receive) {
 170                 u16 sof_mask, eof_mask;
 171
 172                 sof_mask = BIT(DMA_TEST_PDF_FRAME_START);
 173                 eof_mask = BIT(DMA_TEST_PDF_FRAME_END);
 174
 175                 ring = tb_ring_alloc_rx(xd->tb->nhi, -1, DMA_TEST_RX_RING_SIZE,
 176                                         flags, e2e_tx_hop, sof_mask, eof_mask,
 177                                         NULL, NULL);
 178                 if (!ring) {
 179                         dma_test_free_rings(dt);
 180                         return -ENOMEM;
 181                 }
 182
 183                 dt->rx_ring = ring;
 184
 185                 ret = tb_xdomain_alloc_in_hopid(xd, -1);
 186                 if (ret < 0) {
 187                         dma_test_free_rings(dt);
 188                         return ret;
 189                 }
 190
 191                 dt->rx_hopid = ret;
 192         }
 193
 194         ret = tb_xdomain_enable_paths(dt->xd, dt->tx_hopid,
 195                                       dt->tx_ring ? dt->tx_ring->hop : -1,
 196                                       dt->rx_hopid,
 197                                       dt->rx_ring ? dt->rx_ring->hop : -1);
 198         if (ret) {
 199                 dma_test_free_rings(dt);
 200                 return ret;
 201         }
 202
 203         if (dt->tx_ring)
 204                 tb_ring_start(dt->tx_ring);
 205         if (dt->rx_ring)
 206                 tb_ring_start(dt->rx_ring);
 207
 208         return 0;
 209 }
 210
 211 static void dma_test_stop_rings(struct dma_test *dt)
 212 {
 213         int ret;
 214
 215         if (dt->rx_ring)
 216                 tb_ring_stop(dt->rx_ring);
 217         if (dt->tx_ring)
 218                 tb_ring_stop(dt->tx_ring);
 219
 220         ret = tb_xdomain_disable_paths(dt->xd, dt->tx_hopid,
 221                                        dt->tx_ring ? dt->tx_ring->hop : -1,
 222                                        dt->rx_hopid,
 223                                        dt->rx_ring ? dt->rx_ring->hop : -1);
 224         if (ret)
 225                 dev_warn(&dt->svc->dev, "failed to disable DMA paths\n");
 226
 227         dma_test_free_rings(dt);
 228 }
 229
 230 static void dma_test_rx_callback(struct tb_ring *ring, struct ring_frame *frame,
 231                                  bool canceled)
 232 {
 233         struct dma_test_frame *tf = container_of(frame, typeof(*tf), frame);
 234         struct dma_test *dt = tf->dma_test;
 235         struct device *dma_dev = tb_ring_dma_device(dt->rx_ring);
 236
 237         dma_unmap_single(dma_dev, tf->frame.buffer_phy, DMA_TEST_FRAME_SIZE,
 238                          DMA_FROM_DEVICE);
 239         kfree(tf->data);
 240
 241         if (canceled) {
 242                 kfree(tf);
 243                 return;
 244         }
 245
 246         dt->packets_received++;
 247         dev_dbg(&dt->svc->dev, "packet %u/%u received\n", dt->packets_received,
 248                 dt->packets_to_receive);
 249
 250         if (tf->frame.flags & RING_DESC_CRC_ERROR)
 251                 dt->crc_errors++;
 252         if (tf->frame.flags & RING_DESC_BUFFER_OVERRUN)
 253                 dt->buffer_overflow_errors++;
 254
 255         kfree(tf);
 256
 257         if (dt->packets_received == dt->packets_to_receive)
 258                 complete(&dt->complete);
 259 }
 260
 261 static int dma_test_submit_rx(struct dma_test *dt, size_t npackets)
 262 {
 263         struct device *dma_dev = tb_ring_dma_device(dt->rx_ring);
 264         int i;
 265
 266         for (i = 0; i < npackets; i++) {
 267                 struct dma_test_frame *tf;
 268                 dma_addr_t dma_addr;
 269
 270                 tf = kzalloc(sizeof(*tf), GFP_KERNEL);
 271                 if (!tf)
 272                         return -ENOMEM;
 273
 274                 tf->data = kzalloc(DMA_TEST_FRAME_SIZE, GFP_KERNEL);
 275                 if (!tf->data) {
 276                         kfree(tf);
 277                         return -ENOMEM;
 278                 }
 279
 280                 dma_addr = dma_map_single(dma_dev, tf->data, DMA_TEST_FRAME_SIZE,
 281                                           DMA_FROM_DEVICE);
 282                 if (dma_mapping_error(dma_dev, dma_addr)) {
 283                         kfree(tf->data);
 284                         kfree(tf);
 285                         return -ENOMEM;
 286                 }
 287
 288                 tf->frame.buffer_phy = dma_addr;
 289                 tf->frame.callback = dma_test_rx_callback;
 290                 tf->dma_test = dt;
 291                 INIT_LIST_HEAD(&tf->frame.list);
 292
 293                 tb_ring_rx(dt->rx_ring, &tf->frame);
 294         }
 295
 296         return 0;
 297 }
 298
 299 static void dma_test_tx_callback(struct tb_ring *ring, struct ring_frame *frame,
 300                                  bool canceled)
 301 {
 302         struct dma_test_frame *tf = container_of(frame, typeof(*tf), frame);
 303         struct dma_test *dt = tf->dma_test;
 304         struct device *dma_dev = tb_ring_dma_device(dt->tx_ring);
 305
 306         dma_unmap_single(dma_dev, tf->frame.buffer_phy, DMA_TEST_FRAME_SIZE,
 307                          DMA_TO_DEVICE);
 308         kfree(tf->data);
 309         kfree(tf);
 310 }
 311
 312 static int dma_test_submit_tx(struct dma_test *dt, size_t npackets)
 313 {
 314         struct device *dma_dev = tb_ring_dma_device(dt->tx_ring);
 315         int i;
 316
 317         for (i = 0; i < npackets; i++) {
 318                 struct dma_test_frame *tf;
 319                 dma_addr_t dma_addr;
 320
 321                 tf = kzalloc(sizeof(*tf), GFP_KERNEL);
 322                 if (!tf)
 323                         return -ENOMEM;
 324
 325                 tf->frame.size = 0; /* means 4096 */
 326                 tf->dma_test = dt;
 327
 328                 tf->data = kmemdup(dma_test_pattern, DMA_TEST_FRAME_SIZE, GFP_KERNEL);
 329                 if (!tf->data) {
 330                         kfree(tf);
 331                         return -ENOMEM;
 332                 }
 333
 334                 dma_addr = dma_map_single(dma_dev, tf->data, DMA_TEST_FRAME_SIZE,
 335                                           DMA_TO_DEVICE);
 336                 if (dma_mapping_error(dma_dev, dma_addr)) {
 337                         kfree(tf->data);
 338                         kfree(tf);
 339                         return -ENOMEM;
 340                 }
 341
 342                 tf->frame.buffer_phy = dma_addr;
 343                 tf->frame.callback = dma_test_tx_callback;
 344                 tf->frame.sof = DMA_TEST_PDF_FRAME_START;
 345                 tf->frame.eof = DMA_TEST_PDF_FRAME_END;
 346                 INIT_LIST_HEAD(&tf->frame.list);
 347
 348                 dt->packets_sent++;
 349                 dev_dbg(&dt->svc->dev, "packet %u/%u sent\n", dt->packets_sent,
 350                         dt->packets_to_send);
 351
 352                 tb_ring_tx(dt->tx_ring, &tf->frame);
 353         }
 354
 355         return 0;
 356 }
 357
 358 #define DMA_TEST_DEBUGFS_ATTR(__fops, __get, __validate, __set) \
 359 static int __fops ## _show(void *data, u64 *val)                \
 360 {                                                               \
 361         struct tb_service *svc = data;                          \
 362         struct dma_test *dt = tb_service_get_drvdata(svc);      \
 363         int ret;                                                \
 364                                                                 \
 365         ret = mutex_lock_interruptible(&dt->lock);              \
 366         if (ret)                                                \
 367                 return ret;                                     \
 368         __get(dt, val);                                         \
 369         mutex_unlock(&dt->lock);                                \
 370         return 0;                                               \
 371 }                                                               \
 372 static int __fops ## _store(void *data, u64 val)                \
 373 {                                                               \
 374         struct tb_service *svc = data;                          \
 375         struct dma_test *dt = tb_service_get_drvdata(svc);      \
 376         int ret;                                                \
 377                                                                 \
 378         ret = __validate(val);                                  \
 379         if (ret)                                                \
 380                 return ret;                                     \
 381         ret = mutex_lock_interruptible(&dt->lock);              \
 382         if (ret)                                                \
 383                 return ret;                                     \
 384         __set(dt, val);                                         \
 385         mutex_unlock(&dt->lock);                                \
 386         return 0;                                               \
 387 }                                                               \
 388 DEFINE_DEBUGFS_ATTRIBUTE(__fops ## _fops, __fops ## _show,      \
 389                          __fops ## _store, "%llu\n")
 390
 391 static void lanes_get(const struct dma_test *dt, u64 *val)
 392 {
 393         *val = dt->link_width;
 394 }
 395
 396 static int lanes_validate(u64 val)
 397 {
 398         return val > 2 ? -EINVAL : 0;
 399 }
 400
 401 static void lanes_set(struct dma_test *dt, u64 val)
 402 {
 403         dt->link_width = val;
 404 }
 405 DMA_TEST_DEBUGFS_ATTR(lanes, lanes_get, lanes_validate, lanes_set);
 406
 407 static void speed_get(const struct dma_test *dt, u64 *val)
 408 {
 409         *val = dt->link_speed;
 410 }
 411
 412 static int speed_validate(u64 val)
 413 {
 414         switch (val) {
 415         case 40:
 416         case 20:
 417         case 10:
 418         case 0:
 419                 return 0;
 420         default:
 421                 return -EINVAL;
 422         }
 423 }
 424
 425 static void speed_set(struct dma_test *dt, u64 val)
 426 {
 427         dt->link_speed = val;
 428 }
 429 DMA_TEST_DEBUGFS_ATTR(speed, speed_get, speed_validate, speed_set);
 430
 431 static void packets_to_receive_get(const struct dma_test *dt, u64 *val)
 432 {
 433         *val = dt->packets_to_receive;
 434 }
 435
 436 static int packets_to_receive_validate(u64 val)
 437 {
 438         return val > DMA_TEST_MAX_PACKETS ? -EINVAL : 0;
 439 }
 440
 441 static void packets_to_receive_set(struct dma_test *dt, u64 val)
 442 {
 443         dt->packets_to_receive = val;
 444 }
 445 DMA_TEST_DEBUGFS_ATTR(packets_to_receive, packets_to_receive_get,
 446                       packets_to_receive_validate, packets_to_receive_set);
 447
 448 static void packets_to_send_get(const struct dma_test *dt, u64 *val)
 449 {
 450         *val = dt->packets_to_send;
 451 }
 452
 453 static int packets_to_send_validate(u64 val)
 454 {
 455         return val > DMA_TEST_MAX_PACKETS ? -EINVAL : 0;
 456 }
 457
 458 static void packets_to_send_set(struct dma_test *dt, u64 val)
 459 {
 460         dt->packets_to_send = val;
 461 }
 462 DMA_TEST_DEBUGFS_ATTR(packets_to_send, packets_to_send_get,
 463                       packets_to_send_validate, packets_to_send_set);
 464
 465 static int dma_test_set_bonding(struct dma_test *dt)
 466 {
 467         switch (dt->link_width) {
 468         case 2:
 469                 return tb_xdomain_lane_bonding_enable(dt->xd);
 470         case 1:
 471                 tb_xdomain_lane_bonding_disable(dt->xd);
 472                 fallthrough;
 473         default:
 474                 return 0;
 475         }
 476 }
 477
 478 static bool dma_test_validate_config(struct dma_test *dt)
 479 {
 480         if (!dt->packets_to_send && !dt->packets_to_receive)
 481                 return false;
 482         if (dt->packets_to_send && dt->packets_to_receive &&
 483             dt->packets_to_send != dt->packets_to_receive)
 484                 return false;
 485         return true;
 486 }
 487
 488 static void dma_test_check_errors(struct dma_test *dt, int ret)
 489 {
 490         if (!dt->error_code) {
 491                 if (dt->link_speed && dt->xd->link_speed != dt->link_speed) {
 492                         dt->error_code = DMA_TEST_SPEED_ERROR;
 493                 } else if (dt->link_width) {
 494                         const struct tb_xdomain *xd = dt->xd;
 495
 496                         if ((dt->link_width == 1 && xd->link_width != TB_LINK_WIDTH_SINGLE) ||
 497                             (dt->link_width == 2 && xd->link_width < TB_LINK_WIDTH_DUAL))
 498                                 dt->error_code = DMA_TEST_WIDTH_ERROR;
 499                 } else if (dt->packets_to_send != dt->packets_sent ||
 500                          dt->packets_to_receive != dt->packets_received ||
 501                          dt->crc_errors || dt->buffer_overflow_errors) {
 502                         dt->error_code = DMA_TEST_PACKET_ERROR;
 503                 } else {
 504                         return;
 505                 }
 506         }
 507
 508         dt->result = DMA_TEST_FAIL;
 509 }
 510
 511 static int test_store(void *data, u64 val)
 512 {
 513         struct tb_service *svc = data;
 514         struct dma_test *dt = tb_service_get_drvdata(svc);
 515         int ret;
 516
 517         if (val != 1)
 518                 return -EINVAL;
 519
 520         ret = mutex_lock_interruptible(&dt->lock);
 521         if (ret)
 522                 return ret;
 523
 524         dt->packets_sent = 0;
 525         dt->packets_received = 0;
 526         dt->crc_errors = 0;
 527         dt->buffer_overflow_errors = 0;
 528         dt->result = DMA_TEST_SUCCESS;
 529         dt->error_code = DMA_TEST_NO_ERROR;
 530
 531         dev_dbg(&svc->dev, "DMA test starting\n");
 532         if (dt->link_speed)
 533                 dev_dbg(&svc->dev, "link_speed: %u Gb/s\n", dt->link_speed);
 534         if (dt->link_width)
 535                 dev_dbg(&svc->dev, "link_width: %u\n", dt->link_width);
 536         dev_dbg(&svc->dev, "packets_to_send: %u\n", dt->packets_to_send);
 537         dev_dbg(&svc->dev, "packets_to_receive: %u\n", dt->packets_to_receive);
 538
 539         if (!dma_test_validate_config(dt)) {
 540                 dev_err(&svc->dev, "invalid test configuration\n");
 541                 dt->error_code = DMA_TEST_CONFIG_ERROR;
 542                 goto out_unlock;
 543         }
 544
 545         ret = dma_test_set_bonding(dt);
 546         if (ret) {
 547                 dev_err(&svc->dev, "failed to set lanes\n");
 548                 dt->error_code = DMA_TEST_BONDING_ERROR;
 549                 goto out_unlock;
 550         }
 551
 552         ret = dma_test_start_rings(dt);
 553         if (ret) {
 554                 dev_err(&svc->dev, "failed to enable DMA rings\n");
 555                 dt->error_code = DMA_TEST_DMA_ERROR;
 556                 goto out_unlock;
 557         }
 558
 559         if (dt->packets_to_receive) {
 560                 reinit_completion(&dt->complete);
 561                 ret = dma_test_submit_rx(dt, dt->packets_to_receive);
 562                 if (ret) {
 563                         dev_err(&svc->dev, "failed to submit receive buffers\n");
 564                         dt->error_code = DMA_TEST_BUFFER_ERROR;
 565                         goto out_stop;
 566                 }
 567         }
 568
 569         if (dt->packets_to_send) {
 570                 ret = dma_test_submit_tx(dt, dt->packets_to_send);
 571                 if (ret) {
 572                         dev_err(&svc->dev, "failed to submit transmit buffers\n");
 573                         dt->error_code = DMA_TEST_BUFFER_ERROR;
 574                         goto out_stop;
 575                 }
 576         }
 577
 578         if (dt->packets_to_receive) {
 579                 ret = wait_for_completion_interruptible(&dt->complete);
 580                 if (ret) {
 581                         dt->error_code = DMA_TEST_INTERRUPTED;
 582                         goto out_stop;
 583                 }
 584         }
 585
 586 out_stop:
 587         dma_test_stop_rings(dt);
 588 out_unlock:
 589         dma_test_check_errors(dt, ret);
 590         mutex_unlock(&dt->lock);
 591
 592         dev_dbg(&svc->dev, "DMA test %s\n", dma_test_result_names[dt->result]);
 593         return ret;
 594 }
 595 DEFINE_DEBUGFS_ATTRIBUTE(test_fops, NULL, test_store, "%llu\n");
 596
 597 static int status_show(struct seq_file *s, void *not_used)
 598 {
 599         struct tb_service *svc = s->private;
 600         struct dma_test *dt = tb_service_get_drvdata(svc);
 601         int ret;
 602
 603         ret = mutex_lock_interruptible(&dt->lock);
 604         if (ret)
 605                 return ret;
 606
 607         seq_printf(s, "result: %s\n", dma_test_result_names[dt->result]);
 608         if (dt->result == DMA_TEST_NOT_RUN)
 609                 goto out_unlock;
 610
 611         seq_printf(s, "packets received: %u\n", dt->packets_received);
 612         seq_printf(s, "packets sent: %u\n", dt->packets_sent);
 613         seq_printf(s, "CRC errors: %u\n", dt->crc_errors);
 614         seq_printf(s, "buffer overflow errors: %u\n",
 615                    dt->buffer_overflow_errors);
 616         seq_printf(s, "error: %s\n", dma_test_error_names[dt->error_code]);
 617
 618 out_unlock:
 619         mutex_unlock(&dt->lock);
 620         return 0;
 621 }
 622 DEFINE_SHOW_ATTRIBUTE(status);
 623
 624 static void dma_test_debugfs_init(struct tb_service *svc)
 625 {
 626         struct dma_test *dt = tb_service_get_drvdata(svc);
 627
 628         dt->debugfs_dir = debugfs_create_dir("dma_test", svc->debugfs_dir);
 629
 630         debugfs_create_file("lanes", 0600, dt->debugfs_dir, svc, &lanes_fops);
 631         debugfs_create_file("speed", 0600, dt->debugfs_dir, svc, &speed_fops);
 632         debugfs_create_file("packets_to_receive", 0600, dt->debugfs_dir, svc,
 633                             &packets_to_receive_fops);
 634         debugfs_create_file("packets_to_send", 0600, dt->debugfs_dir, svc,
 635                             &packets_to_send_fops);
 636         debugfs_create_file("status", 0400, dt->debugfs_dir, svc, &status_fops);
 637         debugfs_create_file("test", 0200, dt->debugfs_dir, svc, &test_fops);
 638 }
 639
 640 static int dma_test_probe(struct tb_service *svc, const struct tb_service_id *id)
 641 {
 642         struct tb_xdomain *xd = tb_service_parent(svc);
 643         struct dma_test *dt;
 644
 645         dt = devm_kzalloc(&svc->dev, sizeof(*dt), GFP_KERNEL);
 646         if (!dt)
 647                 return -ENOMEM;
 648
 649         dt->svc = svc;
 650         dt->xd = xd;
 651         mutex_init(&dt->lock);
 652         init_completion(&dt->complete);
 653
 654         tb_service_set_drvdata(svc, dt);
 655         dma_test_debugfs_init(svc);
 656
 657         return 0;
 658 }
 659
 660 static void dma_test_remove(struct tb_service *svc)
 661 {
 662         struct dma_test *dt = tb_service_get_drvdata(svc);
 663
 664         mutex_lock(&dt->lock);
 665         debugfs_remove_recursive(dt->debugfs_dir);
 666         mutex_unlock(&dt->lock);
 667 }
 668
 669 static int __maybe_unused dma_test_suspend(struct device *dev)
 670 {
 671         /*
 672          * No need to do anything special here. If userspace is writing
 673          * to the test attribute when suspend started, it comes out from
 674          * wait_for_completion_interruptible() with -ERESTARTSYS and the
 675          * DMA test fails tearing down the rings. Once userspace is
 676          * thawed the kernel restarts the write syscall effectively
 677          * re-running the test.
 678          */
 679         return 0;
 680 }
 681
 682 static int __maybe_unused dma_test_resume(struct device *dev)
 683 {
 684         return 0;
 685 }
 686
 687 static const struct dev_pm_ops dma_test_pm_ops = {
 688         SET_SYSTEM_SLEEP_PM_OPS(dma_test_suspend, dma_test_resume)
 689 };
 690
 691 static const struct tb_service_id dma_test_ids[] = {
 692         { TB_SERVICE("dma_test", 1) },
 693         { },
 694 };
 695 MODULE_DEVICE_TABLE(tbsvc, dma_test_ids);
 696
 697 static struct tb_service_driver dma_test_driver = {
 698         .driver = {
 699                 .owner = THIS_MODULE,
 700                 .name = "thunderbolt_dma_test",
 701                 .pm = &dma_test_pm_ops,
 702         },
 703         .probe = dma_test_probe,
 704         .remove = dma_test_remove,
 705         .id_table = dma_test_ids,
 706 };
 707
 708 static int __init dma_test_init(void)
 709 {
 710         u64 data_value = DMA_TEST_DATA_PATTERN;
 711         int i, ret;
 712
 713         dma_test_pattern = kmalloc(DMA_TEST_FRAME_SIZE, GFP_KERNEL);
 714         if (!dma_test_pattern)
 715                 return -ENOMEM;
 716
 717         for (i = 0; i < DMA_TEST_FRAME_SIZE / sizeof(data_value); i++)
 718                 ((u32 *)dma_test_pattern)[i] = data_value++;
 719
 720         dma_test_dir = tb_property_create_dir(&dma_test_dir_uuid);
 721         if (!dma_test_dir) {
 722                 ret = -ENOMEM;
 723                 goto err_free_pattern;
 724         }
 725
 726         tb_property_add_immediate(dma_test_dir, "prtcid", 1);
 727         tb_property_add_immediate(dma_test_dir, "prtcvers", 1);
 728         tb_property_add_immediate(dma_test_dir, "prtcrevs", 0);
 729         tb_property_add_immediate(dma_test_dir, "prtcstns", 0);
 730
 731         ret = tb_register_property_dir("dma_test", dma_test_dir);
 732         if (ret)
 733                 goto err_free_dir;
 734
 735         ret = tb_register_service_driver(&dma_test_driver);
 736         if (ret)
 737                 goto err_unregister_dir;
 738
 739         return 0;
 740
 741 err_unregister_dir:
 742         tb_unregister_property_dir("dma_test", dma_test_dir);
 743 err_free_dir:
 744         tb_property_free_dir(dma_test_dir);
 745 err_free_pattern:
 746         kfree(dma_test_pattern);
 747
 748         return ret;
 749 }
 750 module_init(dma_test_init);
 751
 752 static void __exit dma_test_exit(void)
 753 {
 754         tb_unregister_service_driver(&dma_test_driver);
 755         tb_unregister_property_dir("dma_test", dma_test_dir);
 756         tb_property_free_dir(dma_test_dir);
 757         kfree(dma_test_pattern);
 758 }
 759 module_exit(dma_test_exit);
 760
 761 MODULE_AUTHOR("Isaac Hazan <isaac.hazan@intel.com>");
 762 MODULE_AUTHOR("Mika Westerberg <mika.westerberg@linux.intel.com>");
 763 MODULE_DESCRIPTION("Thunderbolt/USB4 DMA traffic test driver");
 764 MODULE_LICENSE("GPL v2");