2012-05-17 11:06:32 +00:00
|
|
|
/*
|
|
|
|
* Copyright (C) 2012 Samsung Electronics Co.Ltd
|
|
|
|
* Authors: Joonyoung Shim <jy0922.shim@samsung.com>
|
|
|
|
*
|
|
|
|
* This program is free software; you can redistribute it and/or modify
|
|
|
|
* it under the terms of the GNU General Public License version 2 as
|
|
|
|
* published by the Free Software Foundationr
|
|
|
|
*/
|
|
|
|
|
|
|
|
#include <linux/kernel.h>
|
|
|
|
#include <linux/module.h>
|
|
|
|
#include <linux/clk.h>
|
|
|
|
#include <linux/err.h>
|
|
|
|
#include <linux/interrupt.h>
|
|
|
|
#include <linux/io.h>
|
|
|
|
#include <linux/platform_device.h>
|
|
|
|
#include <linux/pm_runtime.h>
|
|
|
|
#include <linux/slab.h>
|
|
|
|
#include <linux/workqueue.h>
|
2012-11-04 04:53:24 +00:00
|
|
|
#include <linux/dma-mapping.h>
|
|
|
|
#include <linux/dma-attrs.h>
|
2012-05-17 11:06:32 +00:00
|
|
|
|
2012-10-02 17:01:07 +00:00
|
|
|
#include <drm/drmP.h>
|
|
|
|
#include <drm/exynos_drm.h>
|
2012-05-17 11:06:32 +00:00
|
|
|
#include "exynos_drm_drv.h"
|
|
|
|
#include "exynos_drm_gem.h"
|
2012-11-04 04:53:24 +00:00
|
|
|
#include "exynos_drm_iommu.h"
|
2012-05-17 11:06:32 +00:00
|
|
|
|
|
|
|
#define G2D_HW_MAJOR_VER 4
|
|
|
|
#define G2D_HW_MINOR_VER 1
|
|
|
|
|
|
|
|
/* vaild register range set from user: 0x0104 ~ 0x0880 */
|
|
|
|
#define G2D_VALID_START 0x0104
|
|
|
|
#define G2D_VALID_END 0x0880
|
|
|
|
|
|
|
|
/* general registers */
|
|
|
|
#define G2D_SOFT_RESET 0x0000
|
|
|
|
#define G2D_INTEN 0x0004
|
|
|
|
#define G2D_INTC_PEND 0x000C
|
|
|
|
#define G2D_DMA_SFR_BASE_ADDR 0x0080
|
|
|
|
#define G2D_DMA_COMMAND 0x0084
|
|
|
|
#define G2D_DMA_STATUS 0x008C
|
|
|
|
#define G2D_DMA_HOLD_CMD 0x0090
|
|
|
|
|
|
|
|
/* command registers */
|
|
|
|
#define G2D_BITBLT_START 0x0100
|
|
|
|
|
|
|
|
/* registers for base address */
|
|
|
|
#define G2D_SRC_BASE_ADDR 0x0304
|
|
|
|
#define G2D_SRC_PLANE2_BASE_ADDR 0x0318
|
|
|
|
#define G2D_DST_BASE_ADDR 0x0404
|
|
|
|
#define G2D_DST_PLANE2_BASE_ADDR 0x0418
|
|
|
|
#define G2D_PAT_BASE_ADDR 0x0500
|
|
|
|
#define G2D_MSK_BASE_ADDR 0x0520
|
|
|
|
|
|
|
|
/* G2D_SOFT_RESET */
|
|
|
|
#define G2D_SFRCLEAR (1 << 1)
|
|
|
|
#define G2D_R (1 << 0)
|
|
|
|
|
|
|
|
/* G2D_INTEN */
|
|
|
|
#define G2D_INTEN_ACF (1 << 3)
|
|
|
|
#define G2D_INTEN_UCF (1 << 2)
|
|
|
|
#define G2D_INTEN_GCF (1 << 1)
|
|
|
|
#define G2D_INTEN_SCF (1 << 0)
|
|
|
|
|
|
|
|
/* G2D_INTC_PEND */
|
|
|
|
#define G2D_INTP_ACMD_FIN (1 << 3)
|
|
|
|
#define G2D_INTP_UCMD_FIN (1 << 2)
|
|
|
|
#define G2D_INTP_GCMD_FIN (1 << 1)
|
|
|
|
#define G2D_INTP_SCMD_FIN (1 << 0)
|
|
|
|
|
|
|
|
/* G2D_DMA_COMMAND */
|
|
|
|
#define G2D_DMA_HALT (1 << 2)
|
|
|
|
#define G2D_DMA_CONTINUE (1 << 1)
|
|
|
|
#define G2D_DMA_START (1 << 0)
|
|
|
|
|
|
|
|
/* G2D_DMA_STATUS */
|
|
|
|
#define G2D_DMA_LIST_DONE_COUNT (0xFF << 17)
|
|
|
|
#define G2D_DMA_BITBLT_DONE_COUNT (0xFFFF << 1)
|
|
|
|
#define G2D_DMA_DONE (1 << 0)
|
|
|
|
#define G2D_DMA_LIST_DONE_COUNT_OFFSET 17
|
|
|
|
|
|
|
|
/* G2D_DMA_HOLD_CMD */
|
|
|
|
#define G2D_USET_HOLD (1 << 2)
|
|
|
|
#define G2D_LIST_HOLD (1 << 1)
|
|
|
|
#define G2D_BITBLT_HOLD (1 << 0)
|
|
|
|
|
|
|
|
/* G2D_BITBLT_START */
|
|
|
|
#define G2D_START_CASESEL (1 << 2)
|
|
|
|
#define G2D_START_NHOLT (1 << 1)
|
|
|
|
#define G2D_START_BITBLT (1 << 0)
|
|
|
|
|
|
|
|
#define G2D_CMDLIST_SIZE (PAGE_SIZE / 4)
|
|
|
|
#define G2D_CMDLIST_NUM 64
|
|
|
|
#define G2D_CMDLIST_POOL_SIZE (G2D_CMDLIST_SIZE * G2D_CMDLIST_NUM)
|
|
|
|
#define G2D_CMDLIST_DATA_NUM (G2D_CMDLIST_SIZE / sizeof(u32) - 2)
|
|
|
|
|
2012-11-04 04:53:24 +00:00
|
|
|
#define MAX_BUF_ADDR_NR 6
|
|
|
|
|
drm/exynos: add userptr feature for g2d module
This patch adds userptr feautre for G2D module.
The userptr means user space address allocated by malloc().
And the purpose of this feature is to make G2D's dma able
to access the user space region.
To user this feature, user should flag G2D_BUF_USRPTR to
offset variable of struct drm_exynos_g2d_cmd and fill
struct drm_exynos_g2d_userptr with user space address
and size for it and then should set a pointer to
drm_exynos_g2d_userptr object to data variable of struct
drm_exynos_g2d_cmd. The last bit of offset variable is used
to check if the cmdlist's buffer type is userptr or not.
If userptr, the g2d driver gets user space address and size
and then gets pages through get_user_pages().
(another case is counted as gem handle)
Below is sample codes:
static void set_cmd(struct drm_exynos_g2d_cmd *cmd,
unsigned long offset, unsigned long data)
{
cmd->offset = offset;
cmd->data = data;
}
static int solid_fill_test(int x, int y, unsigned long userptr)
{
struct drm_exynos_g2d_cmd cmd_gem[5];
struct drm_exynos_g2d_userptr g2d_userptr;
unsigned int gem_nr = 0;
...
g2d_userptr.userptr = userptr;
g2d_userptr.size = x * y * 4;
set_cmd(&cmd_gem[gem_nr++], DST_BASE_ADDR_REG |
G2D_BUF_USERPTR,
(unsigned long)&g2d_userptr);
...
}
int main(int argc, char **argv)
{
unsigned long addr;
...
addr = malloc(x * y * 4);
...
solid_fill_test(x, y, addr);
...
}
And next, the pages are mapped with iommu table and the device
address is set to cmdlist so that G2D's dma can access it.
As you may know, the pages from get_user_pages() are pinned.
In other words, they CAN NOT be migrated and also swapped out.
So the dma access would be safe.
But the use of userptr feature has performance overhead so
this patch also has memory pool to the userptr feature.
Please, assume that user sends cmdlist filled with userptr
and size every time to g2d driver, and the get_user_pages
funcion will be called every time.
The memory pool has maximum 64MB size and the userptr that
user had ever sent, is holded in the memory pool.
This meaning is that if the userptr from user is same as one
in the memory pool, device address to the userptr in the memory
pool is set to cmdlist.
And last, the pages from get_user_pages() will be freed once
user calls free() and the dma access is completed. Actually,
get_user_pages() takes 2 reference counts if the user process
has never accessed user region allocated by malloc(). Then, if
the user calls free(), the page reference count becomes 1 and
becomes 0 with put_page() call. And the reverse holds as well.
This means how the pages backed are used by dma and freed.
This patch is based on "drm/exynos: add iommu support for g2d",
https://patchwork.kernel.org/patch/1629481/
Signed-off-by: Inki Dae <inki.dae@samsung.com>
Signed-off-by: Kyungmin Park <kyungmin.park@samsung.com>
2012-11-04 13:48:52 +00:00
|
|
|
/* maximum buffer pool size of userptr is 64MB as default */
|
|
|
|
#define MAX_POOL (64 * 1024 * 1024)
|
|
|
|
|
|
|
|
enum {
|
|
|
|
BUF_TYPE_GEM = 1,
|
|
|
|
BUF_TYPE_USERPTR,
|
|
|
|
};
|
|
|
|
|
2012-05-17 11:06:32 +00:00
|
|
|
/* cmdlist data structure */
|
|
|
|
struct g2d_cmdlist {
|
drm/exynos: add userptr feature for g2d module
This patch adds userptr feautre for G2D module.
The userptr means user space address allocated by malloc().
And the purpose of this feature is to make G2D's dma able
to access the user space region.
To user this feature, user should flag G2D_BUF_USRPTR to
offset variable of struct drm_exynos_g2d_cmd and fill
struct drm_exynos_g2d_userptr with user space address
and size for it and then should set a pointer to
drm_exynos_g2d_userptr object to data variable of struct
drm_exynos_g2d_cmd. The last bit of offset variable is used
to check if the cmdlist's buffer type is userptr or not.
If userptr, the g2d driver gets user space address and size
and then gets pages through get_user_pages().
(another case is counted as gem handle)
Below is sample codes:
static void set_cmd(struct drm_exynos_g2d_cmd *cmd,
unsigned long offset, unsigned long data)
{
cmd->offset = offset;
cmd->data = data;
}
static int solid_fill_test(int x, int y, unsigned long userptr)
{
struct drm_exynos_g2d_cmd cmd_gem[5];
struct drm_exynos_g2d_userptr g2d_userptr;
unsigned int gem_nr = 0;
...
g2d_userptr.userptr = userptr;
g2d_userptr.size = x * y * 4;
set_cmd(&cmd_gem[gem_nr++], DST_BASE_ADDR_REG |
G2D_BUF_USERPTR,
(unsigned long)&g2d_userptr);
...
}
int main(int argc, char **argv)
{
unsigned long addr;
...
addr = malloc(x * y * 4);
...
solid_fill_test(x, y, addr);
...
}
And next, the pages are mapped with iommu table and the device
address is set to cmdlist so that G2D's dma can access it.
As you may know, the pages from get_user_pages() are pinned.
In other words, they CAN NOT be migrated and also swapped out.
So the dma access would be safe.
But the use of userptr feature has performance overhead so
this patch also has memory pool to the userptr feature.
Please, assume that user sends cmdlist filled with userptr
and size every time to g2d driver, and the get_user_pages
funcion will be called every time.
The memory pool has maximum 64MB size and the userptr that
user had ever sent, is holded in the memory pool.
This meaning is that if the userptr from user is same as one
in the memory pool, device address to the userptr in the memory
pool is set to cmdlist.
And last, the pages from get_user_pages() will be freed once
user calls free() and the dma access is completed. Actually,
get_user_pages() takes 2 reference counts if the user process
has never accessed user region allocated by malloc(). Then, if
the user calls free(), the page reference count becomes 1 and
becomes 0 with put_page() call. And the reverse holds as well.
This means how the pages backed are used by dma and freed.
This patch is based on "drm/exynos: add iommu support for g2d",
https://patchwork.kernel.org/patch/1629481/
Signed-off-by: Inki Dae <inki.dae@samsung.com>
Signed-off-by: Kyungmin Park <kyungmin.park@samsung.com>
2012-11-04 13:48:52 +00:00
|
|
|
u32 head;
|
|
|
|
unsigned long data[G2D_CMDLIST_DATA_NUM];
|
|
|
|
u32 last; /* last data offset */
|
2012-05-17 11:06:32 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
struct drm_exynos_pending_g2d_event {
|
|
|
|
struct drm_pending_event base;
|
|
|
|
struct drm_exynos_g2d_event event;
|
|
|
|
};
|
|
|
|
|
drm/exynos: add userptr feature for g2d module
This patch adds userptr feautre for G2D module.
The userptr means user space address allocated by malloc().
And the purpose of this feature is to make G2D's dma able
to access the user space region.
To user this feature, user should flag G2D_BUF_USRPTR to
offset variable of struct drm_exynos_g2d_cmd and fill
struct drm_exynos_g2d_userptr with user space address
and size for it and then should set a pointer to
drm_exynos_g2d_userptr object to data variable of struct
drm_exynos_g2d_cmd. The last bit of offset variable is used
to check if the cmdlist's buffer type is userptr or not.
If userptr, the g2d driver gets user space address and size
and then gets pages through get_user_pages().
(another case is counted as gem handle)
Below is sample codes:
static void set_cmd(struct drm_exynos_g2d_cmd *cmd,
unsigned long offset, unsigned long data)
{
cmd->offset = offset;
cmd->data = data;
}
static int solid_fill_test(int x, int y, unsigned long userptr)
{
struct drm_exynos_g2d_cmd cmd_gem[5];
struct drm_exynos_g2d_userptr g2d_userptr;
unsigned int gem_nr = 0;
...
g2d_userptr.userptr = userptr;
g2d_userptr.size = x * y * 4;
set_cmd(&cmd_gem[gem_nr++], DST_BASE_ADDR_REG |
G2D_BUF_USERPTR,
(unsigned long)&g2d_userptr);
...
}
int main(int argc, char **argv)
{
unsigned long addr;
...
addr = malloc(x * y * 4);
...
solid_fill_test(x, y, addr);
...
}
And next, the pages are mapped with iommu table and the device
address is set to cmdlist so that G2D's dma can access it.
As you may know, the pages from get_user_pages() are pinned.
In other words, they CAN NOT be migrated and also swapped out.
So the dma access would be safe.
But the use of userptr feature has performance overhead so
this patch also has memory pool to the userptr feature.
Please, assume that user sends cmdlist filled with userptr
and size every time to g2d driver, and the get_user_pages
funcion will be called every time.
The memory pool has maximum 64MB size and the userptr that
user had ever sent, is holded in the memory pool.
This meaning is that if the userptr from user is same as one
in the memory pool, device address to the userptr in the memory
pool is set to cmdlist.
And last, the pages from get_user_pages() will be freed once
user calls free() and the dma access is completed. Actually,
get_user_pages() takes 2 reference counts if the user process
has never accessed user region allocated by malloc(). Then, if
the user calls free(), the page reference count becomes 1 and
becomes 0 with put_page() call. And the reverse holds as well.
This means how the pages backed are used by dma and freed.
This patch is based on "drm/exynos: add iommu support for g2d",
https://patchwork.kernel.org/patch/1629481/
Signed-off-by: Inki Dae <inki.dae@samsung.com>
Signed-off-by: Kyungmin Park <kyungmin.park@samsung.com>
2012-11-04 13:48:52 +00:00
|
|
|
struct g2d_cmdlist_userptr {
|
|
|
|
struct list_head list;
|
|
|
|
dma_addr_t dma_addr;
|
|
|
|
unsigned long userptr;
|
|
|
|
unsigned long size;
|
|
|
|
struct page **pages;
|
|
|
|
unsigned int npages;
|
|
|
|
struct sg_table *sgt;
|
|
|
|
struct vm_area_struct *vma;
|
|
|
|
atomic_t refcount;
|
|
|
|
bool in_pool;
|
|
|
|
bool out_of_list;
|
|
|
|
};
|
|
|
|
|
2012-05-17 11:06:32 +00:00
|
|
|
struct g2d_cmdlist_node {
|
|
|
|
struct list_head list;
|
|
|
|
struct g2d_cmdlist *cmdlist;
|
2012-11-04 04:53:24 +00:00
|
|
|
unsigned int map_nr;
|
drm/exynos: add userptr feature for g2d module
This patch adds userptr feautre for G2D module.
The userptr means user space address allocated by malloc().
And the purpose of this feature is to make G2D's dma able
to access the user space region.
To user this feature, user should flag G2D_BUF_USRPTR to
offset variable of struct drm_exynos_g2d_cmd and fill
struct drm_exynos_g2d_userptr with user space address
and size for it and then should set a pointer to
drm_exynos_g2d_userptr object to data variable of struct
drm_exynos_g2d_cmd. The last bit of offset variable is used
to check if the cmdlist's buffer type is userptr or not.
If userptr, the g2d driver gets user space address and size
and then gets pages through get_user_pages().
(another case is counted as gem handle)
Below is sample codes:
static void set_cmd(struct drm_exynos_g2d_cmd *cmd,
unsigned long offset, unsigned long data)
{
cmd->offset = offset;
cmd->data = data;
}
static int solid_fill_test(int x, int y, unsigned long userptr)
{
struct drm_exynos_g2d_cmd cmd_gem[5];
struct drm_exynos_g2d_userptr g2d_userptr;
unsigned int gem_nr = 0;
...
g2d_userptr.userptr = userptr;
g2d_userptr.size = x * y * 4;
set_cmd(&cmd_gem[gem_nr++], DST_BASE_ADDR_REG |
G2D_BUF_USERPTR,
(unsigned long)&g2d_userptr);
...
}
int main(int argc, char **argv)
{
unsigned long addr;
...
addr = malloc(x * y * 4);
...
solid_fill_test(x, y, addr);
...
}
And next, the pages are mapped with iommu table and the device
address is set to cmdlist so that G2D's dma can access it.
As you may know, the pages from get_user_pages() are pinned.
In other words, they CAN NOT be migrated and also swapped out.
So the dma access would be safe.
But the use of userptr feature has performance overhead so
this patch also has memory pool to the userptr feature.
Please, assume that user sends cmdlist filled with userptr
and size every time to g2d driver, and the get_user_pages
funcion will be called every time.
The memory pool has maximum 64MB size and the userptr that
user had ever sent, is holded in the memory pool.
This meaning is that if the userptr from user is same as one
in the memory pool, device address to the userptr in the memory
pool is set to cmdlist.
And last, the pages from get_user_pages() will be freed once
user calls free() and the dma access is completed. Actually,
get_user_pages() takes 2 reference counts if the user process
has never accessed user region allocated by malloc(). Then, if
the user calls free(), the page reference count becomes 1 and
becomes 0 with put_page() call. And the reverse holds as well.
This means how the pages backed are used by dma and freed.
This patch is based on "drm/exynos: add iommu support for g2d",
https://patchwork.kernel.org/patch/1629481/
Signed-off-by: Inki Dae <inki.dae@samsung.com>
Signed-off-by: Kyungmin Park <kyungmin.park@samsung.com>
2012-11-04 13:48:52 +00:00
|
|
|
unsigned long handles[MAX_BUF_ADDR_NR];
|
|
|
|
unsigned int obj_type[MAX_BUF_ADDR_NR];
|
2012-05-17 11:06:32 +00:00
|
|
|
dma_addr_t dma_addr;
|
|
|
|
|
|
|
|
struct drm_exynos_pending_g2d_event *event;
|
|
|
|
};
|
|
|
|
|
|
|
|
struct g2d_runqueue_node {
|
|
|
|
struct list_head list;
|
|
|
|
struct list_head run_cmdlist;
|
|
|
|
struct list_head event_list;
|
2012-11-04 04:53:24 +00:00
|
|
|
struct drm_file *filp;
|
2012-09-11 01:45:36 +00:00
|
|
|
pid_t pid;
|
2012-05-17 11:06:32 +00:00
|
|
|
struct completion complete;
|
|
|
|
int async;
|
|
|
|
};
|
|
|
|
|
|
|
|
struct g2d_data {
|
|
|
|
struct device *dev;
|
|
|
|
struct clk *gate_clk;
|
|
|
|
void __iomem *regs;
|
|
|
|
int irq;
|
|
|
|
struct workqueue_struct *g2d_workq;
|
|
|
|
struct work_struct runqueue_work;
|
|
|
|
struct exynos_drm_subdrv subdrv;
|
|
|
|
bool suspended;
|
|
|
|
|
|
|
|
/* cmdlist */
|
|
|
|
struct g2d_cmdlist_node *cmdlist_node;
|
|
|
|
struct list_head free_cmdlist;
|
|
|
|
struct mutex cmdlist_mutex;
|
|
|
|
dma_addr_t cmdlist_pool;
|
|
|
|
void *cmdlist_pool_virt;
|
2012-11-04 04:53:24 +00:00
|
|
|
struct dma_attrs cmdlist_dma_attrs;
|
2012-05-17 11:06:32 +00:00
|
|
|
|
|
|
|
/* runqueue*/
|
|
|
|
struct g2d_runqueue_node *runqueue_node;
|
|
|
|
struct list_head runqueue;
|
|
|
|
struct mutex runqueue_mutex;
|
|
|
|
struct kmem_cache *runqueue_slab;
|
drm/exynos: add userptr feature for g2d module
This patch adds userptr feautre for G2D module.
The userptr means user space address allocated by malloc().
And the purpose of this feature is to make G2D's dma able
to access the user space region.
To user this feature, user should flag G2D_BUF_USRPTR to
offset variable of struct drm_exynos_g2d_cmd and fill
struct drm_exynos_g2d_userptr with user space address
and size for it and then should set a pointer to
drm_exynos_g2d_userptr object to data variable of struct
drm_exynos_g2d_cmd. The last bit of offset variable is used
to check if the cmdlist's buffer type is userptr or not.
If userptr, the g2d driver gets user space address and size
and then gets pages through get_user_pages().
(another case is counted as gem handle)
Below is sample codes:
static void set_cmd(struct drm_exynos_g2d_cmd *cmd,
unsigned long offset, unsigned long data)
{
cmd->offset = offset;
cmd->data = data;
}
static int solid_fill_test(int x, int y, unsigned long userptr)
{
struct drm_exynos_g2d_cmd cmd_gem[5];
struct drm_exynos_g2d_userptr g2d_userptr;
unsigned int gem_nr = 0;
...
g2d_userptr.userptr = userptr;
g2d_userptr.size = x * y * 4;
set_cmd(&cmd_gem[gem_nr++], DST_BASE_ADDR_REG |
G2D_BUF_USERPTR,
(unsigned long)&g2d_userptr);
...
}
int main(int argc, char **argv)
{
unsigned long addr;
...
addr = malloc(x * y * 4);
...
solid_fill_test(x, y, addr);
...
}
And next, the pages are mapped with iommu table and the device
address is set to cmdlist so that G2D's dma can access it.
As you may know, the pages from get_user_pages() are pinned.
In other words, they CAN NOT be migrated and also swapped out.
So the dma access would be safe.
But the use of userptr feature has performance overhead so
this patch also has memory pool to the userptr feature.
Please, assume that user sends cmdlist filled with userptr
and size every time to g2d driver, and the get_user_pages
funcion will be called every time.
The memory pool has maximum 64MB size and the userptr that
user had ever sent, is holded in the memory pool.
This meaning is that if the userptr from user is same as one
in the memory pool, device address to the userptr in the memory
pool is set to cmdlist.
And last, the pages from get_user_pages() will be freed once
user calls free() and the dma access is completed. Actually,
get_user_pages() takes 2 reference counts if the user process
has never accessed user region allocated by malloc(). Then, if
the user calls free(), the page reference count becomes 1 and
becomes 0 with put_page() call. And the reverse holds as well.
This means how the pages backed are used by dma and freed.
This patch is based on "drm/exynos: add iommu support for g2d",
https://patchwork.kernel.org/patch/1629481/
Signed-off-by: Inki Dae <inki.dae@samsung.com>
Signed-off-by: Kyungmin Park <kyungmin.park@samsung.com>
2012-11-04 13:48:52 +00:00
|
|
|
|
|
|
|
unsigned long current_pool;
|
|
|
|
unsigned long max_pool;
|
2012-05-17 11:06:32 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
static int g2d_init_cmdlist(struct g2d_data *g2d)
|
|
|
|
{
|
|
|
|
struct device *dev = g2d->dev;
|
|
|
|
struct g2d_cmdlist_node *node = g2d->cmdlist_node;
|
2012-11-04 04:53:24 +00:00
|
|
|
struct exynos_drm_subdrv *subdrv = &g2d->subdrv;
|
2012-05-17 11:06:32 +00:00
|
|
|
int nr;
|
|
|
|
int ret;
|
|
|
|
|
2012-11-04 04:53:24 +00:00
|
|
|
init_dma_attrs(&g2d->cmdlist_dma_attrs);
|
|
|
|
dma_set_attr(DMA_ATTR_WRITE_COMBINE, &g2d->cmdlist_dma_attrs);
|
|
|
|
|
|
|
|
g2d->cmdlist_pool_virt = dma_alloc_attrs(subdrv->drm_dev->dev,
|
|
|
|
G2D_CMDLIST_POOL_SIZE,
|
|
|
|
&g2d->cmdlist_pool, GFP_KERNEL,
|
|
|
|
&g2d->cmdlist_dma_attrs);
|
2012-05-17 11:06:32 +00:00
|
|
|
if (!g2d->cmdlist_pool_virt) {
|
|
|
|
dev_err(dev, "failed to allocate dma memory\n");
|
|
|
|
return -ENOMEM;
|
|
|
|
}
|
|
|
|
|
2012-09-27 10:26:03 +00:00
|
|
|
node = kcalloc(G2D_CMDLIST_NUM, sizeof(*node), GFP_KERNEL);
|
2012-05-17 11:06:32 +00:00
|
|
|
if (!node) {
|
|
|
|
dev_err(dev, "failed to allocate memory\n");
|
|
|
|
ret = -ENOMEM;
|
|
|
|
goto err;
|
|
|
|
}
|
|
|
|
|
|
|
|
for (nr = 0; nr < G2D_CMDLIST_NUM; nr++) {
|
|
|
|
node[nr].cmdlist =
|
|
|
|
g2d->cmdlist_pool_virt + nr * G2D_CMDLIST_SIZE;
|
|
|
|
node[nr].dma_addr =
|
|
|
|
g2d->cmdlist_pool + nr * G2D_CMDLIST_SIZE;
|
|
|
|
|
|
|
|
list_add_tail(&node[nr].list, &g2d->free_cmdlist);
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
err:
|
2012-11-04 04:53:24 +00:00
|
|
|
dma_free_attrs(subdrv->drm_dev->dev, G2D_CMDLIST_POOL_SIZE,
|
|
|
|
g2d->cmdlist_pool_virt,
|
|
|
|
g2d->cmdlist_pool, &g2d->cmdlist_dma_attrs);
|
2012-05-17 11:06:32 +00:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void g2d_fini_cmdlist(struct g2d_data *g2d)
|
|
|
|
{
|
2012-11-04 04:53:24 +00:00
|
|
|
struct exynos_drm_subdrv *subdrv = &g2d->subdrv;
|
2012-05-17 11:06:32 +00:00
|
|
|
|
|
|
|
kfree(g2d->cmdlist_node);
|
2012-11-04 04:53:24 +00:00
|
|
|
dma_free_attrs(subdrv->drm_dev->dev, G2D_CMDLIST_POOL_SIZE,
|
|
|
|
g2d->cmdlist_pool_virt,
|
|
|
|
g2d->cmdlist_pool, &g2d->cmdlist_dma_attrs);
|
2012-05-17 11:06:32 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static struct g2d_cmdlist_node *g2d_get_cmdlist(struct g2d_data *g2d)
|
|
|
|
{
|
|
|
|
struct device *dev = g2d->dev;
|
|
|
|
struct g2d_cmdlist_node *node;
|
|
|
|
|
|
|
|
mutex_lock(&g2d->cmdlist_mutex);
|
|
|
|
if (list_empty(&g2d->free_cmdlist)) {
|
|
|
|
dev_err(dev, "there is no free cmdlist\n");
|
|
|
|
mutex_unlock(&g2d->cmdlist_mutex);
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
node = list_first_entry(&g2d->free_cmdlist, struct g2d_cmdlist_node,
|
|
|
|
list);
|
|
|
|
list_del_init(&node->list);
|
|
|
|
mutex_unlock(&g2d->cmdlist_mutex);
|
|
|
|
|
|
|
|
return node;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void g2d_put_cmdlist(struct g2d_data *g2d, struct g2d_cmdlist_node *node)
|
|
|
|
{
|
|
|
|
mutex_lock(&g2d->cmdlist_mutex);
|
|
|
|
list_move_tail(&node->list, &g2d->free_cmdlist);
|
|
|
|
mutex_unlock(&g2d->cmdlist_mutex);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void g2d_add_cmdlist_to_inuse(struct exynos_drm_g2d_private *g2d_priv,
|
|
|
|
struct g2d_cmdlist_node *node)
|
|
|
|
{
|
|
|
|
struct g2d_cmdlist_node *lnode;
|
|
|
|
|
|
|
|
if (list_empty(&g2d_priv->inuse_cmdlist))
|
|
|
|
goto add_to_list;
|
|
|
|
|
|
|
|
/* this links to base address of new cmdlist */
|
|
|
|
lnode = list_entry(g2d_priv->inuse_cmdlist.prev,
|
|
|
|
struct g2d_cmdlist_node, list);
|
|
|
|
lnode->cmdlist->data[lnode->cmdlist->last] = node->dma_addr;
|
|
|
|
|
|
|
|
add_to_list:
|
|
|
|
list_add_tail(&node->list, &g2d_priv->inuse_cmdlist);
|
|
|
|
|
|
|
|
if (node->event)
|
|
|
|
list_add_tail(&node->event->base.link, &g2d_priv->event_list);
|
|
|
|
}
|
|
|
|
|
drm/exynos: add userptr feature for g2d module
This patch adds userptr feautre for G2D module.
The userptr means user space address allocated by malloc().
And the purpose of this feature is to make G2D's dma able
to access the user space region.
To user this feature, user should flag G2D_BUF_USRPTR to
offset variable of struct drm_exynos_g2d_cmd and fill
struct drm_exynos_g2d_userptr with user space address
and size for it and then should set a pointer to
drm_exynos_g2d_userptr object to data variable of struct
drm_exynos_g2d_cmd. The last bit of offset variable is used
to check if the cmdlist's buffer type is userptr or not.
If userptr, the g2d driver gets user space address and size
and then gets pages through get_user_pages().
(another case is counted as gem handle)
Below is sample codes:
static void set_cmd(struct drm_exynos_g2d_cmd *cmd,
unsigned long offset, unsigned long data)
{
cmd->offset = offset;
cmd->data = data;
}
static int solid_fill_test(int x, int y, unsigned long userptr)
{
struct drm_exynos_g2d_cmd cmd_gem[5];
struct drm_exynos_g2d_userptr g2d_userptr;
unsigned int gem_nr = 0;
...
g2d_userptr.userptr = userptr;
g2d_userptr.size = x * y * 4;
set_cmd(&cmd_gem[gem_nr++], DST_BASE_ADDR_REG |
G2D_BUF_USERPTR,
(unsigned long)&g2d_userptr);
...
}
int main(int argc, char **argv)
{
unsigned long addr;
...
addr = malloc(x * y * 4);
...
solid_fill_test(x, y, addr);
...
}
And next, the pages are mapped with iommu table and the device
address is set to cmdlist so that G2D's dma can access it.
As you may know, the pages from get_user_pages() are pinned.
In other words, they CAN NOT be migrated and also swapped out.
So the dma access would be safe.
But the use of userptr feature has performance overhead so
this patch also has memory pool to the userptr feature.
Please, assume that user sends cmdlist filled with userptr
and size every time to g2d driver, and the get_user_pages
funcion will be called every time.
The memory pool has maximum 64MB size and the userptr that
user had ever sent, is holded in the memory pool.
This meaning is that if the userptr from user is same as one
in the memory pool, device address to the userptr in the memory
pool is set to cmdlist.
And last, the pages from get_user_pages() will be freed once
user calls free() and the dma access is completed. Actually,
get_user_pages() takes 2 reference counts if the user process
has never accessed user region allocated by malloc(). Then, if
the user calls free(), the page reference count becomes 1 and
becomes 0 with put_page() call. And the reverse holds as well.
This means how the pages backed are used by dma and freed.
This patch is based on "drm/exynos: add iommu support for g2d",
https://patchwork.kernel.org/patch/1629481/
Signed-off-by: Inki Dae <inki.dae@samsung.com>
Signed-off-by: Kyungmin Park <kyungmin.park@samsung.com>
2012-11-04 13:48:52 +00:00
|
|
|
static void g2d_userptr_put_dma_addr(struct drm_device *drm_dev,
|
|
|
|
unsigned long obj,
|
|
|
|
bool force)
|
|
|
|
{
|
|
|
|
struct g2d_cmdlist_userptr *g2d_userptr =
|
|
|
|
(struct g2d_cmdlist_userptr *)obj;
|
|
|
|
|
|
|
|
if (!obj)
|
|
|
|
return;
|
|
|
|
|
|
|
|
if (force)
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
atomic_dec(&g2d_userptr->refcount);
|
|
|
|
|
|
|
|
if (atomic_read(&g2d_userptr->refcount) > 0)
|
|
|
|
return;
|
|
|
|
|
|
|
|
if (g2d_userptr->in_pool)
|
|
|
|
return;
|
|
|
|
|
|
|
|
out:
|
|
|
|
exynos_gem_unmap_sgt_from_dma(drm_dev, g2d_userptr->sgt,
|
|
|
|
DMA_BIDIRECTIONAL);
|
|
|
|
|
|
|
|
exynos_gem_put_pages_to_userptr(g2d_userptr->pages,
|
|
|
|
g2d_userptr->npages,
|
|
|
|
g2d_userptr->vma);
|
|
|
|
|
|
|
|
if (!g2d_userptr->out_of_list)
|
|
|
|
list_del_init(&g2d_userptr->list);
|
|
|
|
|
|
|
|
sg_free_table(g2d_userptr->sgt);
|
|
|
|
kfree(g2d_userptr->sgt);
|
|
|
|
g2d_userptr->sgt = NULL;
|
|
|
|
|
|
|
|
kfree(g2d_userptr->pages);
|
|
|
|
g2d_userptr->pages = NULL;
|
2012-11-23 03:41:59 +00:00
|
|
|
kfree(g2d_userptr);
|
drm/exynos: add userptr feature for g2d module
This patch adds userptr feautre for G2D module.
The userptr means user space address allocated by malloc().
And the purpose of this feature is to make G2D's dma able
to access the user space region.
To user this feature, user should flag G2D_BUF_USRPTR to
offset variable of struct drm_exynos_g2d_cmd and fill
struct drm_exynos_g2d_userptr with user space address
and size for it and then should set a pointer to
drm_exynos_g2d_userptr object to data variable of struct
drm_exynos_g2d_cmd. The last bit of offset variable is used
to check if the cmdlist's buffer type is userptr or not.
If userptr, the g2d driver gets user space address and size
and then gets pages through get_user_pages().
(another case is counted as gem handle)
Below is sample codes:
static void set_cmd(struct drm_exynos_g2d_cmd *cmd,
unsigned long offset, unsigned long data)
{
cmd->offset = offset;
cmd->data = data;
}
static int solid_fill_test(int x, int y, unsigned long userptr)
{
struct drm_exynos_g2d_cmd cmd_gem[5];
struct drm_exynos_g2d_userptr g2d_userptr;
unsigned int gem_nr = 0;
...
g2d_userptr.userptr = userptr;
g2d_userptr.size = x * y * 4;
set_cmd(&cmd_gem[gem_nr++], DST_BASE_ADDR_REG |
G2D_BUF_USERPTR,
(unsigned long)&g2d_userptr);
...
}
int main(int argc, char **argv)
{
unsigned long addr;
...
addr = malloc(x * y * 4);
...
solid_fill_test(x, y, addr);
...
}
And next, the pages are mapped with iommu table and the device
address is set to cmdlist so that G2D's dma can access it.
As you may know, the pages from get_user_pages() are pinned.
In other words, they CAN NOT be migrated and also swapped out.
So the dma access would be safe.
But the use of userptr feature has performance overhead so
this patch also has memory pool to the userptr feature.
Please, assume that user sends cmdlist filled with userptr
and size every time to g2d driver, and the get_user_pages
funcion will be called every time.
The memory pool has maximum 64MB size and the userptr that
user had ever sent, is holded in the memory pool.
This meaning is that if the userptr from user is same as one
in the memory pool, device address to the userptr in the memory
pool is set to cmdlist.
And last, the pages from get_user_pages() will be freed once
user calls free() and the dma access is completed. Actually,
get_user_pages() takes 2 reference counts if the user process
has never accessed user region allocated by malloc(). Then, if
the user calls free(), the page reference count becomes 1 and
becomes 0 with put_page() call. And the reverse holds as well.
This means how the pages backed are used by dma and freed.
This patch is based on "drm/exynos: add iommu support for g2d",
https://patchwork.kernel.org/patch/1629481/
Signed-off-by: Inki Dae <inki.dae@samsung.com>
Signed-off-by: Kyungmin Park <kyungmin.park@samsung.com>
2012-11-04 13:48:52 +00:00
|
|
|
g2d_userptr = NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
dma_addr_t *g2d_userptr_get_dma_addr(struct drm_device *drm_dev,
|
|
|
|
unsigned long userptr,
|
|
|
|
unsigned long size,
|
|
|
|
struct drm_file *filp,
|
|
|
|
unsigned long *obj)
|
|
|
|
{
|
|
|
|
struct drm_exynos_file_private *file_priv = filp->driver_priv;
|
|
|
|
struct exynos_drm_g2d_private *g2d_priv = file_priv->g2d_priv;
|
|
|
|
struct g2d_cmdlist_userptr *g2d_userptr;
|
|
|
|
struct g2d_data *g2d;
|
|
|
|
struct page **pages;
|
|
|
|
struct sg_table *sgt;
|
|
|
|
struct vm_area_struct *vma;
|
|
|
|
unsigned long start, end;
|
|
|
|
unsigned int npages, offset;
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
if (!size) {
|
|
|
|
DRM_ERROR("invalid userptr size.\n");
|
|
|
|
return ERR_PTR(-EINVAL);
|
|
|
|
}
|
|
|
|
|
|
|
|
g2d = dev_get_drvdata(g2d_priv->dev);
|
|
|
|
|
|
|
|
/* check if userptr already exists in userptr_list. */
|
|
|
|
list_for_each_entry(g2d_userptr, &g2d_priv->userptr_list, list) {
|
|
|
|
if (g2d_userptr->userptr == userptr) {
|
|
|
|
/*
|
|
|
|
* also check size because there could be same address
|
|
|
|
* and different size.
|
|
|
|
*/
|
|
|
|
if (g2d_userptr->size == size) {
|
|
|
|
atomic_inc(&g2d_userptr->refcount);
|
|
|
|
*obj = (unsigned long)g2d_userptr;
|
|
|
|
|
|
|
|
return &g2d_userptr->dma_addr;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* at this moment, maybe g2d dma is accessing this
|
|
|
|
* g2d_userptr memory region so just remove this
|
|
|
|
* g2d_userptr object from userptr_list not to be
|
|
|
|
* referred again and also except it the userptr
|
|
|
|
* pool to be released after the dma access completion.
|
|
|
|
*/
|
|
|
|
g2d_userptr->out_of_list = true;
|
|
|
|
g2d_userptr->in_pool = false;
|
|
|
|
list_del_init(&g2d_userptr->list);
|
|
|
|
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
g2d_userptr = kzalloc(sizeof(*g2d_userptr), GFP_KERNEL);
|
|
|
|
if (!g2d_userptr) {
|
|
|
|
DRM_ERROR("failed to allocate g2d_userptr.\n");
|
|
|
|
return ERR_PTR(-ENOMEM);
|
|
|
|
}
|
|
|
|
|
|
|
|
atomic_set(&g2d_userptr->refcount, 1);
|
|
|
|
|
|
|
|
start = userptr & PAGE_MASK;
|
|
|
|
offset = userptr & ~PAGE_MASK;
|
|
|
|
end = PAGE_ALIGN(userptr + size);
|
|
|
|
npages = (end - start) >> PAGE_SHIFT;
|
|
|
|
g2d_userptr->npages = npages;
|
|
|
|
|
|
|
|
pages = kzalloc(npages * sizeof(struct page *), GFP_KERNEL);
|
|
|
|
if (!pages) {
|
|
|
|
DRM_ERROR("failed to allocate pages.\n");
|
|
|
|
kfree(g2d_userptr);
|
|
|
|
return ERR_PTR(-ENOMEM);
|
|
|
|
}
|
|
|
|
|
|
|
|
vma = find_vma(current->mm, userptr);
|
|
|
|
if (!vma) {
|
|
|
|
DRM_ERROR("failed to get vm region.\n");
|
|
|
|
ret = -EFAULT;
|
|
|
|
goto err_free_pages;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (vma->vm_end < userptr + size) {
|
|
|
|
DRM_ERROR("vma is too small.\n");
|
|
|
|
ret = -EFAULT;
|
|
|
|
goto err_free_pages;
|
|
|
|
}
|
|
|
|
|
|
|
|
g2d_userptr->vma = exynos_gem_get_vma(vma);
|
|
|
|
if (!g2d_userptr->vma) {
|
|
|
|
DRM_ERROR("failed to copy vma.\n");
|
|
|
|
ret = -ENOMEM;
|
|
|
|
goto err_free_pages;
|
|
|
|
}
|
|
|
|
|
|
|
|
g2d_userptr->size = size;
|
|
|
|
|
|
|
|
ret = exynos_gem_get_pages_from_userptr(start & PAGE_MASK,
|
|
|
|
npages, pages, vma);
|
|
|
|
if (ret < 0) {
|
|
|
|
DRM_ERROR("failed to get user pages from userptr.\n");
|
|
|
|
goto err_put_vma;
|
|
|
|
}
|
|
|
|
|
|
|
|
g2d_userptr->pages = pages;
|
|
|
|
|
|
|
|
sgt = kzalloc(sizeof *sgt, GFP_KERNEL);
|
|
|
|
if (!sgt) {
|
|
|
|
DRM_ERROR("failed to allocate sg table.\n");
|
|
|
|
ret = -ENOMEM;
|
|
|
|
goto err_free_userptr;
|
|
|
|
}
|
|
|
|
|
|
|
|
ret = sg_alloc_table_from_pages(sgt, pages, npages, offset,
|
|
|
|
size, GFP_KERNEL);
|
|
|
|
if (ret < 0) {
|
|
|
|
DRM_ERROR("failed to get sgt from pages.\n");
|
|
|
|
goto err_free_sgt;
|
|
|
|
}
|
|
|
|
|
|
|
|
g2d_userptr->sgt = sgt;
|
|
|
|
|
|
|
|
ret = exynos_gem_map_sgt_with_dma(drm_dev, g2d_userptr->sgt,
|
|
|
|
DMA_BIDIRECTIONAL);
|
|
|
|
if (ret < 0) {
|
|
|
|
DRM_ERROR("failed to map sgt with dma region.\n");
|
|
|
|
goto err_free_sgt;
|
|
|
|
}
|
|
|
|
|
|
|
|
g2d_userptr->dma_addr = sgt->sgl[0].dma_address;
|
|
|
|
g2d_userptr->userptr = userptr;
|
|
|
|
|
|
|
|
list_add_tail(&g2d_userptr->list, &g2d_priv->userptr_list);
|
|
|
|
|
|
|
|
if (g2d->current_pool + (npages << PAGE_SHIFT) < g2d->max_pool) {
|
|
|
|
g2d->current_pool += npages << PAGE_SHIFT;
|
|
|
|
g2d_userptr->in_pool = true;
|
|
|
|
}
|
|
|
|
|
|
|
|
*obj = (unsigned long)g2d_userptr;
|
|
|
|
|
|
|
|
return &g2d_userptr->dma_addr;
|
|
|
|
|
|
|
|
err_free_sgt:
|
|
|
|
sg_free_table(sgt);
|
|
|
|
kfree(sgt);
|
|
|
|
sgt = NULL;
|
|
|
|
|
|
|
|
err_free_userptr:
|
|
|
|
exynos_gem_put_pages_to_userptr(g2d_userptr->pages,
|
|
|
|
g2d_userptr->npages,
|
|
|
|
g2d_userptr->vma);
|
|
|
|
|
|
|
|
err_put_vma:
|
|
|
|
exynos_gem_put_vma(g2d_userptr->vma);
|
|
|
|
|
|
|
|
err_free_pages:
|
|
|
|
kfree(pages);
|
|
|
|
kfree(g2d_userptr);
|
|
|
|
pages = NULL;
|
|
|
|
g2d_userptr = NULL;
|
|
|
|
|
|
|
|
return ERR_PTR(ret);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void g2d_userptr_free_all(struct drm_device *drm_dev,
|
|
|
|
struct g2d_data *g2d,
|
|
|
|
struct drm_file *filp)
|
|
|
|
{
|
|
|
|
struct drm_exynos_file_private *file_priv = filp->driver_priv;
|
|
|
|
struct exynos_drm_g2d_private *g2d_priv = file_priv->g2d_priv;
|
|
|
|
struct g2d_cmdlist_userptr *g2d_userptr, *n;
|
|
|
|
|
|
|
|
list_for_each_entry_safe(g2d_userptr, n, &g2d_priv->userptr_list, list)
|
|
|
|
if (g2d_userptr->in_pool)
|
|
|
|
g2d_userptr_put_dma_addr(drm_dev,
|
|
|
|
(unsigned long)g2d_userptr,
|
|
|
|
true);
|
|
|
|
|
|
|
|
g2d->current_pool = 0;
|
|
|
|
}
|
|
|
|
|
2012-11-04 04:53:24 +00:00
|
|
|
static int g2d_map_cmdlist_gem(struct g2d_data *g2d,
|
|
|
|
struct g2d_cmdlist_node *node,
|
|
|
|
struct drm_device *drm_dev,
|
|
|
|
struct drm_file *file)
|
2012-05-17 11:06:32 +00:00
|
|
|
{
|
|
|
|
struct g2d_cmdlist *cmdlist = node->cmdlist;
|
|
|
|
int offset;
|
|
|
|
int i;
|
|
|
|
|
2012-11-04 04:53:24 +00:00
|
|
|
for (i = 0; i < node->map_nr; i++) {
|
|
|
|
unsigned long handle;
|
|
|
|
dma_addr_t *addr;
|
2012-05-17 11:06:32 +00:00
|
|
|
|
|
|
|
offset = cmdlist->last - (i * 2 + 1);
|
2012-11-04 04:53:24 +00:00
|
|
|
handle = cmdlist->data[offset];
|
2012-05-17 11:06:32 +00:00
|
|
|
|
drm/exynos: add userptr feature for g2d module
This patch adds userptr feautre for G2D module.
The userptr means user space address allocated by malloc().
And the purpose of this feature is to make G2D's dma able
to access the user space region.
To user this feature, user should flag G2D_BUF_USRPTR to
offset variable of struct drm_exynos_g2d_cmd and fill
struct drm_exynos_g2d_userptr with user space address
and size for it and then should set a pointer to
drm_exynos_g2d_userptr object to data variable of struct
drm_exynos_g2d_cmd. The last bit of offset variable is used
to check if the cmdlist's buffer type is userptr or not.
If userptr, the g2d driver gets user space address and size
and then gets pages through get_user_pages().
(another case is counted as gem handle)
Below is sample codes:
static void set_cmd(struct drm_exynos_g2d_cmd *cmd,
unsigned long offset, unsigned long data)
{
cmd->offset = offset;
cmd->data = data;
}
static int solid_fill_test(int x, int y, unsigned long userptr)
{
struct drm_exynos_g2d_cmd cmd_gem[5];
struct drm_exynos_g2d_userptr g2d_userptr;
unsigned int gem_nr = 0;
...
g2d_userptr.userptr = userptr;
g2d_userptr.size = x * y * 4;
set_cmd(&cmd_gem[gem_nr++], DST_BASE_ADDR_REG |
G2D_BUF_USERPTR,
(unsigned long)&g2d_userptr);
...
}
int main(int argc, char **argv)
{
unsigned long addr;
...
addr = malloc(x * y * 4);
...
solid_fill_test(x, y, addr);
...
}
And next, the pages are mapped with iommu table and the device
address is set to cmdlist so that G2D's dma can access it.
As you may know, the pages from get_user_pages() are pinned.
In other words, they CAN NOT be migrated and also swapped out.
So the dma access would be safe.
But the use of userptr feature has performance overhead so
this patch also has memory pool to the userptr feature.
Please, assume that user sends cmdlist filled with userptr
and size every time to g2d driver, and the get_user_pages
funcion will be called every time.
The memory pool has maximum 64MB size and the userptr that
user had ever sent, is holded in the memory pool.
This meaning is that if the userptr from user is same as one
in the memory pool, device address to the userptr in the memory
pool is set to cmdlist.
And last, the pages from get_user_pages() will be freed once
user calls free() and the dma access is completed. Actually,
get_user_pages() takes 2 reference counts if the user process
has never accessed user region allocated by malloc(). Then, if
the user calls free(), the page reference count becomes 1 and
becomes 0 with put_page() call. And the reverse holds as well.
This means how the pages backed are used by dma and freed.
This patch is based on "drm/exynos: add iommu support for g2d",
https://patchwork.kernel.org/patch/1629481/
Signed-off-by: Inki Dae <inki.dae@samsung.com>
Signed-off-by: Kyungmin Park <kyungmin.park@samsung.com>
2012-11-04 13:48:52 +00:00
|
|
|
if (node->obj_type[i] == BUF_TYPE_GEM) {
|
|
|
|
addr = exynos_drm_gem_get_dma_addr(drm_dev, handle,
|
|
|
|
file);
|
|
|
|
if (IS_ERR(addr)) {
|
|
|
|
node->map_nr = i;
|
|
|
|
return -EFAULT;
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
struct drm_exynos_g2d_userptr g2d_userptr;
|
|
|
|
|
|
|
|
if (copy_from_user(&g2d_userptr, (void __user *)handle,
|
|
|
|
sizeof(struct drm_exynos_g2d_userptr))) {
|
|
|
|
node->map_nr = i;
|
|
|
|
return -EFAULT;
|
|
|
|
}
|
|
|
|
|
|
|
|
addr = g2d_userptr_get_dma_addr(drm_dev,
|
|
|
|
g2d_userptr.userptr,
|
|
|
|
g2d_userptr.size,
|
|
|
|
file,
|
|
|
|
&handle);
|
|
|
|
if (IS_ERR(addr)) {
|
|
|
|
node->map_nr = i;
|
|
|
|
return -EFAULT;
|
|
|
|
}
|
2012-05-17 11:06:32 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
cmdlist->data[offset] = *addr;
|
2012-11-04 04:53:24 +00:00
|
|
|
node->handles[i] = handle;
|
2012-05-17 11:06:32 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2012-11-04 04:53:24 +00:00
|
|
|
static void g2d_unmap_cmdlist_gem(struct g2d_data *g2d,
|
|
|
|
struct g2d_cmdlist_node *node,
|
|
|
|
struct drm_file *filp)
|
2012-05-17 11:06:32 +00:00
|
|
|
{
|
2012-11-04 04:53:24 +00:00
|
|
|
struct exynos_drm_subdrv *subdrv = &g2d->subdrv;
|
|
|
|
int i;
|
2012-05-17 11:06:32 +00:00
|
|
|
|
2012-11-04 04:53:24 +00:00
|
|
|
for (i = 0; i < node->map_nr; i++) {
|
drm/exynos: add userptr feature for g2d module
This patch adds userptr feautre for G2D module.
The userptr means user space address allocated by malloc().
And the purpose of this feature is to make G2D's dma able
to access the user space region.
To user this feature, user should flag G2D_BUF_USRPTR to
offset variable of struct drm_exynos_g2d_cmd and fill
struct drm_exynos_g2d_userptr with user space address
and size for it and then should set a pointer to
drm_exynos_g2d_userptr object to data variable of struct
drm_exynos_g2d_cmd. The last bit of offset variable is used
to check if the cmdlist's buffer type is userptr or not.
If userptr, the g2d driver gets user space address and size
and then gets pages through get_user_pages().
(another case is counted as gem handle)
Below is sample codes:
static void set_cmd(struct drm_exynos_g2d_cmd *cmd,
unsigned long offset, unsigned long data)
{
cmd->offset = offset;
cmd->data = data;
}
static int solid_fill_test(int x, int y, unsigned long userptr)
{
struct drm_exynos_g2d_cmd cmd_gem[5];
struct drm_exynos_g2d_userptr g2d_userptr;
unsigned int gem_nr = 0;
...
g2d_userptr.userptr = userptr;
g2d_userptr.size = x * y * 4;
set_cmd(&cmd_gem[gem_nr++], DST_BASE_ADDR_REG |
G2D_BUF_USERPTR,
(unsigned long)&g2d_userptr);
...
}
int main(int argc, char **argv)
{
unsigned long addr;
...
addr = malloc(x * y * 4);
...
solid_fill_test(x, y, addr);
...
}
And next, the pages are mapped with iommu table and the device
address is set to cmdlist so that G2D's dma can access it.
As you may know, the pages from get_user_pages() are pinned.
In other words, they CAN NOT be migrated and also swapped out.
So the dma access would be safe.
But the use of userptr feature has performance overhead so
this patch also has memory pool to the userptr feature.
Please, assume that user sends cmdlist filled with userptr
and size every time to g2d driver, and the get_user_pages
funcion will be called every time.
The memory pool has maximum 64MB size and the userptr that
user had ever sent, is holded in the memory pool.
This meaning is that if the userptr from user is same as one
in the memory pool, device address to the userptr in the memory
pool is set to cmdlist.
And last, the pages from get_user_pages() will be freed once
user calls free() and the dma access is completed. Actually,
get_user_pages() takes 2 reference counts if the user process
has never accessed user region allocated by malloc(). Then, if
the user calls free(), the page reference count becomes 1 and
becomes 0 with put_page() call. And the reverse holds as well.
This means how the pages backed are used by dma and freed.
This patch is based on "drm/exynos: add iommu support for g2d",
https://patchwork.kernel.org/patch/1629481/
Signed-off-by: Inki Dae <inki.dae@samsung.com>
Signed-off-by: Kyungmin Park <kyungmin.park@samsung.com>
2012-11-04 13:48:52 +00:00
|
|
|
unsigned long handle = node->handles[i];
|
2012-11-04 04:53:24 +00:00
|
|
|
|
drm/exynos: add userptr feature for g2d module
This patch adds userptr feautre for G2D module.
The userptr means user space address allocated by malloc().
And the purpose of this feature is to make G2D's dma able
to access the user space region.
To user this feature, user should flag G2D_BUF_USRPTR to
offset variable of struct drm_exynos_g2d_cmd and fill
struct drm_exynos_g2d_userptr with user space address
and size for it and then should set a pointer to
drm_exynos_g2d_userptr object to data variable of struct
drm_exynos_g2d_cmd. The last bit of offset variable is used
to check if the cmdlist's buffer type is userptr or not.
If userptr, the g2d driver gets user space address and size
and then gets pages through get_user_pages().
(another case is counted as gem handle)
Below is sample codes:
static void set_cmd(struct drm_exynos_g2d_cmd *cmd,
unsigned long offset, unsigned long data)
{
cmd->offset = offset;
cmd->data = data;
}
static int solid_fill_test(int x, int y, unsigned long userptr)
{
struct drm_exynos_g2d_cmd cmd_gem[5];
struct drm_exynos_g2d_userptr g2d_userptr;
unsigned int gem_nr = 0;
...
g2d_userptr.userptr = userptr;
g2d_userptr.size = x * y * 4;
set_cmd(&cmd_gem[gem_nr++], DST_BASE_ADDR_REG |
G2D_BUF_USERPTR,
(unsigned long)&g2d_userptr);
...
}
int main(int argc, char **argv)
{
unsigned long addr;
...
addr = malloc(x * y * 4);
...
solid_fill_test(x, y, addr);
...
}
And next, the pages are mapped with iommu table and the device
address is set to cmdlist so that G2D's dma can access it.
As you may know, the pages from get_user_pages() are pinned.
In other words, they CAN NOT be migrated and also swapped out.
So the dma access would be safe.
But the use of userptr feature has performance overhead so
this patch also has memory pool to the userptr feature.
Please, assume that user sends cmdlist filled with userptr
and size every time to g2d driver, and the get_user_pages
funcion will be called every time.
The memory pool has maximum 64MB size and the userptr that
user had ever sent, is holded in the memory pool.
This meaning is that if the userptr from user is same as one
in the memory pool, device address to the userptr in the memory
pool is set to cmdlist.
And last, the pages from get_user_pages() will be freed once
user calls free() and the dma access is completed. Actually,
get_user_pages() takes 2 reference counts if the user process
has never accessed user region allocated by malloc(). Then, if
the user calls free(), the page reference count becomes 1 and
becomes 0 with put_page() call. And the reverse holds as well.
This means how the pages backed are used by dma and freed.
This patch is based on "drm/exynos: add iommu support for g2d",
https://patchwork.kernel.org/patch/1629481/
Signed-off-by: Inki Dae <inki.dae@samsung.com>
Signed-off-by: Kyungmin Park <kyungmin.park@samsung.com>
2012-11-04 13:48:52 +00:00
|
|
|
if (node->obj_type[i] == BUF_TYPE_GEM)
|
|
|
|
exynos_drm_gem_put_dma_addr(subdrv->drm_dev, handle,
|
|
|
|
filp);
|
|
|
|
else
|
|
|
|
g2d_userptr_put_dma_addr(subdrv->drm_dev, handle,
|
|
|
|
false);
|
2012-05-17 11:06:32 +00:00
|
|
|
|
2012-11-04 04:53:24 +00:00
|
|
|
node->handles[i] = 0;
|
2012-05-17 11:06:32 +00:00
|
|
|
}
|
2012-11-04 04:53:24 +00:00
|
|
|
|
|
|
|
node->map_nr = 0;
|
2012-05-17 11:06:32 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static void g2d_dma_start(struct g2d_data *g2d,
|
|
|
|
struct g2d_runqueue_node *runqueue_node)
|
|
|
|
{
|
|
|
|
struct g2d_cmdlist_node *node =
|
|
|
|
list_first_entry(&runqueue_node->run_cmdlist,
|
|
|
|
struct g2d_cmdlist_node, list);
|
|
|
|
|
|
|
|
pm_runtime_get_sync(g2d->dev);
|
|
|
|
clk_enable(g2d->gate_clk);
|
|
|
|
|
|
|
|
/* interrupt enable */
|
|
|
|
writel_relaxed(G2D_INTEN_ACF | G2D_INTEN_UCF | G2D_INTEN_GCF,
|
|
|
|
g2d->regs + G2D_INTEN);
|
|
|
|
|
|
|
|
writel_relaxed(node->dma_addr, g2d->regs + G2D_DMA_SFR_BASE_ADDR);
|
|
|
|
writel_relaxed(G2D_DMA_START, g2d->regs + G2D_DMA_COMMAND);
|
|
|
|
}
|
|
|
|
|
|
|
|
static struct g2d_runqueue_node *g2d_get_runqueue_node(struct g2d_data *g2d)
|
|
|
|
{
|
|
|
|
struct g2d_runqueue_node *runqueue_node;
|
|
|
|
|
|
|
|
if (list_empty(&g2d->runqueue))
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
runqueue_node = list_first_entry(&g2d->runqueue,
|
|
|
|
struct g2d_runqueue_node, list);
|
|
|
|
list_del_init(&runqueue_node->list);
|
|
|
|
return runqueue_node;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void g2d_free_runqueue_node(struct g2d_data *g2d,
|
|
|
|
struct g2d_runqueue_node *runqueue_node)
|
|
|
|
{
|
2012-11-04 04:53:24 +00:00
|
|
|
struct g2d_cmdlist_node *node;
|
|
|
|
|
2012-05-17 11:06:32 +00:00
|
|
|
if (!runqueue_node)
|
|
|
|
return;
|
|
|
|
|
|
|
|
mutex_lock(&g2d->cmdlist_mutex);
|
2012-11-04 04:53:24 +00:00
|
|
|
/*
|
|
|
|
* commands in run_cmdlist have been completed so unmap all gem
|
|
|
|
* objects in each command node so that they are unreferenced.
|
|
|
|
*/
|
|
|
|
list_for_each_entry(node, &runqueue_node->run_cmdlist, list)
|
|
|
|
g2d_unmap_cmdlist_gem(g2d, node, runqueue_node->filp);
|
2012-05-17 11:06:32 +00:00
|
|
|
list_splice_tail_init(&runqueue_node->run_cmdlist, &g2d->free_cmdlist);
|
|
|
|
mutex_unlock(&g2d->cmdlist_mutex);
|
|
|
|
|
|
|
|
kmem_cache_free(g2d->runqueue_slab, runqueue_node);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void g2d_exec_runqueue(struct g2d_data *g2d)
|
|
|
|
{
|
|
|
|
g2d->runqueue_node = g2d_get_runqueue_node(g2d);
|
|
|
|
if (g2d->runqueue_node)
|
|
|
|
g2d_dma_start(g2d, g2d->runqueue_node);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void g2d_runqueue_worker(struct work_struct *work)
|
|
|
|
{
|
|
|
|
struct g2d_data *g2d = container_of(work, struct g2d_data,
|
|
|
|
runqueue_work);
|
|
|
|
|
|
|
|
|
|
|
|
mutex_lock(&g2d->runqueue_mutex);
|
|
|
|
clk_disable(g2d->gate_clk);
|
|
|
|
pm_runtime_put_sync(g2d->dev);
|
|
|
|
|
|
|
|
complete(&g2d->runqueue_node->complete);
|
|
|
|
if (g2d->runqueue_node->async)
|
|
|
|
g2d_free_runqueue_node(g2d, g2d->runqueue_node);
|
|
|
|
|
|
|
|
if (g2d->suspended)
|
|
|
|
g2d->runqueue_node = NULL;
|
|
|
|
else
|
|
|
|
g2d_exec_runqueue(g2d);
|
|
|
|
mutex_unlock(&g2d->runqueue_mutex);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void g2d_finish_event(struct g2d_data *g2d, u32 cmdlist_no)
|
|
|
|
{
|
|
|
|
struct drm_device *drm_dev = g2d->subdrv.drm_dev;
|
|
|
|
struct g2d_runqueue_node *runqueue_node = g2d->runqueue_node;
|
|
|
|
struct drm_exynos_pending_g2d_event *e;
|
|
|
|
struct timeval now;
|
|
|
|
unsigned long flags;
|
|
|
|
|
|
|
|
if (list_empty(&runqueue_node->event_list))
|
|
|
|
return;
|
|
|
|
|
|
|
|
e = list_first_entry(&runqueue_node->event_list,
|
|
|
|
struct drm_exynos_pending_g2d_event, base.link);
|
|
|
|
|
|
|
|
do_gettimeofday(&now);
|
|
|
|
e->event.tv_sec = now.tv_sec;
|
|
|
|
e->event.tv_usec = now.tv_usec;
|
|
|
|
e->event.cmdlist_no = cmdlist_no;
|
|
|
|
|
|
|
|
spin_lock_irqsave(&drm_dev->event_lock, flags);
|
|
|
|
list_move_tail(&e->base.link, &e->base.file_priv->event_list);
|
|
|
|
wake_up_interruptible(&e->base.file_priv->event_wait);
|
|
|
|
spin_unlock_irqrestore(&drm_dev->event_lock, flags);
|
|
|
|
}
|
|
|
|
|
|
|
|
static irqreturn_t g2d_irq_handler(int irq, void *dev_id)
|
|
|
|
{
|
|
|
|
struct g2d_data *g2d = dev_id;
|
|
|
|
u32 pending;
|
|
|
|
|
|
|
|
pending = readl_relaxed(g2d->regs + G2D_INTC_PEND);
|
|
|
|
if (pending)
|
|
|
|
writel_relaxed(pending, g2d->regs + G2D_INTC_PEND);
|
|
|
|
|
|
|
|
if (pending & G2D_INTP_GCMD_FIN) {
|
|
|
|
u32 cmdlist_no = readl_relaxed(g2d->regs + G2D_DMA_STATUS);
|
|
|
|
|
|
|
|
cmdlist_no = (cmdlist_no & G2D_DMA_LIST_DONE_COUNT) >>
|
|
|
|
G2D_DMA_LIST_DONE_COUNT_OFFSET;
|
|
|
|
|
|
|
|
g2d_finish_event(g2d, cmdlist_no);
|
|
|
|
|
|
|
|
writel_relaxed(0, g2d->regs + G2D_DMA_HOLD_CMD);
|
|
|
|
if (!(pending & G2D_INTP_ACMD_FIN)) {
|
|
|
|
writel_relaxed(G2D_DMA_CONTINUE,
|
|
|
|
g2d->regs + G2D_DMA_COMMAND);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (pending & G2D_INTP_ACMD_FIN)
|
|
|
|
queue_work(g2d->g2d_workq, &g2d->runqueue_work);
|
|
|
|
|
|
|
|
return IRQ_HANDLED;
|
|
|
|
}
|
|
|
|
|
drm/exynos: add userptr feature for g2d module
This patch adds userptr feautre for G2D module.
The userptr means user space address allocated by malloc().
And the purpose of this feature is to make G2D's dma able
to access the user space region.
To user this feature, user should flag G2D_BUF_USRPTR to
offset variable of struct drm_exynos_g2d_cmd and fill
struct drm_exynos_g2d_userptr with user space address
and size for it and then should set a pointer to
drm_exynos_g2d_userptr object to data variable of struct
drm_exynos_g2d_cmd. The last bit of offset variable is used
to check if the cmdlist's buffer type is userptr or not.
If userptr, the g2d driver gets user space address and size
and then gets pages through get_user_pages().
(another case is counted as gem handle)
Below is sample codes:
static void set_cmd(struct drm_exynos_g2d_cmd *cmd,
unsigned long offset, unsigned long data)
{
cmd->offset = offset;
cmd->data = data;
}
static int solid_fill_test(int x, int y, unsigned long userptr)
{
struct drm_exynos_g2d_cmd cmd_gem[5];
struct drm_exynos_g2d_userptr g2d_userptr;
unsigned int gem_nr = 0;
...
g2d_userptr.userptr = userptr;
g2d_userptr.size = x * y * 4;
set_cmd(&cmd_gem[gem_nr++], DST_BASE_ADDR_REG |
G2D_BUF_USERPTR,
(unsigned long)&g2d_userptr);
...
}
int main(int argc, char **argv)
{
unsigned long addr;
...
addr = malloc(x * y * 4);
...
solid_fill_test(x, y, addr);
...
}
And next, the pages are mapped with iommu table and the device
address is set to cmdlist so that G2D's dma can access it.
As you may know, the pages from get_user_pages() are pinned.
In other words, they CAN NOT be migrated and also swapped out.
So the dma access would be safe.
But the use of userptr feature has performance overhead so
this patch also has memory pool to the userptr feature.
Please, assume that user sends cmdlist filled with userptr
and size every time to g2d driver, and the get_user_pages
funcion will be called every time.
The memory pool has maximum 64MB size and the userptr that
user had ever sent, is holded in the memory pool.
This meaning is that if the userptr from user is same as one
in the memory pool, device address to the userptr in the memory
pool is set to cmdlist.
And last, the pages from get_user_pages() will be freed once
user calls free() and the dma access is completed. Actually,
get_user_pages() takes 2 reference counts if the user process
has never accessed user region allocated by malloc(). Then, if
the user calls free(), the page reference count becomes 1 and
becomes 0 with put_page() call. And the reverse holds as well.
This means how the pages backed are used by dma and freed.
This patch is based on "drm/exynos: add iommu support for g2d",
https://patchwork.kernel.org/patch/1629481/
Signed-off-by: Inki Dae <inki.dae@samsung.com>
Signed-off-by: Kyungmin Park <kyungmin.park@samsung.com>
2012-11-04 13:48:52 +00:00
|
|
|
static int g2d_check_reg_offset(struct device *dev,
|
|
|
|
struct g2d_cmdlist_node *node,
|
2012-05-17 11:06:32 +00:00
|
|
|
int nr, bool for_addr)
|
|
|
|
{
|
drm/exynos: add userptr feature for g2d module
This patch adds userptr feautre for G2D module.
The userptr means user space address allocated by malloc().
And the purpose of this feature is to make G2D's dma able
to access the user space region.
To user this feature, user should flag G2D_BUF_USRPTR to
offset variable of struct drm_exynos_g2d_cmd and fill
struct drm_exynos_g2d_userptr with user space address
and size for it and then should set a pointer to
drm_exynos_g2d_userptr object to data variable of struct
drm_exynos_g2d_cmd. The last bit of offset variable is used
to check if the cmdlist's buffer type is userptr or not.
If userptr, the g2d driver gets user space address and size
and then gets pages through get_user_pages().
(another case is counted as gem handle)
Below is sample codes:
static void set_cmd(struct drm_exynos_g2d_cmd *cmd,
unsigned long offset, unsigned long data)
{
cmd->offset = offset;
cmd->data = data;
}
static int solid_fill_test(int x, int y, unsigned long userptr)
{
struct drm_exynos_g2d_cmd cmd_gem[5];
struct drm_exynos_g2d_userptr g2d_userptr;
unsigned int gem_nr = 0;
...
g2d_userptr.userptr = userptr;
g2d_userptr.size = x * y * 4;
set_cmd(&cmd_gem[gem_nr++], DST_BASE_ADDR_REG |
G2D_BUF_USERPTR,
(unsigned long)&g2d_userptr);
...
}
int main(int argc, char **argv)
{
unsigned long addr;
...
addr = malloc(x * y * 4);
...
solid_fill_test(x, y, addr);
...
}
And next, the pages are mapped with iommu table and the device
address is set to cmdlist so that G2D's dma can access it.
As you may know, the pages from get_user_pages() are pinned.
In other words, they CAN NOT be migrated and also swapped out.
So the dma access would be safe.
But the use of userptr feature has performance overhead so
this patch also has memory pool to the userptr feature.
Please, assume that user sends cmdlist filled with userptr
and size every time to g2d driver, and the get_user_pages
funcion will be called every time.
The memory pool has maximum 64MB size and the userptr that
user had ever sent, is holded in the memory pool.
This meaning is that if the userptr from user is same as one
in the memory pool, device address to the userptr in the memory
pool is set to cmdlist.
And last, the pages from get_user_pages() will be freed once
user calls free() and the dma access is completed. Actually,
get_user_pages() takes 2 reference counts if the user process
has never accessed user region allocated by malloc(). Then, if
the user calls free(), the page reference count becomes 1 and
becomes 0 with put_page() call. And the reverse holds as well.
This means how the pages backed are used by dma and freed.
This patch is based on "drm/exynos: add iommu support for g2d",
https://patchwork.kernel.org/patch/1629481/
Signed-off-by: Inki Dae <inki.dae@samsung.com>
Signed-off-by: Kyungmin Park <kyungmin.park@samsung.com>
2012-11-04 13:48:52 +00:00
|
|
|
struct g2d_cmdlist *cmdlist = node->cmdlist;
|
2012-05-17 11:06:32 +00:00
|
|
|
int reg_offset;
|
|
|
|
int index;
|
|
|
|
int i;
|
|
|
|
|
|
|
|
for (i = 0; i < nr; i++) {
|
|
|
|
index = cmdlist->last - 2 * (i + 1);
|
drm/exynos: add userptr feature for g2d module
This patch adds userptr feautre for G2D module.
The userptr means user space address allocated by malloc().
And the purpose of this feature is to make G2D's dma able
to access the user space region.
To user this feature, user should flag G2D_BUF_USRPTR to
offset variable of struct drm_exynos_g2d_cmd and fill
struct drm_exynos_g2d_userptr with user space address
and size for it and then should set a pointer to
drm_exynos_g2d_userptr object to data variable of struct
drm_exynos_g2d_cmd. The last bit of offset variable is used
to check if the cmdlist's buffer type is userptr or not.
If userptr, the g2d driver gets user space address and size
and then gets pages through get_user_pages().
(another case is counted as gem handle)
Below is sample codes:
static void set_cmd(struct drm_exynos_g2d_cmd *cmd,
unsigned long offset, unsigned long data)
{
cmd->offset = offset;
cmd->data = data;
}
static int solid_fill_test(int x, int y, unsigned long userptr)
{
struct drm_exynos_g2d_cmd cmd_gem[5];
struct drm_exynos_g2d_userptr g2d_userptr;
unsigned int gem_nr = 0;
...
g2d_userptr.userptr = userptr;
g2d_userptr.size = x * y * 4;
set_cmd(&cmd_gem[gem_nr++], DST_BASE_ADDR_REG |
G2D_BUF_USERPTR,
(unsigned long)&g2d_userptr);
...
}
int main(int argc, char **argv)
{
unsigned long addr;
...
addr = malloc(x * y * 4);
...
solid_fill_test(x, y, addr);
...
}
And next, the pages are mapped with iommu table and the device
address is set to cmdlist so that G2D's dma can access it.
As you may know, the pages from get_user_pages() are pinned.
In other words, they CAN NOT be migrated and also swapped out.
So the dma access would be safe.
But the use of userptr feature has performance overhead so
this patch also has memory pool to the userptr feature.
Please, assume that user sends cmdlist filled with userptr
and size every time to g2d driver, and the get_user_pages
funcion will be called every time.
The memory pool has maximum 64MB size and the userptr that
user had ever sent, is holded in the memory pool.
This meaning is that if the userptr from user is same as one
in the memory pool, device address to the userptr in the memory
pool is set to cmdlist.
And last, the pages from get_user_pages() will be freed once
user calls free() and the dma access is completed. Actually,
get_user_pages() takes 2 reference counts if the user process
has never accessed user region allocated by malloc(). Then, if
the user calls free(), the page reference count becomes 1 and
becomes 0 with put_page() call. And the reverse holds as well.
This means how the pages backed are used by dma and freed.
This patch is based on "drm/exynos: add iommu support for g2d",
https://patchwork.kernel.org/patch/1629481/
Signed-off-by: Inki Dae <inki.dae@samsung.com>
Signed-off-by: Kyungmin Park <kyungmin.park@samsung.com>
2012-11-04 13:48:52 +00:00
|
|
|
|
|
|
|
if (for_addr) {
|
|
|
|
/* check userptr buffer type. */
|
|
|
|
reg_offset = (cmdlist->data[index] &
|
|
|
|
~0x7fffffff) >> 31;
|
|
|
|
if (reg_offset) {
|
|
|
|
node->obj_type[i] = BUF_TYPE_USERPTR;
|
|
|
|
cmdlist->data[index] &= ~G2D_BUF_USERPTR;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-05-17 11:06:32 +00:00
|
|
|
reg_offset = cmdlist->data[index] & ~0xfffff000;
|
|
|
|
|
|
|
|
if (reg_offset < G2D_VALID_START || reg_offset > G2D_VALID_END)
|
|
|
|
goto err;
|
|
|
|
if (reg_offset % 4)
|
|
|
|
goto err;
|
|
|
|
|
|
|
|
switch (reg_offset) {
|
|
|
|
case G2D_SRC_BASE_ADDR:
|
|
|
|
case G2D_SRC_PLANE2_BASE_ADDR:
|
|
|
|
case G2D_DST_BASE_ADDR:
|
|
|
|
case G2D_DST_PLANE2_BASE_ADDR:
|
|
|
|
case G2D_PAT_BASE_ADDR:
|
|
|
|
case G2D_MSK_BASE_ADDR:
|
|
|
|
if (!for_addr)
|
|
|
|
goto err;
|
drm/exynos: add userptr feature for g2d module
This patch adds userptr feautre for G2D module.
The userptr means user space address allocated by malloc().
And the purpose of this feature is to make G2D's dma able
to access the user space region.
To user this feature, user should flag G2D_BUF_USRPTR to
offset variable of struct drm_exynos_g2d_cmd and fill
struct drm_exynos_g2d_userptr with user space address
and size for it and then should set a pointer to
drm_exynos_g2d_userptr object to data variable of struct
drm_exynos_g2d_cmd. The last bit of offset variable is used
to check if the cmdlist's buffer type is userptr or not.
If userptr, the g2d driver gets user space address and size
and then gets pages through get_user_pages().
(another case is counted as gem handle)
Below is sample codes:
static void set_cmd(struct drm_exynos_g2d_cmd *cmd,
unsigned long offset, unsigned long data)
{
cmd->offset = offset;
cmd->data = data;
}
static int solid_fill_test(int x, int y, unsigned long userptr)
{
struct drm_exynos_g2d_cmd cmd_gem[5];
struct drm_exynos_g2d_userptr g2d_userptr;
unsigned int gem_nr = 0;
...
g2d_userptr.userptr = userptr;
g2d_userptr.size = x * y * 4;
set_cmd(&cmd_gem[gem_nr++], DST_BASE_ADDR_REG |
G2D_BUF_USERPTR,
(unsigned long)&g2d_userptr);
...
}
int main(int argc, char **argv)
{
unsigned long addr;
...
addr = malloc(x * y * 4);
...
solid_fill_test(x, y, addr);
...
}
And next, the pages are mapped with iommu table and the device
address is set to cmdlist so that G2D's dma can access it.
As you may know, the pages from get_user_pages() are pinned.
In other words, they CAN NOT be migrated and also swapped out.
So the dma access would be safe.
But the use of userptr feature has performance overhead so
this patch also has memory pool to the userptr feature.
Please, assume that user sends cmdlist filled with userptr
and size every time to g2d driver, and the get_user_pages
funcion will be called every time.
The memory pool has maximum 64MB size and the userptr that
user had ever sent, is holded in the memory pool.
This meaning is that if the userptr from user is same as one
in the memory pool, device address to the userptr in the memory
pool is set to cmdlist.
And last, the pages from get_user_pages() will be freed once
user calls free() and the dma access is completed. Actually,
get_user_pages() takes 2 reference counts if the user process
has never accessed user region allocated by malloc(). Then, if
the user calls free(), the page reference count becomes 1 and
becomes 0 with put_page() call. And the reverse holds as well.
This means how the pages backed are used by dma and freed.
This patch is based on "drm/exynos: add iommu support for g2d",
https://patchwork.kernel.org/patch/1629481/
Signed-off-by: Inki Dae <inki.dae@samsung.com>
Signed-off-by: Kyungmin Park <kyungmin.park@samsung.com>
2012-11-04 13:48:52 +00:00
|
|
|
|
|
|
|
if (node->obj_type[i] != BUF_TYPE_USERPTR)
|
|
|
|
node->obj_type[i] = BUF_TYPE_GEM;
|
2012-05-17 11:06:32 +00:00
|
|
|
break;
|
|
|
|
default:
|
|
|
|
if (for_addr)
|
|
|
|
goto err;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
err:
|
drm/exynos: add userptr feature for g2d module
This patch adds userptr feautre for G2D module.
The userptr means user space address allocated by malloc().
And the purpose of this feature is to make G2D's dma able
to access the user space region.
To user this feature, user should flag G2D_BUF_USRPTR to
offset variable of struct drm_exynos_g2d_cmd and fill
struct drm_exynos_g2d_userptr with user space address
and size for it and then should set a pointer to
drm_exynos_g2d_userptr object to data variable of struct
drm_exynos_g2d_cmd. The last bit of offset variable is used
to check if the cmdlist's buffer type is userptr or not.
If userptr, the g2d driver gets user space address and size
and then gets pages through get_user_pages().
(another case is counted as gem handle)
Below is sample codes:
static void set_cmd(struct drm_exynos_g2d_cmd *cmd,
unsigned long offset, unsigned long data)
{
cmd->offset = offset;
cmd->data = data;
}
static int solid_fill_test(int x, int y, unsigned long userptr)
{
struct drm_exynos_g2d_cmd cmd_gem[5];
struct drm_exynos_g2d_userptr g2d_userptr;
unsigned int gem_nr = 0;
...
g2d_userptr.userptr = userptr;
g2d_userptr.size = x * y * 4;
set_cmd(&cmd_gem[gem_nr++], DST_BASE_ADDR_REG |
G2D_BUF_USERPTR,
(unsigned long)&g2d_userptr);
...
}
int main(int argc, char **argv)
{
unsigned long addr;
...
addr = malloc(x * y * 4);
...
solid_fill_test(x, y, addr);
...
}
And next, the pages are mapped with iommu table and the device
address is set to cmdlist so that G2D's dma can access it.
As you may know, the pages from get_user_pages() are pinned.
In other words, they CAN NOT be migrated and also swapped out.
So the dma access would be safe.
But the use of userptr feature has performance overhead so
this patch also has memory pool to the userptr feature.
Please, assume that user sends cmdlist filled with userptr
and size every time to g2d driver, and the get_user_pages
funcion will be called every time.
The memory pool has maximum 64MB size and the userptr that
user had ever sent, is holded in the memory pool.
This meaning is that if the userptr from user is same as one
in the memory pool, device address to the userptr in the memory
pool is set to cmdlist.
And last, the pages from get_user_pages() will be freed once
user calls free() and the dma access is completed. Actually,
get_user_pages() takes 2 reference counts if the user process
has never accessed user region allocated by malloc(). Then, if
the user calls free(), the page reference count becomes 1 and
becomes 0 with put_page() call. And the reverse holds as well.
This means how the pages backed are used by dma and freed.
This patch is based on "drm/exynos: add iommu support for g2d",
https://patchwork.kernel.org/patch/1629481/
Signed-off-by: Inki Dae <inki.dae@samsung.com>
Signed-off-by: Kyungmin Park <kyungmin.park@samsung.com>
2012-11-04 13:48:52 +00:00
|
|
|
dev_err(dev, "Bad register offset: 0x%lx\n", cmdlist->data[index]);
|
2012-05-17 11:06:32 +00:00
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* ioctl functions */
|
|
|
|
int exynos_g2d_get_ver_ioctl(struct drm_device *drm_dev, void *data,
|
|
|
|
struct drm_file *file)
|
|
|
|
{
|
|
|
|
struct drm_exynos_g2d_get_ver *ver = data;
|
|
|
|
|
|
|
|
ver->major = G2D_HW_MAJOR_VER;
|
|
|
|
ver->minor = G2D_HW_MINOR_VER;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(exynos_g2d_get_ver_ioctl);
|
|
|
|
|
|
|
|
int exynos_g2d_set_cmdlist_ioctl(struct drm_device *drm_dev, void *data,
|
|
|
|
struct drm_file *file)
|
|
|
|
{
|
|
|
|
struct drm_exynos_file_private *file_priv = file->driver_priv;
|
|
|
|
struct exynos_drm_g2d_private *g2d_priv = file_priv->g2d_priv;
|
|
|
|
struct device *dev = g2d_priv->dev;
|
|
|
|
struct g2d_data *g2d;
|
|
|
|
struct drm_exynos_g2d_set_cmdlist *req = data;
|
|
|
|
struct drm_exynos_g2d_cmd *cmd;
|
|
|
|
struct drm_exynos_pending_g2d_event *e;
|
|
|
|
struct g2d_cmdlist_node *node;
|
|
|
|
struct g2d_cmdlist *cmdlist;
|
|
|
|
unsigned long flags;
|
|
|
|
int size;
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
if (!dev)
|
|
|
|
return -ENODEV;
|
|
|
|
|
|
|
|
g2d = dev_get_drvdata(dev);
|
|
|
|
if (!g2d)
|
|
|
|
return -EFAULT;
|
|
|
|
|
|
|
|
node = g2d_get_cmdlist(g2d);
|
|
|
|
if (!node)
|
|
|
|
return -ENOMEM;
|
|
|
|
|
|
|
|
node->event = NULL;
|
|
|
|
|
|
|
|
if (req->event_type != G2D_EVENT_NOT) {
|
|
|
|
spin_lock_irqsave(&drm_dev->event_lock, flags);
|
|
|
|
if (file->event_space < sizeof(e->event)) {
|
|
|
|
spin_unlock_irqrestore(&drm_dev->event_lock, flags);
|
|
|
|
ret = -ENOMEM;
|
|
|
|
goto err;
|
|
|
|
}
|
|
|
|
file->event_space -= sizeof(e->event);
|
|
|
|
spin_unlock_irqrestore(&drm_dev->event_lock, flags);
|
|
|
|
|
|
|
|
e = kzalloc(sizeof(*node->event), GFP_KERNEL);
|
|
|
|
if (!e) {
|
|
|
|
dev_err(dev, "failed to allocate event\n");
|
|
|
|
|
|
|
|
spin_lock_irqsave(&drm_dev->event_lock, flags);
|
|
|
|
file->event_space += sizeof(e->event);
|
|
|
|
spin_unlock_irqrestore(&drm_dev->event_lock, flags);
|
|
|
|
|
|
|
|
ret = -ENOMEM;
|
|
|
|
goto err;
|
|
|
|
}
|
|
|
|
|
|
|
|
e->event.base.type = DRM_EXYNOS_G2D_EVENT;
|
|
|
|
e->event.base.length = sizeof(e->event);
|
|
|
|
e->event.user_data = req->user_data;
|
|
|
|
e->base.event = &e->event.base;
|
|
|
|
e->base.file_priv = file;
|
|
|
|
e->base.destroy = (void (*) (struct drm_pending_event *)) kfree;
|
|
|
|
|
|
|
|
node->event = e;
|
|
|
|
}
|
|
|
|
|
|
|
|
cmdlist = node->cmdlist;
|
|
|
|
|
|
|
|
cmdlist->last = 0;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* If don't clear SFR registers, the cmdlist is affected by register
|
|
|
|
* values of previous cmdlist. G2D hw executes SFR clear command and
|
|
|
|
* a next command at the same time then the next command is ignored and
|
|
|
|
* is executed rightly from next next command, so needs a dummy command
|
|
|
|
* to next command of SFR clear command.
|
|
|
|
*/
|
|
|
|
cmdlist->data[cmdlist->last++] = G2D_SOFT_RESET;
|
|
|
|
cmdlist->data[cmdlist->last++] = G2D_SFRCLEAR;
|
|
|
|
cmdlist->data[cmdlist->last++] = G2D_SRC_BASE_ADDR;
|
|
|
|
cmdlist->data[cmdlist->last++] = 0;
|
|
|
|
|
|
|
|
if (node->event) {
|
|
|
|
cmdlist->data[cmdlist->last++] = G2D_DMA_HOLD_CMD;
|
|
|
|
cmdlist->data[cmdlist->last++] = G2D_LIST_HOLD;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Check size of cmdlist: last 2 is about G2D_BITBLT_START */
|
drm/exynos: add userptr feature for g2d module
This patch adds userptr feautre for G2D module.
The userptr means user space address allocated by malloc().
And the purpose of this feature is to make G2D's dma able
to access the user space region.
To user this feature, user should flag G2D_BUF_USRPTR to
offset variable of struct drm_exynos_g2d_cmd and fill
struct drm_exynos_g2d_userptr with user space address
and size for it and then should set a pointer to
drm_exynos_g2d_userptr object to data variable of struct
drm_exynos_g2d_cmd. The last bit of offset variable is used
to check if the cmdlist's buffer type is userptr or not.
If userptr, the g2d driver gets user space address and size
and then gets pages through get_user_pages().
(another case is counted as gem handle)
Below is sample codes:
static void set_cmd(struct drm_exynos_g2d_cmd *cmd,
unsigned long offset, unsigned long data)
{
cmd->offset = offset;
cmd->data = data;
}
static int solid_fill_test(int x, int y, unsigned long userptr)
{
struct drm_exynos_g2d_cmd cmd_gem[5];
struct drm_exynos_g2d_userptr g2d_userptr;
unsigned int gem_nr = 0;
...
g2d_userptr.userptr = userptr;
g2d_userptr.size = x * y * 4;
set_cmd(&cmd_gem[gem_nr++], DST_BASE_ADDR_REG |
G2D_BUF_USERPTR,
(unsigned long)&g2d_userptr);
...
}
int main(int argc, char **argv)
{
unsigned long addr;
...
addr = malloc(x * y * 4);
...
solid_fill_test(x, y, addr);
...
}
And next, the pages are mapped with iommu table and the device
address is set to cmdlist so that G2D's dma can access it.
As you may know, the pages from get_user_pages() are pinned.
In other words, they CAN NOT be migrated and also swapped out.
So the dma access would be safe.
But the use of userptr feature has performance overhead so
this patch also has memory pool to the userptr feature.
Please, assume that user sends cmdlist filled with userptr
and size every time to g2d driver, and the get_user_pages
funcion will be called every time.
The memory pool has maximum 64MB size and the userptr that
user had ever sent, is holded in the memory pool.
This meaning is that if the userptr from user is same as one
in the memory pool, device address to the userptr in the memory
pool is set to cmdlist.
And last, the pages from get_user_pages() will be freed once
user calls free() and the dma access is completed. Actually,
get_user_pages() takes 2 reference counts if the user process
has never accessed user region allocated by malloc(). Then, if
the user calls free(), the page reference count becomes 1 and
becomes 0 with put_page() call. And the reverse holds as well.
This means how the pages backed are used by dma and freed.
This patch is based on "drm/exynos: add iommu support for g2d",
https://patchwork.kernel.org/patch/1629481/
Signed-off-by: Inki Dae <inki.dae@samsung.com>
Signed-off-by: Kyungmin Park <kyungmin.park@samsung.com>
2012-11-04 13:48:52 +00:00
|
|
|
size = cmdlist->last + req->cmd_nr * 2 + req->cmd_buf_nr * 2 + 2;
|
2012-05-17 11:06:32 +00:00
|
|
|
if (size > G2D_CMDLIST_DATA_NUM) {
|
|
|
|
dev_err(dev, "cmdlist size is too big\n");
|
|
|
|
ret = -EINVAL;
|
|
|
|
goto err_free_event;
|
|
|
|
}
|
|
|
|
|
|
|
|
cmd = (struct drm_exynos_g2d_cmd *)(uint32_t)req->cmd;
|
|
|
|
|
|
|
|
if (copy_from_user(cmdlist->data + cmdlist->last,
|
|
|
|
(void __user *)cmd,
|
|
|
|
sizeof(*cmd) * req->cmd_nr)) {
|
|
|
|
ret = -EFAULT;
|
|
|
|
goto err_free_event;
|
|
|
|
}
|
|
|
|
cmdlist->last += req->cmd_nr * 2;
|
|
|
|
|
drm/exynos: add userptr feature for g2d module
This patch adds userptr feautre for G2D module.
The userptr means user space address allocated by malloc().
And the purpose of this feature is to make G2D's dma able
to access the user space region.
To user this feature, user should flag G2D_BUF_USRPTR to
offset variable of struct drm_exynos_g2d_cmd and fill
struct drm_exynos_g2d_userptr with user space address
and size for it and then should set a pointer to
drm_exynos_g2d_userptr object to data variable of struct
drm_exynos_g2d_cmd. The last bit of offset variable is used
to check if the cmdlist's buffer type is userptr or not.
If userptr, the g2d driver gets user space address and size
and then gets pages through get_user_pages().
(another case is counted as gem handle)
Below is sample codes:
static void set_cmd(struct drm_exynos_g2d_cmd *cmd,
unsigned long offset, unsigned long data)
{
cmd->offset = offset;
cmd->data = data;
}
static int solid_fill_test(int x, int y, unsigned long userptr)
{
struct drm_exynos_g2d_cmd cmd_gem[5];
struct drm_exynos_g2d_userptr g2d_userptr;
unsigned int gem_nr = 0;
...
g2d_userptr.userptr = userptr;
g2d_userptr.size = x * y * 4;
set_cmd(&cmd_gem[gem_nr++], DST_BASE_ADDR_REG |
G2D_BUF_USERPTR,
(unsigned long)&g2d_userptr);
...
}
int main(int argc, char **argv)
{
unsigned long addr;
...
addr = malloc(x * y * 4);
...
solid_fill_test(x, y, addr);
...
}
And next, the pages are mapped with iommu table and the device
address is set to cmdlist so that G2D's dma can access it.
As you may know, the pages from get_user_pages() are pinned.
In other words, they CAN NOT be migrated and also swapped out.
So the dma access would be safe.
But the use of userptr feature has performance overhead so
this patch also has memory pool to the userptr feature.
Please, assume that user sends cmdlist filled with userptr
and size every time to g2d driver, and the get_user_pages
funcion will be called every time.
The memory pool has maximum 64MB size and the userptr that
user had ever sent, is holded in the memory pool.
This meaning is that if the userptr from user is same as one
in the memory pool, device address to the userptr in the memory
pool is set to cmdlist.
And last, the pages from get_user_pages() will be freed once
user calls free() and the dma access is completed. Actually,
get_user_pages() takes 2 reference counts if the user process
has never accessed user region allocated by malloc(). Then, if
the user calls free(), the page reference count becomes 1 and
becomes 0 with put_page() call. And the reverse holds as well.
This means how the pages backed are used by dma and freed.
This patch is based on "drm/exynos: add iommu support for g2d",
https://patchwork.kernel.org/patch/1629481/
Signed-off-by: Inki Dae <inki.dae@samsung.com>
Signed-off-by: Kyungmin Park <kyungmin.park@samsung.com>
2012-11-04 13:48:52 +00:00
|
|
|
ret = g2d_check_reg_offset(dev, node, req->cmd_nr, false);
|
2012-05-17 11:06:32 +00:00
|
|
|
if (ret < 0)
|
|
|
|
goto err_free_event;
|
|
|
|
|
drm/exynos: add userptr feature for g2d module
This patch adds userptr feautre for G2D module.
The userptr means user space address allocated by malloc().
And the purpose of this feature is to make G2D's dma able
to access the user space region.
To user this feature, user should flag G2D_BUF_USRPTR to
offset variable of struct drm_exynos_g2d_cmd and fill
struct drm_exynos_g2d_userptr with user space address
and size for it and then should set a pointer to
drm_exynos_g2d_userptr object to data variable of struct
drm_exynos_g2d_cmd. The last bit of offset variable is used
to check if the cmdlist's buffer type is userptr or not.
If userptr, the g2d driver gets user space address and size
and then gets pages through get_user_pages().
(another case is counted as gem handle)
Below is sample codes:
static void set_cmd(struct drm_exynos_g2d_cmd *cmd,
unsigned long offset, unsigned long data)
{
cmd->offset = offset;
cmd->data = data;
}
static int solid_fill_test(int x, int y, unsigned long userptr)
{
struct drm_exynos_g2d_cmd cmd_gem[5];
struct drm_exynos_g2d_userptr g2d_userptr;
unsigned int gem_nr = 0;
...
g2d_userptr.userptr = userptr;
g2d_userptr.size = x * y * 4;
set_cmd(&cmd_gem[gem_nr++], DST_BASE_ADDR_REG |
G2D_BUF_USERPTR,
(unsigned long)&g2d_userptr);
...
}
int main(int argc, char **argv)
{
unsigned long addr;
...
addr = malloc(x * y * 4);
...
solid_fill_test(x, y, addr);
...
}
And next, the pages are mapped with iommu table and the device
address is set to cmdlist so that G2D's dma can access it.
As you may know, the pages from get_user_pages() are pinned.
In other words, they CAN NOT be migrated and also swapped out.
So the dma access would be safe.
But the use of userptr feature has performance overhead so
this patch also has memory pool to the userptr feature.
Please, assume that user sends cmdlist filled with userptr
and size every time to g2d driver, and the get_user_pages
funcion will be called every time.
The memory pool has maximum 64MB size and the userptr that
user had ever sent, is holded in the memory pool.
This meaning is that if the userptr from user is same as one
in the memory pool, device address to the userptr in the memory
pool is set to cmdlist.
And last, the pages from get_user_pages() will be freed once
user calls free() and the dma access is completed. Actually,
get_user_pages() takes 2 reference counts if the user process
has never accessed user region allocated by malloc(). Then, if
the user calls free(), the page reference count becomes 1 and
becomes 0 with put_page() call. And the reverse holds as well.
This means how the pages backed are used by dma and freed.
This patch is based on "drm/exynos: add iommu support for g2d",
https://patchwork.kernel.org/patch/1629481/
Signed-off-by: Inki Dae <inki.dae@samsung.com>
Signed-off-by: Kyungmin Park <kyungmin.park@samsung.com>
2012-11-04 13:48:52 +00:00
|
|
|
node->map_nr = req->cmd_buf_nr;
|
|
|
|
if (req->cmd_buf_nr) {
|
|
|
|
struct drm_exynos_g2d_cmd *cmd_buf;
|
2012-05-17 11:06:32 +00:00
|
|
|
|
drm/exynos: add userptr feature for g2d module
This patch adds userptr feautre for G2D module.
The userptr means user space address allocated by malloc().
And the purpose of this feature is to make G2D's dma able
to access the user space region.
To user this feature, user should flag G2D_BUF_USRPTR to
offset variable of struct drm_exynos_g2d_cmd and fill
struct drm_exynos_g2d_userptr with user space address
and size for it and then should set a pointer to
drm_exynos_g2d_userptr object to data variable of struct
drm_exynos_g2d_cmd. The last bit of offset variable is used
to check if the cmdlist's buffer type is userptr or not.
If userptr, the g2d driver gets user space address and size
and then gets pages through get_user_pages().
(another case is counted as gem handle)
Below is sample codes:
static void set_cmd(struct drm_exynos_g2d_cmd *cmd,
unsigned long offset, unsigned long data)
{
cmd->offset = offset;
cmd->data = data;
}
static int solid_fill_test(int x, int y, unsigned long userptr)
{
struct drm_exynos_g2d_cmd cmd_gem[5];
struct drm_exynos_g2d_userptr g2d_userptr;
unsigned int gem_nr = 0;
...
g2d_userptr.userptr = userptr;
g2d_userptr.size = x * y * 4;
set_cmd(&cmd_gem[gem_nr++], DST_BASE_ADDR_REG |
G2D_BUF_USERPTR,
(unsigned long)&g2d_userptr);
...
}
int main(int argc, char **argv)
{
unsigned long addr;
...
addr = malloc(x * y * 4);
...
solid_fill_test(x, y, addr);
...
}
And next, the pages are mapped with iommu table and the device
address is set to cmdlist so that G2D's dma can access it.
As you may know, the pages from get_user_pages() are pinned.
In other words, they CAN NOT be migrated and also swapped out.
So the dma access would be safe.
But the use of userptr feature has performance overhead so
this patch also has memory pool to the userptr feature.
Please, assume that user sends cmdlist filled with userptr
and size every time to g2d driver, and the get_user_pages
funcion will be called every time.
The memory pool has maximum 64MB size and the userptr that
user had ever sent, is holded in the memory pool.
This meaning is that if the userptr from user is same as one
in the memory pool, device address to the userptr in the memory
pool is set to cmdlist.
And last, the pages from get_user_pages() will be freed once
user calls free() and the dma access is completed. Actually,
get_user_pages() takes 2 reference counts if the user process
has never accessed user region allocated by malloc(). Then, if
the user calls free(), the page reference count becomes 1 and
becomes 0 with put_page() call. And the reverse holds as well.
This means how the pages backed are used by dma and freed.
This patch is based on "drm/exynos: add iommu support for g2d",
https://patchwork.kernel.org/patch/1629481/
Signed-off-by: Inki Dae <inki.dae@samsung.com>
Signed-off-by: Kyungmin Park <kyungmin.park@samsung.com>
2012-11-04 13:48:52 +00:00
|
|
|
cmd_buf = (struct drm_exynos_g2d_cmd *)(uint32_t)req->cmd_buf;
|
2012-05-17 11:06:32 +00:00
|
|
|
|
|
|
|
if (copy_from_user(cmdlist->data + cmdlist->last,
|
drm/exynos: add userptr feature for g2d module
This patch adds userptr feautre for G2D module.
The userptr means user space address allocated by malloc().
And the purpose of this feature is to make G2D's dma able
to access the user space region.
To user this feature, user should flag G2D_BUF_USRPTR to
offset variable of struct drm_exynos_g2d_cmd and fill
struct drm_exynos_g2d_userptr with user space address
and size for it and then should set a pointer to
drm_exynos_g2d_userptr object to data variable of struct
drm_exynos_g2d_cmd. The last bit of offset variable is used
to check if the cmdlist's buffer type is userptr or not.
If userptr, the g2d driver gets user space address and size
and then gets pages through get_user_pages().
(another case is counted as gem handle)
Below is sample codes:
static void set_cmd(struct drm_exynos_g2d_cmd *cmd,
unsigned long offset, unsigned long data)
{
cmd->offset = offset;
cmd->data = data;
}
static int solid_fill_test(int x, int y, unsigned long userptr)
{
struct drm_exynos_g2d_cmd cmd_gem[5];
struct drm_exynos_g2d_userptr g2d_userptr;
unsigned int gem_nr = 0;
...
g2d_userptr.userptr = userptr;
g2d_userptr.size = x * y * 4;
set_cmd(&cmd_gem[gem_nr++], DST_BASE_ADDR_REG |
G2D_BUF_USERPTR,
(unsigned long)&g2d_userptr);
...
}
int main(int argc, char **argv)
{
unsigned long addr;
...
addr = malloc(x * y * 4);
...
solid_fill_test(x, y, addr);
...
}
And next, the pages are mapped with iommu table and the device
address is set to cmdlist so that G2D's dma can access it.
As you may know, the pages from get_user_pages() are pinned.
In other words, they CAN NOT be migrated and also swapped out.
So the dma access would be safe.
But the use of userptr feature has performance overhead so
this patch also has memory pool to the userptr feature.
Please, assume that user sends cmdlist filled with userptr
and size every time to g2d driver, and the get_user_pages
funcion will be called every time.
The memory pool has maximum 64MB size and the userptr that
user had ever sent, is holded in the memory pool.
This meaning is that if the userptr from user is same as one
in the memory pool, device address to the userptr in the memory
pool is set to cmdlist.
And last, the pages from get_user_pages() will be freed once
user calls free() and the dma access is completed. Actually,
get_user_pages() takes 2 reference counts if the user process
has never accessed user region allocated by malloc(). Then, if
the user calls free(), the page reference count becomes 1 and
becomes 0 with put_page() call. And the reverse holds as well.
This means how the pages backed are used by dma and freed.
This patch is based on "drm/exynos: add iommu support for g2d",
https://patchwork.kernel.org/patch/1629481/
Signed-off-by: Inki Dae <inki.dae@samsung.com>
Signed-off-by: Kyungmin Park <kyungmin.park@samsung.com>
2012-11-04 13:48:52 +00:00
|
|
|
(void __user *)cmd_buf,
|
|
|
|
sizeof(*cmd_buf) * req->cmd_buf_nr)) {
|
2012-05-17 11:06:32 +00:00
|
|
|
ret = -EFAULT;
|
|
|
|
goto err_free_event;
|
|
|
|
}
|
drm/exynos: add userptr feature for g2d module
This patch adds userptr feautre for G2D module.
The userptr means user space address allocated by malloc().
And the purpose of this feature is to make G2D's dma able
to access the user space region.
To user this feature, user should flag G2D_BUF_USRPTR to
offset variable of struct drm_exynos_g2d_cmd and fill
struct drm_exynos_g2d_userptr with user space address
and size for it and then should set a pointer to
drm_exynos_g2d_userptr object to data variable of struct
drm_exynos_g2d_cmd. The last bit of offset variable is used
to check if the cmdlist's buffer type is userptr or not.
If userptr, the g2d driver gets user space address and size
and then gets pages through get_user_pages().
(another case is counted as gem handle)
Below is sample codes:
static void set_cmd(struct drm_exynos_g2d_cmd *cmd,
unsigned long offset, unsigned long data)
{
cmd->offset = offset;
cmd->data = data;
}
static int solid_fill_test(int x, int y, unsigned long userptr)
{
struct drm_exynos_g2d_cmd cmd_gem[5];
struct drm_exynos_g2d_userptr g2d_userptr;
unsigned int gem_nr = 0;
...
g2d_userptr.userptr = userptr;
g2d_userptr.size = x * y * 4;
set_cmd(&cmd_gem[gem_nr++], DST_BASE_ADDR_REG |
G2D_BUF_USERPTR,
(unsigned long)&g2d_userptr);
...
}
int main(int argc, char **argv)
{
unsigned long addr;
...
addr = malloc(x * y * 4);
...
solid_fill_test(x, y, addr);
...
}
And next, the pages are mapped with iommu table and the device
address is set to cmdlist so that G2D's dma can access it.
As you may know, the pages from get_user_pages() are pinned.
In other words, they CAN NOT be migrated and also swapped out.
So the dma access would be safe.
But the use of userptr feature has performance overhead so
this patch also has memory pool to the userptr feature.
Please, assume that user sends cmdlist filled with userptr
and size every time to g2d driver, and the get_user_pages
funcion will be called every time.
The memory pool has maximum 64MB size and the userptr that
user had ever sent, is holded in the memory pool.
This meaning is that if the userptr from user is same as one
in the memory pool, device address to the userptr in the memory
pool is set to cmdlist.
And last, the pages from get_user_pages() will be freed once
user calls free() and the dma access is completed. Actually,
get_user_pages() takes 2 reference counts if the user process
has never accessed user region allocated by malloc(). Then, if
the user calls free(), the page reference count becomes 1 and
becomes 0 with put_page() call. And the reverse holds as well.
This means how the pages backed are used by dma and freed.
This patch is based on "drm/exynos: add iommu support for g2d",
https://patchwork.kernel.org/patch/1629481/
Signed-off-by: Inki Dae <inki.dae@samsung.com>
Signed-off-by: Kyungmin Park <kyungmin.park@samsung.com>
2012-11-04 13:48:52 +00:00
|
|
|
cmdlist->last += req->cmd_buf_nr * 2;
|
2012-05-17 11:06:32 +00:00
|
|
|
|
drm/exynos: add userptr feature for g2d module
This patch adds userptr feautre for G2D module.
The userptr means user space address allocated by malloc().
And the purpose of this feature is to make G2D's dma able
to access the user space region.
To user this feature, user should flag G2D_BUF_USRPTR to
offset variable of struct drm_exynos_g2d_cmd and fill
struct drm_exynos_g2d_userptr with user space address
and size for it and then should set a pointer to
drm_exynos_g2d_userptr object to data variable of struct
drm_exynos_g2d_cmd. The last bit of offset variable is used
to check if the cmdlist's buffer type is userptr or not.
If userptr, the g2d driver gets user space address and size
and then gets pages through get_user_pages().
(another case is counted as gem handle)
Below is sample codes:
static void set_cmd(struct drm_exynos_g2d_cmd *cmd,
unsigned long offset, unsigned long data)
{
cmd->offset = offset;
cmd->data = data;
}
static int solid_fill_test(int x, int y, unsigned long userptr)
{
struct drm_exynos_g2d_cmd cmd_gem[5];
struct drm_exynos_g2d_userptr g2d_userptr;
unsigned int gem_nr = 0;
...
g2d_userptr.userptr = userptr;
g2d_userptr.size = x * y * 4;
set_cmd(&cmd_gem[gem_nr++], DST_BASE_ADDR_REG |
G2D_BUF_USERPTR,
(unsigned long)&g2d_userptr);
...
}
int main(int argc, char **argv)
{
unsigned long addr;
...
addr = malloc(x * y * 4);
...
solid_fill_test(x, y, addr);
...
}
And next, the pages are mapped with iommu table and the device
address is set to cmdlist so that G2D's dma can access it.
As you may know, the pages from get_user_pages() are pinned.
In other words, they CAN NOT be migrated and also swapped out.
So the dma access would be safe.
But the use of userptr feature has performance overhead so
this patch also has memory pool to the userptr feature.
Please, assume that user sends cmdlist filled with userptr
and size every time to g2d driver, and the get_user_pages
funcion will be called every time.
The memory pool has maximum 64MB size and the userptr that
user had ever sent, is holded in the memory pool.
This meaning is that if the userptr from user is same as one
in the memory pool, device address to the userptr in the memory
pool is set to cmdlist.
And last, the pages from get_user_pages() will be freed once
user calls free() and the dma access is completed. Actually,
get_user_pages() takes 2 reference counts if the user process
has never accessed user region allocated by malloc(). Then, if
the user calls free(), the page reference count becomes 1 and
becomes 0 with put_page() call. And the reverse holds as well.
This means how the pages backed are used by dma and freed.
This patch is based on "drm/exynos: add iommu support for g2d",
https://patchwork.kernel.org/patch/1629481/
Signed-off-by: Inki Dae <inki.dae@samsung.com>
Signed-off-by: Kyungmin Park <kyungmin.park@samsung.com>
2012-11-04 13:48:52 +00:00
|
|
|
ret = g2d_check_reg_offset(dev, node, req->cmd_buf_nr, true);
|
2012-05-17 11:06:32 +00:00
|
|
|
if (ret < 0)
|
|
|
|
goto err_free_event;
|
|
|
|
|
2012-11-04 04:53:24 +00:00
|
|
|
ret = g2d_map_cmdlist_gem(g2d, node, drm_dev, file);
|
2012-05-17 11:06:32 +00:00
|
|
|
if (ret < 0)
|
|
|
|
goto err_unmap;
|
|
|
|
}
|
|
|
|
|
|
|
|
cmdlist->data[cmdlist->last++] = G2D_BITBLT_START;
|
|
|
|
cmdlist->data[cmdlist->last++] = G2D_START_BITBLT;
|
|
|
|
|
|
|
|
/* head */
|
|
|
|
cmdlist->head = cmdlist->last / 2;
|
|
|
|
|
|
|
|
/* tail */
|
|
|
|
cmdlist->data[cmdlist->last] = 0;
|
|
|
|
|
|
|
|
g2d_add_cmdlist_to_inuse(g2d_priv, node);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
err_unmap:
|
2012-11-04 04:53:24 +00:00
|
|
|
g2d_unmap_cmdlist_gem(g2d, node, file);
|
2012-05-17 11:06:32 +00:00
|
|
|
err_free_event:
|
|
|
|
if (node->event) {
|
|
|
|
spin_lock_irqsave(&drm_dev->event_lock, flags);
|
|
|
|
file->event_space += sizeof(e->event);
|
|
|
|
spin_unlock_irqrestore(&drm_dev->event_lock, flags);
|
|
|
|
kfree(node->event);
|
|
|
|
}
|
|
|
|
err:
|
|
|
|
g2d_put_cmdlist(g2d, node);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(exynos_g2d_set_cmdlist_ioctl);
|
|
|
|
|
|
|
|
int exynos_g2d_exec_ioctl(struct drm_device *drm_dev, void *data,
|
|
|
|
struct drm_file *file)
|
|
|
|
{
|
|
|
|
struct drm_exynos_file_private *file_priv = file->driver_priv;
|
|
|
|
struct exynos_drm_g2d_private *g2d_priv = file_priv->g2d_priv;
|
|
|
|
struct device *dev = g2d_priv->dev;
|
|
|
|
struct g2d_data *g2d;
|
|
|
|
struct drm_exynos_g2d_exec *req = data;
|
|
|
|
struct g2d_runqueue_node *runqueue_node;
|
|
|
|
struct list_head *run_cmdlist;
|
|
|
|
struct list_head *event_list;
|
|
|
|
|
|
|
|
if (!dev)
|
|
|
|
return -ENODEV;
|
|
|
|
|
|
|
|
g2d = dev_get_drvdata(dev);
|
|
|
|
if (!g2d)
|
|
|
|
return -EFAULT;
|
|
|
|
|
|
|
|
runqueue_node = kmem_cache_alloc(g2d->runqueue_slab, GFP_KERNEL);
|
|
|
|
if (!runqueue_node) {
|
|
|
|
dev_err(dev, "failed to allocate memory\n");
|
|
|
|
return -ENOMEM;
|
|
|
|
}
|
|
|
|
run_cmdlist = &runqueue_node->run_cmdlist;
|
|
|
|
event_list = &runqueue_node->event_list;
|
|
|
|
INIT_LIST_HEAD(run_cmdlist);
|
|
|
|
INIT_LIST_HEAD(event_list);
|
|
|
|
init_completion(&runqueue_node->complete);
|
|
|
|
runqueue_node->async = req->async;
|
|
|
|
|
|
|
|
list_splice_init(&g2d_priv->inuse_cmdlist, run_cmdlist);
|
|
|
|
list_splice_init(&g2d_priv->event_list, event_list);
|
|
|
|
|
|
|
|
if (list_empty(run_cmdlist)) {
|
|
|
|
dev_err(dev, "there is no inuse cmdlist\n");
|
|
|
|
kmem_cache_free(g2d->runqueue_slab, runqueue_node);
|
|
|
|
return -EPERM;
|
|
|
|
}
|
|
|
|
|
|
|
|
mutex_lock(&g2d->runqueue_mutex);
|
2012-09-11 01:45:36 +00:00
|
|
|
runqueue_node->pid = current->pid;
|
2012-11-04 04:53:24 +00:00
|
|
|
runqueue_node->filp = file;
|
2012-05-17 11:06:32 +00:00
|
|
|
list_add_tail(&runqueue_node->list, &g2d->runqueue);
|
|
|
|
if (!g2d->runqueue_node)
|
|
|
|
g2d_exec_runqueue(g2d);
|
|
|
|
mutex_unlock(&g2d->runqueue_mutex);
|
|
|
|
|
|
|
|
if (runqueue_node->async)
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
wait_for_completion(&runqueue_node->complete);
|
|
|
|
g2d_free_runqueue_node(g2d, runqueue_node);
|
|
|
|
|
|
|
|
out:
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(exynos_g2d_exec_ioctl);
|
|
|
|
|
2012-11-04 04:53:24 +00:00
|
|
|
static int g2d_subdrv_probe(struct drm_device *drm_dev, struct device *dev)
|
|
|
|
{
|
|
|
|
struct g2d_data *g2d;
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
g2d = dev_get_drvdata(dev);
|
|
|
|
if (!g2d)
|
|
|
|
return -EFAULT;
|
|
|
|
|
|
|
|
/* allocate dma-aware cmdlist buffer. */
|
|
|
|
ret = g2d_init_cmdlist(g2d);
|
|
|
|
if (ret < 0) {
|
|
|
|
dev_err(dev, "cmdlist init failed\n");
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!is_drm_iommu_supported(drm_dev))
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
ret = drm_iommu_attach_device(drm_dev, dev);
|
|
|
|
if (ret < 0) {
|
|
|
|
dev_err(dev, "failed to enable iommu.\n");
|
|
|
|
g2d_fini_cmdlist(g2d);
|
|
|
|
}
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
static void g2d_subdrv_remove(struct drm_device *drm_dev, struct device *dev)
|
|
|
|
{
|
|
|
|
if (!is_drm_iommu_supported(drm_dev))
|
|
|
|
return;
|
|
|
|
|
|
|
|
drm_iommu_detach_device(drm_dev, dev);
|
|
|
|
}
|
|
|
|
|
2012-05-17 11:06:32 +00:00
|
|
|
static int g2d_open(struct drm_device *drm_dev, struct device *dev,
|
|
|
|
struct drm_file *file)
|
|
|
|
{
|
|
|
|
struct drm_exynos_file_private *file_priv = file->driver_priv;
|
|
|
|
struct exynos_drm_g2d_private *g2d_priv;
|
|
|
|
|
|
|
|
g2d_priv = kzalloc(sizeof(*g2d_priv), GFP_KERNEL);
|
|
|
|
if (!g2d_priv) {
|
|
|
|
dev_err(dev, "failed to allocate g2d private data\n");
|
|
|
|
return -ENOMEM;
|
|
|
|
}
|
|
|
|
|
|
|
|
g2d_priv->dev = dev;
|
|
|
|
file_priv->g2d_priv = g2d_priv;
|
|
|
|
|
|
|
|
INIT_LIST_HEAD(&g2d_priv->inuse_cmdlist);
|
|
|
|
INIT_LIST_HEAD(&g2d_priv->event_list);
|
drm/exynos: add userptr feature for g2d module
This patch adds userptr feautre for G2D module.
The userptr means user space address allocated by malloc().
And the purpose of this feature is to make G2D's dma able
to access the user space region.
To user this feature, user should flag G2D_BUF_USRPTR to
offset variable of struct drm_exynos_g2d_cmd and fill
struct drm_exynos_g2d_userptr with user space address
and size for it and then should set a pointer to
drm_exynos_g2d_userptr object to data variable of struct
drm_exynos_g2d_cmd. The last bit of offset variable is used
to check if the cmdlist's buffer type is userptr or not.
If userptr, the g2d driver gets user space address and size
and then gets pages through get_user_pages().
(another case is counted as gem handle)
Below is sample codes:
static void set_cmd(struct drm_exynos_g2d_cmd *cmd,
unsigned long offset, unsigned long data)
{
cmd->offset = offset;
cmd->data = data;
}
static int solid_fill_test(int x, int y, unsigned long userptr)
{
struct drm_exynos_g2d_cmd cmd_gem[5];
struct drm_exynos_g2d_userptr g2d_userptr;
unsigned int gem_nr = 0;
...
g2d_userptr.userptr = userptr;
g2d_userptr.size = x * y * 4;
set_cmd(&cmd_gem[gem_nr++], DST_BASE_ADDR_REG |
G2D_BUF_USERPTR,
(unsigned long)&g2d_userptr);
...
}
int main(int argc, char **argv)
{
unsigned long addr;
...
addr = malloc(x * y * 4);
...
solid_fill_test(x, y, addr);
...
}
And next, the pages are mapped with iommu table and the device
address is set to cmdlist so that G2D's dma can access it.
As you may know, the pages from get_user_pages() are pinned.
In other words, they CAN NOT be migrated and also swapped out.
So the dma access would be safe.
But the use of userptr feature has performance overhead so
this patch also has memory pool to the userptr feature.
Please, assume that user sends cmdlist filled with userptr
and size every time to g2d driver, and the get_user_pages
funcion will be called every time.
The memory pool has maximum 64MB size and the userptr that
user had ever sent, is holded in the memory pool.
This meaning is that if the userptr from user is same as one
in the memory pool, device address to the userptr in the memory
pool is set to cmdlist.
And last, the pages from get_user_pages() will be freed once
user calls free() and the dma access is completed. Actually,
get_user_pages() takes 2 reference counts if the user process
has never accessed user region allocated by malloc(). Then, if
the user calls free(), the page reference count becomes 1 and
becomes 0 with put_page() call. And the reverse holds as well.
This means how the pages backed are used by dma and freed.
This patch is based on "drm/exynos: add iommu support for g2d",
https://patchwork.kernel.org/patch/1629481/
Signed-off-by: Inki Dae <inki.dae@samsung.com>
Signed-off-by: Kyungmin Park <kyungmin.park@samsung.com>
2012-11-04 13:48:52 +00:00
|
|
|
INIT_LIST_HEAD(&g2d_priv->userptr_list);
|
2012-05-17 11:06:32 +00:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void g2d_close(struct drm_device *drm_dev, struct device *dev,
|
|
|
|
struct drm_file *file)
|
|
|
|
{
|
|
|
|
struct drm_exynos_file_private *file_priv = file->driver_priv;
|
|
|
|
struct exynos_drm_g2d_private *g2d_priv = file_priv->g2d_priv;
|
|
|
|
struct g2d_data *g2d;
|
|
|
|
struct g2d_cmdlist_node *node, *n;
|
|
|
|
|
|
|
|
if (!dev)
|
|
|
|
return;
|
|
|
|
|
|
|
|
g2d = dev_get_drvdata(dev);
|
|
|
|
if (!g2d)
|
|
|
|
return;
|
|
|
|
|
|
|
|
mutex_lock(&g2d->cmdlist_mutex);
|
2012-11-04 04:53:24 +00:00
|
|
|
list_for_each_entry_safe(node, n, &g2d_priv->inuse_cmdlist, list) {
|
|
|
|
/*
|
|
|
|
* unmap all gem objects not completed.
|
|
|
|
*
|
|
|
|
* P.S. if current process was terminated forcely then
|
|
|
|
* there may be some commands in inuse_cmdlist so unmap
|
|
|
|
* them.
|
|
|
|
*/
|
|
|
|
g2d_unmap_cmdlist_gem(g2d, node, file);
|
2012-05-17 11:06:32 +00:00
|
|
|
list_move_tail(&node->list, &g2d->free_cmdlist);
|
2012-11-04 04:53:24 +00:00
|
|
|
}
|
2012-05-17 11:06:32 +00:00
|
|
|
mutex_unlock(&g2d->cmdlist_mutex);
|
|
|
|
|
drm/exynos: add userptr feature for g2d module
This patch adds userptr feautre for G2D module.
The userptr means user space address allocated by malloc().
And the purpose of this feature is to make G2D's dma able
to access the user space region.
To user this feature, user should flag G2D_BUF_USRPTR to
offset variable of struct drm_exynos_g2d_cmd and fill
struct drm_exynos_g2d_userptr with user space address
and size for it and then should set a pointer to
drm_exynos_g2d_userptr object to data variable of struct
drm_exynos_g2d_cmd. The last bit of offset variable is used
to check if the cmdlist's buffer type is userptr or not.
If userptr, the g2d driver gets user space address and size
and then gets pages through get_user_pages().
(another case is counted as gem handle)
Below is sample codes:
static void set_cmd(struct drm_exynos_g2d_cmd *cmd,
unsigned long offset, unsigned long data)
{
cmd->offset = offset;
cmd->data = data;
}
static int solid_fill_test(int x, int y, unsigned long userptr)
{
struct drm_exynos_g2d_cmd cmd_gem[5];
struct drm_exynos_g2d_userptr g2d_userptr;
unsigned int gem_nr = 0;
...
g2d_userptr.userptr = userptr;
g2d_userptr.size = x * y * 4;
set_cmd(&cmd_gem[gem_nr++], DST_BASE_ADDR_REG |
G2D_BUF_USERPTR,
(unsigned long)&g2d_userptr);
...
}
int main(int argc, char **argv)
{
unsigned long addr;
...
addr = malloc(x * y * 4);
...
solid_fill_test(x, y, addr);
...
}
And next, the pages are mapped with iommu table and the device
address is set to cmdlist so that G2D's dma can access it.
As you may know, the pages from get_user_pages() are pinned.
In other words, they CAN NOT be migrated and also swapped out.
So the dma access would be safe.
But the use of userptr feature has performance overhead so
this patch also has memory pool to the userptr feature.
Please, assume that user sends cmdlist filled with userptr
and size every time to g2d driver, and the get_user_pages
funcion will be called every time.
The memory pool has maximum 64MB size and the userptr that
user had ever sent, is holded in the memory pool.
This meaning is that if the userptr from user is same as one
in the memory pool, device address to the userptr in the memory
pool is set to cmdlist.
And last, the pages from get_user_pages() will be freed once
user calls free() and the dma access is completed. Actually,
get_user_pages() takes 2 reference counts if the user process
has never accessed user region allocated by malloc(). Then, if
the user calls free(), the page reference count becomes 1 and
becomes 0 with put_page() call. And the reverse holds as well.
This means how the pages backed are used by dma and freed.
This patch is based on "drm/exynos: add iommu support for g2d",
https://patchwork.kernel.org/patch/1629481/
Signed-off-by: Inki Dae <inki.dae@samsung.com>
Signed-off-by: Kyungmin Park <kyungmin.park@samsung.com>
2012-11-04 13:48:52 +00:00
|
|
|
/* release all g2d_userptr in pool. */
|
|
|
|
g2d_userptr_free_all(drm_dev, g2d, file);
|
|
|
|
|
2012-05-17 11:06:32 +00:00
|
|
|
kfree(file_priv->g2d_priv);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int __devinit g2d_probe(struct platform_device *pdev)
|
|
|
|
{
|
|
|
|
struct device *dev = &pdev->dev;
|
|
|
|
struct resource *res;
|
|
|
|
struct g2d_data *g2d;
|
|
|
|
struct exynos_drm_subdrv *subdrv;
|
|
|
|
int ret;
|
|
|
|
|
2012-08-06 06:46:20 +00:00
|
|
|
g2d = devm_kzalloc(&pdev->dev, sizeof(*g2d), GFP_KERNEL);
|
2012-05-17 11:06:32 +00:00
|
|
|
if (!g2d) {
|
|
|
|
dev_err(dev, "failed to allocate driver data\n");
|
|
|
|
return -ENOMEM;
|
|
|
|
}
|
|
|
|
|
|
|
|
g2d->runqueue_slab = kmem_cache_create("g2d_runqueue_slab",
|
|
|
|
sizeof(struct g2d_runqueue_node), 0, 0, NULL);
|
2012-08-06 06:46:20 +00:00
|
|
|
if (!g2d->runqueue_slab)
|
|
|
|
return -ENOMEM;
|
2012-05-17 11:06:32 +00:00
|
|
|
|
|
|
|
g2d->dev = dev;
|
|
|
|
|
|
|
|
g2d->g2d_workq = create_singlethread_workqueue("g2d");
|
|
|
|
if (!g2d->g2d_workq) {
|
|
|
|
dev_err(dev, "failed to create workqueue\n");
|
|
|
|
ret = -EINVAL;
|
|
|
|
goto err_destroy_slab;
|
|
|
|
}
|
|
|
|
|
|
|
|
INIT_WORK(&g2d->runqueue_work, g2d_runqueue_worker);
|
|
|
|
INIT_LIST_HEAD(&g2d->free_cmdlist);
|
|
|
|
INIT_LIST_HEAD(&g2d->runqueue);
|
|
|
|
|
|
|
|
mutex_init(&g2d->cmdlist_mutex);
|
|
|
|
mutex_init(&g2d->runqueue_mutex);
|
|
|
|
|
2012-11-23 03:41:58 +00:00
|
|
|
g2d->gate_clk = devm_clk_get(dev, "fimg2d");
|
2012-05-17 11:06:32 +00:00
|
|
|
if (IS_ERR(g2d->gate_clk)) {
|
|
|
|
dev_err(dev, "failed to get gate clock\n");
|
|
|
|
ret = PTR_ERR(g2d->gate_clk);
|
2012-11-04 04:53:24 +00:00
|
|
|
goto err_destroy_workqueue;
|
2012-05-17 11:06:32 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
pm_runtime_enable(dev);
|
|
|
|
|
|
|
|
res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
|
|
|
|
|
2012-08-06 06:46:20 +00:00
|
|
|
g2d->regs = devm_request_and_ioremap(&pdev->dev, res);
|
2012-05-17 11:06:32 +00:00
|
|
|
if (!g2d->regs) {
|
|
|
|
dev_err(dev, "failed to remap I/O memory\n");
|
|
|
|
ret = -ENXIO;
|
2012-08-06 06:46:20 +00:00
|
|
|
goto err_put_clk;
|
2012-05-17 11:06:32 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
g2d->irq = platform_get_irq(pdev, 0);
|
|
|
|
if (g2d->irq < 0) {
|
|
|
|
dev_err(dev, "failed to get irq\n");
|
|
|
|
ret = g2d->irq;
|
2012-08-06 06:46:20 +00:00
|
|
|
goto err_put_clk;
|
2012-05-17 11:06:32 +00:00
|
|
|
}
|
|
|
|
|
2012-08-06 06:46:20 +00:00
|
|
|
ret = devm_request_irq(&pdev->dev, g2d->irq, g2d_irq_handler, 0,
|
|
|
|
"drm_g2d", g2d);
|
2012-05-17 11:06:32 +00:00
|
|
|
if (ret < 0) {
|
|
|
|
dev_err(dev, "irq request failed\n");
|
2012-08-06 06:46:20 +00:00
|
|
|
goto err_put_clk;
|
2012-05-17 11:06:32 +00:00
|
|
|
}
|
|
|
|
|
drm/exynos: add userptr feature for g2d module
This patch adds userptr feautre for G2D module.
The userptr means user space address allocated by malloc().
And the purpose of this feature is to make G2D's dma able
to access the user space region.
To user this feature, user should flag G2D_BUF_USRPTR to
offset variable of struct drm_exynos_g2d_cmd and fill
struct drm_exynos_g2d_userptr with user space address
and size for it and then should set a pointer to
drm_exynos_g2d_userptr object to data variable of struct
drm_exynos_g2d_cmd. The last bit of offset variable is used
to check if the cmdlist's buffer type is userptr or not.
If userptr, the g2d driver gets user space address and size
and then gets pages through get_user_pages().
(another case is counted as gem handle)
Below is sample codes:
static void set_cmd(struct drm_exynos_g2d_cmd *cmd,
unsigned long offset, unsigned long data)
{
cmd->offset = offset;
cmd->data = data;
}
static int solid_fill_test(int x, int y, unsigned long userptr)
{
struct drm_exynos_g2d_cmd cmd_gem[5];
struct drm_exynos_g2d_userptr g2d_userptr;
unsigned int gem_nr = 0;
...
g2d_userptr.userptr = userptr;
g2d_userptr.size = x * y * 4;
set_cmd(&cmd_gem[gem_nr++], DST_BASE_ADDR_REG |
G2D_BUF_USERPTR,
(unsigned long)&g2d_userptr);
...
}
int main(int argc, char **argv)
{
unsigned long addr;
...
addr = malloc(x * y * 4);
...
solid_fill_test(x, y, addr);
...
}
And next, the pages are mapped with iommu table and the device
address is set to cmdlist so that G2D's dma can access it.
As you may know, the pages from get_user_pages() are pinned.
In other words, they CAN NOT be migrated and also swapped out.
So the dma access would be safe.
But the use of userptr feature has performance overhead so
this patch also has memory pool to the userptr feature.
Please, assume that user sends cmdlist filled with userptr
and size every time to g2d driver, and the get_user_pages
funcion will be called every time.
The memory pool has maximum 64MB size and the userptr that
user had ever sent, is holded in the memory pool.
This meaning is that if the userptr from user is same as one
in the memory pool, device address to the userptr in the memory
pool is set to cmdlist.
And last, the pages from get_user_pages() will be freed once
user calls free() and the dma access is completed. Actually,
get_user_pages() takes 2 reference counts if the user process
has never accessed user region allocated by malloc(). Then, if
the user calls free(), the page reference count becomes 1 and
becomes 0 with put_page() call. And the reverse holds as well.
This means how the pages backed are used by dma and freed.
This patch is based on "drm/exynos: add iommu support for g2d",
https://patchwork.kernel.org/patch/1629481/
Signed-off-by: Inki Dae <inki.dae@samsung.com>
Signed-off-by: Kyungmin Park <kyungmin.park@samsung.com>
2012-11-04 13:48:52 +00:00
|
|
|
g2d->max_pool = MAX_POOL;
|
|
|
|
|
2012-05-17 11:06:32 +00:00
|
|
|
platform_set_drvdata(pdev, g2d);
|
|
|
|
|
|
|
|
subdrv = &g2d->subdrv;
|
|
|
|
subdrv->dev = dev;
|
2012-11-04 04:53:24 +00:00
|
|
|
subdrv->probe = g2d_subdrv_probe;
|
|
|
|
subdrv->remove = g2d_subdrv_remove;
|
2012-05-17 11:06:32 +00:00
|
|
|
subdrv->open = g2d_open;
|
|
|
|
subdrv->close = g2d_close;
|
|
|
|
|
|
|
|
ret = exynos_drm_subdrv_register(subdrv);
|
|
|
|
if (ret < 0) {
|
|
|
|
dev_err(dev, "failed to register drm g2d device\n");
|
2012-08-06 06:46:20 +00:00
|
|
|
goto err_put_clk;
|
2012-05-17 11:06:32 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
dev_info(dev, "The exynos g2d(ver %d.%d) successfully probed\n",
|
|
|
|
G2D_HW_MAJOR_VER, G2D_HW_MINOR_VER);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
err_put_clk:
|
|
|
|
pm_runtime_disable(dev);
|
|
|
|
err_destroy_workqueue:
|
|
|
|
destroy_workqueue(g2d->g2d_workq);
|
|
|
|
err_destroy_slab:
|
|
|
|
kmem_cache_destroy(g2d->runqueue_slab);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int __devexit g2d_remove(struct platform_device *pdev)
|
|
|
|
{
|
|
|
|
struct g2d_data *g2d = platform_get_drvdata(pdev);
|
|
|
|
|
|
|
|
cancel_work_sync(&g2d->runqueue_work);
|
|
|
|
exynos_drm_subdrv_unregister(&g2d->subdrv);
|
|
|
|
|
|
|
|
while (g2d->runqueue_node) {
|
|
|
|
g2d_free_runqueue_node(g2d, g2d->runqueue_node);
|
|
|
|
g2d->runqueue_node = g2d_get_runqueue_node(g2d);
|
|
|
|
}
|
|
|
|
|
|
|
|
pm_runtime_disable(&pdev->dev);
|
|
|
|
|
|
|
|
g2d_fini_cmdlist(g2d);
|
|
|
|
destroy_workqueue(g2d->g2d_workq);
|
|
|
|
kmem_cache_destroy(g2d->runqueue_slab);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
#ifdef CONFIG_PM_SLEEP
|
|
|
|
static int g2d_suspend(struct device *dev)
|
|
|
|
{
|
|
|
|
struct g2d_data *g2d = dev_get_drvdata(dev);
|
|
|
|
|
|
|
|
mutex_lock(&g2d->runqueue_mutex);
|
|
|
|
g2d->suspended = true;
|
|
|
|
mutex_unlock(&g2d->runqueue_mutex);
|
|
|
|
|
|
|
|
while (g2d->runqueue_node)
|
|
|
|
/* FIXME: good range? */
|
|
|
|
usleep_range(500, 1000);
|
|
|
|
|
2012-08-20 21:51:24 +00:00
|
|
|
flush_work(&g2d->runqueue_work);
|
2012-05-17 11:06:32 +00:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int g2d_resume(struct device *dev)
|
|
|
|
{
|
|
|
|
struct g2d_data *g2d = dev_get_drvdata(dev);
|
|
|
|
|
|
|
|
g2d->suspended = false;
|
|
|
|
g2d_exec_runqueue(g2d);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2012-08-28 08:41:41 +00:00
|
|
|
static SIMPLE_DEV_PM_OPS(g2d_pm_ops, g2d_suspend, g2d_resume);
|
2012-05-17 11:06:32 +00:00
|
|
|
|
|
|
|
struct platform_driver g2d_driver = {
|
|
|
|
.probe = g2d_probe,
|
|
|
|
.remove = __devexit_p(g2d_remove),
|
|
|
|
.driver = {
|
|
|
|
.name = "s5p-g2d",
|
|
|
|
.owner = THIS_MODULE,
|
|
|
|
.pm = &g2d_pm_ops,
|
|
|
|
},
|
|
|
|
};
|