drivers/net/ethernet/mediatek/mtk_wed.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /* Copyright (C) 2021 Felix Fietkau <nbd@nbd.name> */
   3
   4 #include <linux/kernel.h>
   5 #include <linux/slab.h>
   6 #include <linux/module.h>
   7 #include <linux/bitfield.h>
   8 #include <linux/dma-mapping.h>
   9 #include <linux/skbuff.h>
  10 #include <linux/of_platform.h>
  11 #include <linux/of_address.h>
  12 #include <linux/mfd/syscon.h>
  13 #include <linux/debugfs.h>
  14 #include <linux/soc/mediatek/mtk_wed.h>
  15 #include "mtk_eth_soc.h"
  16 #include "mtk_wed_regs.h"
  17 #include "mtk_wed.h"
  18 #include "mtk_ppe.h"
  19
  20 #define MTK_PCIE_BASE(n)                (0x1a143000 + (n) * 0x2000)
  21
  22 #define MTK_WED_PKT_SIZE                1900
  23 #define MTK_WED_BUF_SIZE                2048
  24 #define MTK_WED_BUF_PER_PAGE            (PAGE_SIZE / 2048)
  25
  26 #define MTK_WED_TX_RING_SIZE            2048
  27 #define MTK_WED_WDMA_RING_SIZE          1024
  28
  29 static struct mtk_wed_hw *hw_list[2];
  30 static DEFINE_MUTEX(hw_lock);
  31
  32 static void
  33 wed_m32(struct mtk_wed_device *dev, u32 reg, u32 mask, u32 val)
  34 {
  35         regmap_update_bits(dev->hw->regs, reg, mask | val, val);
  36 }
  37
  38 static void
  39 wed_set(struct mtk_wed_device *dev, u32 reg, u32 mask)
  40 {
  41         return wed_m32(dev, reg, 0, mask);
  42 }
  43
  44 static void
  45 wed_clr(struct mtk_wed_device *dev, u32 reg, u32 mask)
  46 {
  47         return wed_m32(dev, reg, mask, 0);
  48 }
  49
  50 static void
  51 wdma_m32(struct mtk_wed_device *dev, u32 reg, u32 mask, u32 val)
  52 {
  53         wdma_w32(dev, reg, (wdma_r32(dev, reg) & ~mask) | val);
  54 }
  55
  56 static void
  57 wdma_set(struct mtk_wed_device *dev, u32 reg, u32 mask)
  58 {
  59         wdma_m32(dev, reg, 0, mask);
  60 }
  61
  62 static u32
  63 mtk_wed_read_reset(struct mtk_wed_device *dev)
  64 {
  65         return wed_r32(dev, MTK_WED_RESET);
  66 }
  67
  68 static void
  69 mtk_wed_reset(struct mtk_wed_device *dev, u32 mask)
  70 {
  71         u32 status;
  72
  73         wed_w32(dev, MTK_WED_RESET, mask);
  74         if (readx_poll_timeout(mtk_wed_read_reset, dev, status,
  75                                !(status & mask), 0, 1000))
  76                 WARN_ON_ONCE(1);
  77 }
  78
  79 static struct mtk_wed_hw *
  80 mtk_wed_assign(struct mtk_wed_device *dev)
  81 {
  82         struct mtk_wed_hw *hw;
  83
  84         hw = hw_list[pci_domain_nr(dev->wlan.pci_dev->bus)];
  85         if (!hw || hw->wed_dev)
  86                 return NULL;
  87
  88         hw->wed_dev = dev;
  89         return hw;
  90 }
  91
  92 static int
  93 mtk_wed_buffer_alloc(struct mtk_wed_device *dev)
  94 {
  95         struct mtk_wdma_desc *desc;
  96         dma_addr_t desc_phys;
  97         void **page_list;
  98         int token = dev->wlan.token_start;
  99         int ring_size;
 100         int n_pages;
 101         int i, page_idx;
 102
 103         ring_size = dev->wlan.nbuf & ~(MTK_WED_BUF_PER_PAGE - 1);
 104         n_pages = ring_size / MTK_WED_BUF_PER_PAGE;
 105
 106         page_list = kcalloc(n_pages, sizeof(*page_list), GFP_KERNEL);
 107         if (!page_list)
 108                 return -ENOMEM;
 109
 110         dev->buf_ring.size = ring_size;
 111         dev->buf_ring.pages = page_list;
 112
 113         desc = dma_alloc_coherent(dev->hw->dev, ring_size * sizeof(*desc),
 114                                   &desc_phys, GFP_KERNEL);
 115         if (!desc)
 116                 return -ENOMEM;
 117
 118         dev->buf_ring.desc = desc;
 119         dev->buf_ring.desc_phys = desc_phys;
 120
 121         for (i = 0, page_idx = 0; i < ring_size; i += MTK_WED_BUF_PER_PAGE) {
 122                 dma_addr_t page_phys, buf_phys;
 123                 struct page *page;
 124                 void *buf;
 125                 int s;
 126
 127                 page = __dev_alloc_pages(GFP_KERNEL, 0);
 128                 if (!page)
 129                         return -ENOMEM;
 130
 131                 page_phys = dma_map_page(dev->hw->dev, page, 0, PAGE_SIZE,
 132                                          DMA_BIDIRECTIONAL);
 133                 if (dma_mapping_error(dev->hw->dev, page_phys)) {
 134                         __free_page(page);
 135                         return -ENOMEM;
 136                 }
 137
 138                 page_list[page_idx++] = page;
 139                 dma_sync_single_for_cpu(dev->hw->dev, page_phys, PAGE_SIZE,
 140                                         DMA_BIDIRECTIONAL);
 141
 142                 buf = page_to_virt(page);
 143                 buf_phys = page_phys;
 144
 145                 for (s = 0; s < MTK_WED_BUF_PER_PAGE; s++) {
 146                         u32 txd_size;
 147
 148                         txd_size = dev->wlan.init_buf(buf, buf_phys, token++);
 149
 150                         desc->buf0 = buf_phys;
 151                         desc->buf1 = buf_phys + txd_size;
 152                         desc->ctrl = FIELD_PREP(MTK_WDMA_DESC_CTRL_LEN0,
 153                                                 txd_size) |
 154                                      FIELD_PREP(MTK_WDMA_DESC_CTRL_LEN1,
 155                                                 MTK_WED_BUF_SIZE - txd_size) |
 156                                      MTK_WDMA_DESC_CTRL_LAST_SEG1;
 157                         desc->info = 0;
 158                         desc++;
 159
 160                         buf += MTK_WED_BUF_SIZE;
 161                         buf_phys += MTK_WED_BUF_SIZE;
 162                 }
 163
 164                 dma_sync_single_for_device(dev->hw->dev, page_phys, PAGE_SIZE,
 165                                            DMA_BIDIRECTIONAL);
 166         }
 167
 168         return 0;
 169 }
 170
 171 static void
 172 mtk_wed_free_buffer(struct mtk_wed_device *dev)
 173 {
 174         struct mtk_wdma_desc *desc = dev->buf_ring.desc;
 175         void **page_list = dev->buf_ring.pages;
 176         int page_idx;
 177         int i;
 178
 179         if (!page_list)
 180                 return;
 181
 182         if (!desc)
 183                 goto free_pagelist;
 184
 185         for (i = 0, page_idx = 0; i < dev->buf_ring.size; i += MTK_WED_BUF_PER_PAGE) {
 186                 void *page = page_list[page_idx++];
 187
 188                 if (!page)
 189                         break;
 190
 191                 dma_unmap_page(dev->hw->dev, desc[i].buf0,
 192                                PAGE_SIZE, DMA_BIDIRECTIONAL);
 193                 __free_page(page);
 194         }
 195
 196         dma_free_coherent(dev->hw->dev, dev->buf_ring.size * sizeof(*desc),
 197                           desc, dev->buf_ring.desc_phys);
 198
 199 free_pagelist:
 200         kfree(page_list);
 201 }
 202
 203 static void
 204 mtk_wed_free_ring(struct mtk_wed_device *dev, struct mtk_wed_ring *ring)
 205 {
 206         if (!ring->desc)
 207                 return;
 208
 209         dma_free_coherent(dev->hw->dev, ring->size * sizeof(*ring->desc),
 210                           ring->desc, ring->desc_phys);
 211 }
 212
 213 static void
 214 mtk_wed_free_tx_rings(struct mtk_wed_device *dev)
 215 {
 216         int i;
 217
 218         for (i = 0; i < ARRAY_SIZE(dev->tx_ring); i++)
 219                 mtk_wed_free_ring(dev, &dev->tx_ring[i]);
 220         for (i = 0; i < ARRAY_SIZE(dev->tx_wdma); i++)
 221                 mtk_wed_free_ring(dev, &dev->tx_wdma[i]);
 222 }
 223
 224 static void
 225 mtk_wed_set_ext_int(struct mtk_wed_device *dev, bool en)
 226 {
 227         u32 mask = MTK_WED_EXT_INT_STATUS_ERROR_MASK;
 228
 229         if (!dev->hw->num_flows)
 230                 mask &= ~MTK_WED_EXT_INT_STATUS_TKID_WO_PYLD;
 231
 232         wed_w32(dev, MTK_WED_EXT_INT_MASK, en ? mask : 0);
 233         wed_r32(dev, MTK_WED_EXT_INT_MASK);
 234 }
 235
 236 static void
 237 mtk_wed_stop(struct mtk_wed_device *dev)
 238 {
 239         regmap_write(dev->hw->mirror, dev->hw->index * 4, 0);
 240         mtk_wed_set_ext_int(dev, false);
 241
 242         wed_clr(dev, MTK_WED_CTRL,
 243                 MTK_WED_CTRL_WDMA_INT_AGENT_EN |
 244                 MTK_WED_CTRL_WPDMA_INT_AGENT_EN |
 245                 MTK_WED_CTRL_WED_TX_BM_EN |
 246                 MTK_WED_CTRL_WED_TX_FREE_AGENT_EN);
 247         wed_w32(dev, MTK_WED_WPDMA_INT_TRIGGER, 0);
 248         wed_w32(dev, MTK_WED_WDMA_INT_TRIGGER, 0);
 249         wdma_w32(dev, MTK_WDMA_INT_MASK, 0);
 250         wdma_w32(dev, MTK_WDMA_INT_GRP2, 0);
 251         wed_w32(dev, MTK_WED_WPDMA_INT_MASK, 0);
 252
 253         wed_clr(dev, MTK_WED_GLO_CFG,
 254                 MTK_WED_GLO_CFG_TX_DMA_EN |
 255                 MTK_WED_GLO_CFG_RX_DMA_EN);
 256         wed_clr(dev, MTK_WED_WPDMA_GLO_CFG,
 257                 MTK_WED_WPDMA_GLO_CFG_TX_DRV_EN |
 258                 MTK_WED_WPDMA_GLO_CFG_RX_DRV_EN);
 259         wed_clr(dev, MTK_WED_WDMA_GLO_CFG,
 260                 MTK_WED_WDMA_GLO_CFG_RX_DRV_EN);
 261 }
 262
 263 static void
 264 mtk_wed_detach(struct mtk_wed_device *dev)
 265 {
 266         struct device_node *wlan_node = dev->wlan.pci_dev->dev.of_node;
 267         struct mtk_wed_hw *hw = dev->hw;
 268
 269         mutex_lock(&hw_lock);
 270
 271         mtk_wed_stop(dev);
 272
 273         wdma_w32(dev, MTK_WDMA_RESET_IDX, MTK_WDMA_RESET_IDX_RX);
 274         wdma_w32(dev, MTK_WDMA_RESET_IDX, 0);
 275
 276         mtk_wed_reset(dev, MTK_WED_RESET_WED);
 277
 278         mtk_wed_free_buffer(dev);
 279         mtk_wed_free_tx_rings(dev);
 280
 281         if (of_dma_is_coherent(wlan_node))
 282                 regmap_update_bits(hw->hifsys, HIFSYS_DMA_AG_MAP,
 283                                    BIT(hw->index), BIT(hw->index));
 284
 285         if (!hw_list[!hw->index]->wed_dev &&
 286             hw->eth->dma_dev != hw->eth->dev)
 287                 mtk_eth_set_dma_device(hw->eth, hw->eth->dev);
 288
 289         memset(dev, 0, sizeof(*dev));
 290         module_put(THIS_MODULE);
 291
 292         hw->wed_dev = NULL;
 293         mutex_unlock(&hw_lock);
 294 }
 295
 296 static void
 297 mtk_wed_hw_init_early(struct mtk_wed_device *dev)
 298 {
 299         u32 mask, set;
 300         u32 offset;
 301
 302         mtk_wed_stop(dev);
 303         mtk_wed_reset(dev, MTK_WED_RESET_WED);
 304
 305         mask = MTK_WED_WDMA_GLO_CFG_BT_SIZE |
 306                MTK_WED_WDMA_GLO_CFG_DYNAMIC_DMAD_RECYCLE |
 307                MTK_WED_WDMA_GLO_CFG_RX_DIS_FSM_AUTO_IDLE;
 308         set = FIELD_PREP(MTK_WED_WDMA_GLO_CFG_BT_SIZE, 2) |
 309               MTK_WED_WDMA_GLO_CFG_DYNAMIC_SKIP_DMAD_PREP |
 310               MTK_WED_WDMA_GLO_CFG_IDLE_DMAD_SUPPLY;
 311         wed_m32(dev, MTK_WED_WDMA_GLO_CFG, mask, set);
 312
 313         wdma_set(dev, MTK_WDMA_GLO_CFG, MTK_WDMA_GLO_CFG_RX_INFO_PRERES);
 314
 315         offset = dev->hw->index ? 0x04000400 : 0;
 316         wed_w32(dev, MTK_WED_WDMA_OFFSET0, 0x2a042a20 + offset);
 317         wed_w32(dev, MTK_WED_WDMA_OFFSET1, 0x29002800 + offset);
 318
 319         wed_w32(dev, MTK_WED_PCIE_CFG_BASE, MTK_PCIE_BASE(dev->hw->index));
 320         wed_w32(dev, MTK_WED_WPDMA_CFG_BASE, dev->wlan.wpdma_phys);
 321 }
 322
 323 static void
 324 mtk_wed_hw_init(struct mtk_wed_device *dev)
 325 {
 326         if (dev->init_done)
 327                 return;
 328
 329         dev->init_done = true;
 330         mtk_wed_set_ext_int(dev, false);
 331         wed_w32(dev, MTK_WED_TX_BM_CTRL,
 332                 MTK_WED_TX_BM_CTRL_PAUSE |
 333                 FIELD_PREP(MTK_WED_TX_BM_CTRL_VLD_GRP_NUM,
 334                            dev->buf_ring.size / 128) |
 335                 FIELD_PREP(MTK_WED_TX_BM_CTRL_RSV_GRP_NUM,
 336                            MTK_WED_TX_RING_SIZE / 256));
 337
 338         wed_w32(dev, MTK_WED_TX_BM_BASE, dev->buf_ring.desc_phys);
 339
 340         wed_w32(dev, MTK_WED_TX_BM_TKID,
 341                 FIELD_PREP(MTK_WED_TX_BM_TKID_START,
 342                            dev->wlan.token_start) |
 343                 FIELD_PREP(MTK_WED_TX_BM_TKID_END,
 344                            dev->wlan.token_start + dev->wlan.nbuf - 1));
 345
 346         wed_w32(dev, MTK_WED_TX_BM_BUF_LEN, MTK_WED_PKT_SIZE);
 347
 348         wed_w32(dev, MTK_WED_TX_BM_DYN_THR,
 349                 FIELD_PREP(MTK_WED_TX_BM_DYN_THR_LO, 1) |
 350                 MTK_WED_TX_BM_DYN_THR_HI);
 351
 352         mtk_wed_reset(dev, MTK_WED_RESET_TX_BM);
 353
 354         wed_set(dev, MTK_WED_CTRL,
 355                 MTK_WED_CTRL_WED_TX_BM_EN |
 356                 MTK_WED_CTRL_WED_TX_FREE_AGENT_EN);
 357
 358         wed_clr(dev, MTK_WED_TX_BM_CTRL, MTK_WED_TX_BM_CTRL_PAUSE);
 359 }
 360
 361 static void
 362 mtk_wed_ring_reset(struct mtk_wdma_desc *desc, int size)
 363 {
 364         int i;
 365
 366         for (i = 0; i < size; i++) {
 367                 desc[i].buf0 = 0;
 368                 desc[i].ctrl = cpu_to_le32(MTK_WDMA_DESC_CTRL_DMA_DONE);
 369                 desc[i].buf1 = 0;
 370                 desc[i].info = 0;
 371         }
 372 }
 373
 374 static u32
 375 mtk_wed_check_busy(struct mtk_wed_device *dev)
 376 {
 377         if (wed_r32(dev, MTK_WED_GLO_CFG) & MTK_WED_GLO_CFG_TX_DMA_BUSY)
 378                 return true;
 379
 380         if (wed_r32(dev, MTK_WED_WPDMA_GLO_CFG) &
 381             MTK_WED_WPDMA_GLO_CFG_TX_DRV_BUSY)
 382                 return true;
 383
 384         if (wed_r32(dev, MTK_WED_CTRL) & MTK_WED_CTRL_WDMA_INT_AGENT_BUSY)
 385                 return true;
 386
 387         if (wed_r32(dev, MTK_WED_WDMA_GLO_CFG) &
 388             MTK_WED_WDMA_GLO_CFG_RX_DRV_BUSY)
 389                 return true;
 390
 391         if (wdma_r32(dev, MTK_WDMA_GLO_CFG) &
 392             MTK_WED_WDMA_GLO_CFG_RX_DRV_BUSY)
 393                 return true;
 394
 395         if (wed_r32(dev, MTK_WED_CTRL) &
 396             (MTK_WED_CTRL_WED_TX_BM_BUSY | MTK_WED_CTRL_WED_TX_FREE_AGENT_BUSY))
 397                 return true;
 398
 399         return false;
 400 }
 401
 402 static int
 403 mtk_wed_poll_busy(struct mtk_wed_device *dev)
 404 {
 405         int sleep = 15000;
 406         int timeout = 100 * sleep;
 407         u32 val;
 408
 409         return read_poll_timeout(mtk_wed_check_busy, val, !val, sleep,
 410                                  timeout, false, dev);
 411 }
 412
 413 static void
 414 mtk_wed_reset_dma(struct mtk_wed_device *dev)
 415 {
 416         bool busy = false;
 417         u32 val;
 418         int i;
 419
 420         for (i = 0; i < ARRAY_SIZE(dev->tx_ring); i++) {
 421                 struct mtk_wdma_desc *desc = dev->tx_ring[i].desc;
 422
 423                 if (!desc)
 424                         continue;
 425
 426                 mtk_wed_ring_reset(desc, MTK_WED_TX_RING_SIZE);
 427         }
 428
 429         if (mtk_wed_poll_busy(dev))
 430                 busy = mtk_wed_check_busy(dev);
 431
 432         if (busy) {
 433                 mtk_wed_reset(dev, MTK_WED_RESET_WED_TX_DMA);
 434         } else {
 435                 wed_w32(dev, MTK_WED_RESET_IDX,
 436                         MTK_WED_RESET_IDX_TX |
 437                         MTK_WED_RESET_IDX_RX);
 438                 wed_w32(dev, MTK_WED_RESET_IDX, 0);
 439         }
 440
 441         wdma_w32(dev, MTK_WDMA_RESET_IDX, MTK_WDMA_RESET_IDX_RX);
 442         wdma_w32(dev, MTK_WDMA_RESET_IDX, 0);
 443
 444         if (busy) {
 445                 mtk_wed_reset(dev, MTK_WED_RESET_WDMA_INT_AGENT);
 446                 mtk_wed_reset(dev, MTK_WED_RESET_WDMA_RX_DRV);
 447         } else {
 448                 wed_w32(dev, MTK_WED_WDMA_RESET_IDX,
 449                         MTK_WED_WDMA_RESET_IDX_RX | MTK_WED_WDMA_RESET_IDX_DRV);
 450                 wed_w32(dev, MTK_WED_WDMA_RESET_IDX, 0);
 451
 452                 wed_set(dev, MTK_WED_WDMA_GLO_CFG,
 453                         MTK_WED_WDMA_GLO_CFG_RST_INIT_COMPLETE);
 454
 455                 wed_clr(dev, MTK_WED_WDMA_GLO_CFG,
 456                         MTK_WED_WDMA_GLO_CFG_RST_INIT_COMPLETE);
 457         }
 458
 459         for (i = 0; i < 100; i++) {
 460                 val = wed_r32(dev, MTK_WED_TX_BM_INTF);
 461                 if (FIELD_GET(MTK_WED_TX_BM_INTF_TKFIFO_FDEP, val) == 0x40)
 462                         break;
 463         }
 464
 465         mtk_wed_reset(dev, MTK_WED_RESET_TX_FREE_AGENT);
 466         mtk_wed_reset(dev, MTK_WED_RESET_TX_BM);
 467
 468         if (busy) {
 469                 mtk_wed_reset(dev, MTK_WED_RESET_WPDMA_INT_AGENT);
 470                 mtk_wed_reset(dev, MTK_WED_RESET_WPDMA_TX_DRV);
 471                 mtk_wed_reset(dev, MTK_WED_RESET_WPDMA_RX_DRV);
 472         } else {
 473                 wed_w32(dev, MTK_WED_WPDMA_RESET_IDX,
 474                         MTK_WED_WPDMA_RESET_IDX_TX |
 475                         MTK_WED_WPDMA_RESET_IDX_RX);
 476                 wed_w32(dev, MTK_WED_WPDMA_RESET_IDX, 0);
 477         }
 478
 479 }
 480
 481 static int
 482 mtk_wed_ring_alloc(struct mtk_wed_device *dev, struct mtk_wed_ring *ring,
 483                    int size)
 484 {
 485         ring->desc = dma_alloc_coherent(dev->hw->dev,
 486                                         size * sizeof(*ring->desc),
 487                                         &ring->desc_phys, GFP_KERNEL);
 488         if (!ring->desc)
 489                 return -ENOMEM;
 490
 491         ring->size = size;
 492         mtk_wed_ring_reset(ring->desc, size);
 493
 494         return 0;
 495 }
 496
 497 static int
 498 mtk_wed_wdma_ring_setup(struct mtk_wed_device *dev, int idx, int size)
 499 {
 500         struct mtk_wed_ring *wdma = &dev->tx_wdma[idx];
 501
 502         if (mtk_wed_ring_alloc(dev, wdma, MTK_WED_WDMA_RING_SIZE))
 503                 return -ENOMEM;
 504
 505         wdma_w32(dev, MTK_WDMA_RING_RX(idx) + MTK_WED_RING_OFS_BASE,
 506                  wdma->desc_phys);
 507         wdma_w32(dev, MTK_WDMA_RING_RX(idx) + MTK_WED_RING_OFS_COUNT,
 508                  size);
 509         wdma_w32(dev, MTK_WDMA_RING_RX(idx) + MTK_WED_RING_OFS_CPU_IDX, 0);
 510
 511         wed_w32(dev, MTK_WED_WDMA_RING_RX(idx) + MTK_WED_RING_OFS_BASE,
 512                 wdma->desc_phys);
 513         wed_w32(dev, MTK_WED_WDMA_RING_RX(idx) + MTK_WED_RING_OFS_COUNT,
 514                 size);
 515
 516         return 0;
 517 }
 518
 519 static void
 520 mtk_wed_start(struct mtk_wed_device *dev, u32 irq_mask)
 521 {
 522         u32 wdma_mask;
 523         u32 val;
 524         int i;
 525
 526         for (i = 0; i < ARRAY_SIZE(dev->tx_wdma); i++)
 527                 if (!dev->tx_wdma[i].desc)
 528                         mtk_wed_wdma_ring_setup(dev, i, 16);
 529
 530         wdma_mask = FIELD_PREP(MTK_WDMA_INT_MASK_RX_DONE, GENMASK(1, 0));
 531
 532         mtk_wed_hw_init(dev);
 533
 534         wed_set(dev, MTK_WED_CTRL,
 535                 MTK_WED_CTRL_WDMA_INT_AGENT_EN |
 536                 MTK_WED_CTRL_WPDMA_INT_AGENT_EN |
 537                 MTK_WED_CTRL_WED_TX_BM_EN |
 538                 MTK_WED_CTRL_WED_TX_FREE_AGENT_EN);
 539
 540         wed_w32(dev, MTK_WED_PCIE_INT_TRIGGER, MTK_WED_PCIE_INT_TRIGGER_STATUS);
 541
 542         wed_w32(dev, MTK_WED_WPDMA_INT_TRIGGER,
 543                 MTK_WED_WPDMA_INT_TRIGGER_RX_DONE |
 544                 MTK_WED_WPDMA_INT_TRIGGER_TX_DONE);
 545
 546         wed_set(dev, MTK_WED_WPDMA_INT_CTRL,
 547                 MTK_WED_WPDMA_INT_CTRL_SUBRT_ADV);
 548
 549         wed_w32(dev, MTK_WED_WDMA_INT_TRIGGER, wdma_mask);
 550         wed_clr(dev, MTK_WED_WDMA_INT_CTRL, wdma_mask);
 551
 552         wdma_w32(dev, MTK_WDMA_INT_MASK, wdma_mask);
 553         wdma_w32(dev, MTK_WDMA_INT_GRP2, wdma_mask);
 554
 555         wed_w32(dev, MTK_WED_WPDMA_INT_MASK, irq_mask);
 556         wed_w32(dev, MTK_WED_INT_MASK, irq_mask);
 557
 558         wed_set(dev, MTK_WED_GLO_CFG,
 559                 MTK_WED_GLO_CFG_TX_DMA_EN |
 560                 MTK_WED_GLO_CFG_RX_DMA_EN);
 561         wed_set(dev, MTK_WED_WPDMA_GLO_CFG,
 562                 MTK_WED_WPDMA_GLO_CFG_TX_DRV_EN |
 563                 MTK_WED_WPDMA_GLO_CFG_RX_DRV_EN);
 564         wed_set(dev, MTK_WED_WDMA_GLO_CFG,
 565                 MTK_WED_WDMA_GLO_CFG_RX_DRV_EN);
 566
 567         mtk_wed_set_ext_int(dev, true);
 568         val = dev->wlan.wpdma_phys |
 569               MTK_PCIE_MIRROR_MAP_EN |
 570               FIELD_PREP(MTK_PCIE_MIRROR_MAP_WED_ID, dev->hw->index);
 571
 572         if (dev->hw->index)
 573                 val |= BIT(1);
 574         val |= BIT(0);
 575         regmap_write(dev->hw->mirror, dev->hw->index * 4, val);
 576
 577         dev->running = true;
 578 }
 579
 580 static int
 581 mtk_wed_attach(struct mtk_wed_device *dev)
 582         __releases(RCU)
 583 {
 584         struct mtk_wed_hw *hw;
 585         int ret = 0;
 586
 587         RCU_LOCKDEP_WARN(!rcu_read_lock_held(),
 588                          "mtk_wed_attach without holding the RCU read lock");
 589
 590         if (pci_domain_nr(dev->wlan.pci_dev->bus) > 1 ||
 591             !try_module_get(THIS_MODULE))
 592                 ret = -ENODEV;
 593
 594         rcu_read_unlock();
 595
 596         if (ret)
 597                 return ret;
 598
 599         mutex_lock(&hw_lock);
 600
 601         hw = mtk_wed_assign(dev);
 602         if (!hw) {
 603                 module_put(THIS_MODULE);
 604                 ret = -ENODEV;
 605                 goto out;
 606         }
 607
 608         dev_info(&dev->wlan.pci_dev->dev, "attaching wed device %d\n", hw->index);
 609
 610         dev->hw = hw;
 611         dev->dev = hw->dev;
 612         dev->irq = hw->irq;
 613         dev->wdma_idx = hw->index;
 614
 615         if (hw->eth->dma_dev == hw->eth->dev &&
 616             of_dma_is_coherent(hw->eth->dev->of_node))
 617                 mtk_eth_set_dma_device(hw->eth, hw->dev);
 618
 619         ret = mtk_wed_buffer_alloc(dev);
 620         if (ret) {
 621                 mtk_wed_detach(dev);
 622                 goto out;
 623         }
 624
 625         mtk_wed_hw_init_early(dev);
 626         regmap_update_bits(hw->hifsys, HIFSYS_DMA_AG_MAP, BIT(hw->index), 0);
 627
 628 out:
 629         mutex_unlock(&hw_lock);
 630
 631         return ret;
 632 }
 633
 634 static int
 635 mtk_wed_tx_ring_setup(struct mtk_wed_device *dev, int idx, void __iomem *regs)
 636 {
 637         struct mtk_wed_ring *ring = &dev->tx_ring[idx];
 638
 639         /*
 640          * Tx ring redirection:
 641          * Instead of configuring the WLAN PDMA TX ring directly, the WLAN
 642          * driver allocated DMA ring gets configured into WED MTK_WED_RING_TX(n)
 643          * registers.
 644          *
 645          * WED driver posts its own DMA ring as WLAN PDMA TX and configures it
 646          * into MTK_WED_WPDMA_RING_TX(n) registers.
 647          * It gets filled with packets picked up from WED TX ring and from
 648          * WDMA RX.
 649          */
 650
 651         BUG_ON(idx > ARRAY_SIZE(dev->tx_ring));
 652
 653         if (mtk_wed_ring_alloc(dev, ring, MTK_WED_TX_RING_SIZE))
 654                 return -ENOMEM;
 655
 656         if (mtk_wed_wdma_ring_setup(dev, idx, MTK_WED_WDMA_RING_SIZE))
 657                 return -ENOMEM;
 658
 659         ring->reg_base = MTK_WED_RING_TX(idx);
 660         ring->wpdma = regs;
 661
 662         /* WED -> WPDMA */
 663         wpdma_tx_w32(dev, idx, MTK_WED_RING_OFS_BASE, ring->desc_phys);
 664         wpdma_tx_w32(dev, idx, MTK_WED_RING_OFS_COUNT, MTK_WED_TX_RING_SIZE);
 665         wpdma_tx_w32(dev, idx, MTK_WED_RING_OFS_CPU_IDX, 0);
 666
 667         wed_w32(dev, MTK_WED_WPDMA_RING_TX(idx) + MTK_WED_RING_OFS_BASE,
 668                 ring->desc_phys);
 669         wed_w32(dev, MTK_WED_WPDMA_RING_TX(idx) + MTK_WED_RING_OFS_COUNT,
 670                 MTK_WED_TX_RING_SIZE);
 671         wed_w32(dev, MTK_WED_WPDMA_RING_TX(idx) + MTK_WED_RING_OFS_CPU_IDX, 0);
 672
 673         return 0;
 674 }
 675
 676 static int
 677 mtk_wed_txfree_ring_setup(struct mtk_wed_device *dev, void __iomem *regs)
 678 {
 679         struct mtk_wed_ring *ring = &dev->txfree_ring;
 680         int i;
 681
 682         /*
 683          * For txfree event handling, the same DMA ring is shared between WED
 684          * and WLAN. The WLAN driver accesses the ring index registers through
 685          * WED
 686          */
 687         ring->reg_base = MTK_WED_RING_RX(1);
 688         ring->wpdma = regs;
 689
 690         for (i = 0; i < 12; i += 4) {
 691                 u32 val = readl(regs + i);
 692
 693                 wed_w32(dev, MTK_WED_RING_RX(1) + i, val);
 694                 wed_w32(dev, MTK_WED_WPDMA_RING_RX(1) + i, val);
 695         }
 696
 697         return 0;
 698 }
 699
 700 static u32
 701 mtk_wed_irq_get(struct mtk_wed_device *dev, u32 mask)
 702 {
 703         u32 val;
 704
 705         val = wed_r32(dev, MTK_WED_EXT_INT_STATUS);
 706         wed_w32(dev, MTK_WED_EXT_INT_STATUS, val);
 707         val &= MTK_WED_EXT_INT_STATUS_ERROR_MASK;
 708         if (!dev->hw->num_flows)
 709                 val &= ~MTK_WED_EXT_INT_STATUS_TKID_WO_PYLD;
 710         if (val && net_ratelimit())
 711                 pr_err("mtk_wed%d: error status=%08x\n", dev->hw->index, val);
 712
 713         val = wed_r32(dev, MTK_WED_INT_STATUS);
 714         val &= mask;
 715         wed_w32(dev, MTK_WED_INT_STATUS, val); /* ACK */
 716
 717         return val;
 718 }
 719
 720 static void
 721 mtk_wed_irq_set_mask(struct mtk_wed_device *dev, u32 mask)
 722 {
 723         if (!dev->running)
 724                 return;
 725
 726         mtk_wed_set_ext_int(dev, !!mask);
 727         wed_w32(dev, MTK_WED_INT_MASK, mask);
 728 }
 729
 730 int mtk_wed_flow_add(int index)
 731 {
 732         struct mtk_wed_hw *hw = hw_list[index];
 733         int ret;
 734
 735         if (!hw || !hw->wed_dev)
 736                 return -ENODEV;
 737
 738         if (hw->num_flows) {
 739                 hw->num_flows++;
 740                 return 0;
 741         }
 742
 743         mutex_lock(&hw_lock);
 744         if (!hw->wed_dev) {
 745                 ret = -ENODEV;
 746                 goto out;
 747         }
 748
 749         ret = hw->wed_dev->wlan.offload_enable(hw->wed_dev);
 750         if (!ret)
 751                 hw->num_flows++;
 752         mtk_wed_set_ext_int(hw->wed_dev, true);
 753
 754 out:
 755         mutex_unlock(&hw_lock);
 756
 757         return ret;
 758 }
 759
 760 void mtk_wed_flow_remove(int index)
 761 {
 762         struct mtk_wed_hw *hw = hw_list[index];
 763
 764         if (!hw)
 765                 return;
 766
 767         if (--hw->num_flows)
 768                 return;
 769
 770         mutex_lock(&hw_lock);
 771         if (!hw->wed_dev)
 772                 goto out;
 773
 774         hw->wed_dev->wlan.offload_disable(hw->wed_dev);
 775         mtk_wed_set_ext_int(hw->wed_dev, true);
 776
 777 out:
 778         mutex_unlock(&hw_lock);
 779 }
 780
 781 void mtk_wed_add_hw(struct device_node *np, struct mtk_eth *eth,
 782                     void __iomem *wdma, int index)
 783 {
 784         static const struct mtk_wed_ops wed_ops = {
 785                 .attach = mtk_wed_attach,
 786                 .tx_ring_setup = mtk_wed_tx_ring_setup,
 787                 .txfree_ring_setup = mtk_wed_txfree_ring_setup,
 788                 .start = mtk_wed_start,
 789                 .stop = mtk_wed_stop,
 790                 .reset_dma = mtk_wed_reset_dma,
 791                 .reg_read = wed_r32,
 792                 .reg_write = wed_w32,
 793                 .irq_get = mtk_wed_irq_get,
 794                 .irq_set_mask = mtk_wed_irq_set_mask,
 795                 .detach = mtk_wed_detach,
 796         };
 797         struct device_node *eth_np = eth->dev->of_node;
 798         struct platform_device *pdev;
 799         struct mtk_wed_hw *hw;
 800         struct regmap *regs;
 801         int irq;
 802
 803         if (!np)
 804                 return;
 805
 806         pdev = of_find_device_by_node(np);
 807         if (!pdev)
 808                 return;
 809
 810         get_device(&pdev->dev);
 811         irq = platform_get_irq(pdev, 0);
 812         if (irq < 0)
 813                 return;
 814
 815         regs = syscon_regmap_lookup_by_phandle(np, NULL);
 816         if (!regs)
 817                 return;
 818
 819         rcu_assign_pointer(mtk_soc_wed_ops, &wed_ops);
 820
 821         mutex_lock(&hw_lock);
 822
 823         if (WARN_ON(hw_list[index]))
 824                 goto unlock;
 825
 826         hw = kzalloc(sizeof(*hw), GFP_KERNEL);
 827         hw->node = np;
 828         hw->regs = regs;
 829         hw->eth = eth;
 830         hw->dev = &pdev->dev;
 831         hw->wdma = wdma;
 832         hw->index = index;
 833         hw->irq = irq;
 834         hw->mirror = syscon_regmap_lookup_by_phandle(eth_np,
 835                                                      "mediatek,pcie-mirror");
 836         hw->hifsys = syscon_regmap_lookup_by_phandle(eth_np,
 837                                                      "mediatek,hifsys");
 838         if (IS_ERR(hw->mirror) || IS_ERR(hw->hifsys)) {
 839                 kfree(hw);
 840                 goto unlock;
 841         }
 842
 843         if (!index) {
 844                 regmap_write(hw->mirror, 0, 0);
 845                 regmap_write(hw->mirror, 4, 0);
 846         }
 847         mtk_wed_hw_add_debugfs(hw);
 848
 849         hw_list[index] = hw;
 850
 851 unlock:
 852         mutex_unlock(&hw_lock);
 853 }
 854
 855 void mtk_wed_exit(void)
 856 {
 857         int i;
 858
 859         rcu_assign_pointer(mtk_soc_wed_ops, NULL);
 860
 861         synchronize_rcu();
 862
 863         for (i = 0; i < ARRAY_SIZE(hw_list); i++) {
 864                 struct mtk_wed_hw *hw;
 865
 866                 hw = hw_list[i];
 867                 if (!hw)
 868                         continue;
 869
 870                 hw_list[i] = NULL;
 871                 debugfs_remove(hw->debugfs_dir);
 872                 put_device(hw->dev);
 873                 kfree(hw);
 874         }
 875 }