drivers/net/wireless/ath/ath11k/dbring.c

   1 // SPDX-License-Identifier: BSD-3-Clause-Clear
   2 /*
   3  * Copyright (c) 2019-2020 The Linux Foundation. All rights reserved.
   4  */
   5
   6 #include "core.h"
   7 #include "debug.h"
   8
   9 #define ATH11K_DB_MAGIC_VALUE 0xdeadbeaf
  10
  11 int ath11k_dbring_validate_buffer(struct ath11k *ar, void *buffer, u32 size)
  12 {
  13         u32 *temp;
  14         int idx;
  15
  16         size = size >> 2;
  17
  18         for (idx = 0, temp = buffer; idx < size; idx++, temp++) {
  19                 if (*temp == ATH11K_DB_MAGIC_VALUE)
  20                         return -EINVAL;
  21         }
  22
  23         return 0;
  24 }
  25
  26 static void ath11k_dbring_fill_magic_value(struct ath11k *ar,
  27                                            void *buffer, u32 size)
  28 {
  29         u32 *temp;
  30         int idx;
  31
  32         size = size >> 2;
  33
  34         for (idx = 0, temp = buffer; idx < size; idx++, temp++)
  35                 *temp++ = ATH11K_DB_MAGIC_VALUE;
  36 }
  37
  38 static int ath11k_dbring_bufs_replenish(struct ath11k *ar,
  39                                         struct ath11k_dbring *ring,
  40                                         struct ath11k_dbring_element *buff,
  41                                         enum wmi_direct_buffer_module id)
  42 {
  43         struct ath11k_base *ab = ar->ab;
  44         struct hal_srng *srng;
  45         dma_addr_t paddr;
  46         void *ptr_aligned, *ptr_unaligned, *desc;
  47         int ret;
  48         int buf_id;
  49         u32 cookie;
  50
  51         srng = &ab->hal.srng_list[ring->refill_srng.ring_id];
  52
  53         lockdep_assert_held(&srng->lock);
  54
  55         ath11k_hal_srng_access_begin(ab, srng);
  56
  57         ptr_unaligned = buff->payload;
  58         ptr_aligned = PTR_ALIGN(ptr_unaligned, ring->buf_align);
  59         ath11k_dbring_fill_magic_value(ar, ptr_aligned, ring->buf_sz);
  60         paddr = dma_map_single(ab->dev, ptr_aligned, ring->buf_sz,
  61                                DMA_FROM_DEVICE);
  62
  63         ret = dma_mapping_error(ab->dev, paddr);
  64         if (ret)
  65                 goto err;
  66
  67         spin_lock_bh(&ring->idr_lock);
  68         buf_id = idr_alloc(&ring->bufs_idr, buff, 0, ring->bufs_max, GFP_ATOMIC);
  69         spin_unlock_bh(&ring->idr_lock);
  70         if (buf_id < 0) {
  71                 ret = -ENOBUFS;
  72                 goto err_dma_unmap;
  73         }
  74
  75         desc = ath11k_hal_srng_src_get_next_entry(ab, srng);
  76         if (!desc) {
  77                 ret = -ENOENT;
  78                 goto err_idr_remove;
  79         }
  80
  81         buff->paddr = paddr;
  82
  83         cookie = FIELD_PREP(DP_RXDMA_BUF_COOKIE_PDEV_ID, ar->pdev_idx) |
  84                  FIELD_PREP(DP_RXDMA_BUF_COOKIE_BUF_ID, buf_id);
  85
  86         ath11k_hal_rx_buf_addr_info_set(desc, paddr, cookie, 0);
  87
  88         ath11k_debugfs_add_dbring_entry(ar, id, ATH11K_DBG_DBR_EVENT_REPLENISH, srng);
  89         ath11k_hal_srng_access_end(ab, srng);
  90
  91         return 0;
  92
  93 err_idr_remove:
  94         spin_lock_bh(&ring->idr_lock);
  95         idr_remove(&ring->bufs_idr, buf_id);
  96         spin_unlock_bh(&ring->idr_lock);
  97 err_dma_unmap:
  98         dma_unmap_single(ab->dev, paddr, ring->buf_sz,
  99                          DMA_FROM_DEVICE);
 100 err:
 101         ath11k_hal_srng_access_end(ab, srng);
 102         return ret;
 103 }
 104
 105 static int ath11k_dbring_fill_bufs(struct ath11k *ar,
 106                                    struct ath11k_dbring *ring,
 107                                    enum wmi_direct_buffer_module id)
 108 {
 109         struct ath11k_dbring_element *buff;
 110         struct hal_srng *srng;
 111         int num_remain, req_entries, num_free;
 112         u32 align;
 113         int size, ret;
 114
 115         srng = &ar->ab->hal.srng_list[ring->refill_srng.ring_id];
 116
 117         spin_lock_bh(&srng->lock);
 118
 119         num_free = ath11k_hal_srng_src_num_free(ar->ab, srng, true);
 120         req_entries = min(num_free, ring->bufs_max);
 121         num_remain = req_entries;
 122         align = ring->buf_align;
 123         size = ring->buf_sz + align - 1;
 124
 125         while (num_remain > 0) {
 126                 buff = kzalloc(sizeof(*buff), GFP_ATOMIC);
 127                 if (!buff)
 128                         break;
 129
 130                 buff->payload = kzalloc(size, GFP_ATOMIC);
 131                 if (!buff->payload) {
 132                         kfree(buff);
 133                         break;
 134                 }
 135                 ret = ath11k_dbring_bufs_replenish(ar, ring, buff, id);
 136                 if (ret) {
 137                         ath11k_warn(ar->ab, "failed to replenish db ring num_remain %d req_ent %d\n",
 138                                     num_remain, req_entries);
 139                         kfree(buff->payload);
 140                         kfree(buff);
 141                         break;
 142                 }
 143                 num_remain--;
 144         }
 145
 146         spin_unlock_bh(&srng->lock);
 147
 148         return num_remain;
 149 }
 150
 151 int ath11k_dbring_wmi_cfg_setup(struct ath11k *ar,
 152                                 struct ath11k_dbring *ring,
 153                                 enum wmi_direct_buffer_module id)
 154 {
 155         struct ath11k_wmi_pdev_dma_ring_cfg_req_cmd param = {0};
 156         int ret;
 157
 158         if (id >= WMI_DIRECT_BUF_MAX)
 159                 return -EINVAL;
 160
 161         param.pdev_id           = DP_SW2HW_MACID(ring->pdev_id);
 162         param.module_id         = id;
 163         param.base_paddr_lo     = lower_32_bits(ring->refill_srng.paddr);
 164         param.base_paddr_hi     = upper_32_bits(ring->refill_srng.paddr);
 165         param.head_idx_paddr_lo = lower_32_bits(ring->hp_addr);
 166         param.head_idx_paddr_hi = upper_32_bits(ring->hp_addr);
 167         param.tail_idx_paddr_lo = lower_32_bits(ring->tp_addr);
 168         param.tail_idx_paddr_hi = upper_32_bits(ring->tp_addr);
 169         param.num_elems         = ring->bufs_max;
 170         param.buf_size          = ring->buf_sz;
 171         param.num_resp_per_event = ring->num_resp_per_event;
 172         param.event_timeout_ms  = ring->event_timeout_ms;
 173
 174         ret = ath11k_wmi_pdev_dma_ring_cfg(ar, &param);
 175         if (ret) {
 176                 ath11k_warn(ar->ab, "failed to setup db ring cfg\n");
 177                 return ret;
 178         }
 179
 180         return 0;
 181 }
 182
 183 int ath11k_dbring_set_cfg(struct ath11k *ar, struct ath11k_dbring *ring,
 184                           u32 num_resp_per_event, u32 event_timeout_ms,
 185                           int (*handler)(struct ath11k *,
 186                                          struct ath11k_dbring_data *))
 187 {
 188         if (WARN_ON(!ring))
 189                 return -EINVAL;
 190
 191         ring->num_resp_per_event = num_resp_per_event;
 192         ring->event_timeout_ms = event_timeout_ms;
 193         ring->handler = handler;
 194
 195         return 0;
 196 }
 197
 198 int ath11k_dbring_buf_setup(struct ath11k *ar,
 199                             struct ath11k_dbring *ring,
 200                             struct ath11k_dbring_cap *db_cap)
 201 {
 202         struct ath11k_base *ab = ar->ab;
 203         struct hal_srng *srng;
 204         int ret;
 205
 206         srng = &ab->hal.srng_list[ring->refill_srng.ring_id];
 207         ring->bufs_max = ring->refill_srng.size /
 208                 ath11k_hal_srng_get_entrysize(ab, HAL_RXDMA_DIR_BUF);
 209
 210         ring->buf_sz = db_cap->min_buf_sz;
 211         ring->buf_align = db_cap->min_buf_align;
 212         ring->pdev_id = db_cap->pdev_id;
 213         ring->hp_addr = ath11k_hal_srng_get_hp_addr(ar->ab, srng);
 214         ring->tp_addr = ath11k_hal_srng_get_tp_addr(ar->ab, srng);
 215
 216         ret = ath11k_dbring_fill_bufs(ar, ring, db_cap->id);
 217
 218         return ret;
 219 }
 220
 221 int ath11k_dbring_srng_setup(struct ath11k *ar, struct ath11k_dbring *ring,
 222                              int ring_num, int num_entries)
 223 {
 224         int ret;
 225
 226         ret = ath11k_dp_srng_setup(ar->ab, &ring->refill_srng, HAL_RXDMA_DIR_BUF,
 227                                    ring_num, ar->pdev_idx, num_entries);
 228         if (ret < 0) {
 229                 ath11k_warn(ar->ab, "failed to setup srng: %d ring_id %d\n",
 230                             ret, ring_num);
 231                 goto err;
 232         }
 233
 234         return 0;
 235 err:
 236         ath11k_dp_srng_cleanup(ar->ab, &ring->refill_srng);
 237         return ret;
 238 }
 239
 240 int ath11k_dbring_get_cap(struct ath11k_base *ab,
 241                           u8 pdev_idx,
 242                           enum wmi_direct_buffer_module id,
 243                           struct ath11k_dbring_cap *db_cap)
 244 {
 245         int i;
 246
 247         if (!ab->num_db_cap || !ab->db_caps)
 248                 return -ENOENT;
 249
 250         if (id >= WMI_DIRECT_BUF_MAX)
 251                 return -EINVAL;
 252
 253         for (i = 0; i < ab->num_db_cap; i++) {
 254                 if (pdev_idx == ab->db_caps[i].pdev_id &&
 255                     id == ab->db_caps[i].id) {
 256                         *db_cap = ab->db_caps[i];
 257
 258                         return 0;
 259                 }
 260         }
 261
 262         return -ENOENT;
 263 }
 264
 265 int ath11k_dbring_buffer_release_event(struct ath11k_base *ab,
 266                                        struct ath11k_dbring_buf_release_event *ev)
 267 {
 268         struct ath11k_dbring *ring;
 269         struct hal_srng *srng;
 270         struct ath11k *ar;
 271         struct ath11k_dbring_element *buff;
 272         struct ath11k_dbring_data handler_data;
 273         struct ath11k_buffer_addr desc;
 274         u8 *vaddr_unalign;
 275         u32 num_entry, num_buff_reaped;
 276         u8 pdev_idx, rbm, module_id;
 277         u32 cookie;
 278         int buf_id;
 279         int size;
 280         dma_addr_t paddr;
 281         int ret = 0;
 282
 283         pdev_idx = ev->fixed.pdev_id;
 284         module_id = ev->fixed.module_id;
 285
 286         if (pdev_idx >= ab->num_radios) {
 287                 ath11k_warn(ab, "Invalid pdev id %d\n", pdev_idx);
 288                 return -EINVAL;
 289         }
 290
 291         if (ev->fixed.num_buf_release_entry !=
 292             ev->fixed.num_meta_data_entry) {
 293                 ath11k_warn(ab, "Buffer entry %d mismatch meta entry %d\n",
 294                             ev->fixed.num_buf_release_entry,
 295                             ev->fixed.num_meta_data_entry);
 296                 return -EINVAL;
 297         }
 298
 299         ar = ab->pdevs[pdev_idx].ar;
 300
 301         rcu_read_lock();
 302         if (!rcu_dereference(ab->pdevs_active[pdev_idx])) {
 303                 ret = -EINVAL;
 304                 goto rcu_unlock;
 305         }
 306
 307         switch (ev->fixed.module_id) {
 308         case WMI_DIRECT_BUF_SPECTRAL:
 309                 ring = ath11k_spectral_get_dbring(ar);
 310                 break;
 311         default:
 312                 ring = NULL;
 313                 ath11k_warn(ab, "Recv dma buffer release ev on unsupp module %d\n",
 314                             ev->fixed.module_id);
 315                 break;
 316         }
 317
 318         if (!ring) {
 319                 ret = -EINVAL;
 320                 goto rcu_unlock;
 321         }
 322
 323         srng = &ab->hal.srng_list[ring->refill_srng.ring_id];
 324         num_entry = ev->fixed.num_buf_release_entry;
 325         size = ring->buf_sz + ring->buf_align - 1;
 326         num_buff_reaped = 0;
 327
 328         spin_lock_bh(&srng->lock);
 329
 330         while (num_buff_reaped < num_entry) {
 331                 desc.info0 = ev->buf_entry[num_buff_reaped].paddr_lo;
 332                 desc.info1 = ev->buf_entry[num_buff_reaped].paddr_hi;
 333                 handler_data.meta = ev->meta_data[num_buff_reaped];
 334
 335                 num_buff_reaped++;
 336
 337                 ath11k_hal_rx_buf_addr_info_get(&desc, &paddr, &cookie, &rbm);
 338
 339                 buf_id = FIELD_GET(DP_RXDMA_BUF_COOKIE_BUF_ID, cookie);
 340
 341                 spin_lock_bh(&ring->idr_lock);
 342                 buff = idr_find(&ring->bufs_idr, buf_id);
 343                 if (!buff) {
 344                         spin_unlock_bh(&ring->idr_lock);
 345                         continue;
 346                 }
 347                 idr_remove(&ring->bufs_idr, buf_id);
 348                 spin_unlock_bh(&ring->idr_lock);
 349
 350                 dma_unmap_single(ab->dev, buff->paddr, ring->buf_sz,
 351                                  DMA_FROM_DEVICE);
 352
 353                 ath11k_debugfs_add_dbring_entry(ar, module_id,
 354                                                 ATH11K_DBG_DBR_EVENT_RX, srng);
 355
 356                 if (ring->handler) {
 357                         vaddr_unalign = buff->payload;
 358                         handler_data.data = PTR_ALIGN(vaddr_unalign,
 359                                                       ring->buf_align);
 360                         handler_data.data_sz = ring->buf_sz;
 361
 362                         ring->handler(ar, &handler_data);
 363                 }
 364
 365                 buff->paddr = 0;
 366                 memset(buff->payload, 0, size);
 367                 ath11k_dbring_bufs_replenish(ar, ring, buff, module_id);
 368         }
 369
 370         spin_unlock_bh(&srng->lock);
 371
 372 rcu_unlock:
 373         rcu_read_unlock();
 374
 375         return ret;
 376 }
 377
 378 void ath11k_dbring_srng_cleanup(struct ath11k *ar, struct ath11k_dbring *ring)
 379 {
 380         ath11k_dp_srng_cleanup(ar->ab, &ring->refill_srng);
 381 }
 382
 383 void ath11k_dbring_buf_cleanup(struct ath11k *ar, struct ath11k_dbring *ring)
 384 {
 385         struct ath11k_dbring_element *buff;
 386         int buf_id;
 387
 388         spin_lock_bh(&ring->idr_lock);
 389         idr_for_each_entry(&ring->bufs_idr, buff, buf_id) {
 390                 idr_remove(&ring->bufs_idr, buf_id);
 391                 dma_unmap_single(ar->ab->dev, buff->paddr,
 392                                  ring->buf_sz, DMA_FROM_DEVICE);
 393                 kfree(buff->payload);
 394                 kfree(buff);
 395         }
 396
 397         idr_destroy(&ring->bufs_idr);
 398         spin_unlock_bh(&ring->idr_lock);
 399 }