From b8bfba8adf757ac17de6f415868b259f167fac0f Mon Sep 17 00:00:00 2001 From: Kitae Kim Date: Wed, 11 Sep 2013 20:42:50 +0900 Subject: [PATCH] brillcodec: Source clean-up and rename device name. Changed the driver name from newcodec to brillcodec. Change-Id: I5630c18507c31e79995ed29bd6a736bdcaff10ba Signed-off-by: Kitae Kim --- drivers/maru/maru_new_codec.c | 849 +++++++++++++++++++--------------- 1 file changed, 478 insertions(+), 371 deletions(-) diff --git a/drivers/maru/maru_new_codec.c b/drivers/maru/maru_new_codec.c index 4a76d301fec5..859e9d40c7af 100644 --- a/drivers/maru/maru_new_codec.c +++ b/drivers/maru/maru_new_codec.c @@ -53,61 +53,52 @@ MODULE_DESCRIPTION("Virtual Codec Device Driver"); MODULE_AUTHOR("Kitae KIM -#define NEWCODEC_CURRENT_TIME \ +#define CODEC_CURRENT_TIME \ { \ struct timeval now; \ do_gettimeofday(&now); \ - printk(KERN_INFO "[%s][%d] current time: %ld.%06ld\n", DEVICE_NAME, __LINE__, (long)now.tv_sec, (long)now.tv_usec); \ + printk(KERN_INFO "[%s][%d] current time: %ld.%06ld\n", \ + DEVICE_NAME, __LINE__, (long)now.tv_sec, (long)now.tv_usec); \ } #else -#define NEWCODEC_CURRENT_TIME +#define CODEC_CURRENT_TIME #endif -struct codec_param { - int32_t api_index; - int32_t ctx_index; - int32_t mem_offset; - int32_t mem_type; -}; - -struct codec_mem_info { - uint32_t index; - uint32_t offset; -}; +/* Define i/o and api values. */ +#if 0 enum codec_io_cmd { - CODEC_CMD_COPY_TO_DEVICE_MEM = 5, // user and driver - CODEC_CMD_COPY_FROM_DEVICE_MEM, +// CODEC_CMD_COPY_TO_DEVICE_MEM = 5, // user and driver +// CODEC_CMD_COPY_FROM_DEVICE_MEM, CODEC_CMD_API_INDEX = 10, // driver and device CODEC_CMD_CONTEXT_INDEX, CODEC_CMD_FILE_INDEX, @@ -115,9 +106,9 @@ enum codec_io_cmd { CODEC_CMD_GET_THREAD_STATE, CODEC_CMD_GET_QUEUE, CODEC_CMD_POP_WRITE_QUEUE, - CODEC_CMD_RESET_AVCONTEXT, + CODEC_CMD_RELEASE_AVCONTEXT, CODEC_CMD_GET_VERSION = 20, // user, driver and device - CODEC_CMD_GET_ELEMENT, + CODEC_CMD_GET_ELEMENT_INFO, CODEC_CMD_GET_CONTEXT_INDEX, CODEC_CMD_SECURE_MEMORY= 30, CODEC_CMD_RELEASE_MEMORY, @@ -129,6 +120,29 @@ enum codec_io_cmd { CODEC_CMD_M_SECURE_BUFFER, CODEC_CMD_L_SECURE_BUFFER, }; +#endif + +enum codec_io_cmd { + CODEC_CMD_API_INDEX = 10, // driver and device + CODEC_CMD_CONTEXT_INDEX, + CODEC_CMD_FILE_INDEX, + CODEC_CMD_DEVICE_MEM_OFFSET, + CODEC_CMD_GET_THREAD_STATE, + CODEC_CMD_GET_CTX_FROM_QUEUE, + CODEC_CMD_GET_DATA_FROM_QUEUE, + CODEC_CMD_RELEASE_CONTEXT, + CODEC_CMD_GET_VERSION = 20, + CODEC_CMD_GET_ELEMENT, + CODEC_CMD_GET_CONTEXT_INDEX, + CODEC_CMD_USE_DEVICE_MEM = 40, // plugin and driver + CODEC_CMD_GET_DATA_FROM_SMALL_BUFFER, + CODEC_CMD_GET_DATA_FROM_MEDIUM_BUFFER, + CODEC_CMD_GET_DATA_FROM_LARGE_BUFFER, + CODEC_CMD_SECURE_SMALL_BUFFER, + CODEC_CMD_SECURE_MEDIUM_BUFFER, + CODEC_CMD_SECURE_LARGE_BUFFER, + CODEC_CMD_RELEASE_BUFFER, +}; enum codec_api_index { CODEC_INIT = 0, @@ -140,6 +154,18 @@ enum codec_api_index { CODEC_DEINIT, }; +struct codec_param { + int32_t api_index; + int32_t ctx_index; + int32_t mem_offset; +}; + +struct codec_mem_info { + uint32_t index; + uint32_t offset; +}; + +/* manage device memory block */ struct device_mem { uint32_t blk_id; uint32_t mem_offset; @@ -148,7 +174,7 @@ struct device_mem { struct list_head entry; }; -struct newcodec_device { +struct maru_brill_codec_device { struct pci_dev *dev; /* I/O and Memory Region */ @@ -159,9 +185,14 @@ struct newcodec_device { resource_size_t mem_start; resource_size_t mem_size; + // + struct device_mem *elem; + /* task queue */ +#if 0 struct list_head avail_memblk; struct list_head used_memblk; +#endif struct list_head avail_s_memblk; struct list_head used_s_memblk; @@ -175,33 +206,42 @@ struct newcodec_device { int version; }; -static struct newcodec_device *newcodec; -static int context_flags[CODEC_CONTEXT_SIZE] = { 0, }; - -// semaphore, mutex -static DEFINE_MUTEX(critical_section); -static DEFINE_MUTEX(newcodec_blk_mutex); - -static struct semaphore newcodec_buffer_mutex = - __SEMAPHORE_INITIALIZER(newcodec_buffer_mutex, DEVICE_MEMORY_COUNT); - -#define ENTER_CRITICAL_SECTION mutex_lock(&critical_section); -#define LEAVE_CRITICAL_SECTION mutex_unlock(&critical_section); +/* device memory */ +#define DEVICE_MEMORY_COUNT 8 +#define CODEC_CONTEXT_SIZE 1024 #define CODEC_S_DEVICE_MEM_COUNT 63 // small (256K) 8M -#define CODEC_XS_DEVICE_MEM_COUNT 8 // extra small (1M) 8M +// #define CODEC_XS_DEVICE_MEM_COUNT 8 // extra small (1M) 8M #define CODEC_M_DEVICE_MEM_COUNT 4 // medium (2M) 8M #define CODEC_L_DEVICE_MEM_COUNT 2 // large (4M) 8M #define CODEC_S_DEVICE_MEM_SIZE 0x40000 // small -#define CODEC_XS_DEVICE_MEM_SIZE 0x100000 // extra small +// #define CODEC_XS_DEVICE_MEM_SIZE 0x100000 // extra small #define CODEC_M_DEVICE_MEM_SIZE 0x200000 // medium #define CODEC_L_DEVICE_MEM_SIZE 0x400000 // large + +static struct maru_brill_codec_device *maru_brill_codec; +static int context_flags[CODEC_CONTEXT_SIZE] = { 0, }; + +// semaphore, mutex +static DEFINE_MUTEX(critical_section); + static DEFINE_MUTEX(s_block_mutex); static DEFINE_MUTEX(m_block_mutex); static DEFINE_MUTEX(l_block_mutex); + +#if 0 +static DEFINE_MUTEX(maru_brill_codec_blk_mutex); + +static struct semaphore maru_brill_codec_buffer_mutex = + __SEMAPHORE_INITIALIZER(maru_brill_codec_buffer_mutex, DEVICE_MEMORY_COUNT); +#endif + +#define ENTER_CRITICAL_SECTION mutex_lock(&critical_section); +#define LEAVE_CRITICAL_SECTION mutex_unlock(&critical_section); + static struct semaphore s_buffer_sema = __SEMAPHORE_INITIALIZER(s_buffer_sema, CODEC_S_DEVICE_MEM_COUNT); @@ -214,18 +254,13 @@ static struct semaphore l_buffer_sema = // bottom-half static DECLARE_WAIT_QUEUE_HEAD(wait_queue); -static struct workqueue_struct *newcodec_bh_workqueue; -static void newcodec_bh_func(struct work_struct *work); -static DECLARE_WORK(newcodec_bh_work, newcodec_bh_func); -static void newcodec_bh(struct newcodec_device *dev); - +static struct workqueue_struct *maru_brill_codec_bh_workqueue; +static void maru_brill_codec_bh_func(struct work_struct *work); +static DECLARE_WORK(maru_brill_codec_bh_work, maru_brill_codec_bh_func); +static void maru_brill_codec_bh(struct maru_brill_codec_device *dev); -// internal function -static void newcodec_write_data(int cmd1, int cmd2, - uint32_t value1, uint32_t value2); - -static void newcodec_divide_device_memory(void) +static void maru_brill_codec_divide_device_memory(void) { struct device_mem *elem = NULL; int index = 0, cnt; @@ -240,31 +275,32 @@ static void newcodec_divide_device_memory(void) for (cnt = 0; cnt < CODEC_S_DEVICE_MEM_COUNT; index++, cnt++) { elem[index].mem_offset = (index + 1) * CODEC_S_DEVICE_MEM_SIZE; elem[index].occupied = false; - list_add_tail(&elem[index].entry, &newcodec->avail_s_memblk); + list_add_tail(&elem[index].entry, &maru_brill_codec->avail_s_memblk); } for (cnt = 0; cnt < CODEC_M_DEVICE_MEM_COUNT; index++, cnt++) { elem[index].mem_offset = (16 * 1024 * 1024) + (cnt * CODEC_M_DEVICE_MEM_SIZE); elem[index].occupied = false; - list_add_tail(&elem[index].entry, &newcodec->avail_m_memblk); + list_add_tail(&elem[index].entry, &maru_brill_codec->avail_m_memblk); } -#if 1 for (cnt = 0; cnt < CODEC_L_DEVICE_MEM_COUNT; index++, cnt++) { elem[index].mem_offset = (16 * 1024 * 1024) + (8 * 1024 * 1024) + (cnt * CODEC_L_DEVICE_MEM_SIZE); elem[index].occupied = false; - list_add_tail(&elem[index].entry, &newcodec->avail_l_memblk); + list_add_tail(&elem[index].entry, &maru_brill_codec->avail_l_memblk); } -#endif + + maru_brill_codec->elem = elem; } -static void newcodec_bh_func(struct work_struct *work) +static void maru_brill_codec_bh_func(struct work_struct *work) { uint32_t value; DEBUG("%s\n", __func__); do { - value = readl(newcodec->ioaddr + CODEC_CMD_GET_QUEUE); + value = + readl(maru_brill_codec->ioaddr + CODEC_CMD_GET_CTX_FROM_QUEUE); DEBUG("read a value from device %x.\n", value); if (value) { context_flags[value] = 1; @@ -275,26 +311,26 @@ static void newcodec_bh_func(struct work_struct *work) } while (value); } -static void newcodec_bh(struct newcodec_device *dev) +static void maru_brill_codec_bh(struct maru_brill_codec_device *dev) { DEBUG("add bottom-half function to codec_workqueue\n"); - queue_work(newcodec_bh_workqueue, &newcodec_bh_work); + queue_work(maru_brill_codec_bh_workqueue, &maru_brill_codec_bh_work); } +#if 0 static int lock_buffer(void) { int ret; - ret = down_interruptible(&newcodec_buffer_mutex); + ret = down_interruptible(&maru_brill_codec_buffer_mutex); -// DEBUG("lock buffer_mutex: %d\n", newcodec_buffer_mutex.count); return ret; } static void unlock_buffer(void) { - up(&newcodec_buffer_mutex); -// DEBUG("unlock buffer_mutex: %d\n", newcodec_buffer_mutex.count); + up(&maru_brill_codec_buffer_mutex); } +#endif static int secure_s_device_memory(uint32_t blk_id) { @@ -312,11 +348,9 @@ static int secure_s_device_memory(uint32_t blk_id) mutex_lock(&s_block_mutex); - NEWCODEC_CURRENT_TIME - - if (!list_empty(&newcodec->avail_s_memblk)) { + if (!list_empty(&maru_brill_codec->avail_s_memblk)) { elem = - list_first_entry(&newcodec->avail_s_memblk, + list_first_entry(&maru_brill_codec->avail_s_memblk, struct device_mem, entry); if (!elem) { ret = -1; @@ -326,7 +360,7 @@ static int secure_s_device_memory(uint32_t blk_id) elem->blk_id = blk_id; elem->occupied = true; - list_move_tail(&elem->entry, &newcodec->used_s_memblk); + list_move_tail(&elem->entry, &maru_brill_codec->used_s_memblk); ret = elem->mem_offset; DEBUG("get available memory region: 0x%x\n", ret); } @@ -337,8 +371,6 @@ static int secure_s_device_memory(uint32_t blk_id) up(&s_buffer_sema); } - NEWCODEC_CURRENT_TIME - mutex_unlock(&s_block_mutex); return ret; @@ -350,14 +382,14 @@ static void release_s_device_memory(uint32_t mem_offset) struct list_head *pos, *temp; mutex_lock(&s_block_mutex); - if (!list_empty(&newcodec->used_s_memblk)) { - list_for_each_safe(pos, temp, &newcodec->used_s_memblk) { + if (!list_empty(&maru_brill_codec->used_s_memblk)) { + list_for_each_safe(pos, temp, &maru_brill_codec->used_s_memblk) { elem = list_entry(pos, struct device_mem, entry); if (elem->mem_offset == (uint32_t)mem_offset) { elem->blk_id = 0; elem->occupied = false; - list_move_tail(&elem->entry, &newcodec->avail_s_memblk); + list_move_tail(&elem->entry, &maru_brill_codec->avail_s_memblk); up(&s_buffer_sema); DEBUG("unlock s_buffer_sema: %d\n", s_buffer_sema.count); @@ -386,9 +418,9 @@ static int secure_m_device_memory(uint32_t blk_id) mutex_lock(&m_block_mutex); - if (!list_empty(&newcodec->avail_m_memblk)) { + if (!list_empty(&maru_brill_codec->avail_m_memblk)) { elem = - list_first_entry(&newcodec->avail_m_memblk, + list_first_entry(&maru_brill_codec->avail_m_memblk, struct device_mem, entry); if (!elem) { ret = -1; @@ -398,7 +430,7 @@ static int secure_m_device_memory(uint32_t blk_id) elem->blk_id = blk_id; elem->occupied = true; - list_move_tail(&elem->entry, &newcodec->used_m_memblk); + list_move_tail(&elem->entry, &maru_brill_codec->used_m_memblk); ret = elem->mem_offset; DEBUG("get available memory region: 0x%x\n", ret); } @@ -420,14 +452,14 @@ static void release_m_device_memory(uint32_t mem_offset) struct list_head *pos, *temp; mutex_lock(&m_block_mutex); - if (!list_empty(&newcodec->used_m_memblk)) { - list_for_each_safe(pos, temp, &newcodec->used_m_memblk) { + if (!list_empty(&maru_brill_codec->used_m_memblk)) { + list_for_each_safe(pos, temp, &maru_brill_codec->used_m_memblk) { elem = list_entry(pos, struct device_mem, entry); if (elem->mem_offset == (uint32_t)mem_offset) { elem->blk_id = 0; elem->occupied = false; - list_move_tail(&elem->entry, &newcodec->avail_m_memblk); + list_move_tail(&elem->entry, &maru_brill_codec->avail_m_memblk); up(&m_buffer_sema); break; @@ -445,7 +477,6 @@ static int32_t secure_l_device_memory(uint32_t blk_id) int ret = -1; struct device_mem *elem = NULL; -#if 1 // decrease m_buffer_semaphore DEBUG("before down l_buffer_semaphore: %d\n", l_buffer_sema.count); ret = down_interruptible(&l_buffer_sema); @@ -458,9 +489,9 @@ static int32_t secure_l_device_memory(uint32_t blk_id) mutex_lock(&l_block_mutex); - if (!list_empty(&newcodec->avail_l_memblk)) { + if (!list_empty(&maru_brill_codec->avail_l_memblk)) { elem = - list_first_entry(&newcodec->avail_l_memblk, + list_first_entry(&maru_brill_codec->avail_l_memblk, struct device_mem, entry); if (!elem) { ret = -1; @@ -470,7 +501,7 @@ static int32_t secure_l_device_memory(uint32_t blk_id) elem->blk_id = blk_id; elem->occupied = true; - list_move_tail(&elem->entry, &newcodec->used_l_memblk); + list_move_tail(&elem->entry, &maru_brill_codec->used_l_memblk); ret = elem->mem_offset; DEBUG("get available memory region: 0x%x\n", ret); } @@ -482,7 +513,6 @@ static int32_t secure_l_device_memory(uint32_t blk_id) } mutex_unlock(&l_block_mutex); -#endif return ret; } @@ -492,16 +522,15 @@ static void release_l_device_memory(uint32_t mem_offset) struct device_mem *elem = NULL; struct list_head *pos, *temp; -#if 1 mutex_lock(&l_block_mutex); - if (!list_empty(&newcodec->used_l_memblk)) { - list_for_each_safe(pos, temp, &newcodec->used_l_memblk) { + if (!list_empty(&maru_brill_codec->used_l_memblk)) { + list_for_each_safe(pos, temp, &maru_brill_codec->used_l_memblk) { elem = list_entry(pos, struct device_mem, entry); if (elem->mem_offset == (uint32_t)mem_offset) { elem->blk_id = 0; elem->occupied = false; - list_move(&elem->entry, &newcodec->avail_l_memblk); + list_move(&elem->entry, &maru_brill_codec->avail_l_memblk); up(&l_buffer_sema); DEBUG("up l_buffer_semaphore: %d\n", l_buffer_sema.count); @@ -513,63 +542,58 @@ static void release_l_device_memory(uint32_t mem_offset) DEBUG("there is no used memory block.\n"); } mutex_unlock(&l_block_mutex); -#endif } +#if 0 static int32_t secure_device_memory(uint32_t blk_id) { int ret = 0; + struct device_mem *elem = NULL; lock_buffer(); - { - // check whether avail_memblk is empty. - // move mem_blk to used_blk if it is not empty - // otherwise, the current task will be waiting until a mem_blk is available. - struct device_mem *elem = NULL; - - mutex_lock(&newcodec_blk_mutex); + // check whether avail_memblk is empty. + // move mem_blk to used_blk if it is not empty + // otherwise, the current task will be waiting until a mem_blk is available. + mutex_lock(&maru_brill_codec_blk_mutex); - if (!list_empty(&newcodec->avail_memblk)) { - elem = - list_first_entry(&newcodec->avail_memblk, struct device_mem, entry); - if (!elem) { - ERROR("failed to get first entry from avail_memblk\n"); - ret = -1; - } else { - elem->blk_id = blk_id; - elem->occupied = true; - - list_move_tail(&elem->entry, &newcodec->used_memblk); - ret = elem->mem_offset; - } - } else { - ERROR("no available memory block\n"); - ERROR("the number of buffer mutex: %d\n", newcodec_buffer_mutex.count); + if (!list_empty(&maru_brill_codec->avail_memblk)) { + elem = + list_first_entry(&maru_brill_codec->avail_memblk, struct device_mem, entry); + if (!elem) { + ERROR("failed to get first entry from avail_memblk\n"); ret = -1; - } + } else { + elem->blk_id = blk_id; + elem->occupied = true; - mutex_unlock(&newcodec_blk_mutex); + list_move_tail(&elem->entry, &maru_brill_codec->used_memblk); + ret = elem->mem_offset; + } + } else { + ERROR("no available memory block\n"); + ERROR("the number of buffer mutex: %d\n", maru_brill_codec_buffer_mutex.count); + ret = -1; } + mutex_unlock(&maru_brill_codec_blk_mutex); + return ret; } static void release_device_memory(uint32_t mem_offset) { - -#if 0 struct device_mem *elem = NULL; struct list_head *pos, *temp; - mutex_lock(&newcodec_blk_mutex); - if (!list_empty(&newcodec->used_memblk)) { - list_for_each_safe(pos, temp, &newcodec->used_memblk) { + mutex_lock(&maru_brill_codec_blk_mutex); + if (!list_empty(&maru_brill_codec->used_memblk)) { + list_for_each_safe(pos, temp, &maru_brill_codec->used_memblk) { elem = list_entry(pos, struct device_mem, entry); if (elem->mem_offset == (uint32_t)mem_offset) { elem->blk_id = 0; elem->occupied = false; - list_move(&elem->entry, &newcodec->avail_memblk); + list_move(&elem->entry, &maru_brill_codec->avail_memblk); unlock_buffer(); break; @@ -578,9 +602,12 @@ static void release_device_memory(uint32_t mem_offset) } else { DEBUG("there is no used memory block.\n"); } - mutex_unlock(&newcodec_blk_mutex); + mutex_unlock(&maru_brill_codec_blk_mutex); +} #endif +static void release_device_memory(uint32_t mem_offset) +{ if (mem_offset < (16 * 1024 * 1024)) { DEBUG("release small size of memory\n"); release_s_device_memory(mem_offset); @@ -593,7 +620,8 @@ static void release_device_memory(uint32_t mem_offset) } } -static long newcodec_ioctl(struct file *file, +#if 0 +static long maru_brill_codec_ioctl(struct file *file, unsigned int cmd, unsigned long arg) { @@ -629,9 +657,9 @@ static long newcodec_ioctl(struct file *file, ENTER_CRITICAL_SECTION; writel((uint32_t)value, - newcodec->ioaddr + CODEC_CMD_DEVICE_MEM_OFFSET); + maru_brill_codec->ioaddr + CODEC_CMD_DEVICE_MEM_OFFSET); writel((uint32_t)file, - newcodec->ioaddr + CODEC_CMD_POP_WRITE_QUEUE); + maru_brill_codec->ioaddr + CODEC_CMD_POP_WRITE_QUEUE); LEAVE_CRITICAL_SECTION; if (copy_to_user((void *)arg, &value, sizeof(uint32_t))) { @@ -641,20 +669,19 @@ static long newcodec_ioctl(struct file *file, } } break; - case CODEC_CMD_GET_VERSION: - DEBUG("%s version: %d\n", DEVICE_NAME, newcodec->version); + DEBUG("%s version: %d\n", DEVICE_NAME, maru_brill_codec->version); - if (copy_to_user((void *)arg, &newcodec->version, sizeof(int))) { + if (copy_to_user((void *)arg, &maru_brill_codec->version, sizeof(int))) { ERROR("ioctl: failed to copy data to user\n"); ret = -EIO; } break; - case CODEC_CMD_GET_ELEMENT: + case CODEC_CMD_GET_ELEMENT_INFO: DEBUG("request a device to get codec elements\n"); ENTER_CRITICAL_SECTION; - value = readl(newcodec->ioaddr + cmd); + value = readl(maru_brill_codec->ioaddr + cmd); LEAVE_CRITICAL_SECTION; if (value < 0) { @@ -665,7 +692,7 @@ static long newcodec_ioctl(struct file *file, case CODEC_CMD_GET_CONTEXT_INDEX: DEBUG("request a device to get an index of codec context \n"); - value = readl(newcodec->ioaddr + cmd); + value = readl(maru_brill_codec->ioaddr + cmd); if (value < 0 || value > CODEC_CONTEXT_SIZE) { ERROR("ioctl: failed to get proper context. %d\n", (int)value); ret = -EINVAL; @@ -709,7 +736,7 @@ static long newcodec_ioctl(struct file *file, break; } - if (mem_offset == newcodec->mem_size) { + if (mem_offset == maru_brill_codec->mem_size) { ERROR("offset of device memory is overflow!! 0x%x\n", mem_offset); ret = -EIO; } else { @@ -718,9 +745,9 @@ static long newcodec_ioctl(struct file *file, ENTER_CRITICAL_SECTION; writel((uint32_t)mem_offset, - newcodec->ioaddr + CODEC_CMD_DEVICE_MEM_OFFSET); + maru_brill_codec->ioaddr + CODEC_CMD_DEVICE_MEM_OFFSET); writel((uint32_t)file, - newcodec->ioaddr + CODEC_CMD_POP_WRITE_QUEUE); + maru_brill_codec->ioaddr + CODEC_CMD_POP_WRITE_QUEUE); LEAVE_CRITICAL_SECTION; } } @@ -736,9 +763,12 @@ static long newcodec_ioctl(struct file *file, } else { DEBUG("send a request to pop data from device. %p\n", file); - newcodec_write_data(CODEC_CMD_DEVICE_MEM_OFFSET, - CODEC_CMD_POP_WRITE_QUEUE, - (uint32_t)value, (uint32_t)file); + ENTER_CRITICAL_SECTION; + writel((uint32_t)value, + maru_brill_codec->ioaddr + CODEC_CMD_DEVICE_MEM_OFFSET); + writel((uint32_t)file, + maru_brill_codec->ioaddr + CODEC_CMD_POP_WRITE_QUEUE); + LEAVE_CRITICAL_SECTION; if (copy_to_user((void *)arg, &value, sizeof(int32_t))) { ERROR("ioctl: failed to copy data to user.\n"); @@ -759,9 +789,9 @@ static long newcodec_ioctl(struct file *file, ENTER_CRITICAL_SECTION; writel((uint32_t)value, - newcodec->ioaddr + CODEC_CMD_DEVICE_MEM_OFFSET); + maru_brill_codec->ioaddr + CODEC_CMD_DEVICE_MEM_OFFSET); writel((uint32_t)file, - newcodec->ioaddr + CODEC_CMD_POP_WRITE_QUEUE); + maru_brill_codec->ioaddr + CODEC_CMD_POP_WRITE_QUEUE); LEAVE_CRITICAL_SECTION; if (copy_to_user((void *)arg, &value, sizeof(uint32_t))) { @@ -784,9 +814,9 @@ static long newcodec_ioctl(struct file *file, ENTER_CRITICAL_SECTION; writel((uint32_t)value, - newcodec->ioaddr + CODEC_CMD_DEVICE_MEM_OFFSET); + maru_brill_codec->ioaddr + CODEC_CMD_DEVICE_MEM_OFFSET); writel((uint32_t)file, - newcodec->ioaddr + CODEC_CMD_POP_WRITE_QUEUE); + maru_brill_codec->ioaddr + CODEC_CMD_POP_WRITE_QUEUE); LEAVE_CRITICAL_SECTION; if (copy_to_user((void *)arg, &value, sizeof(uint32_t))) { @@ -842,122 +872,226 @@ static long newcodec_ioctl(struct file *file, return ret; } +#endif -static ssize_t newcodec_read(struct file *file, char __user *buf, - size_t count, loff_t *fops) -{ - DEBUG("do nothing.\n"); - return 0; -} - -static void newcodec_write_data(int cmd1, int cmd2, - uint32_t value1, uint32_t value2) +static long maru_brill_codec_ioctl(struct file *file, + unsigned int cmd, + unsigned long arg) { - ENTER_CRITICAL_SECTION; - writel(value1, newcodec->ioaddr + cmd1); - writel(value2, newcodec->ioaddr + cmd2); - LEAVE_CRITICAL_SECTION; -} + long value = 0, ret = 0; -static void newcodec_func(struct codec_param *param, uint32_t file_index) -{ - int ctx_index, api_index; + switch (cmd) { + case CODEC_CMD_GET_VERSION: + DEBUG("%s version: %d\n", DEVICE_NAME, maru_brill_codec->version); - ctx_index = param->ctx_index; - api_index = param->api_index; - DEBUG("context index: %d\n", ctx_index); + if (copy_to_user((void *)arg, &maru_brill_codec->version, sizeof(int))) { + ERROR("ioctl: failed to copy data to user\n"); + ret = -EIO; + } + break; + case CODEC_CMD_GET_ELEMENT: + DEBUG("request a device to get codec elements\n"); - switch (api_index) { - case CODEC_INIT: + ENTER_CRITICAL_SECTION; + value = readl(maru_brill_codec->ioaddr + cmd); + LEAVE_CRITICAL_SECTION; - NEWCODEC_CURRENT_TIME + if (value < 0) { + ERROR("ioctl: failed to get elements. %d\n", (int)value); + ret = -EINVAL; + } + break; + case CODEC_CMD_GET_CONTEXT_INDEX: + DEBUG("request a device to get an index of codec context \n"); - newcodec_write_data(CODEC_CMD_FILE_INDEX, - CODEC_CMD_CONTEXT_INDEX, - file_index, ctx_index); - - NEWCODEC_CURRENT_TIME + value = readl(maru_brill_codec->ioaddr + cmd); + if (value < 0 || value > CODEC_CONTEXT_SIZE) { + ERROR("ioctl: failed to get proper context. %d\n", (int)value); + ret = -EINVAL; + } else if (copy_to_user((void *)arg, &value, sizeof(int))) { + ERROR("ioctl: failed to copy data to user\n"); + ret = -EIO; + } + break; + case CODEC_CMD_USE_DEVICE_MEM: + { + uint32_t mem_offset; -// wait_event_interruptible(wait_queue, context_flags[ctx_index] != 0); -// context_flags[ctx_index] = 0; + if (copy_from_user(&mem_offset, (void *)arg, sizeof(uint32_t))) { + ERROR("ioctl: failed to copy data from user\n"); + ret = -EIO; break; - case CODEC_DECODE_VIDEO... CODEC_ENCODE_AUDIO: + } - NEWCODEC_CURRENT_TIME + if (mem_offset == maru_brill_codec->mem_size) { + ERROR("offset of device memory is overflow!! 0x%x\n", mem_offset); + ret = -EIO; + } else { + // notify that codec device can copy data to memory region. + DEBUG("send a request to pop data from device. %p\n", file); - newcodec_write_data(CODEC_CMD_FILE_INDEX, - CODEC_CMD_CONTEXT_INDEX, - file_index, ctx_index); + ENTER_CRITICAL_SECTION; + writel((uint32_t)mem_offset, + maru_brill_codec->ioaddr + CODEC_CMD_DEVICE_MEM_OFFSET); + writel((uint32_t)file, + maru_brill_codec->ioaddr + CODEC_CMD_GET_DATA_FROM_QUEUE); + LEAVE_CRITICAL_SECTION; + } + } + break; + case CODEC_CMD_GET_DATA_FROM_SMALL_BUFFER: + DEBUG("read small size of data from device memory\n"); - if (api_index == CODEC_ENCODE_VIDEO) { - // in case of medium and large size of data - release_device_memory(param->mem_offset); - } else { - // in case of small size of data -// INFO("release small size of data\n"); - release_s_device_memory(param->mem_offset); + value = + secure_s_device_memory((uint32_t)file); + if (value < 0) { + ERROR("failed to get available memory\n"); + ret = -EINVAL; + } else { + DEBUG("send a request to pop data from device. %p\n", file); + + ENTER_CRITICAL_SECTION; + writel((uint32_t)value, + maru_brill_codec->ioaddr + CODEC_CMD_DEVICE_MEM_OFFSET); + writel((uint32_t)file, + maru_brill_codec->ioaddr + CODEC_CMD_GET_DATA_FROM_QUEUE); + LEAVE_CRITICAL_SECTION; + + if (copy_to_user((void *)arg, &value, sizeof(int32_t))) { + ERROR("ioctl: failed to copy data to user.\n"); + ret = -EIO; } - wait_event_interruptible(wait_queue, context_flags[ctx_index] != 0); - context_flags[ctx_index] = 0; - break; - case CODEC_PICTURE_COPY: - newcodec_write_data(CODEC_CMD_FILE_INDEX, - CODEC_CMD_CONTEXT_INDEX, - file_index, ctx_index); - wait_event_interruptible(wait_queue, context_flags[ctx_index] != 0); - context_flags[ctx_index] = 0; - break; - case CODEC_DEINIT: - newcodec_write_data(CODEC_CMD_FILE_INDEX, - CODEC_CMD_CONTEXT_INDEX, - file_index, ctx_index); + } + break; + case CODEC_CMD_GET_DATA_FROM_MEDIUM_BUFFER: + DEBUG("read large size of data from device memory\n"); - context_flags[ctx_index] = 0; -// INFO("deinit. reset context_flags[%d]: %d\n", ctx_index, context_flags[ctx_index]); - break; - default: - ERROR("undefined function index: %d", api_index); - } -} + value = + secure_m_device_memory((uint32_t)file); + if (value < 0) { + ERROR("failed to get available memory\n"); + ret = -EINVAL; + } else { + DEBUG("send a request to pop data from device. %p\n", file); + ENTER_CRITICAL_SECTION; + writel((uint32_t)value, + maru_brill_codec->ioaddr + CODEC_CMD_DEVICE_MEM_OFFSET); + writel((uint32_t)file, + maru_brill_codec->ioaddr + CODEC_CMD_GET_DATA_FROM_QUEUE); + LEAVE_CRITICAL_SECTION; -#if 0 -static ssize_t newcodec_write(struct file *file, const char __user *buf, size_t count, loff_t *fops) -{ - struct codec_param ioparam = { 0 }; + if (copy_to_user((void *)arg, &value, sizeof(uint32_t))) { + ERROR("ioctl: failed to copy data to user.\n"); + ret = -EIO; + } + } + break; + case CODEC_CMD_GET_DATA_FROM_LARGE_BUFFER: + DEBUG("read large size of data from device memory\n"); - DEBUG("enter %s. %p\n", __func__, file); + value = + secure_l_device_memory((uint32_t)file); + if (value < 0) { + ERROR("failed to get available memory\n"); + ret = -EINVAL; - if (!newcodec) { - ERROR("failed to get codec device info\n"); - return -EINVAL; - } + } else { + DEBUG("send a request to pop data from device. %p\n", file); - if (copy_from_user(&ioparam, buf, sizeof(struct codec_param))) { - ERROR("failed to get codec parameter from user\n"); - return -EIO; + ENTER_CRITICAL_SECTION; + writel((uint32_t)value, + maru_brill_codec->ioaddr + CODEC_CMD_DEVICE_MEM_OFFSET); + writel((uint32_t)file, + maru_brill_codec->ioaddr + CODEC_CMD_GET_DATA_FROM_QUEUE); + LEAVE_CRITICAL_SECTION; + + if (copy_to_user((void *)arg, &value, sizeof(uint32_t))) { + ERROR("ioctl: failed to copy data to user.\n"); + ret = -EIO; + } + } + break; + case CODEC_CMD_SECURE_SMALL_BUFFER: + value = + secure_s_device_memory((uint32_t)file); + if (value < 0) { + ERROR("failed to get available memory\n"); + ret = -EINVAL; + } else { + if (copy_to_user((void *)arg, &value, sizeof(uint32_t))) { + ERROR("ioctl: failed to copy data to user.\n"); + ret = -EIO; + } + } + break; + case CODEC_CMD_SECURE_MEDIUM_BUFFER: + value = + secure_m_device_memory((uint32_t)file); + if (value < 0) { + ERROR("failed to get available memory\n"); + ret = -EINVAL; + } else { + if (copy_to_user((void *)arg, &value, sizeof(uint32_t))) { + ERROR("ioctl: failed to copy data to user.\n"); + ret = -EIO; + } + } + break; + case CODEC_CMD_SECURE_LARGE_BUFFER: + value = + secure_l_device_memory((uint32_t)file); + if (value < 0) { + ERROR("failed to get available memory\n"); + ret = -EINVAL; + } else { + if (copy_to_user((void *)arg, &value, sizeof(uint32_t))) { + ERROR("ioctl: failed to copy data to user.\n"); + ret = -EIO; + } + } + break; + case CODEC_CMD_RELEASE_BUFFER: + { + uint32_t mem_offset; + + if (copy_from_user(&mem_offset, (void *)arg, sizeof(uint32_t))) { + ERROR("ioctl: failed to copy data from user\n"); + ret = -EIO; + break; + } + release_device_memory(mem_offset); + } + break; + default: + DEBUG("no available command."); + ret = -EINVAL; + break; } - newcodec_func(&ioparam, (uint32_t)file); + return ret; +} - DEBUG("leave %s. %p\n", __func__, file); + +static ssize_t maru_brill_codec_read(struct file *file, char __user *buf, + size_t count, loff_t *fops) +{ + DEBUG("do nothing.\n"); return 0; } -#endif -#if 1 /* Copy data between guest and host using mmap operation. */ -static ssize_t newcodec_write(struct file *file, const char __user *buf, size_t count, loff_t *fops) +static ssize_t maru_brill_codec_write(struct file *file, const char __user *buf, + size_t count, loff_t *fops) { struct codec_param ioparam = { 0 }; int api_index, ctx_index; - if (!newcodec) { + if (!maru_brill_codec) { ERROR("failed to get codec device info\n"); return -EINVAL; } -// memset (&ioparam, 0x00, sizeof(struct codec_param)); if (copy_from_user(&ioparam, buf, sizeof(struct codec_param))) { ERROR("failed to get codec parameter info from user\n"); return -EIO; @@ -973,22 +1107,16 @@ static ssize_t newcodec_write(struct file *file, const char __user *buf, size_t { ENTER_CRITICAL_SECTION; writel((uint32_t)file, - newcodec->ioaddr + CODEC_CMD_FILE_INDEX); + maru_brill_codec->ioaddr + CODEC_CMD_FILE_INDEX); writel((uint32_t)ioparam.mem_offset, - newcodec->ioaddr + CODEC_CMD_DEVICE_MEM_OFFSET); + maru_brill_codec->ioaddr + CODEC_CMD_DEVICE_MEM_OFFSET); writel((int32_t)ioparam.ctx_index, - newcodec->ioaddr + CODEC_CMD_CONTEXT_INDEX); + maru_brill_codec->ioaddr + CODEC_CMD_CONTEXT_INDEX); writel((int32_t)ioparam.api_index, - newcodec->ioaddr + CODEC_CMD_API_INDEX); + maru_brill_codec->ioaddr + CODEC_CMD_API_INDEX); LEAVE_CRITICAL_SECTION; -// release_device_memory(ioparam.mem_offset); - DEBUG("context index: %d\n", ctx_index); - wait_event_interruptible(wait_queue, context_flags[ctx_index] != 0); - - DEBUG("wakeup. %d\n", ctx_index); - context_flags[ctx_index] = 0; } break; @@ -996,16 +1124,15 @@ static ssize_t newcodec_write(struct file *file, const char __user *buf, size_t { ENTER_CRITICAL_SECTION; writel((uint32_t)file, - newcodec->ioaddr + CODEC_CMD_FILE_INDEX); + maru_brill_codec->ioaddr + CODEC_CMD_FILE_INDEX); writel((uint32_t)ioparam.mem_offset, - newcodec->ioaddr + CODEC_CMD_DEVICE_MEM_OFFSET); + maru_brill_codec->ioaddr + CODEC_CMD_DEVICE_MEM_OFFSET); writel((int32_t)ioparam.ctx_index, - newcodec->ioaddr + CODEC_CMD_CONTEXT_INDEX); + maru_brill_codec->ioaddr + CODEC_CMD_CONTEXT_INDEX); writel((int32_t)ioparam.api_index, - newcodec->ioaddr + CODEC_CMD_API_INDEX); + maru_brill_codec->ioaddr + CODEC_CMD_API_INDEX); LEAVE_CRITICAL_SECTION; - if (api_index == CODEC_ENCODE_VIDEO) { // in case of medium and large size of data release_device_memory(ioparam.mem_offset); @@ -1014,41 +1141,35 @@ static ssize_t newcodec_write(struct file *file, const char __user *buf, size_t release_s_device_memory(ioparam.mem_offset); } -// release_device_memory(ioparam.mem_offset); - wait_event_interruptible(wait_queue, context_flags[ctx_index] != 0); context_flags[ctx_index] = 0; } break; - case CODEC_PICTURE_COPY: { ENTER_CRITICAL_SECTION; writel((uint32_t)file, - newcodec->ioaddr + CODEC_CMD_FILE_INDEX); + maru_brill_codec->ioaddr + CODEC_CMD_FILE_INDEX); writel((uint32_t)ioparam.mem_offset, - newcodec->ioaddr + CODEC_CMD_DEVICE_MEM_OFFSET); + maru_brill_codec->ioaddr + CODEC_CMD_DEVICE_MEM_OFFSET); writel((int32_t)ioparam.ctx_index, - newcodec->ioaddr + CODEC_CMD_CONTEXT_INDEX); + maru_brill_codec->ioaddr + CODEC_CMD_CONTEXT_INDEX); writel((int32_t)ioparam.api_index, - newcodec->ioaddr + CODEC_CMD_API_INDEX); + maru_brill_codec->ioaddr + CODEC_CMD_API_INDEX); LEAVE_CRITICAL_SECTION; wait_event_interruptible(wait_queue, context_flags[ctx_index] != 0); context_flags[ctx_index] = 0; } break; - case CODEC_DEINIT: ENTER_CRITICAL_SECTION; writel((uint32_t)file, - newcodec->ioaddr + CODEC_CMD_FILE_INDEX); -// writel((uint32_t)ioparam.mem_offset, -// newcodec->ioaddr + CODEC_CMD_DEVICE_MEM_OFFSET); + maru_brill_codec->ioaddr + CODEC_CMD_FILE_INDEX); writel((int32_t)ioparam.ctx_index, - newcodec->ioaddr + CODEC_CMD_CONTEXT_INDEX); + maru_brill_codec->ioaddr + CODEC_CMD_CONTEXT_INDEX); writel((int32_t)ioparam.api_index, - newcodec->ioaddr + CODEC_CMD_API_INDEX); + maru_brill_codec->ioaddr + CODEC_CMD_API_INDEX); LEAVE_CRITICAL_SECTION; break; default: @@ -1057,9 +1178,8 @@ static ssize_t newcodec_write(struct file *file, const char __user *buf, size_t return 0; } -#endif -static int newcodec_mmap(struct file *file, struct vm_area_struct *vm) +static int maru_brill_codec_mmap(struct file *file, struct vm_area_struct *vm) { unsigned long off; unsigned long phys_addr; @@ -1067,12 +1187,12 @@ static int newcodec_mmap(struct file *file, struct vm_area_struct *vm) int ret = -1; size = vm->vm_end - vm->vm_start; - if (size > newcodec->mem_size) { + if (size > maru_brill_codec->mem_size) { ERROR("over mapping size\n"); return -EINVAL; } off = vm->vm_pgoff << PAGE_SHIFT; - phys_addr = (PAGE_ALIGN(newcodec->mem_start) + off) >> PAGE_SHIFT; + phys_addr = (PAGE_ALIGN(maru_brill_codec->mem_start) + off) >> PAGE_SHIFT; ret = remap_pfn_range(vm, vm->vm_start, phys_addr, size, vm->vm_page_prot); @@ -1087,9 +1207,9 @@ static int newcodec_mmap(struct file *file, struct vm_area_struct *vm) return 0; } -static irqreturn_t newcodec_irq_handler(int irq, void *dev_id) +static irqreturn_t maru_brill_codec_irq_handler(int irq, void *dev_id) { - struct newcodec_device *dev = (struct newcodec_device *)dev_id; + struct maru_brill_codec_device *dev = (struct maru_brill_codec_device *)dev_id; unsigned long flags = 0; int val = 0; @@ -1101,21 +1221,20 @@ static irqreturn_t newcodec_irq_handler(int irq, void *dev_id) spin_lock_irqsave(&dev->lock, flags); DEBUG("handle an interrupt from codec device.\n"); - NEWCODEC_CURRENT_TIME - newcodec_bh(dev); + maru_brill_codec_bh(dev); spin_unlock_irqrestore(&dev->lock, flags); return IRQ_HANDLED; } -static int newcodec_open(struct inode *inode, struct file *file) +static int maru_brill_codec_open(struct inode *inode, struct file *file) { DEBUG("open! struct file:%p\n", file); /* register interrupt handler */ - if (request_irq(newcodec->dev->irq, newcodec_irq_handler, - IRQF_SHARED, DEVICE_NAME, newcodec)) { + if (request_irq(maru_brill_codec->dev->irq, maru_brill_codec_irq_handler, + IRQF_SHARED, DEVICE_NAME, maru_brill_codec)) { ERROR("failed to register irq handle\n"); return -EBUSY; } @@ -1125,12 +1244,12 @@ static int newcodec_open(struct inode *inode, struct file *file) return 0; } -static int newcodec_release(struct inode *inode, struct file *file) +static int maru_brill_codec_release(struct inode *inode, struct file *file) { /* free irq */ - if (newcodec->dev->irq) { + if (maru_brill_codec->dev->irq) { DEBUG("free registered irq\n"); - free_irq(newcodec->dev->irq, newcodec); + free_irq(maru_brill_codec->dev->irq, maru_brill_codec); } DEBUG("%s. file: %p\n", __func__, file); @@ -1141,17 +1260,17 @@ static int newcodec_release(struct inode *inode, struct file *file) struct device_mem *elem = NULL; struct list_head *pos, *temp; - mutex_lock(&newcodec_blk_mutex); + mutex_lock(&maru_brill_codec_blk_mutex); - if (!list_empty(&newcodec->used_memblk)) { - list_for_each_safe(pos, temp, &newcodec->used_memblk) { + if (!list_empty(&maru_brill_codec->used_memblk)) { + list_for_each_safe(pos, temp, &maru_brill_codec->used_memblk) { elem = list_entry(pos, struct device_mem, entry); if (elem->blk_id == (uint32_t)file) { DEBUG("move element(%p) to available memory block.\n", elem); elem->blk_id = 0; elem->occupied = false; - list_move(&elem->entry, &newcodec->avail_memblk); + list_move(&elem->entry, &maru_brill_codec->avail_memblk); unlock_buffer(); } @@ -1160,7 +1279,7 @@ static int newcodec_release(struct inode *inode, struct file *file) DEBUG("there is no used memory block.\n"); } - mutex_unlock(&newcodec_blk_mutex); + mutex_unlock(&maru_brill_codec_blk_mutex); } #endif @@ -1171,15 +1290,15 @@ static int newcodec_release(struct inode *inode, struct file *file) mutex_lock(&s_block_mutex); - if (!list_empty(&newcodec->used_s_memblk)) { - list_for_each_safe(pos, temp, &newcodec->used_s_memblk) { + if (!list_empty(&maru_brill_codec->used_s_memblk)) { + list_for_each_safe(pos, temp, &maru_brill_codec->used_s_memblk) { elem = list_entry(pos, struct device_mem, entry); if (elem->blk_id == (uint32_t)file) { DEBUG("move element(%p) to available memory block.\n", elem); elem->blk_id = 0; elem->occupied = false; - list_move_tail(&elem->entry, &newcodec->avail_s_memblk); + list_move_tail(&elem->entry, &maru_brill_codec->avail_s_memblk); up(&s_buffer_sema); } @@ -1196,7 +1315,7 @@ static int newcodec_release(struct inode *inode, struct file *file) if (file) { ENTER_CRITICAL_SECTION; writel((int32_t)file, - newcodec->ioaddr + CODEC_CMD_RESET_AVCONTEXT); + maru_brill_codec->ioaddr + CODEC_CMD_RELEASE_CONTEXT); LEAVE_CRITICAL_SECTION; } @@ -1206,79 +1325,62 @@ static int newcodec_release(struct inode *inode, struct file *file) } /* define file opertion for CODEC */ -const struct file_operations newcodec_fops = { +const struct file_operations maru_brill_codec_fops = { .owner = THIS_MODULE, - .read = newcodec_read, - .write = newcodec_write, - .unlocked_ioctl = newcodec_ioctl, - .open = newcodec_open, - .mmap = newcodec_mmap, - .release = newcodec_release, + .read = maru_brill_codec_read, + .write = maru_brill_codec_write, + .unlocked_ioctl = maru_brill_codec_ioctl, + .open = maru_brill_codec_open, + .mmap = maru_brill_codec_mmap, + .release = maru_brill_codec_release, }; static struct miscdevice codec_dev = { .minor = MISC_DYNAMIC_MINOR, .name = DEVICE_NAME, - .fops = &newcodec_fops, + .fops = &maru_brill_codec_fops, .mode = S_IRUGO | S_IWUGO, }; -static void newcodec_get_device_version(void) +static void maru_brill_codec_get_device_version(void) { - newcodec->version = - readl(newcodec->ioaddr + CODEC_CMD_GET_VERSION); + maru_brill_codec->version = + readl(maru_brill_codec->ioaddr + CODEC_CMD_GET_VERSION); INFO("device version: %d\n", - newcodec->version); + maru_brill_codec->version); } -static int __devinit newcodec_probe(struct pci_dev *pci_dev, +static int __devinit maru_brill_codec_probe(struct pci_dev *pci_dev, const struct pci_device_id *pci_id) { int ret = 0; INFO("%s: driver is probed.\n", DEVICE_NAME); - newcodec = kzalloc(sizeof(struct newcodec_device), GFP_KERNEL); - if (!newcodec) { + maru_brill_codec = kzalloc(sizeof(struct maru_brill_codec_device), GFP_KERNEL); + if (!maru_brill_codec) { ERROR("Failed to allocate memory for codec.\n"); return -ENOMEM; } - newcodec->dev = pci_dev; - - INIT_LIST_HEAD(&newcodec->avail_memblk); - INIT_LIST_HEAD(&newcodec->used_memblk); - - INIT_LIST_HEAD(&newcodec->avail_s_memblk); - INIT_LIST_HEAD(&newcodec->used_s_memblk); - INIT_LIST_HEAD(&newcodec->avail_m_memblk); - INIT_LIST_HEAD(&newcodec->used_m_memblk); - INIT_LIST_HEAD(&newcodec->avail_l_memblk); - INIT_LIST_HEAD(&newcodec->used_l_memblk); + maru_brill_codec->dev = pci_dev; #if 0 - { - struct device_mem *elem = NULL; - int index; + INIT_LIST_HEAD(&maru_brill_codec->avail_memblk); + INIT_LIST_HEAD(&maru_brill_codec->used_memblk); +#endif - elem = - kzalloc(sizeof(struct device_mem) * DEVICE_MEMORY_COUNT, GFP_KERNEL); - if (!elem) { - ERROR("Falied to allocate memory!!\n"); - return -ENOMEM; - } + INIT_LIST_HEAD(&maru_brill_codec->avail_s_memblk); + INIT_LIST_HEAD(&maru_brill_codec->used_s_memblk); + INIT_LIST_HEAD(&maru_brill_codec->avail_m_memblk); + INIT_LIST_HEAD(&maru_brill_codec->used_m_memblk); + INIT_LIST_HEAD(&maru_brill_codec->avail_l_memblk); + INIT_LIST_HEAD(&maru_brill_codec->used_l_memblk); - for (index = 0; index < DEVICE_MEMORY_COUNT; index++) { - elem[index].mem_offset = index * 0x200000; - elem[index].occupied = false; - list_add_tail(&elem[index].entry, &newcodec->avail_memblk); - } - } -#endif - newcodec_divide_device_memory(); + maru_brill_codec_divide_device_memory(); - spin_lock_init(&newcodec->lock); + spin_lock_init(&maru_brill_codec->lock); if ((ret = pci_enable_device(pci_dev))) { ERROR("pci_enable_device failed\n"); @@ -1286,56 +1388,56 @@ static int __devinit newcodec_probe(struct pci_dev *pci_dev, } pci_set_master(pci_dev); - newcodec->mem_start = pci_resource_start(pci_dev, 0); - newcodec->mem_size = pci_resource_len(pci_dev, 0); - if (!newcodec->mem_start) { + maru_brill_codec->mem_start = pci_resource_start(pci_dev, 0); + maru_brill_codec->mem_size = pci_resource_len(pci_dev, 0); + if (!maru_brill_codec->mem_start) { ERROR("pci_resource_start failed\n"); pci_disable_device(pci_dev); return -ENODEV; } - if (!request_mem_region(newcodec->mem_start, - newcodec->mem_size, + if (!request_mem_region(maru_brill_codec->mem_start, + maru_brill_codec->mem_size, DEVICE_NAME)) { ERROR("request_mem_region failed\n"); pci_disable_device(pci_dev); return -EINVAL; } - newcodec->io_start = pci_resource_start(pci_dev, 1); - newcodec->io_size = pci_resource_len(pci_dev, 1); - if (!newcodec->io_start) { + maru_brill_codec->io_start = pci_resource_start(pci_dev, 1); + maru_brill_codec->io_size = pci_resource_len(pci_dev, 1); + if (!maru_brill_codec->io_start) { ERROR("pci_resource_start failed\n"); - release_mem_region(newcodec->mem_start, newcodec->mem_size); + release_mem_region(maru_brill_codec->mem_start, maru_brill_codec->mem_size); pci_disable_device(pci_dev); return -ENODEV; } - if (!request_mem_region(newcodec->io_start, - newcodec->io_size, + if (!request_mem_region(maru_brill_codec->io_start, + maru_brill_codec->io_size, DEVICE_NAME)) { ERROR("request_io_region failed\n"); - release_mem_region(newcodec->mem_start, newcodec->mem_size); + release_mem_region(maru_brill_codec->mem_start, maru_brill_codec->mem_size); pci_disable_device(pci_dev); return -EINVAL; } - newcodec->ioaddr = ioremap_nocache(newcodec->io_start, newcodec->io_size); - if (!newcodec->ioaddr) { + maru_brill_codec->ioaddr = ioremap_nocache(maru_brill_codec->io_start, maru_brill_codec->io_size); + if (!maru_brill_codec->ioaddr) { ERROR("ioremap failed\n"); - release_mem_region(newcodec->io_start, newcodec->io_size); - release_mem_region(newcodec->mem_start, newcodec->mem_size); + release_mem_region(maru_brill_codec->io_start, maru_brill_codec->io_size); + release_mem_region(maru_brill_codec->mem_start, maru_brill_codec->mem_size); pci_disable_device(pci_dev); return -EINVAL; } - newcodec_get_device_version(); + maru_brill_codec_get_device_version(); if ((ret = misc_register(&codec_dev))) { ERROR("cannot register codec as misc\n"); - iounmap(newcodec->ioaddr); - release_mem_region(newcodec->io_start, newcodec->io_size); - release_mem_region(newcodec->mem_start, newcodec->mem_size); + iounmap(maru_brill_codec->ioaddr); + release_mem_region(maru_brill_codec->io_start, maru_brill_codec->io_size); + release_mem_region(maru_brill_codec->mem_start, maru_brill_codec->mem_size); pci_disable_device(pci_dev); return ret; } @@ -1343,57 +1445,62 @@ static int __devinit newcodec_probe(struct pci_dev *pci_dev, return 0; } -static void __devinit newcodec_remove(struct pci_dev *pci_dev) +static void __devinit maru_brill_codec_remove(struct pci_dev *pci_dev) { - if (newcodec) { - if (newcodec->ioaddr) { - iounmap(newcodec->ioaddr); - newcodec->ioaddr = NULL; + if (maru_brill_codec) { + if (maru_brill_codec->ioaddr) { + iounmap(maru_brill_codec->ioaddr); + maru_brill_codec->ioaddr = NULL; + } + + if (maru_brill_codec->io_start) { + release_mem_region(maru_brill_codec->io_start, + maru_brill_codec->io_size); + maru_brill_codec->io_start = 0; } - if (newcodec->io_start) { - release_mem_region(newcodec->io_start, - newcodec->io_size); - newcodec->io_start = 0; + if (maru_brill_codec->mem_start) { + release_mem_region(maru_brill_codec->mem_start, + maru_brill_codec->mem_size); + maru_brill_codec->mem_start = 0; } - if (newcodec->mem_start) { - release_mem_region(newcodec->mem_start, - newcodec->mem_size); - newcodec->mem_start = 0; + if (maru_brill_codec->elem) { + kfree(maru_brill_codec->elem); + maru_brill_codec->elem = NULL; } - kfree(newcodec); + kfree(maru_brill_codec); } misc_deregister(&codec_dev); pci_disable_device(pci_dev); } -static struct pci_device_id newcodec_pci_table[] __devinitdata = { +static struct pci_device_id maru_brill_codec_pci_table[] __devinitdata = { { .vendor = PCI_VENDOR_ID_TIZEN_EMUL, - .device = PCI_DEVICE_ID_VIRTUAL_NEW_CODEC, + .device = PCI_DEVICE_ID_VIRTUAL_BRILL_CODEC, .subvendor = PCI_ANY_ID, .subdevice = PCI_ANY_ID, }, {}, }; -MODULE_DEVICE_TABLE(pci, newcodec_pci_table); +MODULE_DEVICE_TABLE(pci, maru_brill_codec_pci_table); static struct pci_driver driver = { .name = DEVICE_NAME, - .id_table = newcodec_pci_table, - .probe = newcodec_probe, - .remove = newcodec_remove, + .id_table = maru_brill_codec_pci_table, + .probe = maru_brill_codec_probe, + .remove = maru_brill_codec_remove, }; -static int __init newcodec_init(void) +static int __init maru_brill_codec_init(void) { INFO("driver is initialized.\n"); - newcodec_bh_workqueue = create_workqueue ("newcodec"); - if (!newcodec_bh_workqueue) { + maru_brill_codec_bh_workqueue = create_workqueue ("maru_brill_codec"); + if (!maru_brill_codec_bh_workqueue) { ERROR("failed to allocate workqueue\n"); return -ENOMEM; } @@ -1401,15 +1508,15 @@ static int __init newcodec_init(void) return pci_register_driver(&driver); } -static void __exit newcodec_exit(void) +static void __exit maru_brill_codec_exit(void) { INFO("driver is finalized.\n"); - if (newcodec_bh_workqueue) { - destroy_workqueue (newcodec_bh_workqueue); - newcodec_bh_workqueue = NULL; + if (maru_brill_codec_bh_workqueue) { + destroy_workqueue (maru_brill_codec_bh_workqueue); + maru_brill_codec_bh_workqueue = NULL; } pci_unregister_driver(&driver); } -module_init(newcodec_init); -module_exit(newcodec_exit); +module_init(maru_brill_codec_init); +module_exit(maru_brill_codec_exit); -- 2.34.1