445 lines
11 KiB
C
445 lines
11 KiB
C
|
// SPDX-License-Identifier: ISC
|
||
|
|
/*
|
||
|
|
* Copyright (c) 2012-2015,2017 Qualcomm Atheros, Inc.
|
||
|
|
* Copyright (c) 2018, The Linux Foundation. All rights reserved.
|
||
|
|
*/
|
||
|
|
|
||
|
|
#include <linux/types.h>
|
||
|
|
#include <linux/errno.h>
|
||
|
|
#include <linux/fs.h>
|
||
|
|
#include <linux/seq_file.h>
|
||
|
|
#include "wmi.h"
|
||
|
|
#include "wil6210.h"
|
||
|
|
#include "txrx.h"
|
||
|
|
#include "pmc.h"
|
||
|
|
|
||
|
|
struct desc_alloc_info {
|
||
|
|
dma_addr_t pa;
|
||
|
|
void *va;
|
||
|
|
};
|
||
|
|
|
||
|
|
static int wil_is_pmc_allocated(struct pmc_ctx *pmc)
|
||
|
|
{
|
||
|
|
return !!pmc->pring_va;
|
||
|
|
}
|
||
|
|
|
||
|
|
void wil_pmc_init(struct wil6210_priv *wil)
|
||
|
|
{
|
||
|
|
memset(&wil->pmc, 0, sizeof(struct pmc_ctx));
|
||
|
|
mutex_init(&wil->pmc.lock);
|
||
|
|
}
|
||
|
|
|
||
|
|
/* Allocate the physical ring (p-ring) and the required
|
||
|
|
* number of descriptors of required size.
|
||
|
|
* Initialize the descriptors as required by pmc dma.
|
||
|
|
* The descriptors' buffers dwords are initialized to hold
|
||
|
|
* dword's serial number in the lsw and reserved value
|
||
|
|
* PCM_DATA_INVALID_DW_VAL in the msw.
|
||
|
|
*/
|
||
|
|
void wil_pmc_alloc(struct wil6210_priv *wil,
|
||
|
|
int num_descriptors,
|
||
|
|
int descriptor_size)
|
||
|
|
{
|
||
|
|
u32 i;
|
||
|
|
struct pmc_ctx *pmc = &wil->pmc;
|
||
|
|
struct device *dev = wil_to_dev(wil);
|
||
|
|
struct wil6210_vif *vif = ndev_to_vif(wil->main_ndev);
|
||
|
|
struct wmi_pmc_cmd pmc_cmd = {0};
|
||
|
|
int last_cmd_err = -ENOMEM;
|
||
|
|
|
||
|
|
mutex_lock(&pmc->lock);
|
||
|
|
|
||
|
|
if (wil_is_pmc_allocated(pmc)) {
|
||
|
|
/* sanity check */
|
||
|
|
wil_err(wil, "ERROR pmc is already allocated\n");
|
||
|
|
goto no_release_err;
|
||
|
|
}
|
||
|
|
if ((num_descriptors <= 0) || (descriptor_size <= 0)) {
|
||
|
|
wil_err(wil,
|
||
|
|
"Invalid params num_descriptors(%d), descriptor_size(%d)\n",
|
||
|
|
num_descriptors, descriptor_size);
|
||
|
|
last_cmd_err = -EINVAL;
|
||
|
|
goto no_release_err;
|
||
|
|
}
|
||
|
|
|
||
|
|
if (num_descriptors > (1 << WIL_RING_SIZE_ORDER_MAX)) {
|
||
|
|
wil_err(wil,
|
||
|
|
"num_descriptors(%d) exceeds max ring size %d\n",
|
||
|
|
num_descriptors, 1 << WIL_RING_SIZE_ORDER_MAX);
|
||
|
|
last_cmd_err = -EINVAL;
|
||
|
|
goto no_release_err;
|
||
|
|
}
|
||
|
|
|
||
|
|
if (num_descriptors > INT_MAX / descriptor_size) {
|
||
|
|
wil_err(wil,
|
||
|
|
"Overflow in num_descriptors(%d)*descriptor_size(%d)\n",
|
||
|
|
num_descriptors, descriptor_size);
|
||
|
|
last_cmd_err = -EINVAL;
|
||
|
|
goto no_release_err;
|
||
|
|
}
|
||
|
|
|
||
|
|
pmc->num_descriptors = num_descriptors;
|
||
|
|
pmc->descriptor_size = descriptor_size;
|
||
|
|
|
||
|
|
wil_dbg_misc(wil, "pmc_alloc: %d descriptors x %d bytes each\n",
|
||
|
|
num_descriptors, descriptor_size);
|
||
|
|
|
||
|
|
/* allocate descriptors info list in pmc context*/
|
||
|
|
pmc->descriptors = kcalloc(num_descriptors,
|
||
|
|
sizeof(struct desc_alloc_info),
|
||
|
|
GFP_KERNEL);
|
||
|
|
if (!pmc->descriptors) {
|
||
|
|
wil_err(wil, "ERROR allocating pmc skb list\n");
|
||
|
|
goto no_release_err;
|
||
|
|
}
|
||
|
|
|
||
|
|
wil_dbg_misc(wil, "pmc_alloc: allocated descriptors info list %p\n",
|
||
|
|
pmc->descriptors);
|
||
|
|
|
||
|
|
/* Allocate pring buffer and descriptors.
|
||
|
|
* vring->va should be aligned on its size rounded up to power of 2
|
||
|
|
* This is granted by the dma_alloc_coherent.
|
||
|
|
*
|
||
|
|
* HW has limitation that all vrings addresses must share the same
|
||
|
|
* upper 16 msb bits part of 48 bits address. To workaround that,
|
||
|
|
* if we are using more than 32 bit addresses switch to 32 bit
|
||
|
|
* allocation before allocating vring memory.
|
||
|
|
*
|
||
|
|
* There's no check for the return value of dma_set_mask_and_coherent,
|
||
|
|
* since we assume if we were able to set the mask during
|
||
|
|
* initialization in this system it will not fail if we set it again
|
||
|
|
*/
|
||
|
|
if (wil->dma_addr_size > 32)
|
||
|
|
dma_set_mask_and_coherent(dev, DMA_BIT_MASK(32));
|
||
|
|
|
||
|
|
pmc->pring_va = dma_alloc_coherent(dev,
|
||
|
|
sizeof(struct vring_tx_desc) * num_descriptors,
|
||
|
|
&pmc->pring_pa,
|
||
|
|
GFP_KERNEL);
|
||
|
|
|
||
|
|
if (wil->dma_addr_size > 32)
|
||
|
|
dma_set_mask_and_coherent(dev,
|
||
|
|
DMA_BIT_MASK(wil->dma_addr_size));
|
||
|
|
|
||
|
|
wil_dbg_misc(wil,
|
||
|
|
"pmc_alloc: allocated pring %p => %pad. %zd x %d = total %zd bytes\n",
|
||
|
|
pmc->pring_va, &pmc->pring_pa,
|
||
|
|
sizeof(struct vring_tx_desc),
|
||
|
|
num_descriptors,
|
||
|
|
sizeof(struct vring_tx_desc) * num_descriptors);
|
||
|
|
|
||
|
|
if (!pmc->pring_va) {
|
||
|
|
wil_err(wil, "ERROR allocating pmc pring\n");
|
||
|
|
goto release_pmc_skb_list;
|
||
|
|
}
|
||
|
|
|
||
|
|
/* initially, all descriptors are SW owned
|
||
|
|
* For Tx, Rx, and PMC, ownership bit is at the same location, thus
|
||
|
|
* we can use any
|
||
|
|
*/
|
||
|
|
for (i = 0; i < num_descriptors; i++) {
|
||
|
|
struct vring_tx_desc *_d = &pmc->pring_va[i];
|
||
|
|
struct vring_tx_desc dd = {}, *d = ⅆ
|
||
|
|
int j = 0;
|
||
|
|
|
||
|
|
pmc->descriptors[i].va = dma_alloc_coherent(dev,
|
||
|
|
descriptor_size,
|
||
|
|
&pmc->descriptors[i].pa,
|
||
|
|
GFP_KERNEL);
|
||
|
|
|
||
|
|
if (unlikely(!pmc->descriptors[i].va)) {
|
||
|
|
wil_err(wil, "ERROR allocating pmc descriptor %d", i);
|
||
|
|
goto release_pmc_skbs;
|
||
|
|
}
|
||
|
|
|
||
|
|
for (j = 0; j < descriptor_size / sizeof(u32); j++) {
|
||
|
|
u32 *p = (u32 *)pmc->descriptors[i].va + j;
|
||
|
|
*p = PCM_DATA_INVALID_DW_VAL | j;
|
||
|
|
}
|
||
|
|
|
||
|
|
/* configure dma descriptor */
|
||
|
|
d->dma.addr.addr_low =
|
||
|
|
cpu_to_le32(lower_32_bits(pmc->descriptors[i].pa));
|
||
|
|
d->dma.addr.addr_high =
|
||
|
|
cpu_to_le16((u16)upper_32_bits(pmc->descriptors[i].pa));
|
||
|
|
d->dma.status = 0; /* 0 = HW_OWNED */
|
||
|
|
d->dma.length = cpu_to_le16(descriptor_size);
|
||
|
|
d->dma.d0 = BIT(9) | RX_DMA_D0_CMD_DMA_IT;
|
||
|
|
*_d = *d;
|
||
|
|
}
|
||
|
|
|
||
|
|
wil_dbg_misc(wil, "pmc_alloc: allocated successfully\n");
|
||
|
|
|
||
|
|
pmc_cmd.op = WMI_PMC_ALLOCATE;
|
||
|
|
pmc_cmd.ring_size = cpu_to_le16(pmc->num_descriptors);
|
||
|
|
pmc_cmd.mem_base = cpu_to_le64(pmc->pring_pa);
|
||
|
|
|
||
|
|
wil_dbg_misc(wil, "pmc_alloc: send WMI_PMC_CMD with ALLOCATE op\n");
|
||
|
|
pmc->last_cmd_status = wmi_send(wil,
|
||
|
|
WMI_PMC_CMDID,
|
||
|
|
vif->mid,
|
||
|
|
&pmc_cmd,
|
||
|
|
sizeof(pmc_cmd));
|
||
|
|
if (pmc->last_cmd_status) {
|
||
|
|
wil_err(wil,
|
||
|
|
"WMI_PMC_CMD with ALLOCATE op failed with status %d",
|
||
|
|
pmc->last_cmd_status);
|
||
|
|
goto release_pmc_skbs;
|
||
|
|
}
|
||
|
|
|
||
|
|
mutex_unlock(&pmc->lock);
|
||
|
|
|
||
|
|
return;
|
||
|
|
|
||
|
|
release_pmc_skbs:
|
||
|
|
wil_err(wil, "exit on error: Releasing skbs...\n");
|
||
|
|
for (i = 0; i < num_descriptors && pmc->descriptors[i].va; i++) {
|
||
|
|
dma_free_coherent(dev,
|
||
|
|
descriptor_size,
|
||
|
|
pmc->descriptors[i].va,
|
||
|
|
pmc->descriptors[i].pa);
|
||
|
|
|
||
|
|
pmc->descriptors[i].va = NULL;
|
||
|
|
}
|
||
|
|
wil_err(wil, "exit on error: Releasing pring...\n");
|
||
|
|
|
||
|
|
dma_free_coherent(dev,
|
||
|
|
sizeof(struct vring_tx_desc) * num_descriptors,
|
||
|
|
pmc->pring_va,
|
||
|
|
pmc->pring_pa);
|
||
|
|
|
||
|
|
pmc->pring_va = NULL;
|
||
|
|
|
||
|
|
release_pmc_skb_list:
|
||
|
|
wil_err(wil, "exit on error: Releasing descriptors info list...\n");
|
||
|
|
kfree(pmc->descriptors);
|
||
|
|
pmc->descriptors = NULL;
|
||
|
|
|
||
|
|
no_release_err:
|
||
|
|
pmc->last_cmd_status = last_cmd_err;
|
||
|
|
mutex_unlock(&pmc->lock);
|
||
|
|
}
|
||
|
|
|
||
|
|
/* Traverse the p-ring and release all buffers.
|
||
|
|
* At the end release the p-ring memory
|
||
|
|
*/
|
||
|
|
void wil_pmc_free(struct wil6210_priv *wil, int send_pmc_cmd)
|
||
|
|
{
|
||
|
|
struct pmc_ctx *pmc = &wil->pmc;
|
||
|
|
struct device *dev = wil_to_dev(wil);
|
||
|
|
struct wil6210_vif *vif = ndev_to_vif(wil->main_ndev);
|
||
|
|
struct wmi_pmc_cmd pmc_cmd = {0};
|
||
|
|
|
||
|
|
mutex_lock(&pmc->lock);
|
||
|
|
|
||
|
|
pmc->last_cmd_status = 0;
|
||
|
|
|
||
|
|
if (!wil_is_pmc_allocated(pmc)) {
|
||
|
|
wil_dbg_misc(wil,
|
||
|
|
"pmc_free: Error, can't free - not allocated\n");
|
||
|
|
pmc->last_cmd_status = -EPERM;
|
||
|
|
mutex_unlock(&pmc->lock);
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
|
||
|
|
if (send_pmc_cmd) {
|
||
|
|
wil_dbg_misc(wil, "send WMI_PMC_CMD with RELEASE op\n");
|
||
|
|
pmc_cmd.op = WMI_PMC_RELEASE;
|
||
|
|
pmc->last_cmd_status =
|
||
|
|
wmi_send(wil, WMI_PMC_CMDID, vif->mid,
|
||
|
|
&pmc_cmd, sizeof(pmc_cmd));
|
||
|
|
if (pmc->last_cmd_status) {
|
||
|
|
wil_err(wil,
|
||
|
|
"WMI_PMC_CMD with RELEASE op failed, status %d",
|
||
|
|
pmc->last_cmd_status);
|
||
|
|
/* There's nothing we can do with this error.
|
||
|
|
* Normally, it should never occur.
|
||
|
|
* Continue to freeing all memory allocated for pmc.
|
||
|
|
*/
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
if (pmc->pring_va) {
|
||
|
|
size_t buf_size = sizeof(struct vring_tx_desc) *
|
||
|
|
pmc->num_descriptors;
|
||
|
|
|
||
|
|
wil_dbg_misc(wil, "pmc_free: free pring va %p\n",
|
||
|
|
pmc->pring_va);
|
||
|
|
dma_free_coherent(dev, buf_size, pmc->pring_va, pmc->pring_pa);
|
||
|
|
|
||
|
|
pmc->pring_va = NULL;
|
||
|
|
} else {
|
||
|
|
pmc->last_cmd_status = -ENOENT;
|
||
|
|
}
|
||
|
|
|
||
|
|
if (pmc->descriptors) {
|
||
|
|
int i;
|
||
|
|
|
||
|
|
for (i = 0;
|
||
|
|
i < pmc->num_descriptors && pmc->descriptors[i].va; i++) {
|
||
|
|
dma_free_coherent(dev,
|
||
|
|
pmc->descriptor_size,
|
||
|
|
pmc->descriptors[i].va,
|
||
|
|
pmc->descriptors[i].pa);
|
||
|
|
pmc->descriptors[i].va = NULL;
|
||
|
|
}
|
||
|
|
wil_dbg_misc(wil, "pmc_free: free descriptor info %d/%d\n", i,
|
||
|
|
pmc->num_descriptors);
|
||
|
|
wil_dbg_misc(wil,
|
||
|
|
"pmc_free: free pmc descriptors info list %p\n",
|
||
|
|
pmc->descriptors);
|
||
|
|
kfree(pmc->descriptors);
|
||
|
|
pmc->descriptors = NULL;
|
||
|
|
} else {
|
||
|
|
pmc->last_cmd_status = -ENOENT;
|
||
|
|
}
|
||
|
|
|
||
|
|
mutex_unlock(&pmc->lock);
|
||
|
|
}
|
||
|
|
|
||
|
|
/* Status of the last operation requested via debugfs: alloc/free/read.
|
||
|
|
* 0 - success or negative errno
|
||
|
|
*/
|
||
|
|
int wil_pmc_last_cmd_status(struct wil6210_priv *wil)
|
||
|
|
{
|
||
|
|
wil_dbg_misc(wil, "pmc_last_cmd_status: status %d\n",
|
||
|
|
wil->pmc.last_cmd_status);
|
||
|
|
|
||
|
|
return wil->pmc.last_cmd_status;
|
||
|
|
}
|
||
|
|
|
||
|
|
/* Read from required position up to the end of current descriptor,
|
||
|
|
* depends on descriptor size configured during alloc request.
|
||
|
|
*/
|
||
|
|
ssize_t wil_pmc_read(struct file *filp, char __user *buf, size_t count,
|
||
|
|
loff_t *f_pos)
|
||
|
|
{
|
||
|
|
struct wil6210_priv *wil = filp->private_data;
|
||
|
|
struct pmc_ctx *pmc = &wil->pmc;
|
||
|
|
size_t retval = 0;
|
||
|
|
unsigned long long idx;
|
||
|
|
loff_t offset;
|
||
|
|
size_t pmc_size;
|
||
|
|
|
||
|
|
mutex_lock(&pmc->lock);
|
||
|
|
|
||
|
|
if (!wil_is_pmc_allocated(pmc)) {
|
||
|
|
wil_err(wil, "error, pmc is not allocated!\n");
|
||
|
|
pmc->last_cmd_status = -EPERM;
|
||
|
|
mutex_unlock(&pmc->lock);
|
||
|
|
return -EPERM;
|
||
|
|
}
|
||
|
|
|
||
|
|
pmc_size = pmc->descriptor_size * pmc->num_descriptors;
|
||
|
|
|
||
|
|
wil_dbg_misc(wil,
|
||
|
|
"pmc_read: size %u, pos %lld\n",
|
||
|
|
(u32)count, *f_pos);
|
||
|
|
|
||
|
|
pmc->last_cmd_status = 0;
|
||
|
|
|
||
|
|
idx = *f_pos;
|
||
|
|
do_div(idx, pmc->descriptor_size);
|
||
|
|
offset = *f_pos - (idx * pmc->descriptor_size);
|
||
|
|
|
||
|
|
if (*f_pos >= pmc_size) {
|
||
|
|
wil_dbg_misc(wil,
|
||
|
|
"pmc_read: reached end of pmc buf: %lld >= %u\n",
|
||
|
|
*f_pos, (u32)pmc_size);
|
||
|
|
pmc->last_cmd_status = -ERANGE;
|
||
|
|
goto out;
|
||
|
|
}
|
||
|
|
|
||
|
|
wil_dbg_misc(wil,
|
||
|
|
"pmc_read: read from pos %lld (descriptor %llu, offset %llu) %zu bytes\n",
|
||
|
|
*f_pos, idx, offset, count);
|
||
|
|
|
||
|
|
/* if no errors, return the copied byte count */
|
||
|
|
retval = simple_read_from_buffer(buf,
|
||
|
|
count,
|
||
|
|
&offset,
|
||
|
|
pmc->descriptors[idx].va,
|
||
|
|
pmc->descriptor_size);
|
||
|
|
*f_pos += retval;
|
||
|
|
out:
|
||
|
|
mutex_unlock(&pmc->lock);
|
||
|
|
|
||
|
|
return retval;
|
||
|
|
}
|
||
|
|
|
||
|
|
loff_t wil_pmc_llseek(struct file *filp, loff_t off, int whence)
|
||
|
|
{
|
||
|
|
loff_t newpos;
|
||
|
|
struct wil6210_priv *wil = filp->private_data;
|
||
|
|
struct pmc_ctx *pmc = &wil->pmc;
|
||
|
|
size_t pmc_size;
|
||
|
|
|
||
|
|
mutex_lock(&pmc->lock);
|
||
|
|
|
||
|
|
if (!wil_is_pmc_allocated(pmc)) {
|
||
|
|
wil_err(wil, "error, pmc is not allocated!\n");
|
||
|
|
pmc->last_cmd_status = -EPERM;
|
||
|
|
mutex_unlock(&pmc->lock);
|
||
|
|
return -EPERM;
|
||
|
|
}
|
||
|
|
|
||
|
|
pmc_size = pmc->descriptor_size * pmc->num_descriptors;
|
||
|
|
|
||
|
|
switch (whence) {
|
||
|
|
case 0: /* SEEK_SET */
|
||
|
|
newpos = off;
|
||
|
|
break;
|
||
|
|
|
||
|
|
case 1: /* SEEK_CUR */
|
||
|
|
newpos = filp->f_pos + off;
|
||
|
|
break;
|
||
|
|
|
||
|
|
case 2: /* SEEK_END */
|
||
|
|
newpos = pmc_size;
|
||
|
|
break;
|
||
|
|
|
||
|
|
default: /* can't happen */
|
||
|
|
newpos = -EINVAL;
|
||
|
|
goto out;
|
||
|
|
}
|
||
|
|
|
||
|
|
if (newpos < 0) {
|
||
|
|
newpos = -EINVAL;
|
||
|
|
goto out;
|
||
|
|
}
|
||
|
|
if (newpos > pmc_size)
|
||
|
|
newpos = pmc_size;
|
||
|
|
|
||
|
|
filp->f_pos = newpos;
|
||
|
|
|
||
|
|
out:
|
||
|
|
mutex_unlock(&pmc->lock);
|
||
|
|
|
||
|
|
return newpos;
|
||
|
|
}
|
||
|
|
|
||
|
|
int wil_pmcring_read(struct seq_file *s, void *data)
|
||
|
|
{
|
||
|
|
struct wil6210_priv *wil = s->private;
|
||
|
|
struct pmc_ctx *pmc = &wil->pmc;
|
||
|
|
size_t pmc_ring_size =
|
||
|
|
sizeof(struct vring_rx_desc) * pmc->num_descriptors;
|
||
|
|
|
||
|
|
mutex_lock(&pmc->lock);
|
||
|
|
|
||
|
|
if (!wil_is_pmc_allocated(pmc)) {
|
||
|
|
wil_err(wil, "error, pmc is not allocated!\n");
|
||
|
|
pmc->last_cmd_status = -EPERM;
|
||
|
|
mutex_unlock(&pmc->lock);
|
||
|
|
return -EPERM;
|
||
|
|
}
|
||
|
|
|
||
|
|
wil_dbg_misc(wil, "pmcring_read: size %zu\n", pmc_ring_size);
|
||
|
|
|
||
|
|
seq_write(s, pmc->pring_va, pmc_ring_size);
|
||
|
|
|
||
|
|
mutex_unlock(&pmc->lock);
|
||
|
|
|
||
|
|
return 0;
|
||
|
|
}
|