/*
|
* Copyright (C) 2016-2018 Spreadtrum Communications Inc.
|
* 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 "ioctl.h"
|
#include "pcie.h"
|
#include "edma_engine.h"
|
|
enum PCIE_ARG_INDEX {
|
PCIE_ARG_ADDR,
|
PCIE_ARG_VALUE,
|
PCIE_ARG_SIZE,
|
PCIE_ARG_BAR,
|
PCIE_ARG_RUN,
|
PCIE_ARG_OFFSET,
|
PCIE_ARG_VIR,
|
PCIE_ARG_REGION,
|
PCIE_ARG_TWO_LINK,
|
PCIE_ARG_MODE,
|
PCIE_ARG_MAX,
|
};
|
|
static struct arg_t pcie_args[PCIE_ARG_MAX] = {
|
{PCIE_ARG_ADDR, "addr", 0},
|
{PCIE_ARG_VALUE, "value", 0},
|
{PCIE_ARG_SIZE, "size", 4},
|
{PCIE_ARG_BAR, "bar", 0},
|
{PCIE_ARG_OFFSET, "offset", 0},
|
{PCIE_ARG_RUN, "run", 0},
|
{PCIE_ARG_VIR, "vir", 0},
|
{PCIE_ARG_REGION, "region", 0},
|
{PCIE_ARG_TWO_LINK, "link", 0},
|
{PCIE_ARG_MODE, "mode", 0},
|
};
|
|
struct arg_t *pcie_arg_index(unsigned int index)
|
{
|
int i;
|
|
for (i = 0; i < PCIE_ARG_MAX; i++) {
|
if (index == pcie_args[i].id)
|
return &pcie_args[i];
|
|
}
|
return NULL;
|
}
|
|
static unsigned long args_value(int index)
|
{
|
int i;
|
|
for (i = 0; i < PCIE_ARG_MAX; i++) {
|
if (index == pcie_args[i].id)
|
return pcie_args[i].def;
|
}
|
|
return -1;
|
}
|
|
static int hwcopy(unsigned char *dest, unsigned char *src, int len)
|
{
|
int i;
|
|
for (i = 0; i < (len / 4); i++) {
|
*((int *)(dest)) = *((int *)(src));
|
dest += 4;
|
src += 4;
|
}
|
for (i = 0; i < (len % 4); i++) {
|
*dest = *src;
|
dest++;
|
src++;
|
}
|
|
return 0;
|
}
|
|
static int cmdline_args(char *cmdline, char *cmd, struct arg_t *args, int argc)
|
{
|
int status = 0;
|
char *end;
|
char *argname;
|
char *cp;
|
int DONE;
|
int FOUND = 0;
|
|
unsigned short base;
|
unsigned long result, value;
|
unsigned long val;
|
unsigned long i;
|
unsigned long j;
|
|
for (i = 0; i < argc; i++)
|
args[i].def = 0;
|
|
/* get cmd */
|
while (*cmdline == ' ' || *cmdline == '\t')
|
cmdline++;
|
|
while (*cmdline != ' ' && *cmdline != '\t' && *cmdline != '\0') {
|
*cmd = *cmdline;
|
cmd++;
|
cmdline++;
|
}
|
*cmd = '\0';
|
if (*cmdline == '\0')
|
goto WEDONE;
|
|
*cmdline = '\0';
|
cmdline++;
|
while (*cmdline == ' ' || *cmdline == '\t')
|
cmdline++;
|
|
end = cmdline;
|
while (*end == ' ' || *end == '\t')
|
end++;
|
|
/*
|
* Parse cmdline
|
*/
|
DONE = (*end == '\0') ? 1 : 0;
|
while (!DONE) {
|
/* get the register name */
|
while (*end != '=' && *end != '\0')
|
end++;
|
if (*end == '\0') {
|
status = 1;
|
goto WEDONE;
|
}
|
*end = '\0';
|
argname = cmdline;
|
/* now get value to write to register */
|
cmdline = ++end;
|
/* if there's whitespace after the '=', exit with an error */
|
if (*end == ' ' || *end == '\t' || *end == '\n') {
|
status = 1;
|
goto WEDONE;
|
}
|
while (*end != ' ' && *end != '\t' && *end != '\n'
|
&& *end != '\0')
|
end++;
|
if (*end == '\0')
|
DONE = 1;
|
else
|
*end = '\0';
|
|
if (!strcmp(argname, "file") || !strcmp(argname, "filec")) {
|
val = 1;
|
} else {
|
/* get the base, convert value to base-10 if necessary */
|
val = 0;
|
result = 0;
|
cp = cmdline;
|
if (cp[0] == '0' && (cp[1] == 'x' || cp[1] == 'X')) {
|
base = 16;
|
cp += 2;
|
|
} else {
|
base = 10;
|
}
|
while (isxdigit(*cp)) {
|
value = isdigit(*cp) ? (*cp - '0')
|
: ((islower(*cp) ? toupper(*cp) : *cp) -
|
'A' + 10);
|
|
result = result * base + value;
|
cp++;
|
}
|
|
val = result;
|
}
|
|
FOUND = 0;
|
/*
|
* verify the register arg is valid, and if the value is not
|
* too big, write it to the corresponding location in arg_vals
|
*/
|
for (j = 0; j < argc && !FOUND; j++) {
|
if (!strcmp(argname, args[j].name)) {
|
args[j].def = val;
|
FOUND = 1;
|
}
|
}
|
if (!FOUND) {
|
PCIE_ERR("arg %s err\n", argname);
|
status = 0;
|
goto WEDONE;
|
}
|
|
/*
|
* point cmdline and end to next non-whitespace
|
* (next argument)
|
*/
|
cmdline = ++end;
|
while (*cmdline == ' ' || *cmdline == '\t' || *cmdline == '\n')
|
cmdline++;
|
end = cmdline;
|
/*
|
* if, after skipping whitespace, we hit end of line or EOF,
|
* we're done
|
*/
|
if (*end == '\0')
|
DONE = 1;
|
}
|
|
WEDONE:
|
return status;
|
}
|
|
static int pcie_cmd_proc(struct char_drv_info *dev, unsigned char *input,
|
int input_len, struct tlv *replay)
|
{
|
int ret, bar, offset, i, run, flag;
|
unsigned long addr, value, size, mode;
|
unsigned char cmd[64], string[512] = { 0 }, *buf, *mem;
|
struct pcicmd *pcicmd;
|
struct dma_buf dm;
|
struct wcn_pcie_info *priv;
|
|
priv = dev->pcie_dev_info;
|
|
/* IRAM */
|
pcicmd = (struct pcicmd *) (pcie_bar_vmem(priv, 0) +
|
cp2_test_addr1 + cp2_test_addr2);
|
|
ret = cmdline_args(input, cmd, pcie_args, PCIE_ARG_MAX);
|
if (ret) {
|
PCIE_INFO("cmdline_args err\n");
|
return -1;
|
} else if (!strcmp("mread", cmd)) {
|
addr = args_value(PCIE_ARG_ADDR);
|
size = args_value(PCIE_ARG_SIZE);
|
|
replay->t = 1;
|
replay->l = size;
|
memcpy(replay->v, (unsigned char *)addr, replay->l);
|
} else if (!strcmp("mwrite", cmd)) {
|
addr = args_value(PCIE_ARG_ADDR);
|
value = args_value(PCIE_ARG_VALUE);
|
size = args_value(PCIE_ARG_SIZE);
|
PCIE_INFO("memwrite addr=0x%lx value=0x%lx size=%ld\n",
|
addr, value, size);
|
memcpy((char *)(addr), (char *)&value, 4);
|
} else if (!strcmp("init", cmd)) {
|
struct inbound_reg *ibreg =
|
(struct inbound_reg *) ibreg_base(priv, 0);
|
|
if (ibreg == NULL) {
|
PCIE_ERR("ibreg(0) NULL\n");
|
return -1;
|
}
|
ibreg->lower_target_addr = 0x40000000;
|
ibreg->upper_target_addr = 0x00000000;
|
ibreg->type = 0x00000000;
|
ibreg->limit = 0x00FFFFFF;
|
ibreg->en = 0xc0000000;
|
replay->t = 1;
|
replay->l = sizeof(struct inbound_reg);
|
hwcopy(replay->v, (unsigned char *)ibreg, replay->l);
|
} else if (!strcmp("config", cmd)) {
|
size = args_value(PCIE_ARG_SIZE);
|
if (size < 256)
|
replay->l = 256;
|
else
|
replay->l = size;
|
replay->t = 1;
|
pcie_config_read(priv, 0, replay->v, replay->l);
|
} else if (!strcmp("bwrite", cmd)) {
|
bar = args_value(PCIE_ARG_BAR);
|
offset = args_value(PCIE_ARG_OFFSET);
|
value = args_value(PCIE_ARG_VALUE);
|
|
sprintf(string, "bwrite bar=%d offset=0x%x value=0x%lx\n", bar,
|
offset, value);
|
PCIE_INFO("do %s\n", string);
|
pcie_bar_write(priv, bar, offset, (char *)(&value), 4);
|
replay->t = 0;
|
replay->l = strlen(string);
|
memcpy(replay->v, string, replay->l);
|
} else if (!strcmp("bread", cmd)) {
|
bar = args_value(PCIE_ARG_BAR);
|
offset = args_value(PCIE_ARG_OFFSET);
|
size = args_value(PCIE_ARG_SIZE);
|
buf = pcie_bar_vmem(priv, bar) + offset;
|
PCIE_INFO("kernel bread bar=%d offset=0x%x size=0x%lx\n", bar,
|
offset, size);
|
replay->t = 1;
|
replay->l = size;
|
hwcopy(replay->v, buf, replay->l);
|
} else if (!strcmp("dmalloc", cmd)) {
|
size = args_value(PCIE_ARG_SIZE);
|
|
ret = dmalloc(priv, &dm, size);
|
if (!ret) {
|
sprintf(string, "dmalloc(%ld) 0x%lx, 0x%lx ok\n",
|
size, dm.vir, dm.phy);
|
} else
|
sprintf(string, "dmalloc(%ld) fail\n", size);
|
replay->t = 0;
|
replay->l = strlen(string);
|
memcpy(replay->v, string, replay->l);
|
} else if (!strcmp("malloc", cmd)) {
|
size = args_value(PCIE_ARG_SIZE);
|
mem = (unsigned char *)mpool_malloc(size);
|
|
} else if (!strcmp("outbound", cmd)) {
|
addr = args_value(PCIE_ARG_ADDR);
|
size = args_value(PCIE_ARG_SIZE);
|
run = args_value(PCIE_ARG_RUN);
|
|
pcicmd->addr1 = addr;
|
pcicmd->arg[0] = size;
|
pcicmd->arg[1] = run;
|
pcicmd->cmd = 0x00000002;
|
flag = 1;
|
i = 10000;
|
while (i--) {
|
if (pcicmd->cmd == MAGIC_VALUE) {
|
replay->t = 0;
|
replay->l = 128;
|
memcpy(replay->v,
|
pcie_bar_vmem(priv, 0) + cp2_test_addr3 +
|
cp2_test_addr4, 128);
|
sprintf(string, "ok\n");
|
replay->t = 0;
|
replay->l = strlen(string);
|
memcpy(replay->v, string, replay->l);
|
flag = 0;
|
break;
|
}
|
usleep_range(1000, 2000);
|
}
|
if (flag == 1) {
|
sprintf(string, "cmd timeout\n");
|
replay->t = 0;
|
replay->l = strlen(string);
|
memcpy(replay->v, string, replay->l);
|
}
|
} else if (!strcmp("inbound", cmd)) {
|
bar = args_value(PCIE_ARG_BAR);
|
offset = args_value(PCIE_ARG_OFFSET);
|
size = args_value(PCIE_ARG_SIZE);
|
run = args_value(PCIE_ARG_RUN);
|
|
PCIE_INFO("inbound(%d,%ld,%d)\n", offset, size, run);
|
|
mem = kmalloc(size, GFP_KERNEL);
|
buf = kmalloc(size, GFP_KERNEL);
|
if ((!mem) || (!buf)) {
|
kfree(mem);
|
kfree(buf);
|
PCIE_ERR("kmalloc(%ld) err\n", size);
|
return 0;
|
}
|
for (i = 0; i < run; i++) {
|
memcpy(buf + 0, (char *)(&i), 4);
|
memset(buf + 4, (char)i, size - 4);
|
memcpy(pcie_bar_vmem(priv, bar) + offset, buf,
|
size);
|
memcpy(mem, pcie_bar_vmem(priv, bar) + offset,
|
size);
|
if (memcmp(buf, mem, size)) {
|
sprintf(string, "inbound run %d err\n", i);
|
break;
|
}
|
}
|
if (i == run) {
|
sprintf(string, "inbound(0x%x,0x%lx,0x%x) ok\n", offset,
|
size, run);
|
}
|
PCIE_INFO("%s", string);
|
replay->t = 0;
|
replay->l = strlen(string);
|
memcpy(replay->v, string, replay->l);
|
|
kfree(mem);
|
kfree(buf);
|
} else if (!strcmp("lo_start", cmd)) {
|
mode = args_value(PCIE_ARG_MODE);
|
lo_start(mode);
|
} else if (!strcmp("lo_stop", cmd))
|
lo_stop();
|
else
|
PCIE_INFO("unknown cmd %s\n", cmd);
|
|
return 0;
|
}
|
|
int hexdump(char *name, char *buf, int len)
|
{
|
int i, count;
|
unsigned int *p;
|
|
count = len / 32;
|
count += 1;
|
PCIE_INFO("%s %s hex(len=%d):\n", __func__, name, len);
|
for (i = 0; i < count; i++) {
|
p = (unsigned int *)(buf + i * 32);
|
PCIE_INFO("mem[0x%04x] 0x%08x,0x%08x,0x%08x,0x%08x,"
|
"0x%08x,0x%08x,0x%08x,0x%08x,\n",
|
i * 32, p[0], p[1], p[2], p[3],
|
p[4], p[5], p[6], p[7]);
|
}
|
|
return 0;
|
}
|
|
static int char_open(struct inode *inode, struct file *filp)
|
{
|
struct char_drv_info *dev;
|
|
PCIE_INFO("%s\n", __func__);
|
dev = container_of(inode->i_cdev, struct char_drv_info, testcdev);
|
filp->private_data = dev;
|
|
return 0;
|
}
|
|
static ssize_t char_write(struct file *filp, const char __user *buffer,
|
size_t count, loff_t *offset)
|
{
|
PCIE_INFO("%s\n", __func__);
|
|
return 0;
|
}
|
|
static ssize_t char_read(struct file *filp, char __user *buffer, size_t count,
|
loff_t *offset)
|
{
|
PCIE_INFO("%s\n", __func__);
|
|
return 0;
|
}
|
|
static int char_release(struct inode *inode, struct file *filp)
|
{
|
PCIE_INFO("%s\n", __func__);
|
|
return 0;
|
}
|
|
static long char_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
|
{
|
int ret;
|
struct tlv *tlv;
|
unsigned char *buf[2];
|
struct char_drv_info *dev = filp->private_data;
|
|
buf[0] = kmalloc(4096, GFP_KERNEL);
|
buf[1] = kmalloc(4096, GFP_KERNEL);
|
|
tlv = (struct tlv *) buf[1];
|
|
ret = copy_from_user(buf[0], (char __user *)arg, 64);
|
PCIE_INFO("input:%s\n", buf[0]);
|
|
pcie_cmd_proc(dev, buf[0], 4096, (struct tlv *) buf[1]);
|
|
/* sizeof(struct tlv) + tlv->l */
|
ret = copy_to_user((char __user *)arg, buf[1], 4096);
|
|
kfree(buf[0]);
|
kfree(buf[1]);
|
|
return 0;
|
}
|
|
static const struct file_operations fop = {
|
.owner = THIS_MODULE,
|
.open = char_open,
|
.release = char_release,
|
.write = char_write,
|
.read = char_read,
|
.unlocked_ioctl = char_ioctl,
|
};
|
|
static int ioctlcmd_init(struct wcn_pcie_info *bus)
|
{
|
int ret;
|
dev_t dev;
|
struct char_drv_info *drv;
|
|
drv = kmalloc(sizeof(struct char_drv_info), GFP_KERNEL);
|
if (!drv) {
|
ret = -ENOMEM;
|
return ret;
|
}
|
|
bus->p_char = drv;
|
drv->pcie_dev_info = bus;
|
drv->major = 321;
|
dev = MKDEV(drv->major, 0);
|
ret = register_chrdev_region(dev, 1, "char");
|
if (ret) {
|
alloc_chrdev_region(&dev, 0, 1, "char");
|
drv->major = MAJOR(dev);
|
}
|
drv->testcdev.owner = THIS_MODULE;
|
cdev_init(&(drv->testcdev), &fop);
|
cdev_add(&(drv->testcdev), dev, 1);
|
|
drv->myclass = class_create(THIS_MODULE, "char_class");
|
drv->mydev = device_create(drv->myclass, NULL, dev, NULL, "kchar");
|
PCIE_INFO("module init ok ...\n");
|
|
return 0;
|
}
|
|
int ioctlcmd_deinit(struct wcn_pcie_info *bus)
|
{
|
dev_t dev;
|
struct char_drv_info *drv = bus->p_char;
|
|
dev = MKDEV(drv->major, 0);
|
|
device_destroy(drv->myclass, dev);
|
class_destroy(drv->myclass);
|
|
cdev_del(&(drv->testcdev));
|
unregister_chrdev_region(dev, 1);
|
PCIE_INFO("module exit ok....\n");
|
|
return 0;
|
}
|
|
int dbg_attach_bus(struct wcn_pcie_info *bus)
|
{
|
return ioctlcmd_init(bus);
|
}
|
