drivers/net/wireless/ath/wil6210/pmc.c

   1 /*
   2  * Copyright (c) 2012-2015,2017 Qualcomm Atheros, Inc.
   3  * Copyright (c) 2018, The Linux Foundation. All rights reserved.
   4  *
   5  * Permission to use, copy, modify, and/or distribute this software for any
   6  * purpose with or without fee is hereby granted, provided that the above
   7  * copyright notice and this permission notice appear in all copies.
   8  *
   9  * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
  10  * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
  11  * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
  12  * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
  13  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
  14  * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
  15  * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  16  */
  17
  18 #include <linux/types.h>
  19 #include <linux/errno.h>
  20 #include <linux/fs.h>
  21 #include "wmi.h"
  22 #include "wil6210.h"
  23 #include "txrx.h"
  24 #include "pmc.h"
  25
  26 struct desc_alloc_info {
  27         dma_addr_t pa;
  28         void      *va;
  29 };
  30
  31 static int wil_is_pmc_allocated(struct pmc_ctx *pmc)
  32 {
  33         return !!pmc->pring_va;
  34 }
  35
  36 void wil_pmc_init(struct wil6210_priv *wil)
  37 {
  38         memset(&wil->pmc, 0, sizeof(struct pmc_ctx));
  39         mutex_init(&wil->pmc.lock);
  40 }
  41
  42 /**
  43  * Allocate the physical ring (p-ring) and the required
  44  * number of descriptors of required size.
  45  * Initialize the descriptors as required by pmc dma.
  46  * The descriptors' buffers dwords are initialized to hold
  47  * dword's serial number in the lsw and reserved value
  48  * PCM_DATA_INVALID_DW_VAL in the msw.
  49  */
  50 void wil_pmc_alloc(struct wil6210_priv *wil,
  51                    int num_descriptors,
  52                    int descriptor_size)
  53 {
  54         u32 i;
  55         struct pmc_ctx *pmc = &wil->pmc;
  56         struct device *dev = wil_to_dev(wil);
  57         struct wil6210_vif *vif = ndev_to_vif(wil->main_ndev);
  58         struct wmi_pmc_cmd pmc_cmd = {0};
  59         int last_cmd_err = -ENOMEM;
  60
  61         mutex_lock(&pmc->lock);
  62
  63         if (wil_is_pmc_allocated(pmc)) {
  64                 /* sanity check */
  65                 wil_err(wil, "ERROR pmc is already allocated\n");
  66                 goto no_release_err;
  67         }
  68         if ((num_descriptors <= 0) || (descriptor_size <= 0)) {
  69                 wil_err(wil,
  70                         "Invalid params num_descriptors(%d), descriptor_size(%d)\n",
  71                         num_descriptors, descriptor_size);
  72                 last_cmd_err = -EINVAL;
  73                 goto no_release_err;
  74         }
  75
  76         if (num_descriptors > (1 << WIL_RING_SIZE_ORDER_MAX)) {
  77                 wil_err(wil,
  78                         "num_descriptors(%d) exceeds max ring size %d\n",
  79                         num_descriptors, 1 << WIL_RING_SIZE_ORDER_MAX);
  80                 last_cmd_err = -EINVAL;
  81                 goto no_release_err;
  82         }
  83
  84         if (num_descriptors > INT_MAX / descriptor_size) {
  85                 wil_err(wil,
  86                         "Overflow in num_descriptors(%d)*descriptor_size(%d)\n",
  87                         num_descriptors, descriptor_size);
  88                 last_cmd_err = -EINVAL;
  89                 goto no_release_err;
  90         }
  91
  92         pmc->num_descriptors = num_descriptors;
  93         pmc->descriptor_size = descriptor_size;
  94
  95         wil_dbg_misc(wil, "pmc_alloc: %d descriptors x %d bytes each\n",
  96                      num_descriptors, descriptor_size);
  97
  98         /* allocate descriptors info list in pmc context*/
  99         pmc->descriptors = kcalloc(num_descriptors,
 100                                   sizeof(struct desc_alloc_info),
 101                                   GFP_KERNEL);
 102         if (!pmc->descriptors) {
 103                 wil_err(wil, "ERROR allocating pmc skb list\n");
 104                 goto no_release_err;
 105         }
 106
 107         wil_dbg_misc(wil, "pmc_alloc: allocated descriptors info list %p\n",
 108                      pmc->descriptors);
 109
 110         /* Allocate pring buffer and descriptors.
 111          * vring->va should be aligned on its size rounded up to power of 2
 112          * This is granted by the dma_alloc_coherent.
 113          *
 114          * HW has limitation that all vrings addresses must share the same
 115          * upper 16 msb bits part of 48 bits address. To workaround that,
 116          * if we are using more than 32 bit addresses switch to 32 bit
 117          * allocation before allocating vring memory.
 118          *
 119          * There's no check for the return value of dma_set_mask_and_coherent,
 120          * since we assume if we were able to set the mask during
 121          * initialization in this system it will not fail if we set it again
 122          */
 123         if (wil->dma_addr_size > 32)
 124                 dma_set_mask_and_coherent(dev, DMA_BIT_MASK(32));
 125
 126         pmc->pring_va = dma_alloc_coherent(dev,
 127                         sizeof(struct vring_tx_desc) * num_descriptors,
 128                         &pmc->pring_pa,
 129                         GFP_KERNEL);
 130
 131         if (wil->dma_addr_size > 32)
 132                 dma_set_mask_and_coherent(dev,
 133                                           DMA_BIT_MASK(wil->dma_addr_size));
 134
 135         wil_dbg_misc(wil,
 136                      "pmc_alloc: allocated pring %p => %pad. %zd x %d = total %zd bytes\n",
 137                      pmc->pring_va, &pmc->pring_pa,
 138                      sizeof(struct vring_tx_desc),
 139                      num_descriptors,
 140                      sizeof(struct vring_tx_desc) * num_descriptors);
 141
 142         if (!pmc->pring_va) {
 143                 wil_err(wil, "ERROR allocating pmc pring\n");
 144                 goto release_pmc_skb_list;
 145         }
 146
 147         /* initially, all descriptors are SW owned
 148          * For Tx, Rx, and PMC, ownership bit is at the same location, thus
 149          * we can use any
 150          */
 151         for (i = 0; i < num_descriptors; i++) {
 152                 struct vring_tx_desc *_d = &pmc->pring_va[i];
 153                 struct vring_tx_desc dd = {}, *d = &dd;
 154                 int j = 0;
 155
 156                 pmc->descriptors[i].va = dma_alloc_coherent(dev,
 157                         descriptor_size,
 158                         &pmc->descriptors[i].pa,
 159                         GFP_KERNEL);
 160
 161                 if (unlikely(!pmc->descriptors[i].va)) {
 162                         wil_err(wil, "ERROR allocating pmc descriptor %d", i);
 163                         goto release_pmc_skbs;
 164                 }
 165
 166                 for (j = 0; j < descriptor_size / sizeof(u32); j++) {
 167                         u32 *p = (u32 *)pmc->descriptors[i].va + j;
 168                         *p = PCM_DATA_INVALID_DW_VAL | j;
 169                 }
 170
 171                 /* configure dma descriptor */
 172                 d->dma.addr.addr_low =
 173                         cpu_to_le32(lower_32_bits(pmc->descriptors[i].pa));
 174                 d->dma.addr.addr_high =
 175                         cpu_to_le16((u16)upper_32_bits(pmc->descriptors[i].pa));
 176                 d->dma.status = 0; /* 0 = HW_OWNED */
 177                 d->dma.length = cpu_to_le16(descriptor_size);
 178                 d->dma.d0 = BIT(9) | RX_DMA_D0_CMD_DMA_IT;
 179                 *_d = *d;
 180         }
 181
 182         wil_dbg_misc(wil, "pmc_alloc: allocated successfully\n");
 183
 184         pmc_cmd.op = WMI_PMC_ALLOCATE;
 185         pmc_cmd.ring_size = cpu_to_le16(pmc->num_descriptors);
 186         pmc_cmd.mem_base = cpu_to_le64(pmc->pring_pa);
 187
 188         wil_dbg_misc(wil, "pmc_alloc: send WMI_PMC_CMD with ALLOCATE op\n");
 189         pmc->last_cmd_status = wmi_send(wil,
 190                                         WMI_PMC_CMDID,
 191                                         vif->mid,
 192                                         &pmc_cmd,
 193                                         sizeof(pmc_cmd));
 194         if (pmc->last_cmd_status) {
 195                 wil_err(wil,
 196                         "WMI_PMC_CMD with ALLOCATE op failed with status %d",
 197                         pmc->last_cmd_status);
 198                 goto release_pmc_skbs;
 199         }
 200
 201         mutex_unlock(&pmc->lock);
 202
 203         return;
 204
 205 release_pmc_skbs:
 206         wil_err(wil, "exit on error: Releasing skbs...\n");
 207         for (i = 0; i < num_descriptors && pmc->descriptors[i].va; i++) {
 208                 dma_free_coherent(dev,
 209                                   descriptor_size,
 210                                   pmc->descriptors[i].va,
 211                                   pmc->descriptors[i].pa);
 212
 213                 pmc->descriptors[i].va = NULL;
 214         }
 215         wil_err(wil, "exit on error: Releasing pring...\n");
 216
 217         dma_free_coherent(dev,
 218                           sizeof(struct vring_tx_desc) * num_descriptors,
 219                           pmc->pring_va,
 220                           pmc->pring_pa);
 221
 222         pmc->pring_va = NULL;
 223
 224 release_pmc_skb_list:
 225         wil_err(wil, "exit on error: Releasing descriptors info list...\n");
 226         kfree(pmc->descriptors);
 227         pmc->descriptors = NULL;
 228
 229 no_release_err:
 230         pmc->last_cmd_status = last_cmd_err;
 231         mutex_unlock(&pmc->lock);
 232 }
 233
 234 /**
 235  * Traverse the p-ring and release all buffers.
 236  * At the end release the p-ring memory
 237  */
 238 void wil_pmc_free(struct wil6210_priv *wil, int send_pmc_cmd)
 239 {
 240         struct pmc_ctx *pmc = &wil->pmc;
 241         struct device *dev = wil_to_dev(wil);
 242         struct wil6210_vif *vif = ndev_to_vif(wil->main_ndev);
 243         struct wmi_pmc_cmd pmc_cmd = {0};
 244
 245         mutex_lock(&pmc->lock);
 246
 247         pmc->last_cmd_status = 0;
 248
 249         if (!wil_is_pmc_allocated(pmc)) {
 250                 wil_dbg_misc(wil,
 251                              "pmc_free: Error, can't free - not allocated\n");
 252                 pmc->last_cmd_status = -EPERM;
 253                 mutex_unlock(&pmc->lock);
 254                 return;
 255         }
 256
 257         if (send_pmc_cmd) {
 258                 wil_dbg_misc(wil, "send WMI_PMC_CMD with RELEASE op\n");
 259                 pmc_cmd.op = WMI_PMC_RELEASE;
 260                 pmc->last_cmd_status =
 261                                 wmi_send(wil, WMI_PMC_CMDID, vif->mid,
 262                                          &pmc_cmd, sizeof(pmc_cmd));
 263                 if (pmc->last_cmd_status) {
 264                         wil_err(wil,
 265                                 "WMI_PMC_CMD with RELEASE op failed, status %d",
 266                                 pmc->last_cmd_status);
 267                         /* There's nothing we can do with this error.
 268                          * Normally, it should never occur.
 269                          * Continue to freeing all memory allocated for pmc.
 270                          */
 271                 }
 272         }
 273
 274         if (pmc->pring_va) {
 275                 size_t buf_size = sizeof(struct vring_tx_desc) *
 276                                   pmc->num_descriptors;
 277
 278                 wil_dbg_misc(wil, "pmc_free: free pring va %p\n",
 279                              pmc->pring_va);
 280                 dma_free_coherent(dev, buf_size, pmc->pring_va, pmc->pring_pa);
 281
 282                 pmc->pring_va = NULL;
 283         } else {
 284                 pmc->last_cmd_status = -ENOENT;
 285         }
 286
 287         if (pmc->descriptors) {
 288                 int i;
 289
 290                 for (i = 0;
 291                      i < pmc->num_descriptors && pmc->descriptors[i].va; i++) {
 292                         dma_free_coherent(dev,
 293                                           pmc->descriptor_size,
 294                                           pmc->descriptors[i].va,
 295                                           pmc->descriptors[i].pa);
 296                         pmc->descriptors[i].va = NULL;
 297                 }
 298                 wil_dbg_misc(wil, "pmc_free: free descriptor info %d/%d\n", i,
 299                              pmc->num_descriptors);
 300                 wil_dbg_misc(wil,
 301                              "pmc_free: free pmc descriptors info list %p\n",
 302                              pmc->descriptors);
 303                 kfree(pmc->descriptors);
 304                 pmc->descriptors = NULL;
 305         } else {
 306                 pmc->last_cmd_status = -ENOENT;
 307         }
 308
 309         mutex_unlock(&pmc->lock);
 310 }
 311
 312 /**
 313  * Status of the last operation requested via debugfs: alloc/free/read.
 314  * 0 - success or negative errno
 315  */
 316 int wil_pmc_last_cmd_status(struct wil6210_priv *wil)
 317 {
 318         wil_dbg_misc(wil, "pmc_last_cmd_status: status %d\n",
 319                      wil->pmc.last_cmd_status);
 320
 321         return wil->pmc.last_cmd_status;
 322 }
 323
 324 /**
 325  * Read from required position up to the end of current descriptor,
 326  * depends on descriptor size configured during alloc request.
 327  */
 328 ssize_t wil_pmc_read(struct file *filp, char __user *buf, size_t count,
 329                      loff_t *f_pos)
 330 {
 331         struct wil6210_priv *wil = filp->private_data;
 332         struct pmc_ctx *pmc = &wil->pmc;
 333         size_t retval = 0;
 334         unsigned long long idx;
 335         loff_t offset;
 336         size_t pmc_size;
 337
 338         mutex_lock(&pmc->lock);
 339
 340         if (!wil_is_pmc_allocated(pmc)) {
 341                 wil_err(wil, "error, pmc is not allocated!\n");
 342                 pmc->last_cmd_status = -EPERM;
 343                 mutex_unlock(&pmc->lock);
 344                 return -EPERM;
 345         }
 346
 347         pmc_size = pmc->descriptor_size * pmc->num_descriptors;
 348
 349         wil_dbg_misc(wil,
 350                      "pmc_read: size %u, pos %lld\n",
 351                      (u32)count, *f_pos);
 352
 353         pmc->last_cmd_status = 0;
 354
 355         idx = *f_pos;
 356         do_div(idx, pmc->descriptor_size);
 357         offset = *f_pos - (idx * pmc->descriptor_size);
 358
 359         if (*f_pos >= pmc_size) {
 360                 wil_dbg_misc(wil,
 361                              "pmc_read: reached end of pmc buf: %lld >= %u\n",
 362                              *f_pos, (u32)pmc_size);
 363                 pmc->last_cmd_status = -ERANGE;
 364                 goto out;
 365         }
 366
 367         wil_dbg_misc(wil,
 368                      "pmc_read: read from pos %lld (descriptor %llu, offset %llu) %zu bytes\n",
 369                      *f_pos, idx, offset, count);
 370
 371         /* if no errors, return the copied byte count */
 372         retval = simple_read_from_buffer(buf,
 373                                          count,
 374                                          &offset,
 375                                          pmc->descriptors[idx].va,
 376                                          pmc->descriptor_size);
 377         *f_pos += retval;
 378 out:
 379         mutex_unlock(&pmc->lock);
 380
 381         return retval;
 382 }
 383
 384 loff_t wil_pmc_llseek(struct file *filp, loff_t off, int whence)
 385 {
 386         loff_t newpos;
 387         struct wil6210_priv *wil = filp->private_data;
 388         struct pmc_ctx *pmc = &wil->pmc;
 389         size_t pmc_size;
 390
 391         mutex_lock(&pmc->lock);
 392
 393         if (!wil_is_pmc_allocated(pmc)) {
 394                 wil_err(wil, "error, pmc is not allocated!\n");
 395                 pmc->last_cmd_status = -EPERM;
 396                 mutex_unlock(&pmc->lock);
 397                 return -EPERM;
 398         }
 399
 400         pmc_size = pmc->descriptor_size * pmc->num_descriptors;
 401
 402         switch (whence) {
 403         case 0: /* SEEK_SET */
 404                 newpos = off;
 405                 break;
 406
 407         case 1: /* SEEK_CUR */
 408                 newpos = filp->f_pos + off;
 409                 break;
 410
 411         case 2: /* SEEK_END */
 412                 newpos = pmc_size;
 413                 break;
 414
 415         default: /* can't happen */
 416                 newpos = -EINVAL;
 417                 goto out;
 418         }
 419
 420         if (newpos < 0) {
 421                 newpos = -EINVAL;
 422                 goto out;
 423         }
 424         if (newpos > pmc_size)
 425                 newpos = pmc_size;
 426
 427         filp->f_pos = newpos;
 428
 429 out:
 430         mutex_unlock(&pmc->lock);
 431
 432         return newpos;
 433 }