M7350/kernel/arch/arm/mach-msm/dma_test.c

361 lines
9.0 KiB
C
Raw Normal View History

2024-09-09 08:52:07 +00:00
/* Copyright (c) 2008-2009, The Linux Foundation. All rights reserved.
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License version 2 and
* only version 2 as published by the Free Software Foundation.
*
* 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/slab.h>
#include <linux/dma-mapping.h>
#include <linux/init.h>
#include <linux/module.h>
#include <linux/fs.h>
#include <linux/miscdevice.h>
#include <linux/uaccess.h>
#include <mach/dma.h>
#include <mach/dma_test.h>
/**********************************************************************
* User-space testing of the DMA driver.
* Intended to be loaded as a module. We have a bunch of static
* buffers that the user-side can refer to. The main DMA is simply
* used memory-to-memory. Device DMA is best tested with the specific
* device driver in question.
*/
#define MAX_TEST_BUFFERS 40
#define MAX_TEST_BUFFER_SIZE 65536
static void *(buffers[MAX_TEST_BUFFERS]);
static int sizes[MAX_TEST_BUFFERS];
/* Anything that allocates or deallocates buffers must lock with this
* mutex. */
static DEFINE_SEMAPHORE(buffer_lock);
/* Each buffer has a semaphore associated with it that will be held
* for the duration of any operations on that buffer. It also must be
* available to free the given buffer. */
static struct semaphore buffer_sems[MAX_TEST_BUFFERS];
#define buffer_up(num) up(&buffer_sems[num])
#define buffer_down(num) down(&buffer_sems[num])
/* Use the General Purpose DMA channel as our test channel. This channel
* should be available on any target. */
#define TEST_CHANNEL DMOV_GP_CHAN
struct private {
/* Each open instance is allowed a single pending
* operation. */
struct semaphore sem;
/* Simple command buffer. Allocated and freed by driver. */
/* TODO: Allocate these together. */
dmov_s *command_ptr;
/* Indirect. */
u32 *command_ptr_ptr;
/* Indicates completion with pending request. */
struct completion complete;
};
static void free_buffers(void)
{
int i;
for (i = 0; i < MAX_TEST_BUFFERS; i++) {
if (sizes[i] > 0) {
kfree(buffers[i]);
sizes[i] = 0;
}
}
}
/* Copy between two buffers, using the DMA. */
/* Allocate a buffer of a requested size. */
static int buffer_req(struct msm_dma_alloc_req *req)
{
int i;
if (req->size <= 0 || req->size > MAX_TEST_BUFFER_SIZE)
return -EINVAL;
down(&buffer_lock);
/* Find a free buffer. */
for (i = 0; i < MAX_TEST_BUFFERS; i++)
if (sizes[i] == 0)
break;
if (i >= MAX_TEST_BUFFERS)
goto error;
buffers[i] = kmalloc(req->size, GFP_KERNEL | __GFP_DMA);
if (buffers[i] == 0)
goto error;
sizes[i] = req->size;
req->bufnum = i;
up(&buffer_lock);
return 0;
error:
up(&buffer_lock);
return -ENOSPC;
}
static int dma_scopy(struct msm_dma_scopy *scopy, struct private *priv)
{
int err = 0;
dma_addr_t mapped_cmd;
dma_addr_t mapped_cmd_ptr;
buffer_down(scopy->srcbuf);
if (scopy->srcbuf != scopy->destbuf)
buffer_down(scopy->destbuf);
priv->command_ptr->cmd = CMD_PTR_LP | CMD_MODE_SINGLE;
priv->command_ptr->src = dma_map_single(NULL, buffers[scopy->srcbuf],
scopy->size, DMA_TO_DEVICE);
priv->command_ptr->dst = dma_map_single(NULL, buffers[scopy->destbuf],
scopy->size, DMA_FROM_DEVICE);
priv->command_ptr->len = scopy->size;
mapped_cmd =
dma_map_single(NULL, priv->command_ptr, sizeof(*priv->command_ptr),
DMA_TO_DEVICE);
*(priv->command_ptr_ptr) = CMD_PTR_ADDR(mapped_cmd) | CMD_PTR_LP;
mapped_cmd_ptr = dma_map_single(NULL, priv->command_ptr_ptr,
sizeof(*priv->command_ptr_ptr),
DMA_TO_DEVICE);
msm_dmov_exec_cmd(TEST_CHANNEL,
DMOV_CMD_PTR_LIST | DMOV_CMD_ADDR(mapped_cmd_ptr));
dma_unmap_single(NULL, (dma_addr_t) mapped_cmd_ptr,
sizeof(*priv->command_ptr_ptr), DMA_TO_DEVICE);
dma_unmap_single(NULL, (dma_addr_t) mapped_cmd,
sizeof(*priv->command_ptr), DMA_TO_DEVICE);
dma_unmap_single(NULL, (dma_addr_t) priv->command_ptr->dst,
scopy->size, DMA_FROM_DEVICE);
dma_unmap_single(NULL, (dma_addr_t) priv->command_ptr->src,
scopy->size, DMA_TO_DEVICE);
if (scopy->srcbuf != scopy->destbuf)
buffer_up(scopy->destbuf);
buffer_up(scopy->srcbuf);
return err;
}
static int dma_test_open(struct inode *inode, struct file *file)
{
struct private *priv;
printk(KERN_ALERT "%s\n", __func__);
priv = kmalloc(sizeof(struct private), GFP_KERNEL);
if (priv == NULL)
return -ENOMEM;
file->private_data = priv;
sema_init(&priv->sem, 1);
/* Note, that these should be allocated together so we don't
* waste 32 bytes for each. */
/* Allocate the command pointer. */
priv->command_ptr = kmalloc(sizeof(&priv->command_ptr),
GFP_KERNEL | __GFP_DMA);
if (priv->command_ptr == NULL) {
kfree(priv);
return -ENOSPC;
}
/* And the indirect pointer. */
priv->command_ptr_ptr = kmalloc(sizeof(u32), GFP_KERNEL | __GFP_DMA);
if (priv->command_ptr_ptr == NULL) {
kfree(priv->command_ptr);
kfree(priv);
return -ENOSPC;
}
return 0;
}
static int dma_test_release(struct inode *inode, struct file *file)
{
struct private *priv;
printk(KERN_ALERT "%s\n", __func__);
if (file->private_data != NULL) {
priv = file->private_data;
kfree(priv->command_ptr_ptr);
kfree(priv->command_ptr);
}
kfree(file->private_data);
file->private_data = NULL;
return 0;
}
static long dma_test_ioctl(struct file *file, unsigned cmd, unsigned long arg)
{
int err = 0;
int tmp;
struct msm_dma_alloc_req alloc_req;
struct msm_dma_bufxfer xfer;
struct msm_dma_scopy scopy;
struct private *priv = file->private_data;
/* Verify user arguments. */
if (_IOC_TYPE(cmd) != MSM_DMA_IOC_MAGIC)
return -ENOTTY;
switch (cmd) {
case MSM_DMA_IOALLOC:
if (!access_ok(VERIFY_WRITE, (void __user *)arg,
sizeof(alloc_req)))
return -EFAULT;
if (__copy_from_user(&alloc_req, (void __user *)arg,
sizeof(alloc_req)))
return -EFAULT;
err = buffer_req(&alloc_req);
if (err < 0)
return err;
if (__copy_to_user((void __user *)arg, &alloc_req,
sizeof(alloc_req)))
return -EFAULT;
break;
case MSM_DMA_IOFREEALL:
down(&buffer_lock);
for (tmp = 0; tmp < MAX_TEST_BUFFERS; tmp++) {
buffer_down(tmp);
if (sizes[tmp] > 0) {
kfree(buffers[tmp]);
sizes[tmp] = 0;
}
buffer_up(tmp);
}
up(&buffer_lock);
break;
case MSM_DMA_IOWBUF:
if (copy_from_user(&xfer, (void __user *)arg, sizeof(xfer)))
return -EFAULT;
if (xfer.bufnum < 0 || xfer.bufnum >= MAX_TEST_BUFFERS)
return -EINVAL;
buffer_down(xfer.bufnum);
if (sizes[xfer.bufnum] == 0 ||
xfer.size <= 0 || xfer.size > sizes[xfer.bufnum]) {
buffer_up(xfer.bufnum);
return -EINVAL;
}
if (copy_from_user(buffers[xfer.bufnum],
(void __user *)xfer.data, xfer.size))
err = -EFAULT;
buffer_up(xfer.bufnum);
break;
case MSM_DMA_IORBUF:
if (copy_from_user(&xfer, (void __user *)arg, sizeof(xfer)))
return -EFAULT;
if (xfer.bufnum < 0 || xfer.bufnum >= MAX_TEST_BUFFERS)
return -EINVAL;
buffer_down(xfer.bufnum);
if (sizes[xfer.bufnum] == 0 ||
xfer.size <= 0 || xfer.size > sizes[xfer.bufnum]) {
buffer_up(xfer.bufnum);
return -EINVAL;
}
if (copy_to_user((void __user *)xfer.data, buffers[xfer.bufnum],
xfer.size))
err = -EFAULT;
buffer_up(xfer.bufnum);
break;
case MSM_DMA_IOSCOPY:
if (copy_from_user(&scopy, (void __user *)arg, sizeof(scopy)))
return -EFAULT;
if (scopy.srcbuf < 0 || scopy.srcbuf >= MAX_TEST_BUFFERS ||
sizes[scopy.srcbuf] == 0 ||
scopy.destbuf < 0 || scopy.destbuf >= MAX_TEST_BUFFERS ||
sizes[scopy.destbuf] == 0 ||
scopy.size > sizes[scopy.destbuf] ||
scopy.size > sizes[scopy.srcbuf])
return -EINVAL;
#if 0
/* Test interface using memcpy. */
memcpy(buffers[scopy.destbuf],
buffers[scopy.srcbuf], scopy.size);
#else
err = dma_scopy(&scopy, priv);
#endif
break;
default:
return -ENOTTY;
}
return err;
}
/**********************************************************************
* Register ourselves as a misc device to be able to test the DMA code
* from userspace. */
static const struct file_operations dma_test_fops = {
.owner = THIS_MODULE,
.unlocked_ioctl = dma_test_ioctl,
.open = dma_test_open,
.release = dma_test_release,
};
static struct miscdevice dma_test_dev = {
.minor = MISC_DYNAMIC_MINOR,
.name = "msmdma",
.fops = &dma_test_fops,
};
static int dma_test_init(void)
{
int ret, i;
ret = misc_register(&dma_test_dev);
if (ret < 0)
return ret;
for (i = 0; i < MAX_TEST_BUFFERS; i++)
sema_init(&buffer_sems[i], 1);
printk(KERN_ALERT "%s, minor number %d\n", __func__, dma_test_dev.minor);
return 0;
}
static void dma_test_exit(void)
{
free_buffers();
misc_deregister(&dma_test_dev);
printk(KERN_ALERT "%s\n", __func__);
}
MODULE_LICENSE("GPL v2");
MODULE_AUTHOR("David Brown, Qualcomm, Incorporated");
MODULE_DESCRIPTION("Test for MSM DMA driver");
MODULE_VERSION("1.01");
module_init(dma_test_init);
module_exit(dma_test_exit);