/*
|
* Copyright (C) 2016 Spreadtrum Communications Inc.
|
*
|
* Authors :
|
* star.liu <star.liu@spreadtrum.com>
|
* yifei.li <yifei.li@spreadtrum.com>
|
*
|
* This software is licensed under the terms of the GNU General Public
|
* License version 2, as published by the Free Software Foundation, and
|
* may be copied, distributed, and modified under those terms.
|
*
|
* This program is distributed in the hope that it will be useful,
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
* GNU General Public License for more details.
|
*/
|
|
#include <linux/prefetch.h>
|
#include <linux/version.h>
|
#include <wcn_bus.h>
|
#include "rx_msg.h"
|
#include "tx_msg.h"
|
#include "cmdevt.h"
|
#include "work.h"
|
|
#define GET_NEXT_ADDR_TRANS_VALUE(value, offset) \
|
(struct sprdwl_addr_trans_value *)((unsigned char *)value + offset)
|
|
#define SKB_SHARED_INFO_OFFSET \
|
SKB_DATA_ALIGN(SPRDWL_MAX_DATA_RXLEN + NET_SKB_PAD)
|
|
void check_mh_buffer(struct device *dev, void *buffer, dma_addr_t pa,
|
size_t size, enum dma_data_direction direction)
|
{
|
#define MAX_RETRY_NUM 8
|
int retry = 0;
|
|
if (direction == DMA_FROM_DEVICE) {
|
struct rx_msdu_desc *desc = buffer + sizeof(struct rx_mh_desc);
|
|
/* Check whether this buffer is ok to use */
|
while ((desc->data_write_done != 1) ||
|
(retry < MAX_RETRY_NUM)) {
|
wl_err("%s: hw still writing: 0x%lx, 0x%lx\n",
|
__func__, (unsigned long)buffer,
|
(unsigned long)pa);
|
/* FIXME: Should we delay here? */
|
dma_sync_single_for_device(dev, pa, size, direction);
|
retry++;
|
}
|
} else {
|
while (((((struct pcie_addr_buffer *)buffer)->
|
buffer_ctrl.buffer_inuse) != 0) ||
|
(retry < MAX_RETRY_NUM)) {
|
wl_err("%s: hw still writing: 0x%lx, 0x%lx\n",
|
__func__, (unsigned long)buffer,
|
(unsigned long)pa);
|
dma_sync_single_for_device(dev, pa, size, direction);
|
retry++;
|
}
|
}
|
|
if (retry >= MAX_RETRY_NUM) {
|
/* TODO: How to deal with this situation? */
|
dma_sync_single_for_device(dev, pa, size, direction);
|
wl_err("%s: hw still writing: 0x%lx, 0x%lx\n",
|
__func__, (unsigned long)buffer, (unsigned long)pa);
|
}
|
}
|
|
unsigned long mm_virt_to_phys(struct device *dev, void *buffer, size_t size,
|
enum dma_data_direction direction)
|
{
|
dma_addr_t pa = 0;
|
unsigned long pcie_addr = 0;
|
|
pa = dma_map_single(dev, buffer, size, direction);
|
if (likely(!dma_mapping_error(dev, pa)))
|
pcie_addr = pa | SPRDWL_MH_ADDRESS_BIT;
|
|
return pcie_addr;
|
}
|
|
void *mm_phys_to_virt(struct device *dev, unsigned long pcie_addr, size_t size,
|
enum dma_data_direction direction, bool is_mh)
|
{
|
dma_addr_t pa = 0;
|
void *buffer = NULL;
|
|
pa = pcie_addr & (~(SPRDWL_MH_ADDRESS_BIT) & SPRDWL_PHYS_MASK);
|
buffer = phys_to_virt(pa);
|
|
dma_sync_single_for_device(dev, pa, size, direction);
|
|
if (is_mh)
|
check_mh_buffer(dev, buffer, pa, size, direction);
|
|
dma_unmap_single(dev, pa, size, direction);
|
|
return buffer;
|
}
|
|
static inline struct sk_buff *mm_build_skb(void *data, int len, int buffer_type)
|
{
|
return build_skb(data, (buffer_type ? len : 0));
|
}
|
|
static struct sk_buff
|
*mm_data2skb_process(struct sprdwl_mm *mm_entry, void *data, int len)
|
{
|
struct sk_buff *skb = NULL;
|
|
skb = dev_alloc_skb(len);
|
if (likely(skb))
|
memcpy(skb->data, data, len);
|
|
return skb;
|
}
|
|
static inline void mm_flush_buffer(struct sprdwl_mm *mm_entry)
|
{
|
/* TODO: Should we stop something here? */
|
|
/* Free all skbs */
|
skb_queue_purge(&mm_entry->buffer_list);
|
}
|
|
static inline void mm_alloc_addr_buf(struct sprdwl_mm *mm_entry)
|
{
|
struct sprdwl_addr_trans_value *value = NULL;
|
struct sprdwl_addr_hdr *hdr = NULL;
|
void *p = NULL;
|
|
p = kmalloc((mm_entry->hif_offset + SPRDWL_ADDR_BUF_LEN), GFP_KERNEL);
|
if (likely(p)) {
|
hdr = (struct sprdwl_addr_hdr *)(p + mm_entry->hif_offset);
|
value = (struct sprdwl_addr_trans_value *)hdr->paydata;
|
|
/* Tell CP that this CMD is used to add MH buffer */
|
hdr->common.reserv = 1;
|
/* NOTE: CP do not care ctx_id & rsp */
|
hdr->common.ctx_id = 0;
|
hdr->common.rsp = 0;
|
hdr->common.type = SPRDWL_TYPE_DATA_PCIE_ADDR;
|
|
value->type = 0;
|
value->num = 0;
|
}
|
|
mm_entry->hdr = (void *)hdr;
|
mm_entry->addr_trans = (void *)value;
|
}
|
|
static inline int mm_do_addr_buf(struct sprdwl_mm *mm_entry)
|
{
|
struct sprdwl_rx_if *rx_if =
|
container_of(mm_entry, struct sprdwl_rx_if, mm_entry);
|
struct sprdwl_addr_trans_value *value =
|
(struct sprdwl_addr_trans_value *)mm_entry->addr_trans;
|
int ret = 0;
|
int addr_trans_len = 0;
|
|
/* NOTE: addr_buf should be allocating after being sent,
|
* JUST avoid addr_buf allocating fail after being sent here
|
*/
|
if (unlikely(!value)) {
|
wl_debug("%s: addr buf is NULL, re-alloc here\n", __func__);
|
mm_alloc_addr_buf(mm_entry);
|
if (unlikely(!mm_entry->addr_trans)) {
|
wl_err("%s: alloc addr buf fail!\n", __func__);
|
ret = -ENOMEM;
|
}
|
} else if (value->num >= SPRDWL_MAX_ADD_MH_BUF_ONCE) {
|
addr_trans_len = sizeof(struct sprdwl_addr_hdr) +
|
sizeof(struct sprdwl_addr_trans_value) +
|
(value->num*SPRDWL_PHYS_LEN);
|
|
/* FIXME: temporary solution, would TX supply API for us? */
|
/* TODO: How to do with tx fail? */
|
if ((if_tx_addr_trans(rx_if->intf, mm_entry->hdr,
|
addr_trans_len) >= 0)) {
|
mm_alloc_addr_buf(mm_entry);
|
if (unlikely(!mm_entry->addr_trans)) {
|
wl_err("%s: alloc addr buf fail!\n", __func__);
|
ret = -ENOMEM;
|
}
|
} else {
|
wl_err("%s: send addr buf fail!\n", __func__);
|
ret = -EIO;
|
}
|
}
|
|
return ret;
|
}
|
|
static int mm_w_addr_buf(struct sprdwl_mm *mm_entry, unsigned long pcie_addr)
|
{
|
int ret = 0;
|
struct sprdwl_addr_trans_value *value = NULL;
|
|
ret = mm_do_addr_buf(mm_entry);
|
if (!ret) {
|
value = (struct sprdwl_addr_trans_value *)mm_entry->addr_trans;
|
|
/* NOTE: MH is little endian */
|
memcpy((void *)value->address[value->num],
|
&pcie_addr, SPRDWL_PHYS_LEN);
|
value->num++;
|
/* do not care the result here */
|
mm_do_addr_buf(mm_entry);
|
}
|
|
return ret;
|
}
|
|
static int mm_single_buffer_alloc(struct sprdwl_mm *mm_entry)
|
{
|
struct sprdwl_rx_if *rx_if =
|
container_of(mm_entry, struct sprdwl_rx_if, mm_entry);
|
struct sk_buff *skb = NULL;
|
unsigned long pcie_addr = 0;
|
int ret = -ENOMEM;
|
|
skb = dev_alloc_skb(SPRDWL_MAX_DATA_RXLEN);
|
if (skb) {
|
/* hook skb address after skb end
|
* first 64 bits of skb_shared_info are
|
* nr_frags, tx_flags, gso_size, gso_segs, gso_type
|
* It could be re-used and MUST clean after using
|
*/
|
memcpy((void *)skb_end_pointer(skb), &skb, sizeof(skb));
|
/* transfer virt to phys */
|
pcie_addr = mm_virt_to_phys(&rx_if->intf->pdev->dev,
|
skb->data, SPRDWL_MAX_DATA_RXLEN,
|
DMA_FROM_DEVICE);
|
|
if (unlikely(!pcie_addr)) {
|
ret = mm_w_addr_buf(mm_entry, pcie_addr);
|
if (ret) {
|
wl_err("%s: write addr buf fail: %d\n",
|
__func__, ret);
|
dev_kfree_skb(skb);
|
} else {
|
/* queue skb */
|
skb_queue_tail(&mm_entry->buffer_list, skb);
|
}
|
}
|
} else {
|
wl_err("%s: alloc skb fail\n", __func__);
|
}
|
|
return ret;
|
}
|
|
int mm_buffer_alloc(struct sprdwl_mm *mm_entry, int need_num)
|
{
|
int num = 0, ret = 0;
|
|
for (num = 0; num < need_num; num++) {
|
ret = mm_single_buffer_alloc(mm_entry);
|
if (ret) {
|
wl_err("%s: alloc num: %d, need num: %d, ret: %d\n",
|
__func__, num, need_num, ret);
|
break;
|
}
|
}
|
|
return ret;
|
}
|
|
static struct sk_buff *mm_single_buffer_unlink(struct sprdwl_mm *mm_entry,
|
unsigned long pcie_addr)
|
{
|
struct sprdwl_rx_if *rx_if =
|
container_of(mm_entry, struct sprdwl_rx_if, mm_entry);
|
struct sk_buff *skb = NULL;
|
void *buffer = NULL;
|
|
buffer = mm_phys_to_virt(&rx_if->intf->pdev->dev, pcie_addr,
|
SPRDWL_MAX_DATA_RXLEN, DMA_FROM_DEVICE, true);
|
|
memcpy(&skb, (buffer + SKB_SHARED_INFO_OFFSET), sizeof(skb));
|
skb_unlink(skb, &mm_entry->buffer_list);
|
memset((void *)skb_end_pointer(skb), 0x0, sizeof(skb));
|
|
return skb;
|
}
|
|
static int mm_buffer_relink(struct sprdwl_mm *mm_entry,
|
struct sprdwl_addr_trans_value *value,
|
int total_len)
|
{
|
int num = 0;
|
unsigned long pcie_addr = 0;
|
struct sk_buff *skb = NULL;
|
int len = 0, ret = 0;
|
|
for (num = 0; num < value->num; num++) {
|
len += SPRDWL_PHYS_LEN;
|
if (unlikely(len > total_len)) {
|
wl_err("%s: total_len:%d < len:%d\n",
|
__func__, total_len, len);
|
wl_err("%s: total %d pkts, relink %d pkts\n",
|
__func__, value->num, num);
|
len = -EINVAL;
|
break;
|
}
|
|
memcpy(&pcie_addr, value->address[num], SPRDWL_PHYS_LEN);
|
pcie_addr &= SPRDWL_PHYS_MASK;
|
|
ret = mm_w_addr_buf(mm_entry, pcie_addr);
|
if (ret) {
|
wl_err("%s: write addr buf fail: %d\n", __func__, ret);
|
skb = mm_single_buffer_unlink(mm_entry, pcie_addr);
|
if (likely(skb))
|
dev_kfree_skb(skb);
|
else
|
wl_err("%s: unlink skb fail!\n", __func__);
|
}
|
|
skb = NULL;
|
pcie_addr = 0;
|
}
|
|
return len;
|
}
|
|
static int mm_buffer_unlink(struct sprdwl_mm *mm_entry,
|
struct sprdwl_addr_trans_value *value,
|
int total_len)
|
{
|
int num = 0;
|
unsigned long pcie_addr = 0;
|
struct sk_buff *skb = NULL;
|
struct rx_msdu_desc *msdu_desc = NULL;
|
int len = 0;
|
unsigned short csum = 0;
|
struct sprdwl_rx_if *rx_if =
|
container_of(mm_entry, struct sprdwl_rx_if, mm_entry);
|
|
for (num = 0; num < value->num; num++) {
|
len += SPRDWL_PHYS_LEN;
|
if (unlikely(len > total_len)) {
|
wl_err("%s: total_len:%d < len:%d\n",
|
__func__, total_len, len);
|
wl_err("%s: total %d pkts, unlink %d pkts\n",
|
__func__, value->num, num);
|
len = -EINVAL;
|
break;
|
}
|
|
memcpy(&pcie_addr, value->address[num], SPRDWL_PHYS_LEN);
|
pcie_addr &= SPRDWL_PHYS_MASK;
|
|
skb = mm_single_buffer_unlink(mm_entry, pcie_addr);
|
if (likely(skb)) {
|
csum = get_pcie_data_csum((void *)rx_if->intf,
|
skb->data);
|
skb_reserve(skb, sizeof(struct rx_mh_desc));
|
/* TODO: Would CP do this? */
|
msdu_desc = (struct rx_msdu_desc *)skb->data;
|
msdu_desc->msdu_offset -=
|
sizeof(struct rx_mh_desc);
|
/* TODO: Check whether prefetch work */
|
prefetch(skb->data);
|
|
if (likely(fill_skb_csum(skb, csum) >= 0))
|
sprdwl_rx_process(rx_if, skb);
|
else /* checksum error, free skb */
|
dev_kfree_skb(skb);
|
|
mm_single_buffer_alloc(mm_entry);
|
} else {
|
wl_err("%s: unlink skb fail!\n", __func__);
|
}
|
|
skb = NULL;
|
pcie_addr = 0;
|
}
|
|
return len;
|
}
|
|
inline bool is_compound_data(struct sprdwl_mm *mm_entry, void *data)
|
{
|
struct rx_msdu_desc *msdu_desc =
|
(struct rx_msdu_desc *)(data + mm_entry->hif_offset);
|
|
wl_debug("%s: short_pkt_num: %d\n", __func__, msdu_desc->short_pkt_num);
|
|
return (msdu_desc->short_pkt_num > 1);
|
}
|
|
static void
|
mm_compound_data_process(struct sprdwl_mm *mm_entry, void *compound_data,
|
int total_len, int buffer_type)
|
{
|
#define ALIGN_8BYTE(a) (((a) + 7) & ~7)
|
void *pos_data = NULL;
|
int num = 0, msdu_len = 0, len = 0;
|
struct sk_buff *skb = NULL;
|
struct sprdwl_rx_if *rx_if =
|
container_of(mm_entry, struct sprdwl_rx_if, mm_entry);
|
|
wl_debug("%s: num: %d, total_len: %d\n", __func__, num, total_len);
|
|
pos_data = compound_data + mm_entry->hif_offset;
|
total_len -= mm_entry->hif_offset;
|
num = ((struct rx_msdu_desc *)pos_data)->short_pkt_num;
|
|
while (num--) {
|
msdu_len = msdu_total_len((struct rx_msdu_desc *)pos_data);
|
len += ALIGN_8BYTE(msdu_len);
|
if (unlikely(len > total_len)) {
|
wl_err("%s: total_len:%d < len:%d, leave %d pkts\n",
|
__func__, total_len, len, (num + 1));
|
break;
|
}
|
|
wl_debug("%s: msdu_len: %d, len: %d\n",
|
__func__, msdu_len, len);
|
|
skb = mm_data2skb_process(mm_entry, pos_data, msdu_len);
|
if (unlikely(!skb)) {
|
wl_err("%s: alloc skb fail, leave %d pkts\n",
|
__func__, (num + 1));
|
break;
|
}
|
|
sprdwl_rx_process(rx_if, skb);
|
|
pos_data = (unsigned char *)pos_data +
|
ALIGN_8BYTE(msdu_len + sizeof(struct rx_mh_desc));
|
skb = NULL;
|
}
|
|
sprdwl_free_data(compound_data, buffer_type);
|
}
|
|
static void mm_normal_data_process(struct sprdwl_mm *mm_entry,
|
void *data, int len, int buffer_type)
|
{
|
int skb_len = 0;
|
unsigned short csum = 0;
|
bool free_data = false;
|
struct sk_buff *skb = NULL;
|
struct rx_msdu_desc *msdu_desc =
|
(struct rx_msdu_desc *)(data + mm_entry->hif_offset);
|
struct sprdwl_rx_if *rx_if =
|
container_of(mm_entry, struct sprdwl_rx_if, mm_entry);
|
|
if (unlikely(len < sizeof(struct rx_msdu_desc))) {
|
wl_err("%s: data len is %d, too short\n",
|
__func__, len);
|
free_data = true;
|
} else {
|
csum = get_sdio_data_csum((void *)rx_if->intf, data);
|
skb_len = SKB_DATA_ALIGN(sizeof(struct skb_shared_info)) +
|
SKB_DATA_ALIGN(msdu_total_len(msdu_desc) +
|
mm_entry->hif_offset);
|
|
/*0: sdma, 1: adma*/
|
if (sprdwcn_bus_get_rx_mode() == 1) {
|
if (likely(skb_len <= len)) {
|
/* Use len instead of skb_len
|
* because we could reserve more tailroom
|
*/
|
|
skb = mm_build_skb(data, skb_len, buffer_type);
|
} else {
|
/* Should not happen */
|
wl_err("%s: data len is %d, skb need %d\n",
|
__func__, len, skb_len);
|
skb = mm_data2skb_process(mm_entry, data,
|
SKB_WITH_OVERHEAD(skb_len));
|
free_data = true;
|
}
|
} else {
|
skb = mm_data2skb_process(mm_entry, data, SKB_WITH_OVERHEAD(skb_len));
|
free_data = true;
|
}
|
|
if (unlikely(!skb)) {
|
wl_err("%s: alloc skb fail\n", __func__);
|
free_data = true;
|
} else {
|
skb_reserve(skb, mm_entry->hif_offset);
|
|
if (likely(fill_skb_csum(skb, csum) >= 0))
|
sprdwl_rx_process(rx_if, skb);
|
else /* checksum error, free skb */
|
dev_kfree_skb(skb);
|
}
|
}
|
|
if (free_data)
|
sprdwl_free_data(data, buffer_type);
|
}
|
|
|
/* NOTE: This function JUST work when mm_w_addr_buf() work abnormal */
|
static inline void mm_refill_buffer(struct sprdwl_mm *mm_entry)
|
{
|
int num = SPRDWL_MAX_MH_BUF - skb_queue_len(&mm_entry->buffer_list);
|
|
wl_debug("%s: need to refill %d buffer\n", __func__, num);
|
|
if (num > 0) {
|
mm_buffer_alloc(mm_entry, num);
|
} else if (num < 0) {
|
/* Should never happen */
|
wl_err("%s: %d > mx addr buf!\n", __func__, num);
|
}
|
}
|
|
static int mm_single_event_process(struct sprdwl_mm *mm_entry,
|
struct sprdwl_addr_trans_value *value,
|
int len)
|
{
|
int ret = 0;
|
|
switch (value->type) {
|
case SPRDWL_PROCESS_BUFFER:
|
ret = mm_buffer_unlink(mm_entry, value, len);
|
break;
|
case SPRDWL_FREE_BUFFER:
|
ret = mm_buffer_relink(mm_entry, value, len);
|
break;
|
case SPRDWL_REQUEST_BUFFER:
|
/* NOTE: Not need to do anything here */
|
break;
|
case SPRDWL_FLUSH_BUFFER:
|
mm_flush_buffer(mm_entry);
|
break;
|
default:
|
wl_err("%s: err type: %d\n", __func__, value->type);
|
ret = -EINVAL;
|
}
|
|
if (value->type < SPRDWL_FLUSH_BUFFER)
|
mm_refill_buffer(mm_entry);
|
|
return (ret < 0) ? ret : (ret + sizeof(*value));
|
}
|
|
/* PCIE DATA EVENT */
|
void mm_mh_data_event_process(struct sprdwl_mm *mm_entry, void *data,
|
int len, int buffer_type)
|
{
|
int offset = 0;
|
struct sprdwl_addr_hdr *hdr =
|
(struct sprdwl_addr_hdr *)(data + mm_entry->hif_offset);
|
struct sprdwl_addr_trans *addr_trans =
|
(struct sprdwl_addr_trans *)hdr->paydata;
|
struct sprdwl_addr_trans_value *value = addr_trans->value;
|
unsigned char tlv_num = addr_trans->tlv_num;
|
int remain_len = len - sizeof(*addr_trans);
|
|
while (tlv_num--) {
|
remain_len = remain_len - offset - sizeof(*value);
|
if (remain_len < 0) {
|
wl_err("%s: remain tlv num: %d\n", __func__, tlv_num);
|
break;
|
}
|
|
value = GET_NEXT_ADDR_TRANS_VALUE(value, offset);
|
offset = mm_single_event_process(mm_entry, value, remain_len);
|
if (offset < 0) {
|
wl_err("%s: do mh event fail: %d!\n",
|
__func__, offset);
|
break;
|
}
|
}
|
|
sprdwl_free_data(data, buffer_type);
|
}
|
|
/* NORMAL DATA */
|
void mm_mh_data_process(struct sprdwl_mm *mm_entry, void *data,
|
int len, int buffer_type)
|
{
|
if (is_compound_data(mm_entry, data))
|
mm_compound_data_process(mm_entry, data, len, buffer_type);
|
else
|
mm_normal_data_process(mm_entry, data, len, buffer_type);
|
}
|
|
int sprdwl_mm_init(struct sprdwl_mm *mm_entry, void *intf)
|
{
|
int ret = 0;
|
|
mm_entry->hif_offset = ((struct sprdwl_intf *)intf)->hif_offset;
|
|
if (((struct sprdwl_intf *)intf)->priv->hw_type ==
|
SPRDWL_HW_PCIE) {
|
skb_queue_head_init(&mm_entry->buffer_list);
|
|
ret = mm_buffer_alloc(mm_entry, SPRDWL_MAX_MH_BUF);
|
if (ret)
|
wl_err("%s: alloc rx if fail\n", __func__);
|
}
|
|
return ret;
|
}
|
|
int sprdwl_mm_deinit(struct sprdwl_mm *mm_entry, void *intf)
|
{
|
if (((struct sprdwl_intf *)intf)->priv->hw_type ==
|
SPRDWL_HW_PCIE) {
|
/* NOTE: pclint says kfree(NULL) is safe */
|
kfree(mm_entry->hdr);
|
mm_entry->hdr = NULL;
|
mm_entry->addr_trans = NULL;
|
mm_flush_buffer(mm_entry);
|
}
|
|
mm_entry->hif_offset = 0;
|
return 0;
|
}
|
