drivers/net/ethernet/sfc/tc_counters.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /****************************************************************************
   3  * Driver for Solarflare network controllers and boards
   4  * Copyright 2022 Advanced Micro Devices, Inc.
   5  *
   6  * This program is free software; you can redistribute it and/or modify it
   7  * under the terms of the GNU General Public License version 2 as published
   8  * by the Free Software Foundation, incorporated herein by reference.
   9  */
  10
  11 #include "tc_counters.h"
  12 #include "tc_encap_actions.h"
  13 #include "mae_counter_format.h"
  14 #include "mae.h"
  15 #include "rx_common.h"
  16
  17 /* Counter-management hashtables */
  18
  19 static const struct rhashtable_params efx_tc_counter_id_ht_params = {
  20         .key_len        = offsetof(struct efx_tc_counter_index, linkage),
  21         .key_offset     = 0,
  22         .head_offset    = offsetof(struct efx_tc_counter_index, linkage),
  23 };
  24
  25 static const struct rhashtable_params efx_tc_counter_ht_params = {
  26         .key_len        = offsetof(struct efx_tc_counter, linkage),
  27         .key_offset     = 0,
  28         .head_offset    = offsetof(struct efx_tc_counter, linkage),
  29 };
  30
  31 static void efx_tc_counter_free(void *ptr, void *__unused)
  32 {
  33         struct efx_tc_counter *cnt = ptr;
  34
  35         WARN_ON(!list_empty(&cnt->users));
  36         /* We'd like to synchronize_rcu() here, but unfortunately we aren't
  37          * removing the element from the hashtable (it's not clear that's a
  38          * safe thing to do in an rhashtable_free_and_destroy free_fn), so
  39          * threads could still be obtaining new pointers to *cnt if they can
  40          * race against this function at all.
  41          */
  42         flush_work(&cnt->work);
  43         EFX_WARN_ON_PARANOID(spin_is_locked(&cnt->lock));
  44         kfree(cnt);
  45 }
  46
  47 static void efx_tc_counter_id_free(void *ptr, void *__unused)
  48 {
  49         struct efx_tc_counter_index *ctr = ptr;
  50
  51         WARN_ON(refcount_read(&ctr->ref));
  52         kfree(ctr);
  53 }
  54
  55 int efx_tc_init_counters(struct efx_nic *efx)
  56 {
  57         int rc;
  58
  59         rc = rhashtable_init(&efx->tc->counter_id_ht, &efx_tc_counter_id_ht_params);
  60         if (rc < 0)
  61                 goto fail_counter_id_ht;
  62         rc = rhashtable_init(&efx->tc->counter_ht, &efx_tc_counter_ht_params);
  63         if (rc < 0)
  64                 goto fail_counter_ht;
  65         return 0;
  66 fail_counter_ht:
  67         rhashtable_destroy(&efx->tc->counter_id_ht);
  68 fail_counter_id_ht:
  69         return rc;
  70 }
  71
  72 /* Only call this in init failure teardown.
  73  * Normal exit should fini instead as there may be entries in the table.
  74  */
  75 void efx_tc_destroy_counters(struct efx_nic *efx)
  76 {
  77         rhashtable_destroy(&efx->tc->counter_ht);
  78         rhashtable_destroy(&efx->tc->counter_id_ht);
  79 }
  80
  81 void efx_tc_fini_counters(struct efx_nic *efx)
  82 {
  83         rhashtable_free_and_destroy(&efx->tc->counter_id_ht, efx_tc_counter_id_free, NULL);
  84         rhashtable_free_and_destroy(&efx->tc->counter_ht, efx_tc_counter_free, NULL);
  85 }
  86
  87 static void efx_tc_counter_work(struct work_struct *work)
  88 {
  89         struct efx_tc_counter *cnt = container_of(work, struct efx_tc_counter, work);
  90         struct efx_tc_encap_action *encap;
  91         struct efx_tc_action_set *act;
  92         unsigned long touched;
  93         struct neighbour *n;
  94
  95         spin_lock_bh(&cnt->lock);
  96         touched = READ_ONCE(cnt->touched);
  97
  98         list_for_each_entry(act, &cnt->users, count_user) {
  99                 encap = act->encap_md;
 100                 if (!encap)
 101                         continue;
 102                 if (!encap->neigh) /* can't happen */
 103                         continue;
 104                 if (time_after_eq(encap->neigh->used, touched))
 105                         continue;
 106                 encap->neigh->used = touched;
 107                 /* We have passed traffic using this ARP entry, so
 108                  * indicate to the ARP cache that it's still active
 109                  */
 110                 if (encap->neigh->dst_ip)
 111                         n = neigh_lookup(&arp_tbl, &encap->neigh->dst_ip,
 112                                          encap->neigh->egdev);
 113                 else
 114 #if IS_ENABLED(CONFIG_IPV6)
 115                         n = neigh_lookup(ipv6_stub->nd_tbl,
 116                                          &encap->neigh->dst_ip6,
 117                                          encap->neigh->egdev);
 118 #else
 119                         n = NULL;
 120 #endif
 121                 if (!n)
 122                         continue;
 123
 124                 neigh_event_send(n, NULL);
 125                 neigh_release(n);
 126         }
 127         spin_unlock_bh(&cnt->lock);
 128 }
 129
 130 /* Counter allocation */
 131
 132 struct efx_tc_counter *efx_tc_flower_allocate_counter(struct efx_nic *efx,
 133                                                       int type)
 134 {
 135         struct efx_tc_counter *cnt;
 136         int rc, rc2;
 137
 138         cnt = kzalloc(sizeof(*cnt), GFP_USER);
 139         if (!cnt)
 140                 return ERR_PTR(-ENOMEM);
 141
 142         spin_lock_init(&cnt->lock);
 143         INIT_WORK(&cnt->work, efx_tc_counter_work);
 144         cnt->touched = jiffies;
 145         cnt->type = type;
 146
 147         rc = efx_mae_allocate_counter(efx, cnt);
 148         if (rc)
 149                 goto fail1;
 150         INIT_LIST_HEAD(&cnt->users);
 151         rc = rhashtable_insert_fast(&efx->tc->counter_ht, &cnt->linkage,
 152                                     efx_tc_counter_ht_params);
 153         if (rc)
 154                 goto fail2;
 155         return cnt;
 156 fail2:
 157         /* If we get here, it implies that we couldn't insert into the table,
 158          * which in turn probably means that the fw_id was already taken.
 159          * In that case, it's unclear whether we really 'own' the fw_id; but
 160          * the firmware seemed to think we did, so it's proper to free it.
 161          */
 162         rc2 = efx_mae_free_counter(efx, cnt);
 163         if (rc2)
 164                 netif_warn(efx, hw, efx->net_dev,
 165                            "Failed to free MAE counter %u, rc %d\n",
 166                            cnt->fw_id, rc2);
 167 fail1:
 168         kfree(cnt);
 169         return ERR_PTR(rc > 0 ? -EIO : rc);
 170 }
 171
 172 void efx_tc_flower_release_counter(struct efx_nic *efx,
 173                                    struct efx_tc_counter *cnt)
 174 {
 175         int rc;
 176
 177         rhashtable_remove_fast(&efx->tc->counter_ht, &cnt->linkage,
 178                                efx_tc_counter_ht_params);
 179         rc = efx_mae_free_counter(efx, cnt);
 180         if (rc)
 181                 netif_warn(efx, hw, efx->net_dev,
 182                            "Failed to free MAE counter %u, rc %d\n",
 183                            cnt->fw_id, rc);
 184         WARN_ON(!list_empty(&cnt->users));
 185         /* This doesn't protect counter updates coming in arbitrarily long
 186          * after we deleted the counter.  The RCU just ensures that we won't
 187          * free the counter while another thread has a pointer to it.
 188          * Ensuring we don't update the wrong counter if the ID gets re-used
 189          * is handled by the generation count.
 190          */
 191         synchronize_rcu();
 192         flush_work(&cnt->work);
 193         EFX_WARN_ON_PARANOID(spin_is_locked(&cnt->lock));
 194         kfree(cnt);
 195 }
 196
 197 static struct efx_tc_counter *efx_tc_flower_find_counter_by_fw_id(
 198                                 struct efx_nic *efx, int type, u32 fw_id)
 199 {
 200         struct efx_tc_counter key = {};
 201
 202         key.fw_id = fw_id;
 203         key.type = type;
 204
 205         return rhashtable_lookup_fast(&efx->tc->counter_ht, &key,
 206                                       efx_tc_counter_ht_params);
 207 }
 208
 209 /* TC cookie to counter mapping */
 210
 211 void efx_tc_flower_put_counter_index(struct efx_nic *efx,
 212                                      struct efx_tc_counter_index *ctr)
 213 {
 214         if (!refcount_dec_and_test(&ctr->ref))
 215                 return; /* still in use */
 216         rhashtable_remove_fast(&efx->tc->counter_id_ht, &ctr->linkage,
 217                                efx_tc_counter_id_ht_params);
 218         efx_tc_flower_release_counter(efx, ctr->cnt);
 219         kfree(ctr);
 220 }
 221
 222 struct efx_tc_counter_index *efx_tc_flower_get_counter_index(
 223                                 struct efx_nic *efx, unsigned long cookie,
 224                                 enum efx_tc_counter_type type)
 225 {
 226         struct efx_tc_counter_index *ctr, *old;
 227         struct efx_tc_counter *cnt;
 228
 229         ctr = kzalloc(sizeof(*ctr), GFP_USER);
 230         if (!ctr)
 231                 return ERR_PTR(-ENOMEM);
 232         ctr->cookie = cookie;
 233         old = rhashtable_lookup_get_insert_fast(&efx->tc->counter_id_ht,
 234                                                 &ctr->linkage,
 235                                                 efx_tc_counter_id_ht_params);
 236         if (old) {
 237                 /* don't need our new entry */
 238                 kfree(ctr);
 239                 if (IS_ERR(old)) /* oh dear, it's actually an error */
 240                         return ERR_CAST(old);
 241                 if (!refcount_inc_not_zero(&old->ref))
 242                         return ERR_PTR(-EAGAIN);
 243                 /* existing entry found */
 244                 ctr = old;
 245         } else {
 246                 cnt = efx_tc_flower_allocate_counter(efx, type);
 247                 if (IS_ERR(cnt)) {
 248                         rhashtable_remove_fast(&efx->tc->counter_id_ht,
 249                                                &ctr->linkage,
 250                                                efx_tc_counter_id_ht_params);
 251                         kfree(ctr);
 252                         return ERR_CAST(cnt);
 253                 }
 254                 ctr->cnt = cnt;
 255                 refcount_set(&ctr->ref, 1);
 256         }
 257         return ctr;
 258 }
 259
 260 struct efx_tc_counter_index *efx_tc_flower_find_counter_index(
 261                                 struct efx_nic *efx, unsigned long cookie)
 262 {
 263         struct efx_tc_counter_index key = {};
 264
 265         key.cookie = cookie;
 266         return rhashtable_lookup_fast(&efx->tc->counter_id_ht, &key,
 267                                       efx_tc_counter_id_ht_params);
 268 }
 269
 270 /* TC Channel.  Counter updates are delivered on this channel's RXQ. */
 271
 272 static void efx_tc_handle_no_channel(struct efx_nic *efx)
 273 {
 274         netif_warn(efx, drv, efx->net_dev,
 275                    "MAE counters require MSI-X and 1 additional interrupt vector.\n");
 276 }
 277
 278 static int efx_tc_probe_channel(struct efx_channel *channel)
 279 {
 280         struct efx_rx_queue *rx_queue = &channel->rx_queue;
 281
 282         channel->irq_moderation_us = 0;
 283         rx_queue->core_index = 0;
 284
 285         INIT_WORK(&rx_queue->grant_work, efx_mae_counters_grant_credits);
 286
 287         return 0;
 288 }
 289
 290 static int efx_tc_start_channel(struct efx_channel *channel)
 291 {
 292         struct efx_rx_queue *rx_queue = efx_channel_get_rx_queue(channel);
 293         struct efx_nic *efx = channel->efx;
 294
 295         return efx_mae_start_counters(efx, rx_queue);
 296 }
 297
 298 static void efx_tc_stop_channel(struct efx_channel *channel)
 299 {
 300         struct efx_rx_queue *rx_queue = efx_channel_get_rx_queue(channel);
 301         struct efx_nic *efx = channel->efx;
 302         int rc;
 303
 304         rc = efx_mae_stop_counters(efx, rx_queue);
 305         if (rc)
 306                 netif_warn(efx, drv, efx->net_dev,
 307                            "Failed to stop MAE counters streaming, rc=%d.\n",
 308                            rc);
 309         rx_queue->grant_credits = false;
 310         flush_work(&rx_queue->grant_work);
 311 }
 312
 313 static void efx_tc_remove_channel(struct efx_channel *channel)
 314 {
 315 }
 316
 317 static void efx_tc_get_channel_name(struct efx_channel *channel,
 318                                     char *buf, size_t len)
 319 {
 320         snprintf(buf, len, "%s-mae", channel->efx->name);
 321 }
 322
 323 static void efx_tc_counter_update(struct efx_nic *efx,
 324                                   enum efx_tc_counter_type counter_type,
 325                                   u32 counter_idx, u64 packets, u64 bytes,
 326                                   u32 mark)
 327 {
 328         struct efx_tc_counter *cnt;
 329
 330         rcu_read_lock(); /* Protect against deletion of 'cnt' */
 331         cnt = efx_tc_flower_find_counter_by_fw_id(efx, counter_type, counter_idx);
 332         if (!cnt) {
 333                 /* This can legitimately happen when a counter is removed,
 334                  * with updates for the counter still in-flight; however this
 335                  * should be an infrequent occurrence.
 336                  */
 337                 if (net_ratelimit())
 338                         netif_dbg(efx, drv, efx->net_dev,
 339                                   "Got update for unwanted MAE counter %u type %u\n",
 340                                   counter_idx, counter_type);
 341                 goto out;
 342         }
 343
 344         spin_lock_bh(&cnt->lock);
 345         if ((s32)mark - (s32)cnt->gen < 0) {
 346                 /* This counter update packet is from before the counter was
 347                  * allocated; thus it must be for a previous counter with
 348                  * the same ID that has since been freed, and it should be
 349                  * ignored.
 350                  */
 351         } else {
 352                 /* Update latest seen generation count.  This ensures that
 353                  * even a long-lived counter won't start getting ignored if
 354                  * the generation count wraps around, unless it somehow
 355                  * manages to go 1<<31 generations without an update.
 356                  */
 357                 cnt->gen = mark;
 358                 /* update counter values */
 359                 cnt->packets += packets;
 360                 cnt->bytes += bytes;
 361                 cnt->touched = jiffies;
 362         }
 363         spin_unlock_bh(&cnt->lock);
 364         schedule_work(&cnt->work);
 365 out:
 366         rcu_read_unlock();
 367 }
 368
 369 static void efx_tc_rx_version_1(struct efx_nic *efx, const u8 *data, u32 mark)
 370 {
 371         u16 n_counters, i;
 372
 373         /* Header format:
 374          * + |   0    |   1    |   2    |   3    |
 375          * 0 |version |         reserved         |
 376          * 4 |    seq_index    |   n_counters    |
 377          */
 378
 379         n_counters = le16_to_cpu(*(const __le16 *)(data + 6));
 380
 381         /* Counter update entry format:
 382          * | 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | a | b | c | d | e | f |
 383          * |  counter_idx  |     packet_count      |      byte_count       |
 384          */
 385         for (i = 0; i < n_counters; i++) {
 386                 const void *entry = data + 8 + 16 * i;
 387                 u64 packet_count, byte_count;
 388                 u32 counter_idx;
 389
 390                 counter_idx = le32_to_cpu(*(const __le32 *)entry);
 391                 packet_count = le32_to_cpu(*(const __le32 *)(entry + 4)) |
 392                                ((u64)le16_to_cpu(*(const __le16 *)(entry + 8)) << 32);
 393                 byte_count = le16_to_cpu(*(const __le16 *)(entry + 10)) |
 394                              ((u64)le32_to_cpu(*(const __le32 *)(entry + 12)) << 16);
 395                 efx_tc_counter_update(efx, EFX_TC_COUNTER_TYPE_AR, counter_idx,
 396                                       packet_count, byte_count, mark);
 397         }
 398 }
 399
 400 #define TCV2_HDR_PTR(pkt, field)                                                \
 401         ((void)BUILD_BUG_ON_ZERO(ERF_SC_PACKETISER_HEADER_##field##_LBN & 7),   \
 402          (pkt) + ERF_SC_PACKETISER_HEADER_##field##_LBN / 8)
 403 #define TCV2_HDR_BYTE(pkt, field)                                               \
 404         ((void)BUILD_BUG_ON_ZERO(ERF_SC_PACKETISER_HEADER_##field##_WIDTH != 8),\
 405          *TCV2_HDR_PTR(pkt, field))
 406 #define TCV2_HDR_WORD(pkt, field)                                               \
 407         ((void)BUILD_BUG_ON_ZERO(ERF_SC_PACKETISER_HEADER_##field##_WIDTH != 16),\
 408          (void)BUILD_BUG_ON_ZERO(ERF_SC_PACKETISER_HEADER_##field##_LBN & 15),  \
 409          *(__force const __le16 *)TCV2_HDR_PTR(pkt, field))
 410 #define TCV2_PKT_PTR(pkt, poff, i, field)                                       \
 411         ((void)BUILD_BUG_ON_ZERO(ERF_SC_PACKETISER_PAYLOAD_##field##_LBN & 7),  \
 412          (pkt) + ERF_SC_PACKETISER_PAYLOAD_##field##_LBN/8 + poff +             \
 413          i * ER_RX_SL_PACKETISER_PAYLOAD_WORD_SIZE)
 414
 415 /* Read a little-endian 48-bit field with 16-bit alignment */
 416 static u64 efx_tc_read48(const __le16 *field)
 417 {
 418         u64 out = 0;
 419         int i;
 420
 421         for (i = 0; i < 3; i++)
 422                 out |= (u64)le16_to_cpu(field[i]) << (i * 16);
 423         return out;
 424 }
 425
 426 static enum efx_tc_counter_type efx_tc_rx_version_2(struct efx_nic *efx,
 427                                                     const u8 *data, u32 mark)
 428 {
 429         u8 payload_offset, header_offset, ident;
 430         enum efx_tc_counter_type type;
 431         u16 n_counters, i;
 432
 433         ident = TCV2_HDR_BYTE(data, IDENTIFIER);
 434         switch (ident) {
 435         case ERF_SC_PACKETISER_HEADER_IDENTIFIER_AR:
 436                 type = EFX_TC_COUNTER_TYPE_AR;
 437                 break;
 438         case ERF_SC_PACKETISER_HEADER_IDENTIFIER_CT:
 439                 type = EFX_TC_COUNTER_TYPE_CT;
 440                 break;
 441         case ERF_SC_PACKETISER_HEADER_IDENTIFIER_OR:
 442                 type = EFX_TC_COUNTER_TYPE_OR;
 443                 break;
 444         default:
 445                 if (net_ratelimit())
 446                         netif_err(efx, drv, efx->net_dev,
 447                                   "ignored v2 MAE counter packet (bad identifier %u"
 448                                   "), counters may be inaccurate\n", ident);
 449                 return EFX_TC_COUNTER_TYPE_MAX;
 450         }
 451         header_offset = TCV2_HDR_BYTE(data, HEADER_OFFSET);
 452         /* mae_counter_format.h implies that this offset is fixed, since it
 453          * carries on with SOP-based LBNs for the fields in this header
 454          */
 455         if (header_offset != ERF_SC_PACKETISER_HEADER_HEADER_OFFSET_DEFAULT) {
 456                 if (net_ratelimit())
 457                         netif_err(efx, drv, efx->net_dev,
 458                                   "choked on v2 MAE counter packet (bad header_offset %u"
 459                                   "), counters may be inaccurate\n", header_offset);
 460                 return EFX_TC_COUNTER_TYPE_MAX;
 461         }
 462         payload_offset = TCV2_HDR_BYTE(data, PAYLOAD_OFFSET);
 463         n_counters = le16_to_cpu(TCV2_HDR_WORD(data, COUNT));
 464
 465         for (i = 0; i < n_counters; i++) {
 466                 const void *counter_idx_p, *packet_count_p, *byte_count_p;
 467                 u64 packet_count, byte_count;
 468                 u32 counter_idx;
 469
 470                 /* 24-bit field with 32-bit alignment */
 471                 counter_idx_p = TCV2_PKT_PTR(data, payload_offset, i, COUNTER_INDEX);
 472                 BUILD_BUG_ON(ERF_SC_PACKETISER_PAYLOAD_COUNTER_INDEX_WIDTH != 24);
 473                 BUILD_BUG_ON(ERF_SC_PACKETISER_PAYLOAD_COUNTER_INDEX_LBN & 31);
 474                 counter_idx = le32_to_cpu(*(const __le32 *)counter_idx_p) & 0xffffff;
 475                 /* 48-bit field with 16-bit alignment */
 476                 packet_count_p = TCV2_PKT_PTR(data, payload_offset, i, PACKET_COUNT);
 477                 BUILD_BUG_ON(ERF_SC_PACKETISER_PAYLOAD_PACKET_COUNT_WIDTH != 48);
 478                 BUILD_BUG_ON(ERF_SC_PACKETISER_PAYLOAD_PACKET_COUNT_LBN & 15);
 479                 packet_count = efx_tc_read48((const __le16 *)packet_count_p);
 480                 /* 48-bit field with 16-bit alignment */
 481                 byte_count_p = TCV2_PKT_PTR(data, payload_offset, i, BYTE_COUNT);
 482                 BUILD_BUG_ON(ERF_SC_PACKETISER_PAYLOAD_BYTE_COUNT_WIDTH != 48);
 483                 BUILD_BUG_ON(ERF_SC_PACKETISER_PAYLOAD_BYTE_COUNT_LBN & 15);
 484                 byte_count = efx_tc_read48((const __le16 *)byte_count_p);
 485
 486                 if (type == EFX_TC_COUNTER_TYPE_CT) {
 487                         /* CT counters are 1-bit saturating counters to update
 488                          * the lastuse time in CT stats. A received CT counter
 489                          * should have packet counter to 0 and only LSB bit on
 490                          * in byte counter.
 491                          */
 492                         if (packet_count || byte_count != 1)
 493                                 netdev_warn_once(efx->net_dev,
 494                                                  "CT counter with inconsistent state (%llu, %llu)\n",
 495                                                  packet_count, byte_count);
 496                         /* Do not increment the driver's byte counter */
 497                         byte_count = 0;
 498                 }
 499
 500                 efx_tc_counter_update(efx, type, counter_idx, packet_count,
 501                                       byte_count, mark);
 502         }
 503         return type;
 504 }
 505
 506 /* We always swallow the packet, whether successful or not, since it's not
 507  * a network packet and shouldn't ever be forwarded to the stack.
 508  * @mark is the generation count for counter allocations.
 509  */
 510 static bool efx_tc_rx(struct efx_rx_queue *rx_queue, u32 mark)
 511 {
 512         struct efx_channel *channel = efx_rx_queue_channel(rx_queue);
 513         struct efx_rx_buffer *rx_buf = efx_rx_buffer(rx_queue,
 514                                                      channel->rx_pkt_index);
 515         const u8 *data = efx_rx_buf_va(rx_buf);
 516         struct efx_nic *efx = rx_queue->efx;
 517         enum efx_tc_counter_type type;
 518         u8 version;
 519
 520         /* version is always first byte of packet */
 521         version = *data;
 522         switch (version) {
 523         case 1:
 524                 type = EFX_TC_COUNTER_TYPE_AR;
 525                 efx_tc_rx_version_1(efx, data, mark);
 526                 break;
 527         case ERF_SC_PACKETISER_HEADER_VERSION_VALUE: // 2
 528                 type = efx_tc_rx_version_2(efx, data, mark);
 529                 break;
 530         default:
 531                 if (net_ratelimit())
 532                         netif_err(efx, drv, efx->net_dev,
 533                                   "choked on MAE counter packet (bad version %u"
 534                                   "); counters may be inaccurate\n",
 535                                   version);
 536                 goto out;
 537         }
 538
 539         if (type < EFX_TC_COUNTER_TYPE_MAX) {
 540                 /* Update seen_gen unconditionally, to avoid a missed wakeup if
 541                  * we race with efx_mae_stop_counters().
 542                  */
 543                 efx->tc->seen_gen[type] = mark;
 544                 if (efx->tc->flush_counters &&
 545                     (s32)(efx->tc->flush_gen[type] - mark) <= 0)
 546                         wake_up(&efx->tc->flush_wq);
 547         }
 548 out:
 549         efx_free_rx_buffers(rx_queue, rx_buf, 1);
 550         channel->rx_pkt_n_frags = 0;
 551         return true;
 552 }
 553
 554 const struct efx_channel_type efx_tc_channel_type = {
 555         .handle_no_channel      = efx_tc_handle_no_channel,
 556         .pre_probe              = efx_tc_probe_channel,
 557         .start                  = efx_tc_start_channel,
 558         .stop                   = efx_tc_stop_channel,
 559         .post_remove            = efx_tc_remove_channel,
 560         .get_name               = efx_tc_get_channel_name,
 561         .receive_raw            = efx_tc_rx,
 562         .keep_eventq            = true,
 563 };