/*++ * WonderMedia Memory Block driver * * Copyright c 2010 WonderMedia Technologies, Inc. * * This program is free software: you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation, either version 2 of the License, or * (at your option) any later version. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see . * * WonderMedia Technologies, Inc. * 10F, 529, Chung-Cheng Road, Hsin-Tien, Taipei 231, R.O.C --*/ /*---------------------------------------------------------------------------- * MODULE : driver/video/wmt/memblock.c * DATE : 2008/12/08 * DESCRIPTION : Physical memory management driver * HISTORY : * Version 1.0.0.2 , 2013/11/12 *----------------------------------------------------------------------------*/ #ifndef MEMBLOCK_C #define MEMBLOCK_C #endif #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include "com-mb.h" #include #define THE_MB_USER "WMT-MB" #define MB_VERSION_MAJOR 1 #define MB_VERSION_MINOR 0 #define MB_VERSION_MICRO 0 #define MB_VERSION_BUILD 6 #define MB_DEBUG #define MB_INFO(fmt, args...) \ printk(KERN_INFO "["THE_MB_USER"] " fmt , ## args) #define MB_WARN(fmt, args...) \ printk(KERN_WARNING "["THE_MB_USER" *W*] " fmt, ## args) #define MB_ERROR(fmt, args...) \ printk(KERN_ERR "["THE_MB_USER" *E*] " fmt , ## args) #ifdef MB_DEBUG #define MB_OPDBG(fmt, args...) { /* FILE OPERATION DBG */ \ if (MBMSG_LEVEL) { \ printk("\t" KERN_DEBUG "["THE_MB_USER"] %s: " fmt, \ __func__ , ## args); \ } \ } #define MB_DBG(fmt, args...) { \ if (MBMSG_LEVEL > 1) { \ printk("\t" KERN_DEBUG "["THE_MB_USER"] %s: " fmt, \ __func__ , ## args); \ } \ } #define MB_WDBG(fmt, args...) { \ if (MBMSG_LEVEL > 2) { \ printk("\t" KERN_DEBUG "["THE_MB_USER"] %s: " fmt, \ __func__ , ## args); \ } \ } #else #define MB_OPDBG(fmt, args...) do {} while (0) #define MB_DBG(fmt, args...) do {} while (0) #define MB_WDBG(fmt, args...) do {} while (0) #endif #ifdef CONFIG_WMT_MB_RESERVE_FROM_IO #include #define MBIO_FSCREENINFO FBIOGET_FSCREENINFO #define MBA_MAX_ORDER 20 /* 2^20 pages = 4 GB */ #else #define MBA_MAX_ORDER (MAX_ORDER - 1) /* 2^10 pages = 4 MB */ #endif #define MBA_MIN_ORDER (MAX_ORDER - 5) /* 2^6 pages = 256 KB */ #define MBAFLAG_STATIC 0x80000000 /* static, without release if empty */ #define MBFLAG_CACHED 0x00000001 /* MB mapping as cachable */ #define MBFIND_VIRT 0x00000000 /* search virt address */ #define MBFIND_PHYS 0x00000001 /* search phys address */ #define MBUFIND_USER 0x00000001 /* search user address */ #define MBUFIND_VIRT 0x00000002 /* search kernel virt address */ #define MBUFIND_PHYS 0x00000004 /* search kernel phys address */ #define MBUFIND_ALL 0x00000010 /* search all mbu */ #define MBUFIND_CREATOR 0x00000020 /* search creator */ #define MBUFIND_MMAP 0x00000040 /* search mbu which mapping from user */ #define MBUFIND_GETPUT 0x00000080 /* search mbu which came from get/put */ #define MBUFIND_ADDRMASK (MBUFIND_USER|MBUFIND_VIRT|MBUFIND_PHYS) #define MBPROC_BUFSIZE (16*1024) #define MBA_SHOW_BUFSIZE (8*1024) #define MB_SHOW_BUFSIZE (4*1024) #define MB_COUNT(mb) atomic_read(&(mb)->count) #define MB_IN_USE(mb) (MB_COUNT(mb)) /* count != 0 */ #define PAGE_KB(a) ((a)*(PAGE_SIZE/1024)) #define MB_COMBIND_MBA(h, t) { \ (h)->pgi.pfn_end = (t)->pgi.pfn_end; \ (h)->pages += (t)->pages; \ (h)->tot_free_pages += (t)->tot_free_pages; \ (h)->max_available_pages += (t)->max_available_pages; \ list_del(&((t)->mba_list)); \ wmt_mbah->nr_mba--; \ kmem_cache_free(wmt_mbah->mba_cachep, t); \ } #define list_loop list_for_each_entry struct mb_user; struct page_info { unsigned long pfn_start; /* start pfn of this block */ unsigned long pfn_end; /* end pfn of this block */ }; struct mba_host_struct { /* MB area link list link all MBAs */ struct list_head mba_list; /* page information of this MBA */ unsigned int nr_mba; /* total pages of all manager MBAs */ unsigned long tot_pages; /* total static pages of all manager MBAs */ unsigned long tot_static_pages; /* total free pages of all manager MBAs */ unsigned long tot_free_pages; /* max free pages of all manager MBAs */ unsigned long max_available_pages; /* allocator of MBA, use slab to prevent memory from fragment. */ struct kmem_cache *mba_cachep; /* allocator of MB, use slab to prevent memory from fragment. */ struct kmem_cache *mb_cachep; /* allocator of mb_user, use slab to prevent memory from fragment. */ struct kmem_cache *mbu_cachep; /* allocator of mb_task_info, use slab to prevent memory from fragment. */ struct kmem_cache *mbti_cachep; }; struct mb_area_struct { /* MB area link list link all MBAs */ struct list_head mba_list; /* link list link to all MBs belong to this MBA */ struct list_head mb_list; /* pointer point to dedicated MBAH */ struct mba_host_struct *mbah; /* flags of MBA */ unsigned int flags; /* prefech record task id */ pid_t tgid; /* start physical address of this MBA */ unsigned long phys; /* start virtual address of this MBA */ void *virt; /* size of this MB area. Normally, MAX kernel permitted size */ unsigned long pages; /* page information of this MBA */ struct page_info pgi; /* page information of this MBA */ unsigned int nr_mb; /* cur total free pages of this MBA */ unsigned long tot_free_pages; /* cur max free pages of this MBA */ unsigned long max_available_pages; }; struct mb_struct { /* MB link list link all MBs in dedicated MBA */ struct list_head mb_list; /* pointer point to dedicated MBA */ struct mb_area_struct *mba; /* MB kernel page information */ struct page_info pgi; /* start physical address of this MB */ unsigned long phys; /* start virtual address of this MB */ void *virt; /* allocate size */ unsigned long size; /* current MB use count, release until zero */ atomic_t count; /* flags of MB */ unsigned int flags; /* point to owner created the mb. this enlisted in mbu_list */ struct mb_user *creator; /* use for trace the user of mb */ struct list_head mbu_list; }; struct mb_user { /* user link list link all users (include creator) of belonged MB */ struct list_head mbu_list; /* the mb to which this user belong */ struct mb_struct *mb; /* task id to which user belonged, user space user only */ pid_t tgid; /* mb_mmap and MBIO_GET : user address mb_get and mb->creator : physical address */ unsigned long addr; /* kernel space user: mb size * user space user: mmap size * zero: owner - user space allocate but not mapped yet * not owner -come from get/put */ unsigned long size; /* user name for recoder */ char the_user[TASK_COMM_LEN+1]; }; struct mb_task_info { /* task link list link all tasks which use MBDev */ struct list_head mbti_list; pid_t tgid; /* task pid */ atomic_t count; /* multi open record */ char task_name[TASK_COMM_LEN+1]; struct task_struct *task; }; #ifdef CONFIG_WMT_MB_SIZE static int MB_TOTAL_SIZE = CONFIG_WMT_MB_SIZE * 1024; #else static int MB_TOTAL_SIZE = 32 * 1024; #endif static struct mba_host_struct *wmt_mbah; static struct mb_task_info wmt_mbti; const struct file_operations mb_fops; static unsigned char MBMSG_LEVEL; static unsigned char MBMAX_ORDER; static unsigned char MBMIN_ORDER; static unsigned char USR2PRDT_METHOD; /* read/write spinlock for multientry protection. */ static spinlock_t mb_do_lock; static spinlock_t mb_search_lock; static spinlock_t mb_ioctl_lock; static spinlock_t mb_task_mm_lock; static spinlock_t mb_task_lock; static char show_mb_buffer[MB_SHOW_BUFSIZE]; static char show_mba_buffer[MBA_SHOW_BUFSIZE]; static inline uint64_t checkSum(unsigned long phys, int size, int type) { char *d = (type) ? __va(phys) : mb_phys_to_virt(phys); int i, pageSize, len, offset; uint64_t sum, cs = 0; len = size; offset = (unsigned long)d % PAGE_SIZE; while (len > 0) { sum = 0; pageSize = min((int)(PAGE_SIZE - offset), len); for (i = 0; i < pageSize; i++) sum += d[i]; MB_WDBG("[CS] addr %#lx ~ %#lx size %#x cs %#llx\n", phys, phys + size, size, sum); MB_WDBG("[CS:DATA] %02x %02x %02x %02x %02x %02x %02x %02x\n", d[0] & 0xff, d[1] & 0xff, d[2] & 0xff, d[3] & 0xff, d[4] & 0xff, d[5] & 0xff, d[6] & 0xff, d[7] & 0xff); d += pageSize; len -= pageSize; cs += sum; } return cs; } unsigned long user_to_phys(unsigned long user) { unsigned long par, phys, offset; offset = user % PAGE_SIZE; asm volatile( "mcr p15, 0, %[user], c7, c8, 0\n" "isb\n" "mrc p15, 0, %[par], c7, c4, 0\n" : [par] "=r" (par) : [user] "r" (user)); phys = (par & PAGE_MASK) + offset; MB_DBG("%s: user %lx par %lx phys %lx\n", __func__, user, par, phys); return (par & 0x1) ? 0 : phys; } EXPORT_SYMBOL(user_to_phys); /* return address is guaranteeed only under page alignment */ void *user_to_virt(unsigned long user) { unsigned long phys; phys = user_to_phys(user); if (!phys) { MB_WARN("user 0x%lx to virt fail.\n", user); return 0; } return __va(phys); } EXPORT_SYMBOL(user_to_virt); struct prdt_info { int index; int items; int offset; int size; struct prdt_struct *prdt; struct prdt_struct *last; }; static int prdt_proc(struct prdt_info *info, unsigned long phys) { int len; if (!info) { MB_WARN("PRDT process fail. (NULL info)\n"); return -1; } /* PRDT has done or no PRDT space */ if (info->size <= 0 || (info->last && info->last->EDT)) return 0; len = PAGE_SIZE - info->offset; if (len > info->size) /* last page */ len = info->size; /* Check it could combind with previous one */ if (info->last && /* prd size boundary check, MAX 60K */ (info->last->size <= ((1 << 16) - (2 * PAGE_SIZE))) && /* page continuity check */ ((info->last->addr + info->last->size) == phys)) info->last->size += len; else { /* create new one */ if (!info->items) { MB_WARN("PRD table full (ptr %p # %d left %d).\n", info->last+1, info->index+1, info->size); if (info->last) info->last->EDT = 1; return -1; } if (info->last == NULL) info->last = info->prdt; else info->last++; info->last->addr = phys + info->offset; info->last->size = len; info->index++; info->items--; info->offset = 0; } info->size -= len; info->last->reserve = 0; info->last->EDT = (info->size) ? 0 : 1; MB_WDBG("\t[PRD %3d] %p (0x%x ~ 0x%x, 0x%x, %x) phys 0x%lx offset 0x%x len 0x%x left %x\n", info->index, info->last, info->last->addr, info->last->addr + info->last->size, info->last->size, info->last->EDT, phys, info->offset, len, info->size); return 0; } static inline void show_prdt(struct prdt_struct *next) { int idx = 1; while (!next->EDT) { MB_INFO("PRDT %d-th item: addr %x size %d EDT %d\n", idx, next->addr, next->size, next->EDT); idx++; next++; } MB_INFO("PRDT last(%d-th) item: addr %x size %d EDT %d\n", idx, next->addr, next->size, next->EDT); } int user_to_prdt( unsigned long user, unsigned int size, struct prdt_struct *prdt, unsigned int items) { struct prdt_info info = {0}; unsigned long addr; int idx; if (!prdt || ((size / PAGE_SIZE) + 2) > items) { MB_WARN("PRD table space not enough (ptr %p at least %lu but %d).\n", prdt, (size/PAGE_SIZE)+2, items); return -EINVAL; } MB_DBG("Memory(%#lx,%#x) PRDT(%p,%d)\n", user, size, prdt, items); info.items = items; info.offset = user % PAGE_SIZE; info.size = size; info.prdt = prdt; addr = user & PAGE_MASK; while (info.size > 0) { unsigned long phys = user_to_phys(addr); if (!phys) { MB_WARN("user to prdt fail: unknown addr %lx (%lx, %x)\n", addr, user, size); return -EINVAL; } prdt_proc(&info, phys); addr += PAGE_SIZE; } /* flush cache */ MB_WDBG("flush PRDT %p, from %lx size %d\n", prdt, user, size); dmac_flush_range((const void *)user, (const void *)(user + size)); for (idx = 0;; idx++) { MB_WDBG("PRDT[%d] %p addr %x( ~ %x) size %d EDT %d (%p ~ %p)\n", idx, &prdt[idx], prdt[idx].addr, prdt[idx].addr + prdt[idx].size, prdt[idx].size, prdt[idx].EDT, __va(prdt[idx].addr), __va(prdt[idx].addr + prdt[idx].size)); outer_flush_range(prdt[idx].addr, prdt[idx].addr + prdt[idx].size); if (prdt[idx].EDT) break; } /* show_prdt(prdt); */ return 0; } EXPORT_SYMBOL(user_to_prdt); int mb_to_prdt( unsigned long phys, unsigned int size, struct prdt_struct *prdt, unsigned int items) { struct prdt_info info = {0}; unsigned long addr; void *virt = NULL; int idx; if (!prdt || ((size / PAGE_SIZE) + 2) > items) { MB_WARN("PRD table space not enough (ptr %p at least %lu but %d).\n", prdt, (size/PAGE_SIZE)+2, items); return -EINVAL; } MB_DBG("Memory(%#lx,%#x) PRDT(%p,%d)\n", phys, size, prdt, items); info.items = items; info.offset = phys % PAGE_SIZE; info.size = size; info.prdt = prdt; addr = phys & PAGE_MASK; while (info.size > 0) { prdt_proc(&info, addr); addr += PAGE_SIZE; } /* flush cache */ MB_WDBG("PRDT %p, from %lx size %d\n", prdt, phys, size); virt = mb_phys_to_virt(phys); dmac_flush_range(virt, virt + size); for (idx = 0;; idx++) { MB_WDBG("PRDT[%d] addr %x size %d EDT %d\n", idx, prdt[idx].addr, prdt[idx].size, prdt[idx].EDT); outer_flush_range(prdt[idx].addr, prdt[idx].addr + prdt[idx].size); if (prdt[idx].EDT) break; } /* show_prdt(prdt); */ return 0; } EXPORT_SYMBOL(mb_to_prdt); unsigned int wmt_mmu_table_size(unsigned int size) { unsigned int nPte, nPde, need; if (!size) return 0; nPte = (size / PAGE_SIZE) + 2; /* maybe cross page up and down boundary */ nPde = PAGE_ALIGN(nPte * 4) / PAGE_SIZE; need = PAGE_ALIGN(nPde * 4); need += nPte * 4; MB_DBG("PDE %d PTE %d RequestSize %d\n", nPde, nPte, need); return need; } EXPORT_SYMBOL(wmt_mmu_table_size); int wmt_mmu_table_check( unsigned int mmuPhys, unsigned int mmuSize, unsigned int size) { int request; if (!size) { MB_WARN("mmu table failure. NULL size\n"); return 0; } if (!mmuSize) { MB_WARN("mmu table failure. NULL mmu size\n"); return 0; } if (mmuPhys % PAGE_SIZE) { MB_WARN("mmu table failure. PDE Table not align\n"); return 0; } request = wmt_mmu_table_size(size); if (mmuSize < request) { MB_WARN("mmu table failure. size %d < %d (request)\n", mmuSize, request); return 0; } return 1; } EXPORT_SYMBOL(wmt_mmu_table_check); void wmt_mmu_table_dump(struct mmu_table_info *info) { unsigned int size, iPde, iPte, addrOffset; unsigned int *mmuVirt, *pte = NULL, *pde = NULL; if (info == 0) { MB_ERROR("[WMT_MMU_TABLE] Null input pointer\n"); return; } mmuVirt = (unsigned int *)mb_phys_to_virt(info->addr); size = info->size; iPte = (info->offset >> 12) % 1024; iPde = (info->offset >> 22) % 1024; addrOffset = info->offset % PAGE_SIZE; MB_INFO("MMU (%x): offset pde %x pte %x addr %x\n", info->offset, iPde, iPte, addrOffset); pde = mmuVirt; pte = mb_phys_to_virt(pde[iPde]); while (size > 0) { int pageSize = min((unsigned int)(PAGE_SIZE - addrOffset), size); MB_INFO("PDE(%p/%#x @ %d) -> PTE(%p/%#x @ %d) -> %#x, s %#x # %#x\n", pde + iPde, info->addr + iPde * sizeof(pde), iPde, pte + iPte, pde[iPde] + iPte * sizeof(pte), iPte, pte[iPte] + addrOffset, pageSize, size); iPte++; addrOffset = 0; size -= pageSize; if (!(iPte % 1024)) { iPde++; iPte = 0; pte = mb_phys_to_virt(pde[iPde]); } } } EXPORT_SYMBOL(wmt_mmu_table_dump); /* parameter: mmuPhys [IN] mmu table phys address mmuSize [IN] mmu table size addr [IN] physical address of convert data size [IN] convert size */ unsigned int wmt_mmu_table_from_phys( unsigned int mmuPhys, unsigned int mmuSize, unsigned int addr, unsigned int size) { unsigned int iPde, iPte, nPte, nPde, virBufAddr; unsigned int *pte, *pde, *mmuVirt; int64_t len = size; void *virt = NULL; iPde = iPte = nPte = nPde = 0; if (!wmt_mmu_table_check(mmuPhys, mmuSize, size)) { MB_WARN("phys %x (size %d) to mmu fail\n", addr, size); return 0xFFFFFFFF; } virt = mb_phys_to_virt(addr); virBufAddr = addr % PAGE_SIZE; nPte = size / PAGE_SIZE + 2; nPde = PAGE_ALIGN(nPte * 4) / PAGE_SIZE; pde = mmuVirt = mb_phys_to_virt(mmuPhys); pte = pde + nPde * 1024; *pde = mmuPhys + nPde * PAGE_SIZE; MB_DBG("[%s] pde %p/%x # %d pte %p/%x # %d\n", __func__, pde, mmuPhys, nPde, pte, *pde, nPte); while (len > 0) { pte[iPte] = addr & PAGE_MASK; iPte++; if (!(iPte % 1024)) { pde[iPte + 1] = pde[iPte] + PAGE_SIZE; iPte++; } addr += PAGE_SIZE; len -= PAGE_SIZE; } dmac_flush_range(virt, virt + size); outer_flush_range(addr, addr + size); return virBufAddr; } EXPORT_SYMBOL(wmt_mmu_table_from_phys); struct mmu_info { unsigned int size; unsigned int iPte; unsigned int *pte; unsigned int *pde; }; static inline int wmt_mmu_table_proc(struct mmu_info *info, unsigned long phys) { int pageSize, offset; if (!info) { MB_WARN("WMT MMU process fail. (NULL info)\n"); return -1; } if (info->size <= 0) { MB_WARN("WMT MMU process fail. (size %d)\n", info->size); return -1; } offset = phys % PAGE_SIZE; pageSize = min((unsigned int)(PAGE_SIZE - offset), info->size); *info->pte = phys & PAGE_MASK; info->size -= pageSize; MB_WDBG("\t[PTE] PDE[%d](%p)=%x PTE[%d](%p)=%x size %#x left %#x\n", info->iPte/1024, info->pde, *info->pde, info->iPte, info->pte, *info->pte, pageSize, info->size); info->pte++; info->iPte++; if (!(info->iPte % 1024)) { *info->pde = mb_virt_to_phys(info->pte); info->pde++; } return 0; } /* parameter: mmuPhys [IN] mmu table phys address mmuSize [IN] mmu table size addr [IN] physical address of convert data size [IN] convert size */ unsigned int wmt_mmu_table_from_user( unsigned int mmuPhys, unsigned int mmuSize, unsigned int user, unsigned int size) { #ifndef __KERNEL__ return wmt_mmu_table_from_phys(mmuPhys, mmuSize, user, size); #else struct mmu_info info = {0}; unsigned int nPte, nPde; unsigned long addr = user; int offset = user % PAGE_SIZE; if (!wmt_mmu_table_check(mmuPhys, mmuSize, size)) { printk(KERN_WARNING "user %x (size %d) to mmu fail\n", user, size); return 0xFFFFFFFF; } MB_DBG("[%s] Memory(%#x,%#x) MMU(%#x,%d)\n", __func__, user, size, mmuPhys, mmuSize); nPte = size / PAGE_SIZE + 2; nPde = PAGE_ALIGN(nPte * 4) / PAGE_SIZE; info.size = size; info.pde = mb_phys_to_virt(mmuPhys); info.pte = info.pde + nPde * 1024; *info.pde = mmuPhys + nPde * PAGE_SIZE; dmac_flush_range((const void *)user, (const void *)(user + size)); while (info.size > 0) { unsigned long phys = user_to_phys(addr); int pageSize = min((unsigned int)(PAGE_SIZE - offset), info.size); if (!phys) { MB_WARN("user to mmu fail: unknown addr %lx (%x # %x)\n", addr, user, size); return -EINVAL; } outer_flush_range(phys, phys + pageSize); wmt_mmu_table_proc(&info, phys); addr += pageSize; offset = 0; } return user % PAGE_SIZE; #endif } EXPORT_SYMBOL(wmt_mmu_table_from_user); /* parameter: addr [IN] start address (user or phys depends on addr_type) size [IN] size of memory addrType [IN] address type (0: phys 1: user) info [out] pointer of mmu table info */ unsigned int wmt_mmu_table_create( unsigned int addr, unsigned int size, unsigned int addrType, struct mmu_table_info *info) { int i, nPde, nPte, *pde, mmuSize; unsigned int *mmuAddr = NULL; if (!addr || !size || !info || addrType > 1) { MB_ERROR("[WMT_MMU_TABLE] invalid args:\n"); MB_ERROR("\t addr %x # %x type %x info %p\n", addr, size, addrType, info); return -EINVAL; } mmuSize = wmt_mmu_table_size(size); info->addr = mb_alloc(mmuSize); info->size = size; MB_DBG("[%s] mmu table (%#x # %#x) addr %#x size %#x type %d\n", __func__, info->addr, mmuSize, addr, size, addrType); if (!info->addr) { MB_ERROR("[%s] fail. Out of MB (%d)\n", __func__, mmuSize); return -ENOMEM; } pde = mmuAddr = (unsigned int *)mb_phys_to_virt((unsigned long)info->addr); memset(mmuAddr, 0x0, mmuSize); nPte = (size / PAGE_SIZE) + 2; /* maybe cross page up and down boundary */ nPde = PAGE_ALIGN(nPte * 4) / PAGE_SIZE; for (i = 1; i <= nPde; i++, pde++) *pde = info->addr + i * PAGE_SIZE; info->offset = (addrType) ? wmt_mmu_table_from_user(info->addr, mmuSize, addr, size) : wmt_mmu_table_from_phys(info->addr, mmuSize, addr, size); if (info->offset == 0xFFFFFFFF) { MB_ERROR("[WMT_MMU_TABLE] create fail:"); MB_ERROR("\ttype %x addr %x # %x mmuAddr %p/%x # %d\n", addrType, addr, size, mmuAddr, info->addr, info->size); mb_free(info->addr); return -EFAULT; } MB_DBG("[%s] success! (addr %#x size %#x offset %#x)\n", __func__, info->addr, info->size, info->offset); return 0; } EXPORT_SYMBOL(wmt_mmu_table_create); unsigned int wmt_mmu_table_destroy(struct mmu_table_info *info) { if (!info) { MB_ERROR("[WMT_MMU_TABLE] destroy fail. NULL mmu table info"); return -EINVAL; } MB_DBG("[%s] success! addr %#x\n", __func__, info->addr); mb_free(info->addr); return 0; } EXPORT_SYMBOL(wmt_mmu_table_destroy); static int mb_show_mb( struct mb_struct *mb, char *msg, char *str, int size ) { struct mb_user *mbu; char *p; if (!str && MBMSG_LEVEL <= 1) return 0; if (!mb) return 0; memset(show_mb_buffer, 0x0, MB_SHOW_BUFSIZE); p = show_mb_buffer; p += sprintf(p, "%s%s[MB,%p] %p %08lx %4ldKB [%4lx,%4lx] %3x\n", msg ? msg : "", msg ? " " : "", mb, mb->virt, mb->phys, mb->size/1024, mb->pgi.pfn_start, mb->pgi.pfn_end, MB_COUNT(mb)); if (!list_empty(&mb->mbu_list)) { list_loop(mbu, &mb->mbu_list, mbu_list) { char tmp[256], *p1 = tmp; int expectLen = (int)(p - show_mb_buffer); p1 += sprintf(tmp, " [%s%s,%p] %08lx ", (mbu == mb->creator) ? "O" : " ", (mbu->tgid == MB_DEF_TGID) ? "K" : "U", mbu, mbu->addr); p1 += sprintf(p1, "# %4ldKB By %s(%d)\n", mbu->size/1024, mbu->the_user, mbu->tgid); expectLen += strlen(tmp) + 1; if (expectLen > MB_SHOW_BUFSIZE) { p += sprintf(p, "\n\n .......\n"); break; } p += sprintf(p, "%s", tmp); } } if (str) { if (strlen(show_mb_buffer) < size) size = strlen(show_mb_buffer); strncpy(str, show_mb_buffer, size); } else { size = strlen(show_mb_buffer); MB_DBG("%s", show_mb_buffer); } return size; } static int mb_show_mba( struct mb_area_struct *mba, char *msg, char *str, int size, int follow ) { struct mb_struct *mb; char *p; int idx = 1; if (!str && MBMSG_LEVEL <= 1) return 0; if (!mba) return 0; memset(show_mba_buffer, 0x0, MBA_SHOW_BUFSIZE); p = show_mba_buffer; if (msg) p += sprintf(p, "%s ", msg); p += sprintf(p, "[%p] %p %08lx %3ldMB [%5lx,%5lx] ", mba, mba->virt, mba->phys, PAGE_KB(mba->pages)/1024, mba->pgi.pfn_start, mba->pgi.pfn_end); p += sprintf(p, "%3x %6ldKB/%6ldKB %s\n", mba->nr_mb, PAGE_KB(mba->max_available_pages), PAGE_KB(mba->tot_free_pages), (mba->flags | MBAFLAG_STATIC) ? "S" : "D"); if (follow) { p += sprintf(p, " index - [MemBlock] VirtAddr PhysAddr"); p += sprintf(p, " size [ zs, ze] cnt\n"); list_loop(mb, &mba->mb_list, mb_list) { if ((MBA_SHOW_BUFSIZE - (p - show_mba_buffer)) < 22) { p += sprintf(p, "\n\n more ...\n"); break; } p += sprintf(p, " %5d - ", idx++); /* -2 is for \n and zero */ p += mb_show_mb(mb, NULL, p, MBA_SHOW_BUFSIZE - (p - show_mba_buffer) - 2); } } p += sprintf(p, "\n"); if (str) { if (strlen(show_mba_buffer) < size) size = strlen(show_mba_buffer); strncpy(str, show_mba_buffer, size); } else { size = strlen(show_mba_buffer); MB_DBG("%s", show_mba_buffer); } return size; } /* return physical address */ #ifdef CONFIG_WMT_MB_RESERVE_FROM_IO /* mb_do_lock locked */ static void *mb_alloc_pages(unsigned long *phys, unsigned long *nr_pages) { unsigned int order = get_order(num_physpages << PAGE_SHIFT); unsigned int size = *nr_pages << PAGE_SHIFT; unsigned long addr = ((1 << order) - *nr_pages) << PAGE_SHIFT; void *virt = NULL; if (!nr_pages || !phys) { MB_WARN("mb_alloc_pages fail. unknown argument\n"); return NULL; } *phys = 0; if (*nr_pages == 0) { MB_WARN("mb_alloc_pages zero size\n"); return NULL; } if (!request_mem_region(addr, size, "memblock")) { MB_WARN("request memory region fail. addr %#lx size %d(KB).\n", addr, size/1024); return NULL; } virt = ioremap(addr, size); if (!virt) { MB_WARN("cannot ioremap memory. addr %#lx size %d(KB).\n", addr, size/1024); release_mem_region(addr, size); return NULL; } *phys = addr; MB_DBG("allocate mem region. addr V %p P %#lx size %d(KB)\n", virt, addr, size/1024); return virt; } /* mb_do_lock locked */ static void mb_free_pages(void *virt, unsigned long phys, unsigned int nr_pages) { iounmap(virt); MB_DBG("release mem region. addr V %p P %#lx size %d(KB)\n", virt, phys, 4*nr_pages); return release_mem_region(phys, nr_pages << PAGE_SHIFT); } #else /* mb_do_lock locked */ static void *mb_alloc_pages(unsigned long *phys, unsigned long *nr_pages) { unsigned int i, order; unsigned long virt = 0; struct zone *zone; if (!nr_pages || !phys) { MB_WARN("mb_alloc_pages fail. unknown argument\n"); return NULL; } *phys = 0; if (*nr_pages == 0) { MB_WARN("mb_alloc_pages zero size\n"); return NULL; } order = get_order(*nr_pages * PAGE_SIZE); order = max(order, (unsigned int)(MBA_MIN_ORDER)); MB_DBG(" %ld/%d pages, order %d\n", *nr_pages, 1 << order, order); if (order > MBMAX_ORDER) { MB_WARN("mb_alloc_mba fail. page out of size, %ld/%d/%d\n", *nr_pages, (1<node_zones; for (i = order; i < MAX_ORDER; i++) { if (zone->free_area[i].nr_free) { virt = __get_free_pages(GFP_ATOMIC | GFP_DMA, order); break; } } if (virt) { *nr_pages = 1 << order; *phys = __pa(virt); for (i = 0; i < *nr_pages; i++) SetPageReserved(virt_to_page(virt + i * PAGE_SIZE)); MB_DBG("allocate mem region. addr V %#lx P %#lx size %ld(KB)\n", virt, *phys, PAGE_KB(*nr_pages)); } else { struct free_area *fa; char msg[256], *p = msg; MB_WARN("__get_free_pages fail! (pages: %d free %lu)\n", 1 << order, (unsigned long)nr_free_pages()); zone = (first_online_pgdat())->node_zones; fa = zone->free_area; p += sprintf(msg, "DMA ZONE:"); for (i = 0; i < MAX_ORDER; i++) p += sprintf(p, " %ld*%dKB", fa[i].nr_free, 4 << i); MB_WARN("%s= %ldkB\n", msg, PAGE_KB(nr_free_pages())); } return (void *)virt; } /* mb_do_lock locked */ static void mb_free_pages(void *virt, unsigned long phys, unsigned int nr_pages) { unsigned int index; if (!phys || !nr_pages) { MB_WARN("mb_free_pages unknow addr V %p P %#lx size %d pages\n", virt, phys, nr_pages); return; } for (index = 0; index < nr_pages; index++) { unsigned long addr = (unsigned long)virt + index * PAGE_SIZE; ClearPageReserved(virt_to_page(addr)); } free_pages((unsigned long)virt, get_order(nr_pages * PAGE_SIZE)); } #endif /* mb_do_lock locked */ static struct mb_area_struct *mb_alloc_mba(unsigned int pages) { struct mba_host_struct *mbah = wmt_mbah; struct mb_area_struct *mba; if (!mbah || !pages) { MB_WARN("mb_alloc_mba fail. mbah %p, pages %d\n", mbah, pages); return NULL; } mba = kmem_cache_alloc(mbah->mba_cachep, GFP_ATOMIC); if (!mba) { MB_WARN("mb_alloc_mba fail. out of memory\n"); return NULL; } memset(mba, 0x0, sizeof(struct mb_area_struct)); mba->pages = pages; mba->virt = mb_alloc_pages(&mba->phys, &mba->pages); if (!mba->virt) { MB_WARN("mb_alloc_mba fail. no available space\n"); kmem_cache_free(mbah->mba_cachep, mba); return NULL; } /* initialization */ INIT_LIST_HEAD(&mba->mb_list); INIT_LIST_HEAD(&mba->mba_list); mba->mbah = mbah; mba->tot_free_pages = mba->max_available_pages = mba->pages; mba->pgi.pfn_start = mba->phys >> PAGE_SHIFT; mba->pgi.pfn_end = mba->pgi.pfn_start + mba->pages; list_add_tail(&mba->mba_list, &mbah->mba_list); /* update MBA host */ mbah->nr_mba++; mbah->tot_pages += mba->pages; mbah->tot_free_pages += mba->tot_free_pages; if (mbah->max_available_pages < mba->max_available_pages) mbah->max_available_pages = mba->max_available_pages; mb_show_mba(mba, "alloc", NULL, 0, 0); return mba; } /* mb_do_lock locked */ static int mb_free_mba(struct mb_area_struct *mba) { struct mba_host_struct *mbah; struct mb_area_struct *entry; if (!mba || !mba->mbah || mba->nr_mb) { MB_WARN("mb_free_mba fail. unknow arg.(%p,%p,%x)\n", mba, mba ? mba->mbah : NULL, mba ? mba->nr_mb : 0); return -EFAULT; } mbah = mba->mbah; list_loop(entry, &mbah->mba_list, mba_list) { if (entry == mba) break; } if (entry != mba) { MB_WARN("mb_free_mba fail. unknow MBA %p\n", mba); return -EFAULT; } if (mba->flags & MBAFLAG_STATIC) return 0; mb_show_mba(mba, "ReleaseMBA", NULL, 0, 0); /* free mba */ list_del(&mba->mba_list); mb_free_pages(mba->virt, mba->phys, mba->pages); mbah->nr_mba--; mbah->tot_free_pages -= mba->tot_free_pages; mbah->tot_pages -= mba->pages; kmem_cache_free(mbah->mba_cachep, mba); mba = NULL; /* update max mb size */ mbah->max_available_pages = 0; list_loop(entry, &mbah->mba_list, mba_list) { if (mbah->max_available_pages < entry->max_available_pages) mbah->max_available_pages = entry->max_available_pages; } return 0; } /* mb_do_lock locked */ static struct mb_struct *mb_alloc_mb( struct mb_area_struct *mba, unsigned long size) { struct mba_host_struct *mbah; struct mb_struct *mb, *entry; struct list_head *next; unsigned long pages, zs, ze; if (!mba || !mba->mbah || !size) { MB_WARN("mb_alloc_mb fail. unknow arg.(%p,%p,%lx)\n", mba, mba ? mba->mbah : NULL, size); return NULL; } mbah = mba->mbah; size = PAGE_ALIGN(size); pages = size >> PAGE_SHIFT; /* mb free size is not enough */ if (mba->max_available_pages < pages) { MB_WARN("mb_alloc_mb fail. no space in MBA (%lx<%lx)\n", pages, mba->max_available_pages); return NULL; } /* search available zone zone start from mba start */ ze = zs = mba->pgi.pfn_start; next = &mba->mb_list; list_loop(entry, &mba->mb_list, mb_list) { next = &entry->mb_list; ze = entry->pgi.pfn_start; if ((ze - zs) >= pages) break; zs = entry->pgi.pfn_end; } if (zs >= ze) { next = &mba->mb_list; ze = mba->pgi.pfn_end; } /* impossible, something wrong */ if ((ze - zs) < pages) { MB_WARN("something wrong in MBA %p when allocate MB.\n", mba); return NULL; } MB_DBG("Zone finding start %lx end %lx size %lx for size %lx\n", zs, ze, ze - zs, pages); mb = kmem_cache_alloc(mbah->mb_cachep, GFP_ATOMIC); if (!mb) { MB_WARN("mb_alloc_mb mb_cachep out of memory\n"); return NULL; } memset(mb, 0x0, sizeof(struct mb_struct)); INIT_LIST_HEAD(&mb->mb_list); INIT_LIST_HEAD(&mb->mbu_list); mb->mba = mba; mb->pgi.pfn_start = zs; mb->pgi.pfn_end = mb->pgi.pfn_start + pages; mb->size = size; mb->phys = mba->phys + ((zs - mba->pgi.pfn_start) << PAGE_SHIFT); mb->virt = mba->virt + (mb->phys - mba->phys); list_add_tail(&mb->mb_list, next); mba->nr_mb++; mba->tot_free_pages -= pages; mbah->tot_free_pages -= pages; /* update mba */ zs = mba->pgi.pfn_start; mba->max_available_pages = 0; list_loop(entry, &mba->mb_list, mb_list) { mba->max_available_pages = max(entry->pgi.pfn_start - zs, mba->max_available_pages); zs = entry->pgi.pfn_end; } mba->max_available_pages = max(mba->pgi.pfn_end - zs, mba->max_available_pages); /* update mbah */ mbah->max_available_pages = 0; list_loop(mba, &mbah->mba_list, mba_list) { if (mbah->max_available_pages < mba->max_available_pages) mbah->max_available_pages = mba->max_available_pages; } mb_show_mb(mb, "alloc", NULL, 0); return mb; } /* mb_do_lock locked */ static int mb_free_mb(struct mb_struct *mb) { unsigned long zs, nr_pages; struct mba_host_struct *mbah; struct mb_area_struct *mba; struct mb_struct *entry; if (!mb) { MB_WARN("mb_free_mb fail. unknow MB %p.\n", mb); return -EFAULT; } if (MB_IN_USE(mb)) { MB_WARN("mb_free_mb fail. invalid arg.(%p,%x,%lx,%ldKB)\n", mb, MB_COUNT(mb), mb->phys, mb->size/1024); return -EINVAL; } mba = mb->mba; if (!mba || !mba->mbah) { MB_WARN("mb_free_mb fail. unknow para.(%p,%p)\n", mba, mba ? mba->mbah : NULL); return -EFAULT; } list_loop(entry, &mba->mb_list, mb_list) { if (entry == mb) break; } if (entry != mb) { MB_WARN("mb_free_mb fail. unknow MB %p\n", mb); return -EFAULT; } mbah = mba->mbah; mb_show_mb(mb, "Retrieve unused MB", NULL, 0); /* free mb */ list_del(&mb->mb_list); kmem_cache_free(mbah->mb_cachep, mb); mba->nr_mb--; mb = NULL; /* unused mba, release it */ if (!mba->nr_mb && !(mba->flags & MBAFLAG_STATIC)) return mb_free_mba(mba); /* update max mb size and free mb size */ /* reduce old one and then increase new one */ mbah->tot_free_pages -= mba->tot_free_pages; zs = mba->pgi.pfn_start; mba->tot_free_pages = mba->max_available_pages = nr_pages = 0; list_loop(entry, &mba->mb_list, mb_list) { nr_pages = max(entry->pgi.pfn_start - zs, nr_pages); mba->tot_free_pages += entry->pgi.pfn_start - zs; zs = entry->pgi.pfn_end; } mba->tot_free_pages += mba->pgi.pfn_end - zs; mba->max_available_pages = max(mba->pgi.pfn_end - zs, nr_pages); mbah->tot_free_pages += mba->tot_free_pages; /* add new one */ mbah->max_available_pages = max(mbah->max_available_pages, mba->max_available_pages); return 0; } /* type 0 - virtual address * 1 - physical address */ static struct mb_struct *mb_find_mb(void *addr, int type) { struct mba_host_struct *mbah = wmt_mbah; struct mb_area_struct *mba; struct mb_struct *mb; unsigned long flags; if (!addr || (type != MBFIND_PHYS && type != MBFIND_VIRT)) { MB_WARN("mb_find_mb fail. unknow type %d addr %p\n", type, addr); return NULL; } MB_DBG("IN, type %x addr %p\n", type, addr); spin_lock_irqsave(&mb_search_lock, flags); list_loop(mba, &mbah->mba_list, mba_list) { void *eaddr, *saddr = (void *)(mba->phys); if (type != MBFIND_PHYS) saddr = mba->virt; eaddr = saddr + mba->pages*PAGE_SIZE; if (addr < saddr || addr > eaddr) continue; /* address out of mba range */ list_loop(mb, &mba->mb_list, mb_list) { void *mbaddr = (void *)(mb->phys); if (type != MBFIND_PHYS) mbaddr = mb->virt; if (addr >= mbaddr && addr < (mbaddr + mb->size)) { spin_unlock_irqrestore(&mb_search_lock, flags); MB_DBG("OUT, va %p pa %lx s %ld(KB) cnt %d\n", mb->virt, mb->phys, mb->size/1024, MB_COUNT(mb)); return mb; } } } spin_unlock_irqrestore(&mb_search_lock, flags); MB_DBG("OUT, NULL mb\n"); return NULL; } /* * addr - search address * tgid - task pid * st - search type (MBUFIND_XXX) * MBUFIND_USER: user address * MBUFIND_VIRT: kernel virt address * MBUFIND_PHYS: kernel phys address * MBUFIND_ALL: * 1. mbu->tgid == tgid * 2. tgid == MB_DEF_TGID, address and * one of MBUFIND_VIRT and MBUFIND_PHYS must be set * tgid != MB_DEF_TGID, address and MBUFIND_USER must be set * MBUFIND_CREATOR: * 1. mbu->tgid == tgid * 2. tgid == MB_DEF_TGID, address and * one of MBUFIND_VIRT and MBUFIND_PHYS must be set * tgid != MB_DEF_TGID, address and MBUFIND_USER must be set * 3. mbu == mb->creator * 4. mbu->size == mb->size * MBUFIND_GETPUT: * 1. mbu->tgid == tgid * 2. tgid == MB_DEF_TGID, address and * MBUFIND_PHYS must be set (mbu->addr == mb->phys) * tgid != MB_DEF_TGID, address and * MBUFIND_USER must be set (mbu->addr == user address) * 3. mbu->size == 0 * MBUFIND_MMAP: * 1. mbu->tgid == tgid * 2. address and MBUFIND_USER must be set * 3. mbu->size != 0 */ static struct mb_user *mb_find_mbu(void *addr, pid_t tgid, int st) { struct mba_host_struct *mbah = wmt_mbah; struct mb_area_struct *mba = NULL; struct mb_struct *mb = NULL; struct mb_user *mbu = NULL; unsigned long flags; if (!addr || !(st & MBUFIND_ADDRMASK)) { MB_WARN("mb_find_mbu fail. unknow addr %p\n", addr); return NULL; } MB_DBG("IN, addr %p search type %x TGID %x CurTask %s\n", addr, st, tgid, current->comm); spin_lock_irqsave(&mb_search_lock, flags); list_loop(mba, &mbah->mba_list, mba_list) { if (st & (MBUFIND_VIRT | MBUFIND_PHYS)) { void *eaddr, *saddr = (void *)mba->phys; if (st & MBUFIND_VIRT) saddr = mba->virt; eaddr = saddr + mba->pages*PAGE_SIZE; if (addr < saddr || addr > eaddr) continue; /* address out of mba range */ } list_loop(mb, &mba->mb_list, mb_list) { if ((st & MBUFIND_PHYS) && (addr != (void *)mb->phys)) continue; /* physical address not match */ if ((st & MBUFIND_VIRT) && (addr != mb->virt)) continue; /* virtual address not match */ list_loop(mbu, &mb->mbu_list, mbu_list) { if (mbu->tgid != tgid && tgid != MB_DEF_TGID) continue; /* tgid not match */ if ((st & MBUFIND_USER) && (addr != (void *)mbu->addr)) continue; /* user address not match */ if (st & MBUFIND_ALL) goto leave; /* found */ if (st & MBUFIND_CREATOR) { mbu = mb->creator; goto leave; /* found */ } /* found (if mmap, mbu->size has map size) */ if (st & MBUFIND_MMAP && mbu->size) goto leave; /* found (if get/put, mbu->size should be 0) */ if (st & MBUFIND_GETPUT && mbu->addr && !mbu->size) goto leave; } } } mbu = NULL; leave: if (mbu == NULL) MB_DBG("OUT, NULL mbu\n"); if (mbu) MB_DBG("OUT, mbu %p (%p TGID %x a %#lx s %ld(KB) by %s)\n", mbu, mbu->mb, mbu->tgid, mbu->addr, mbu->size/1024, mbu->the_user); spin_unlock_irqrestore(&mb_search_lock, flags); return mbu; } static void mb_update_mbah(void) { unsigned long mbah_free = 0, mbah_max = 0; struct mba_host_struct *mbah = wmt_mbah; struct mb_area_struct *mba = NULL; struct mb_struct *mb = NULL; if (!mbah) { MB_WARN("mb_update_mbah fail. unknow mbah\n"); return; } list_loop(mba, &mbah->mba_list, mba_list) { unsigned long mba_free = 0, mba_max = 0, nr_pages = 0; unsigned long zs = mba->pgi.pfn_start; /* zone start */ list_loop(mb, &mba->mb_list, mb_list) { nr_pages = max(mb->pgi.pfn_start - zs, nr_pages); mba_free += mb->pgi.pfn_start - zs; zs = mb->pgi.pfn_end; } mba_free += mba->pgi.pfn_end - zs; mbah_free += mba_free; mba_max = max(mba->pgi.pfn_end - zs, nr_pages); mbah_max = max(mbah_max, mba_max); } mbah->tot_free_pages = mbah_free; mbah->max_available_pages = mbah_max; return; } /* called from kernel only, mb_do_lock isn't needed */ void *mb_do_phys_to_virt(unsigned long phys, pid_t tgid, char *name) { struct mb_struct *mb = NULL; void *virt = NULL; MB_DBG("IN, Phys %lx TGID %x NAME %s\n", phys, tgid, name); mb = mb_find_mb((void *)phys, MBFIND_PHYS); if (mb) virt = mb->virt + (phys - mb->phys); else { virt = __va(phys); MB_WARN("%s do phys to virt fail. addr %lx not found\n", name, phys); } MB_DBG("OUT, Virt %p\n", virt); return virt; } EXPORT_SYMBOL(mb_do_phys_to_virt); /* called from kernel only, mb_do_lock isn't needed */ unsigned long mb_do_virt_to_phys(void *virt, pid_t tgid, char *name) { struct mb_struct *mb = NULL; unsigned long phys = 0x0; MB_DBG("IN, Virt %p TGID %x NAME %s\n", virt, tgid, name); mb = mb_find_mb(virt, MBFIND_VIRT); if (mb) phys = mb->phys + (virt - mb->virt); else { phys = __pa(virt); MB_WARN("%s do virt to phys fail. addr %p not found\n", name, virt); } MB_DBG("OUT, Phys %lx\n", phys); return phys; } EXPORT_SYMBOL(mb_do_virt_to_phys); unsigned long mb_do_user_to_phys(unsigned long user, pid_t tgid, char *name) { unsigned long flags, phys = 0; struct mb_user *mbu = NULL; MB_DBG("IN, usr %lx TGID %x name %s\n", user, tgid, name); spin_lock_irqsave(&mb_do_lock, flags); mbu = mb_find_mbu((void *)user, tgid, MBUFIND_USER|MBUFIND_ALL); if (!mbu) { spin_unlock_irqrestore(&mb_do_lock, flags); MB_WARN("%s do user to phys. unknow addr %lx\n", name, user); return 0; } if (!mbu->mb) MB_WARN("%s do user to phys fail. unknow block (addr %lx)\n", name, user); else phys = mbu->mb->phys; spin_unlock_irqrestore(&mb_do_lock, flags); MB_DBG("OUT, Phys %#lx\n", phys); return phys; } EXPORT_SYMBOL(mb_do_user_to_phys); unsigned long mb_do_user_to_virt(unsigned long user, pid_t tgid, char *name) { struct mb_user *mbu = NULL; unsigned long flags; void *virt = NULL; MB_DBG("IN, usr %lx TGID %x name %s\n", user, tgid, name); spin_lock_irqsave(&mb_do_lock, flags); mbu = mb_find_mbu((void *)user, tgid, MBUFIND_USER|MBUFIND_ALL); if (!mbu) { spin_unlock_irqrestore(&mb_do_lock, flags); MB_WARN("%s user to virt fail. unknow addr %lx\n", name, user); return 0; } if (!mbu->mb) MB_WARN("%s user to virt fail. unknow block (addr %lx)\n", name, user); else virt = mbu->mb->virt; spin_unlock_irqrestore(&mb_do_lock, flags); MB_DBG("OUT, Virt %p\n", virt); return (unsigned long)virt; } EXPORT_SYMBOL(mb_do_user_to_virt); /* physical address */ int mb_do_counter(unsigned long addr, char *name) { struct mb_struct *mb; unsigned long flags; int counter = -1; MB_DBG("IN, addr %#lx name %s\n", addr, name); if (!addr || !wmt_mbah) { MB_WARN("%s do counter fail. invalid args %p/%lx\n", name, wmt_mbah, addr); return -EINVAL; } spin_lock_irqsave(&mb_do_lock, flags); mb = mb_find_mb((void *)addr, MBFIND_PHYS); counter = (mb) ? MB_COUNT(mb) : -1; spin_unlock_irqrestore(&mb_do_lock, flags); MB_DBG("OUT, addr %#lx count %d\n", addr, counter); return counter; } EXPORT_SYMBOL(mb_do_counter); unsigned long mb_do_alloc(unsigned long size, pid_t tgid, char *name) { struct mb_area_struct *entry, *mba = NULL; struct mb_struct *mb = NULL; struct mb_user *mbu = NULL; unsigned long flags, addr; unsigned int pages; size_t ns; /* name size */ if (!name) { MB_WARN("mb_alloc fail. null user tgid %x\n", tgid); return 0; } size = PAGE_ALIGN(size); pages = size >> PAGE_SHIFT; if (!pages) { MB_WARN("%s alloc fail. unavailable size %x(KB)\n", name, 4*pages); return 0; } mbu = kmem_cache_alloc(wmt_mbah->mbu_cachep, GFP_ATOMIC); if (!mbu) { MB_WARN("%s alloc fail. mbu_cachep out of memory.\n", name); return 0; } memset(mbu, 0x0, sizeof(struct mb_user)); MB_DBG("IN, TGID %x size %ld(KB) name %s\n", tgid, size/1024, name); spin_lock_irqsave(&mb_do_lock, flags); if (pages > wmt_mbah->max_available_pages) { #ifdef CONFIG_WMT_MB_DYNAMIC_ALLOCATE_SUPPORT mba = mb_alloc_mba(pages); if (mba == NULL) MB_WARN("%s alloc %u page fail. [MBA %lu/%lu/%lu]\n", name, pages, wmt_mbah->max_available_pages, wmt_mbah->tot_free_pages, wmt_mbah->tot_pages); #else MB_DBG("DYNAMIC ALLOCATED(%u) unsuported. [MBA %lu/%lu/%lu]\n", pages, wmt_mbah->max_available_pages, wmt_mbah->tot_free_pages, wmt_mbah->tot_pages); goto error; #endif } else { list_loop(entry, &wmt_mbah->mba_list, mba_list) { if (entry->max_available_pages >= pages) { mba = entry; break; } } } if (!mba) { MB_WARN("%s alloc fail. dedicated MBA not found\n", name); goto error; } mb = mb_alloc_mb(mba, size); if (mb == NULL) { MB_WARN("%s alloc fail. create MB\n", name); goto error; } INIT_LIST_HEAD(&mbu->mbu_list); mbu->mb = mb; mbu->tgid = tgid; mbu->size = mb->size; /* mbu->addr = 0; // address of creator is 0 */ ns = strlen(name); if (ns > TASK_COMM_LEN) ns = TASK_COMM_LEN; strncpy(mbu->the_user, name, ns); mbu->the_user[ns] = 0; list_add_tail(&mbu->mbu_list, &mb->mbu_list); atomic_inc(&mb->count); mb->creator = mbu; addr = mb->phys; spin_unlock_irqrestore(&mb_do_lock, flags); MB_DBG("OUT, Addr %lx TGID %x size %ld(KB) name %s\n", addr, tgid, size/1024, name); return addr; error: kmem_cache_free(wmt_mbah->mbu_cachep, mbu); spin_unlock_irqrestore(&mb_do_lock, flags); return 0; } EXPORT_SYMBOL(mb_do_alloc); /* physical address */ int mb_do_free(unsigned long addr, pid_t tgid, char *name) { struct mb_struct *mb; struct mb_user *mbu; unsigned long flags; size_t ns; /* name size */ int ret; if (!addr || !name) { MB_WARN("mb_free fail. invalid args %lx/%s\n", addr, name); return -EINVAL; } MB_DBG("IN, TGID %x addr %#lx name %s\n", tgid, addr, name); spin_lock_irqsave(&mb_do_lock, flags); mbu = mb_find_mbu((void *)addr, tgid, MBUFIND_PHYS|MBUFIND_CREATOR); if (!mbu || !mbu->mb) { spin_unlock_irqrestore(&mb_do_lock, flags); MB_WARN("%s free fail. unknow addr %lx\n", name, addr); return -EINVAL; } ns = strlen(name); if (ns > TASK_COMM_LEN) ns = TASK_COMM_LEN; if (strncmp(mbu->the_user, name, ns)) MB_DBG("Owner no match. (%s/%s)\n", mbu->the_user, name); mb = mbu->mb; list_del(&mbu->mbu_list); kmem_cache_free(wmt_mbah->mbu_cachep, mbu); mb->creator = NULL; atomic_dec(&mb->count); if (MB_IN_USE(mb)) { MB_DBG("\n", mb->phys, MB_COUNT(mb)); spin_unlock_irqrestore(&mb_do_lock, flags); return 0; } ret = mb_free_mb(mb); spin_unlock_irqrestore(&mb_do_lock, flags); MB_DBG("OUT\n"); return ret; } EXPORT_SYMBOL(mb_do_free); int mb_do_get(unsigned long addr, pid_t tgid, char *name) { struct mb_user *mbu = NULL, *newmbu; struct mb_struct *mb = NULL; unsigned long flags; size_t ns; /* name size */ void *virt = (void *)addr; if (!addr || !name) { MB_WARN("mb_do_get fail. invalid args %lx/%s\n", addr, name); return -EINVAL; } newmbu = kmem_cache_alloc(wmt_mbah->mbu_cachep, GFP_ATOMIC); if (!newmbu) { MB_DBG("\n"); return -ENOMEM; } MB_DBG("IN, TGID %x addr %#lx name %s\n", tgid, addr, name); spin_lock_irqsave(&mb_do_lock, flags); if (tgid != MB_DEF_TGID) { /* find user address, only exist on MMAP */ mbu = mb_find_mbu(virt, tgid, MBUFIND_USER|MBUFIND_MMAP); mb = (mbu) ? mbu->mb : NULL; } else mb = mb_find_mb(virt, MBFIND_PHYS); if (!mb) { spin_unlock_irqrestore(&mb_do_lock, flags); kmem_cache_free(wmt_mbah->mbu_cachep, newmbu); MB_WARN("%s mb_get fail. unknown addr %8lx\n", name, addr); return -EFAULT; } memset(newmbu, 0x0, sizeof(struct mb_user)); INIT_LIST_HEAD(&newmbu->mbu_list); newmbu->addr = addr; newmbu->mb = mb; newmbu->tgid = tgid; ns = strlen(name); if (ns > TASK_COMM_LEN) ns = TASK_COMM_LEN; strncpy(newmbu->the_user, name, ns); newmbu->the_user[ns] = 0; atomic_inc(&mb->count); list_add_tail(&newmbu->mbu_list, &mb->mbu_list); spin_unlock_irqrestore(&mb_do_lock, flags); MB_DBG("out, [mbu] addr %lx %s [mb] addr %lx cnt %d\n", addr, newmbu->the_user, mb->phys, MB_COUNT(mb)); return 0; } EXPORT_SYMBOL(mb_do_get); int mb_do_put(unsigned long addr, pid_t tgid, char *name) { struct mb_struct *mb; struct mb_user *mbu; unsigned long flags; void *virt = (void *)addr; if (!addr || !name) { MB_WARN("mb_do_put fail. invalid args %lx/%s\n", addr, name); return -EINVAL; } MB_DBG("IN, TGID %x addr %#lx name %s\n", tgid, addr, name); spin_lock_irqsave(&mb_do_lock, flags); if (tgid == MB_DEF_TGID) mbu = mb_find_mbu(virt, tgid, MBUFIND_PHYS|MBUFIND_GETPUT); else mbu = mb_find_mbu(virt, tgid, MBUFIND_USER|MBUFIND_GETPUT); if (!mbu) { spin_unlock_irqrestore(&mb_do_lock, flags); MB_WARN("%s mb_put fail. unknow addr %8lx\n", name, addr); return -EINVAL; } mb = mbu->mb; if (!MB_IN_USE(mb)) { spin_unlock_irqrestore(&mb_do_lock, flags); MB_WARN("%s mb_put fail. block %p unbalance.\n", name, mb); return -EPERM; } list_del_init(&mbu->mbu_list); atomic_dec(&mb->count); /* retrieve unused block */ if (!MB_IN_USE(mb)) mb_free_mb(mb); spin_unlock_irqrestore(&mb_do_lock, flags); kmem_cache_free(wmt_mbah->mbu_cachep, mbu); MB_DBG("out, [mbu] addr %lx %s [mb] addr %lx cnt %d\n", addr, mbu->the_user, mb->phys, MB_COUNT(mb)); return 0; } EXPORT_SYMBOL(mb_do_put); #define DEVICE_NAME "Memory Block" static int mb_dev_major; static int mb_dev_minor; static int mb_dev_nr; static struct cdev *mb_cdev; static struct class *mb_dev_class; static int mb_open(struct inode *inode, struct file *filp) { struct mb_task_info *mbti = NULL; unsigned long flags; int task_exist = 0; size_t ns; if (filp->private_data) { MB_ERROR("none empty private data.\n"); return -EFAULT; } spin_lock_irqsave(&mb_task_lock, flags); list_loop(mbti, &wmt_mbti.mbti_list, mbti_list) { if (mbti->task && mbti->tgid == current->tgid) { task_exist = 1; break; } } if (!task_exist) { mbti = kmem_cache_alloc(wmt_mbah->mbti_cachep, GFP_ATOMIC); if (!mbti) { spin_unlock_irqrestore(&mb_task_lock, flags); MB_ERROR("out of memory (mb_task_info).\n"); return -EFAULT; } memset(mbti, 0x0, sizeof(struct mb_task_info)); INIT_LIST_HEAD(&mbti->mbti_list); mbti->task = current; mbti->tgid = current->tgid; ns = strlen(current->comm); if (ns > TASK_COMM_LEN) ns = TASK_COMM_LEN; strncpy(mbti->task_name, current->comm, ns); mbti->task_name[ns] = 0; atomic_set(&mbti->count, 0); list_add_tail(&mbti->mbti_list, &wmt_mbti.mbti_list); } atomic_inc(&mbti->count); MB_DBG("mb driver is opened by task(%p) %s TGID %x count %d.\n", current, current->comm, current->tgid, atomic_read(&(mbti->count))); filp->private_data = (void *)mbti; spin_unlock_irqrestore(&mb_task_lock, flags); return 0; } static int mb_release(struct inode *inode, struct file *filp) { struct mb_area_struct *mba; struct mb_struct *mb; struct mb_user *mbu; struct mb_task_info *cmbti = NULL, *mbti = NULL; unsigned long flags, tflags; int task_exist = 0; cmbti = (struct mb_task_info *)(filp->private_data); if (!cmbti) { MB_ERROR("none empty private data.\n"); return -EFAULT; } spin_lock_irqsave(&mb_task_lock, tflags); list_loop(mbti, &wmt_mbti.mbti_list, mbti_list) { if (mbti->task && mbti->tgid == cmbti->tgid) { atomic_dec(&mbti->count); task_exist = 1; break; } } if (!task_exist) { spin_unlock_irqrestore(&mb_task_lock, tflags); MB_INFO("mb driver is closed by unknown task %s TGID %x.\n", current->comm, current->tgid); return 0; } MB_DBG("mb driver is closed by task %s TGID %x cnt %d.\n", mbti->task_name, mbti->tgid, atomic_read(&mbti->count)); if (atomic_read(&mbti->count)) { spin_unlock_irqrestore(&mb_task_lock, tflags); return 0; } spin_lock_irqsave(&mb_ioctl_lock, flags); RESCAN_MBA: /* munmap virtual memroy and retrieve unused MB */ list_loop(mba, &wmt_mbah->mba_list, mba_list) { #ifdef CONFIG_WMT_MB_DYNAMIC_ALLOCATE_SUPPORT if (mba->tgid == mbti->tgid) { /* free prefetched mba marker */ wmt_mbah->tot_static_pages -= mba->pages; mba->flags &= ~(MBAFLAG_STATIC); mba->tgid = MB_DEF_TGID; if (!mba->nr_mb) { mb_free_mba(mba); goto RESCAN_MBA; } } #endif list_loop(mb, &mba->mb_list, mb_list) { RESCAN_MBU: list_loop(mbu, &mb->mbu_list, mbu_list) { if (mbu->tgid == mbti->tgid) { char msg[128], *p = msg; const char *opStr[3] = { "\"ALLOC\"", "\"MAP\"", "\"GET\""}; int op = (mbu->size) ? 1 : 2; if (mb->creator == mbu) { op = 0; mb->creator = NULL; } p += sprintf(p, "Stop mb operation %s", opStr[op]); p += sprintf(p, "(addr %lx # %lu(KB) ", mb->phys, mbu->size/1024); p += sprintf(p, "by %s) (Cnt %d)\n", mbu->the_user, MB_COUNT(mb)-1); MB_INFO("%s", msg); atomic_dec(&mb->count); list_del_init(&mbu->mbu_list); kmem_cache_free( wmt_mbah->mbu_cachep, mbu); if (MB_COUNT(mb)) goto RESCAN_MBU; MB_INFO("Recycle mb addr %lx # %lu\n", mb->phys, mb->size); mb_free_mb(mb); goto RESCAN_MBA; } } } } mb_update_mbah(); list_del(&mbti->mbti_list); kmem_cache_free(wmt_mbah->mbti_cachep, mbti); filp->private_data = NULL; spin_unlock_irqrestore(&mb_ioctl_lock, flags); spin_unlock_irqrestore(&mb_task_lock, tflags); return 0; } static long mb_ioctl(struct file *filp, unsigned int cmd, unsigned long arg) { struct mb_task_info *mbti = NULL; struct mb_area_struct *mba = NULL; struct mb_struct *mb = NULL; struct mb_user *mbu = NULL; unsigned long value, flags, phys, virt, size; pid_t tgid = MB_DEF_TGID; int count, ret = 0, cmdSize; size_t len; /* check type and number, if fail return ENOTTY */ #ifdef CONFIG_WMT_MB_RESERVE_FROM_IO if (_IOC_TYPE(cmd) != MB_IOC_MAGIC && cmd != FBIOGET_FSCREENINFO) return -ENOTTY; #else if (_IOC_TYPE(cmd) != MB_IOC_MAGIC) return -ENOTTY; #endif /* check argument area */ cmdSize = _IOC_SIZE(cmd); if (_IOC_DIR(cmd) & _IOC_READ) ret = !access_ok(VERIFY_WRITE, (void __user *) arg, cmdSize); else if (_IOC_DIR(cmd) & _IOC_WRITE) ret = !access_ok(VERIFY_READ, (void __user *) arg, cmdSize); if (ret) return -EFAULT; /* check task validation */ if (!filp || !filp->private_data) { MB_ERROR("mmap with null file info or task.\n"); return -EFAULT; } mbti = (struct mb_task_info *)(filp->private_data); tgid = mbti->tgid; if (tgid != current->tgid) { MB_WARN("ioctl within diff task.\n"); MB_WARN("Open: task %s TGID %x VS Curr: task %s TGID %x\n", mbti->task_name, tgid, current->comm, current->tgid); } switch (cmd) { /* _IOR (MB_IOC_MAGIC, 16, unsigned long) O: mb driver version */ case MBIO_GET_VERSION: value = MB_VERSION_MAJOR << 24 | MB_VERSION_MINOR << 16 | MB_VERSION_MICRO << 8 | MB_VERSION_BUILD; put_user(value, (unsigned long *)arg); break; /* _IOWR(MB_IOC_MAGIC, 0, unsigned long) * I: size * O: physical address */ case MBIO_MALLOC: get_user(value, (unsigned long *)arg); phys = mb_do_alloc(value, tgid, mbti->task_name); if (!phys) { MB_WARN("MALLOC: size %ld fail.\n\n", value); return -EFAULT; } MB_OPDBG("MALLOC: addr %lx size %ld\n\n", phys, value); put_user(phys, (unsigned long *)arg); break; /* _IOW (MB_IOC_MAGIC, 17, unsigned long) O: property of MB */ case MBIO_SET_CACHABLE: get_user(value, (unsigned long *)arg); spin_lock_irqsave(&mb_do_lock, flags); mb = mb_find_mb((void *)value, MBFIND_PHYS); if (!mb) { spin_unlock_irqrestore(&mb_do_lock, flags); MB_WARN("SET_CACHABLE: phys %8lx (name %s) fail\n", value, mbti->task_name); return -EFAULT; } mb->flags |= MBFLAG_CACHED; spin_unlock_irqrestore(&mb_do_lock, flags); MB_OPDBG("SET_CACHABLE: phys %8lx\n\n", value); break; /* _IOW (MB_IOC_MAGIC,18, unsigned long) O: property of MB */ case MBIO_CLR_CACHABLE: get_user(value, (unsigned long *)arg); spin_lock_irqsave(&mb_do_lock, flags); mb = mb_find_mb((void *)value, MBFIND_PHYS); if (!mb) { spin_unlock_irqrestore(&mb_do_lock, flags); MB_WARN("CLR_CACHABLE: phys %8lx (name %s) fail\n", value, mbti->task_name); return -EFAULT; } mb->flags &= ~MBFLAG_CACHED; spin_unlock_irqrestore(&mb_do_lock, flags); MB_OPDBG("CLR_CACHABLE: phys %8lx\n\n", value); break; /* _IOWR(MB_IOC_MAGIC, 1, unsigned long) * I: user address if map, physical address if not map * O: ummap size */ case MBIO_FREE: /* if not unmap, unmap first */ get_user(value, (unsigned long *)arg); spin_lock_irqsave(&mb_ioctl_lock, flags); size = value; mbu = mb_find_mbu((void *)value, tgid, MBUFIND_USER|MBUFIND_MMAP); if (mbu != NULL) { size = mbu->size; value = mbu->mb->phys; list_del(&mbu->mbu_list); atomic_dec(&mbu->mb->count); kmem_cache_free(wmt_mbah->mbu_cachep, mbu); } else MB_DBG("FREE: unknown MMAP addr %lx\n", value); ret = mb_do_free(value, tgid, mbti->task_name); spin_unlock_irqrestore(&mb_ioctl_lock, flags); if (ret < 0) MB_WARN("FREE: addr %lx fail\n", value); /* return mmap size for ummap */ put_user(size, (unsigned long *)arg); MB_OPDBG("FREE: addr %lx out %ld\n\n", value, size); break; /* _IOWR(MB_IOC_MAGIC, 2, unsigned long) * I: user address * O: ummap size */ case MBIO_UNMAP: get_user(value, (unsigned long *)arg); spin_lock_irqsave(&mb_ioctl_lock, flags); mbu = mb_find_mbu((void *)value, tgid, MBUFIND_USER|MBUFIND_MMAP); if (mbu == NULL) { spin_unlock_irqrestore(&mb_ioctl_lock, flags); MB_WARN("UNMAP: addr %lx fail\n\n", value); return -EFAULT; } mb = mbu->mb; size = mbu->size; list_del(&mbu->mbu_list); kmem_cache_free(wmt_mbah->mbu_cachep, mbu); atomic_dec(&mb->count); count = MB_COUNT(mb); if (count <= 0) MB_WARN("UNMAP: MB %8lx count %d weird\n\n", mb->phys, count); spin_unlock_irqrestore(&mb_ioctl_lock, flags); /* return mmap size for ummap */ put_user(size, (unsigned long *)arg); return 0; /* _IOWR(MB_IOC_MAGIC, 3, unsigned long) * I: phys address * O: mb size */ case MBIO_MBSIZE: get_user(value, (unsigned long *)arg); spin_lock_irqsave(&mb_ioctl_lock, flags); mb = mb_find_mb((void *)value, MBFIND_PHYS); if (mb == NULL) { spin_unlock_irqrestore(&mb_ioctl_lock, flags); MB_WARN("MBSIZE: user %lx fail.\n\n", value); return -EFAULT; } size = mb->size; spin_unlock_irqrestore(&mb_ioctl_lock, flags); MB_OPDBG("MBSIZE: addr %lx size %ld\n\n", value, size); put_user(size, (unsigned long *)arg); break; /* _IOR (MB_IOC_MAGIC, 4, unsigned long) * O: max free mba size */ case MBIO_MAX_AVAILABLE_SIZE: put_user(wmt_mbah->max_available_pages*PAGE_SIZE, (unsigned long *)arg); MB_OPDBG("MAX_MB_SIZE: size %ld KB\n\n", PAGE_KB(wmt_mbah->max_available_pages)); break; /* _IOW (MB_IOC_MAGIC, 5, unsigned long) * I: user address */ case MBIO_GET: get_user(value, (unsigned long *)arg); ret = mb_do_get(value, tgid, mbti->task_name); if (MBMSG_LEVEL) { spin_lock_irqsave(&mb_ioctl_lock, flags); mbu = mb_find_mbu((void *)value, tgid, MBUFIND_USER|MBUFIND_GETPUT); count = mbu ? MB_COUNT(mbu->mb) : 0xffffffff; MB_OPDBG("GET: addr %lx cnt %x\n\n", value, count); spin_unlock_irqrestore(&mb_ioctl_lock, flags); } break; /* _IOW (MB_IOC_MAGIC, 6, unsigned long) * I: user address */ case MBIO_PUT: get_user(value, (unsigned long *)arg); if (MBMSG_LEVEL) { spin_lock_irqsave(&mb_ioctl_lock, flags); mbu = mb_find_mbu((void *)value, tgid, MBUFIND_USER|MBUFIND_GETPUT); count = mbu ? MB_COUNT(mbu->mb) - 1 : 0xffffffff; MB_OPDBG("PUT: addr %lx cnt %x\n\n", value, count); spin_unlock_irqrestore(&mb_ioctl_lock, flags); } ret = mb_do_put(value, tgid, mbti->task_name); break; /* _IOWR(MB_IOC_MAGIC, 7, unsigned long) * I: user address * O: virt address */ case MBIO_USER_TO_VIRT: get_user(value, (unsigned long *)arg); virt = mb_do_user_to_virt(value, tgid, mbti->task_name); put_user(virt, (unsigned long *)arg); MB_OPDBG("USER_TO_VERT: user %8lx virt %lx\n\n", value, virt); break; /* _IOWR(MB_IOC_MAGIC, 8, unsigned long) * I: user address * O: phys address */ case MBIO_USER_TO_PHYS: get_user(value, (unsigned long *)arg); phys = mb_do_user_to_phys(value, tgid, mbti->task_name); put_user(phys, (unsigned long *)arg); MB_OPDBG("USER_TO_PHYS: user %8lx phys %lx\n\n", value, phys); break; #ifdef CONFIG_WMT_MB_RESERVE_FROM_IO /* This IOCTRL is provide AP to recognize MB region as framebuffer, then can access mb memory directly. */ case MBIO_FSCREENINFO: { struct fb_fix_screeninfo ffs; if (!wmt_mbah || list_empty(&wmt_mbah->mba_list)) { MB_WARN("MBIO_FSCREENINFO: MB driver does not init.\n"); return -EFAULT; } mba = (struct mb_area_struct *)wmt_mbah->mba_list.next; ffs.smem_start = mba->phys; ffs.smem_len = wmt_mbah->tot_static_pages * PAGE_SIZE; if (copy_to_user((void __user *)arg, &ffs, sizeof(ffs))) ret = -EFAULT; MB_OPDBG("FSCREENINFO: phys %lx len %x\n\n", ffs.smem_start, ffs.smem_len); break; } #endif /* _IOW (MB_IOC_MAGIC, 9, unsigned long) * I: size */ case MBIO_PREFETCH: { unsigned long fetch_size = 0; get_user(value, (unsigned long *)arg); #ifdef CONFIG_WMT_MB_DYNAMIC_ALLOCATE_SUPPORT { unsigned long try_size = 0; MB_OPDBG("PREFETCH: size %ld KB\n\n", value/1024); spin_lock_irqsave(&mb_ioctl_lock, flags); while (try_size < value) { int order; order = get_order(value-fetch_size); if (order > MBMAX_ORDER) order = MBMAX_ORDER; try_size += (1 << order) * PAGE_SIZE; mba = mb_alloc_mba(1 << order); if (mba) { mba->flags |= MBAFLAG_STATIC; mba->tgid = current->tgid; wmt_mbah->tot_static_pages += mba->pages; fetch_size += mba->pages * PAGE_SIZE; } } spin_unlock_irqrestore(&mb_ioctl_lock, flags); MB_INFO("PREFETCH: SIZE %ld / %ld kB by %s\n", fetch_size/1024, value/1024, current->comm); } #else MB_WARN("PREFETCH: SIZE %ld / %ld kB by %s fail\n", fetch_size/1024, value/1024, current->comm); MB_WARN("PREFETCH: Dynamic Allocated Not Support\n"); ret = -ENOTTY; #endif break; } /* _IOW (MB_IOC_MAGIC, 10, unsigned long) * O: static mba size */ case MBIO_STATIC_SIZE: put_user(wmt_mbah->tot_static_pages * PAGE_SIZE, (unsigned long *)arg); MB_OPDBG("STATIC_SIZE: size %ld KB\n\n", PAGE_KB(wmt_mbah->tot_static_pages)); break; /* _IOWR(MB_IOC_MAGIC,11, unsigned long) * I: physical address * O: use counter */ case MBIO_MB_USER_COUNT: get_user(value, (unsigned long *)arg); spin_lock_irqsave(&mb_ioctl_lock, flags); mb = mb_find_mb((void *)value, MBFIND_PHYS); if (mb == NULL) size = 0; else size = MB_COUNT(mb); spin_unlock_irqrestore(&mb_ioctl_lock, flags); put_user(size, (unsigned long *)arg); MB_OPDBG("USER_COUNT: addr %lx count %ld\n\n", value, size); break; /* _IO (MB_IOC_MAGIC,12) */ case MBIO_FORCE_RESET: spin_lock_irqsave(&mb_ioctl_lock, flags); RESCAN_MBA: list_loop(mba, &wmt_mbah->mba_list, mba_list) { list_loop(mb, &mba->mb_list, mb_list) { list_loop( mbu, &mb->mbu_list, mbu_list) { list_del(&mbu->mbu_list); kmem_cache_free( wmt_mbah->mbu_cachep, mbu); } mb->creator = NULL; atomic_set(&mb->count, 0); mb_free_mb(mb); /* because mba link maybe breaken */ goto RESCAN_MBA; } } mb_update_mbah(); spin_unlock_irqrestore(&mb_ioctl_lock, flags); MB_OPDBG("RESET: OK\n\n"); break; /* _IOW (MB_IOC_MAGIC,13, unsigned long) // I: phys address */ case MBIO_GET_BY_PHYS: get_user(value, (unsigned long *)arg); if (!value || !mbti->task_name || tgid == MB_DEF_TGID) { MB_WARN("GET(phys): invalid args %lx/%d/%s\n", value, tgid, mbti->task_name); return -EINVAL; } mbu = kmem_cache_alloc(wmt_mbah->mbu_cachep, GFP_ATOMIC); if (!mbu) { MB_WARN("GET(phys): mbu_cachep out of memory\n"); return -ENOMEM; } spin_lock_irqsave(&mb_do_lock, flags); mb = mb_find_mb((void *)value, MBFIND_PHYS); if (!mb) { spin_unlock_irqrestore(&mb_do_lock, flags); kmem_cache_free(wmt_mbah->mbu_cachep, mbu); MB_WARN("GET(phys): unknown phys %8lx name %s\n", value, mbti->task_name); return -EFAULT; } memset(mbu, 0x0, sizeof(struct mb_user)); INIT_LIST_HEAD(&mbu->mbu_list); mbu->addr = value; mbu->mb = mb; mbu->tgid = tgid; len = strlen(mbti->task_name); if (len > TASK_COMM_LEN) len = TASK_COMM_LEN; strncpy(mbu->the_user, mbti->task_name, len); mbu->the_user[len] = 0; atomic_inc(&mb->count); list_add_tail(&mbu->mbu_list, &mb->mbu_list); spin_unlock_irqrestore(&mb_do_lock, flags); MB_OPDBG("GET(phys): phys %8lx cnt %x\n\n", value, MB_COUNT(mb)); break; /* _IOW (MB_IOC_MAGIC,14, unsigned long) // I: phys address */ case MBIO_PUT_BY_PHYS: get_user(value, (unsigned long *)arg); if (!value || !mbti->task_name || tgid == MB_DEF_TGID) { MB_WARN("PUT(phys): invalid args %lx/%d/%s\n", value, tgid, mbti->task_name); return -EINVAL; } spin_lock_irqsave(&mb_do_lock, flags); mbu = mb_find_mbu((void *)value, tgid, MBUFIND_PHYS|MBUFIND_GETPUT); if (!mbu) { spin_unlock_irqrestore(&mb_do_lock, flags); MB_WARN("PUT(phys): unknow phys %8lx name %s\n", value, mbti->task_name); return -EINVAL; } mb = mbu->mb; if (!MB_IN_USE(mb)) { spin_unlock_irqrestore(&mb_do_lock, flags); MB_WARN("PUT(phys): phys %8lx unbalance.\n", value); return -EPERM; } list_del_init(&mbu->mbu_list); atomic_dec(&mb->count); size = MB_COUNT(mb); /* retrieve unused block */ if (!size) mb_free_mb(mb); spin_unlock_irqrestore(&mb_do_lock, flags); kmem_cache_free(wmt_mbah->mbu_cachep, mbu); MB_OPDBG("PUT(phys): phys %8lx cnt %lx\n\n", value, size); break; /* _IOW (MB_IOC_MAGIC,15, unsigned long) // I: user address */ case MBIO_SYNC_CACHE: get_user(value, (unsigned long *)arg); spin_lock_irqsave(&mb_ioctl_lock, flags); mbu = mb_find_mbu((void *)value, tgid, MBUFIND_USER|MBUFIND_MMAP); if (mbu == NULL) { spin_unlock_irqrestore(&mb_ioctl_lock, flags); MB_WARN("SYNC_CACHE: invalid addr %lx\n\n", value); return -EFAULT; } mb = mbu->mb; size = mbu->size; dmac_flush_range(mb->virt, mb->virt + size); outer_flush_range(mb->phys, mb->phys + size); MB_OPDBG("SYNC_CACHE: (%lx # %lx) V %p ~ %p P %lx ~ %lx\n\n", value, size, mb->virt, mb->virt + size, mb->phys, mb->phys + size); spin_unlock_irqrestore(&mb_ioctl_lock, flags); return 0; /* _IOW(MB_IOC_MAGIC, 19, unsigned long) // I: phys address */ case MBIO_STATIC_GET: get_user(value, (unsigned long *)arg); if (!value || !mbti->task_name || tgid == MB_DEF_TGID) { MB_WARN("GET(STATIC): invalid args %lx/%d/%s\n", value, tgid, mbti->task_name); return -EINVAL; } ret = mb_do_get(value, MB_DEF_TGID, mbti->task_name); if (ret != 0) MB_WARN("GET(STATIC): fail (args %lx/%d/%s). ret %d\n", value, tgid, mbti->task_name, ret); MB_OPDBG("GET(STATIC): phys %8lx done\n\n", value); break; /* _IOW(MB_IOC_MAGIC, 20, unsigned long) // I: phys address */ case MBIO_STATIC_PUT: get_user(value, (unsigned long *)arg); if (!value || !mbti->task_name || tgid == MB_DEF_TGID) { MB_WARN("PUT(STATIC): invalid args %lx/%d/%s\n", value, tgid, mbti->task_name); return -EINVAL; } ret = mb_do_put(value, MB_DEF_TGID, mbti->task_name); if (ret != 0) MB_WARN("PUT(STATIC): fail (args %lx/%d/%s). ret %d\n", value, tgid, mbti->task_name, ret); MB_OPDBG("PUT(STATIC): phys %8lx done\n\n", value); break; /* _IOWR(MB_IOC_MAGIC, 100, unsigned long) I: user address O: physical address */ case MBIO_TEST_USER2PHYS: get_user(value, (unsigned long *)arg); if (!value) { MB_WARN("USER2PHYS: invalid args %lx/%d/%s\n", value, tgid, mbti->task_name); return -EINVAL; } phys = user_to_phys(value); put_user(phys, (unsigned long *)arg); if (!phys) MB_WARN("USER2PHYS fail: value %#lx phys %#lx\n", value, phys); break; /* _IOWR(MB_IOC_MAGIC, 101, unsigned long) I: user address, size, prdt addr, and prdt size */ case MBIO_TEST_USER2PRDT: /* _IOW(MB_IOC_MAGIC, 103, unsigned long) * I: user address, size, prdt addr, and prdt size */ case MBIO_TEST_MB2PRDT: { int items, type = (cmd == MBIO_TEST_MB2PRDT) ? 0 : 1; unsigned long size, data[4] = {0}; struct prdt_struct *prdt; copy_from_user(data, (const void *)arg, 4 * sizeof(unsigned long)); if (!data[0] || !data[1] || !data[2] || !data[3]) { MB_WARN("%s: invalid args [%#lx, %#lx, %#lx, %#lx]\n", type ? "MB2PRDT" : "USER2PRDT", data[0], data[1], data[2], data[3]); return -EINVAL; } items = data[1] / PAGE_SIZE + 2; size = items * sizeof(struct prdt_struct); if (data[3] < size) { MB_WARN("%s: invalid args. prdt size %#lx < %#lx\n", type ? "MB2PRDT" : "USER2PRDT", data[3], size); return -EINVAL; } prdt = kmalloc(size, GFP_ATOMIC); if (prdt == NULL) { MB_WARN("%s: fail, no prdt space %d for size %ld\n", type ? "MB2PRDT" : "USER2PRDT", items * sizeof(struct prdt_struct), data[1]); return -EINVAL; } MB_DBG("%s: IN %#lx, %#lx, %#lx, %#lx\n", type ? "MB2PRDT" : "USER2PRDT", data[0], data[1], data[2], data[3]); memset(prdt, 0x0, items * sizeof(struct prdt_struct)); if ((!type && !mb_to_prdt(data[0], data[1], prdt, items)) || (!user_to_prdt(data[0], data[1], prdt, items))) { if (MBMSG_LEVEL) show_prdt(prdt); copy_to_user((void __user *)data[2], prdt, size); MB_INFO("%s: Done %#lx, %#lx, %#lx, %#lx\n", type ? "MB2PRDT" : "USER2PRDT", data[0], data[1], data[2], data[3]); } else { MB_WARN("%s: fail.\n", type ? "MB2PRDT" : "USER2PRDT"); ret = -EINVAL; } kfree(prdt); break; } /* _IOWR(MB_IOC_MAGIC, 102, unsigned long) I: user address, size, mmu addr, and mmu size O: mmu physical addr */ case MBIO_TEST_USER2MMUT: /* _IOWR(MB_IOC_MAGIC, 104, unsigned long) I: user address, size, mmu addr, and mmu size O: mmu physical addr */ case MBIO_TEST_MB2MMUT: { int type = (cmd == MBIO_TEST_MB2MMUT) ? 0 : 1; unsigned long mmuSize, data[4] = {0}; struct mmu_table_info info = {0}; copy_from_user(data, (const void *)arg, 4 * sizeof(unsigned long)); if (!data[0] || !data[1] || !data[2] || !data[3]) { MB_WARN("%s: invalid args [%#lx, %#lx, %#lx, %#lx]\n", type ? "USER2MMUT" : "PHYS2MMUT", data[0], data[1], data[2], data[3]); return -EINVAL; } mmuSize = wmt_mmu_table_size(data[1]); if (data[3] < mmuSize) { MB_WARN("%s: invalid args. mmu size %#lx < %#lx\n", type ? "MB2PRDT" : "USER2PRDT", data[3], mmuSize); return -EINVAL; } MB_DBG("%s: IN %#lx, %#lx, %#lx, %#lx(req %#lx)\n", type ? "USER2MMUT" : "PHYS2MMUT", data[0], data[1], data[2], data[3], mmuSize); if (wmt_mmu_table_create(data[0], data[1], type, &info) == 0) { void *mmuAddr = mb_phys_to_virt((unsigned long)info.addr); if (MBMSG_LEVEL) wmt_mmu_table_dump(&info); copy_to_user((void __user *)data[2], mmuAddr, mmuSize); put_user(info.addr, (unsigned long *)arg); ret = mb_do_get(info.addr, MB_DEF_TGID, mbti->task_name); wmt_mmu_table_destroy(&info); MB_INFO("%s: Done %#lx, %#lx, %#lx, %#lx\n", type ? "USER2MMUT" : "PHYS2MMUT", data[0], data[1], data[2], data[3]); } else { MB_WARN("%s: fail. no mmu table space for size %ld\n", type ? "USER2MMUT" : "PHYS2MMUT", data[1]); return -EINVAL; } break; } default: ret = -ENOTTY; break; } return ret; } static int mb_mmap(struct file *filp, struct vm_area_struct *vma) { struct mb_user *mbu = NULL; struct mb_task_info *mbti; struct mb_struct *mb; unsigned long off, flags; unsigned int len; pid_t tgid; size_t ns; if (!filp || !filp->private_data) { MB_ERROR("mmap with null file info or task.\n"); return -EFAULT; } mbti = (struct mb_task_info *)(filp->private_data); tgid = mbti->tgid; if (tgid != current->tgid) { MB_WARN("mmap within diff task.\n"); MB_WARN("Open: task %s TGID %x VS Curr: task %s TGID %x\n", mbti->task_name, tgid, current->comm, current->tgid); } off = vma->vm_pgoff << PAGE_SHIFT; MB_DBG("IN, offset %lx TGID %x name %s\n", off, tgid, mbti->task_name); #ifdef CONFIG_WMT_MB_RESERVE_FROM_IO /* if page offset under MB total size, it means page offset * is not physical address from MB_alloc and then map function * works like framebuffer. * Suppose MB total size will not cross MBAH phys start address */ if (vma->vm_pgoff <= wmt_mbah->tot_static_pages) { struct mb_area_struct *mba = NULL; unsigned long mbtotal = wmt_mbah->tot_static_pages << PAGE_SHIFT; if ((vma->vm_end - vma->vm_start + off) > mbtotal) { MB_ERROR("mmap io fail. range %lx @ [%lx, %lx] s %lx\n", off, vma->vm_start, vma->vm_end, mbtotal); return -EINVAL; } mba = (struct mb_area_struct *)wmt_mbah->mba_list.next; vma->vm_pgoff += mba->phys >> PAGE_SHIFT; vma->vm_flags |= VM_IO | VM_RESERVED; if (io_remap_pfn_range(vma, vma->vm_start, vma->vm_pgoff, vma->vm_end - vma->vm_start, vma->vm_page_prot)) { MB_ERROR("mmap io fail. (io_remap pfn %lx len %lx)\n", vma->vm_pgoff, vma->vm_end - vma->vm_start); return -EAGAIN; } MB_OPDBG("MAP: IO from %lx to %lx/%lx size %ld\n\n", vma->vm_pgoff << PAGE_SHIFT, vma->vm_start, vma->vm_end, vma->vm_end - vma->vm_start); return 0; } #endif mbu = kmem_cache_alloc(wmt_mbah->mbu_cachep, GFP_ATOMIC); if (!mbu) { MB_ERROR("mbu_cachep out of memory.\n"); return -ENOMEM; } spin_lock_irqsave(&mb_ioctl_lock, flags); mb = mb_find_mb((void *)off, MBFIND_PHYS); if (!mb) { spin_unlock_irqrestore(&mb_ioctl_lock, flags); kmem_cache_free(wmt_mbah->mbu_cachep, mbu); MB_ERROR("map addr %lx not exist in MB.\n", off); return -EINVAL; } len = PAGE_ALIGN(mb->phys + mb->size); if ((vma->vm_end - vma->vm_start + off) > len) { spin_unlock_irqrestore(&mb_ioctl_lock, flags); kmem_cache_free(wmt_mbah->mbu_cachep, mbu); return -EINVAL; } memset(mbu, 0x0, sizeof(struct mb_user)); INIT_LIST_HEAD(&mbu->mbu_list); mbu->tgid = tgid; mbu->mb = mb; mbu->addr = vma->vm_start; mbu->size = vma->vm_end - vma->vm_start; ns = strlen(mbti->task_name); if (ns > TASK_COMM_LEN) ns = TASK_COMM_LEN; strncpy(mbu->the_user, mbti->task_name, ns); mbu->the_user[ns] = 0; list_add_tail(&mbu->mbu_list, &mb->mbu_list); atomic_inc(&mb->count); off = mb->phys; spin_unlock_irqrestore(&mb_ioctl_lock, flags); vma->vm_flags |= VM_IO | VM_RESERVED; if (!(mb->flags & MBFLAG_CACHED)) vma->vm_page_prot = pgprot_writecombine(vma->vm_page_prot); if (io_remap_pfn_range(vma, vma->vm_start, vma->vm_pgoff, vma->vm_end - vma->vm_start, vma->vm_page_prot)) { spin_lock_irqsave(&mb_ioctl_lock, flags); list_del(&mbu->mbu_list); atomic_dec(&mb->count); kmem_cache_free(wmt_mbah->mbu_cachep, mbu); spin_unlock_irqrestore(&mb_ioctl_lock, flags); MB_ERROR("virtual address memory map fail.\n"); return -EAGAIN; } MB_OPDBG("MAP: IO from %lx to %lx/%lx size %ld mbcnt %d\n\n", off, vma->vm_start, vma->vm_end, (vma->vm_end - vma->vm_start), MB_COUNT(mb)); return 0; } /*!************************************************************************* driver file operations struct define ****************************************************************************/ const struct file_operations mb_fops = { .owner = THIS_MODULE, .open = mb_open, .release = mb_release, .unlocked_ioctl = mb_ioctl, .mmap = mb_mmap, }; static int mb_probe(struct platform_device *dev) { struct mb_area_struct *mba = NULL, *bind = NULL; unsigned long flags; int ret = 0; dev_t dev_no; dev_no = MKDEV(mb_dev_major, mb_dev_minor); if (wmt_mbah) { MB_ERROR("%s dirty.\n", DEVICE_NAME); return -EINVAL; } /* register char device */ mb_cdev = cdev_alloc(); if (!mb_cdev) { MB_ERROR("alloc dev error.\n"); return -ENOMEM; } cdev_init(mb_cdev, &mb_fops); ret = cdev_add(mb_cdev, dev_no, 1); if (ret) { MB_ERROR("reg char dev error(%d).\n", ret); cdev_del(mb_cdev); return ret; } wmt_mbah = kmalloc(sizeof(struct mba_host_struct), GFP_ATOMIC); if (!wmt_mbah) { MB_ERROR("out of memory (mb_area_struct).\n"); cdev_del(mb_cdev); return -ENOMEM; } memset(wmt_mbah, 0x0, sizeof(struct mba_host_struct)); wmt_mbah->mba_cachep = kmem_cache_create("mb_area_struct", sizeof(struct mb_area_struct), 0, SLAB_HWCACHE_ALIGN, NULL); if (!wmt_mbah->mba_cachep) { MB_ERROR("out of memory (mba_cachep).\n"); kfree(wmt_mbah); cdev_del(mb_cdev); return -ENOMEM; } wmt_mbah->mb_cachep = kmem_cache_create("mb_struct", sizeof(struct mb_struct), 0, SLAB_HWCACHE_ALIGN, NULL); if (!wmt_mbah->mb_cachep) { MB_ERROR("out of memory (mb_cachep).\n"); kmem_cache_destroy(wmt_mbah->mba_cachep); kfree(wmt_mbah); cdev_del(mb_cdev); return -ENOMEM; } wmt_mbah->mbu_cachep = kmem_cache_create("mb_user", sizeof(struct mb_user), 0, SLAB_HWCACHE_ALIGN, NULL); if (!wmt_mbah->mbu_cachep) { MB_ERROR("out of memory (mbu_cachep).\n"); kmem_cache_destroy(wmt_mbah->mb_cachep); kmem_cache_destroy(wmt_mbah->mba_cachep); kfree(wmt_mbah); cdev_del(mb_cdev); return -ENOMEM; } wmt_mbah->mbti_cachep = kmem_cache_create("mb_task_info", sizeof(struct mb_task_info), 0, SLAB_HWCACHE_ALIGN, NULL); if (!wmt_mbah->mbti_cachep) { MB_ERROR("out of memory (mbti_cachep).\n"); kmem_cache_destroy(wmt_mbah->mbu_cachep); kmem_cache_destroy(wmt_mbah->mb_cachep); kmem_cache_destroy(wmt_mbah->mba_cachep); kfree(wmt_mbah); cdev_del(mb_cdev); return -ENOMEM; } MBMAX_ORDER = MBA_MAX_ORDER; MBMIN_ORDER = MBA_MIN_ORDER; INIT_LIST_HEAD(&wmt_mbah->mba_list); INIT_LIST_HEAD(&wmt_mbti.mbti_list); spin_lock_init(&mb_do_lock); spin_lock_init(&mb_search_lock); spin_lock_init(&mb_ioctl_lock); spin_lock_init(&mb_task_mm_lock); spin_lock_init(&mb_task_lock); MB_INFO("Preparing VIDEO BUFFER (SIZE %d kB) ...\n", MB_TOTAL_SIZE); spin_lock_irqsave(&mb_do_lock, flags); while (PAGE_KB(wmt_mbah->tot_static_pages) < MB_TOTAL_SIZE) { int pages = MB_TOTAL_SIZE*1024 - wmt_mbah->tot_static_pages * PAGE_SIZE; pages = min((pages >> PAGE_SHIFT), (int)(1 << MBMAX_ORDER)); mba = mb_alloc_mba(pages); if (mba) { mba->flags |= MBAFLAG_STATIC; mba->tgid = MB_DEF_TGID; wmt_mbah->tot_static_pages += mba->pages; /* conbine to continue mba if possible */ if (bind && bind->pgi.pfn_end == mba->pgi.pfn_start) { MB_COMBIND_MBA(bind, mba); continue; } if (bind && bind->pgi.pfn_start == mba->pgi.pfn_end) MB_COMBIND_MBA(mba, bind); bind = mba; } } spin_unlock_irqrestore(&mb_do_lock, flags); mb_update_mbah(); MB_INFO("MB version: %d.%d.%d.%d\n", MB_VERSION_MAJOR, MB_VERSION_MINOR, MB_VERSION_MICRO, MB_VERSION_BUILD); MB_INFO("MAX MB Area size: Max %ld Kb Min %ld Kb\n", PAGE_KB(1 << MBMAX_ORDER), PAGE_KB(1 << MBMIN_ORDER)); MB_INFO("prob /dev/%s major %d, minor %d\n", DEVICE_NAME, mb_dev_major, mb_dev_minor); return ret; } static int mb_remove(struct platform_device *dev) { if (mb_cdev) cdev_del(mb_cdev); if (wmt_mbah) { if (wmt_mbah->mba_cachep) kmem_cache_destroy(wmt_mbah->mba_cachep); if (wmt_mbah->mb_cachep) kmem_cache_destroy(wmt_mbah->mb_cachep); if (wmt_mbah->mbu_cachep) kmem_cache_destroy(wmt_mbah->mbu_cachep); if (wmt_mbah->mbti_cachep) kmem_cache_destroy(wmt_mbah->mbti_cachep); kfree(wmt_mbah); } MB_INFO("MB dev remove\n"); return 0; } static int mb_suspend(struct platform_device *dev, pm_message_t state) { MB_DBG("MB get suspend, Event %d.\n", state.event); return 0; } static int mb_resume(struct platform_device *dev) { MB_DBG("MB get resume.\n"); return 0; } int mb_area_read_proc( char *buf, char **start, off_t off, int count, int *eof, void *data ) { struct mb_area_struct *mba; struct free_area *fa; struct zone *zone; unsigned long flags; unsigned int idx = 1; char *p = buf, *base = (char *)data; int datalen = 0, len; if (!data || !count) { p += sprintf(p, "no resource for mb_area read proc. (%p,%d)\n", data, count); return p-buf; } if (!wmt_mbah) { p += sprintf(p, "no MB area host existed.\n"); return p-buf; } spin_lock_irqsave(&mb_ioctl_lock, flags); if (!off) { /* re read mb area information */ p = base; memset(p, 0x0, MBPROC_BUFSIZE); /* show block information */ p += sprintf(p, "VERSION: %3d.%3d.%3d.%3d\n", MB_VERSION_MAJOR, MB_VERSION_MINOR, MB_VERSION_MICRO, MB_VERSION_BUILD); p += sprintf(p, "MESSAGE LEVEL: %8d /%8lx\n", MBMSG_LEVEL, __pa(&MBMSG_LEVEL)); p += sprintf(p, "STATIC MB SIZE: %8ld MB /%5d MB\n", PAGE_KB(wmt_mbah->tot_static_pages)/1024, MB_TOTAL_SIZE/1024); p += sprintf(p, "MAX MBA ORDER: %8d /%8lx\n", MBMAX_ORDER, __pa(&MBMAX_ORDER)); p += sprintf(p, "MIN MBA ORDER: %8d /%8lx\n\n", MBMIN_ORDER, __pa(&MBMIN_ORDER)); p += sprintf(p, "USER TO PRDT METHOD: %8d /%8lx\n\n", USR2PRDT_METHOD, __pa(&USR2PRDT_METHOD)); p += sprintf(p, "total MB areas: %8d\n", wmt_mbah->nr_mba); p += sprintf(p, "total size: %8ld kB\n", PAGE_KB(wmt_mbah->tot_pages)); p += sprintf(p, "total free size: %8ld kB\n", PAGE_KB(wmt_mbah->tot_free_pages)); p += sprintf(p, "max MB size: %8ld kB\n\n", PAGE_KB(wmt_mbah->max_available_pages)); list_loop(mba, &wmt_mbah->mba_list, mba_list) { p += sprintf(p, "(ID) [MB Area] VirtAddr PhysAddr "); p += sprintf(p, "size [ zs, ze] MBs Max/"); p += sprintf(p, " Free Ste\n"); len = (int)(p-base); if ((MBPROC_BUFSIZE - len) < 12) { p += sprintf(p, " more ...\n"); break; } p += sprintf(p, "(%2d)", idx++); len = (int)(p-base); /* show all MBs */ /* -2 is for \n and zero */ p += mb_show_mba(mba, NULL, p, MBPROC_BUFSIZE - len - 2, 1); p += sprintf(p, "\n"); } /* show memory fragment */ zone = (first_online_pgdat())->node_zones; fa = zone->free_area; p += sprintf(p, "DMA ZONE:\n"); for (idx = 0; idx < MAX_ORDER; idx++) p += sprintf(p, " %5ld * %5ldkB = %5ld kB\n", fa[idx].nr_free, PAGE_KB((1<= datalen) { *eof = 1; return 0; } len = min((int)(datalen - off), count); memcpy(buf, &base[off], len); *start = (char *)len; /* for case1: *start < page, mass read data */ return len; } static struct platform_driver mb_driver = { .driver.name = "wmt_mb", .probe = mb_probe, .remove = mb_remove, .suspend = mb_suspend, .resume = mb_resume }; static void mb_platform_release(struct device *device) { return; } static struct platform_device mb_device = { .name = "wmt_mb", .id = 0, .dev = { .release = mb_platform_release, }, .num_resources = 0, .resource = NULL, }; static int __init mb_init(void) { int varlen = 32, ret = -1, mbtotal = 0; unsigned char buf[32]; dev_t dev_no; mb_dev_major = MB_MAJOR; mb_dev_minor = 0; mb_dev_nr = 1; dev_no = MKDEV(mb_dev_major, mb_dev_minor); ret = register_chrdev_region(dev_no, mb_dev_nr, "wmt_mb"); if (ret < 0) { MB_ERROR("can't get %s device major %d\n", DEVICE_NAME, mb_dev_major); return ret; } if (wmt_getsyspara("mbsize", buf, &varlen) == 0) { sscanf(buf, "%dM", &mbtotal); mbtotal *= 1024; MB_INFO("Set MB total size %d KB\n", mbtotal); if (mbtotal > 0) MB_TOTAL_SIZE = mbtotal; } wmt_mbah = NULL; MBMSG_LEVEL = MBMAX_ORDER = MBMIN_ORDER = USR2PRDT_METHOD = 0; mb_dev_class = class_create(THIS_MODULE, "mbdev"); device_create(mb_dev_class, NULL, dev_no, NULL, "mbdev"); #ifdef CONFIG_PROC_FS { void *proc_buffer = kmalloc(MBPROC_BUFSIZE, GFP_KERNEL); struct proc_dir_entry *res = NULL; if (proc_buffer) { memset(proc_buffer, 0x0, MBPROC_BUFSIZE); res = create_proc_entry("mbinfo", 0, NULL); if (res) { res->read_proc = mb_area_read_proc; res->data = proc_buffer; MB_DBG("create MB proc\n"); } else kfree(proc_buffer); } } #endif ret = platform_driver_register(&mb_driver); if (!ret) { ret = platform_device_register(&mb_device); if (ret) platform_driver_unregister(&mb_driver); } return ret; } /* because mb will not exit from system, not need to release proc resource */ static void __exit mb_exit(void) { dev_t dev_no; platform_driver_unregister(&mb_driver); platform_device_unregister(&mb_device); dev_no = MKDEV(mb_dev_major, mb_dev_minor); device_destroy(mb_dev_class, dev_no); class_destroy(mb_dev_class); unregister_chrdev_region(dev_no, mb_dev_nr); return; } fs_initcall(mb_init); module_exit(mb_exit); MODULE_AUTHOR("WonderMedia Technologies, Inc."); MODULE_DESCRIPTION("memory block driver"); MODULE_LICENSE("GPL");