drivers/frame_provider/decoder/utils/decoder_mmu_box.c - manifest_repos/media_modules - Git at Google

 /*
  * drivers/amlogic/media/frame_provider/decoder/utils/decoder_mmu_box.c
  *
  * Copyright (C) 2016 Amlogic, Inc. All rights reserved.
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License 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.
  *
  */

 #include <linux/kernel.h>
 #include <linux/module.h>
 #include <linux/types.h>
 #include <linux/errno.h>
 #include <linux/interrupt.h>
 #include <linux/semaphore.h>
 #include <linux/delay.h>
 #include <linux/timer.h>
 #include <linux/kfifo.h>
 #include <linux/kthread.h>
 #include <linux/slab.h>
 #include <linux/amlogic/media/codec_mm/codec_mm_scatter.h>
 #include <linux/platform_device.h>
 struct decoder_mmu_box {
 	int max_sc_num;
 	const char *name;
 	int channel_id;
 	int tvp_mode;
 	struct mutex mutex;
 	struct list_head list;
 	struct codec_mm_scatter *sc_list[1];
 };
 #define MAX_KEEP_FRAME 4
 #define START_KEEP_ID 0x9
 #define MAX_KEEP_ID    (INT_MAX - 1)
 struct decoder_mmu_box_mgr {
 	int num;
 	struct mutex mutex;
 	struct codec_mm_scatter *keep_sc[MAX_KEEP_FRAME];
 	int	keep_id[MAX_KEEP_FRAME];
 	int next_id;/*id for keep & free.*/
 	struct list_head box_list;
 };
 static struct decoder_mmu_box_mgr global_mgr;
 static struct decoder_mmu_box_mgr *get_decoder_mmu_box_mgr(void)
 {
 	return &global_mgr;
 }

 static int decoder_mmu_box_mgr_add_box(struct decoder_mmu_box *box)
 {
 	struct decoder_mmu_box_mgr *mgr = get_decoder_mmu_box_mgr();

 	mutex_lock(&mgr->mutex);
 	list_add_tail(&box->list, &mgr->box_list);
 	mutex_unlock(&mgr->mutex);
 	return 0;
 }

 static int decoder_mmu_box_mgr_del_box(struct decoder_mmu_box *box)
 {
 	struct decoder_mmu_box_mgr *mgr = get_decoder_mmu_box_mgr();

 	mutex_lock(&mgr->mutex);
 	list_del(&box->list);
 	mutex_unlock(&mgr->mutex);
 	return 0;
 }

 int decoder_mmu_box_sc_check(void *handle, int is_tvp)
 {
 	struct decoder_mmu_box *box = handle;
 	if (!box) {
 			pr_err("mmu box NULL !!!\n");
 			return 0;
 	}
 	return codec_mm_scatter_size(is_tvp);
 }
 EXPORT_SYMBOL(decoder_mmu_box_sc_check);


 void *decoder_mmu_box_alloc_box(const char *name,
 	int channel_id,
 	int max_num,
 	int min_size_M,
 	int mem_flags)
 /*min_size_M:wait alloc this size*/
 {
 	struct decoder_mmu_box *box;
 	int size;

 	pr_debug("decoder_mmu_box_alloc_box, mem_flags = 0x%x\n", mem_flags);

 	size = sizeof(struct decoder_mmu_box) +
 			sizeof(struct codec_mm_scatter *) *
 			max_num;
 	box = kmalloc(size, GFP_KERNEL);
 	if (!box) {
 		pr_err("can't alloc decoder buffers box!!!\n");
 		return NULL;
 	}
 	memset(box, 0, size);
 	box->max_sc_num = max_num;
 	box->name = name;
 	box->channel_id = channel_id;
 	box->tvp_mode = mem_flags;

 	mutex_init(&box->mutex);
 	INIT_LIST_HEAD(&box->list);
 	decoder_mmu_box_mgr_add_box(box);
 	codec_mm_scatter_mgt_delay_free_switch(1, 2000,
 		min_size_M, box->tvp_mode);
 	return (void *)box;
 }
 EXPORT_SYMBOL(decoder_mmu_box_alloc_box);

 int decoder_mmu_box_alloc_idx(
 	void *handle, int idx, int num_pages,
 	unsigned int *mmu_index_adr)
 {
 	struct decoder_mmu_box *box = handle;
 	struct codec_mm_scatter *sc;
 	int ret;
 	int i;

 	if (!box || idx < 0 || idx >= box->max_sc_num) {
 		pr_err("can't alloc mmu box(%p),idx:%d\n",
 			box, idx);
 		return -1;
 	}
 	mutex_lock(&box->mutex);
 	sc = box->sc_list[idx];
 	if (sc) {
 		if (sc->page_max_cnt >= num_pages)
 			ret = codec_mm_scatter_alloc_want_pages(sc,
 				num_pages);
 		else {
 			codec_mm_scatter_dec_owner_user(sc, 0);
 			box->sc_list[idx] = NULL;
 			sc = NULL;
 		}

 	}
 	if (!sc) {
 		sc = codec_mm_scatter_alloc(num_pages + 64, num_pages,
 			box->tvp_mode);
 		if (!sc) {
 			mutex_unlock(&box->mutex);
 			pr_err("alloc mmu failed, need pages=%d\n",
 				num_pages);
 			return -1;
 		}
 		box->sc_list[idx] = sc;
 	}

 	for (i = 0; i < num_pages; i++)
 		mmu_index_adr[i] = PAGE_INDEX(sc->pages_list[i]);

 	mutex_unlock(&box->mutex);

 	return 0;
 }
 EXPORT_SYMBOL(decoder_mmu_box_alloc_idx);

 int decoder_mmu_box_free_idx_tail(
 		void *handle, int idx,
 		int start_release_index)
 {
 	struct decoder_mmu_box *box = handle;
 	struct codec_mm_scatter *sc;

 	if (!box || idx < 0 || idx >= box->max_sc_num) {
 		pr_err("can't free tail mmu box(%p),idx:%d in (%d-%d)\n",
 			box, idx, 0,
 			box ? (box->max_sc_num - 1) : 0);
 		return -1;
 	}
 	mutex_lock(&box->mutex);
 	sc = box->sc_list[idx];
 	if (sc && start_release_index < sc->page_cnt)
 		codec_mm_scatter_free_tail_pages_fast(sc,
 				start_release_index);
 	mutex_unlock(&box->mutex);
 	return 0;
 }
 EXPORT_SYMBOL(decoder_mmu_box_free_idx_tail);

 int decoder_mmu_box_free_idx(void *handle, int idx)
 {
 	struct decoder_mmu_box *box = handle;
 	struct codec_mm_scatter *sc;

 	if (!box || idx < 0 || idx >= box->max_sc_num) {
 		pr_err("can't free idx of box(%p),idx:%d  in (%d-%d)\n",
 			box, idx, 0,
 			box ? (box->max_sc_num - 1) : 0);
 		return -1;
 	}

 	mutex_lock(&box->mutex);
 	sc = box->sc_list[idx];
 	if (sc && sc->page_cnt > 0) {
 		codec_mm_scatter_dec_owner_user(sc, 0);
 		box->sc_list[idx] = NULL;
 	}

 	mutex_unlock(&box->mutex);

 	return 0;
 }
 EXPORT_SYMBOL(decoder_mmu_box_free_idx);

 int decoder_mmu_box_free(void *handle)
 {
 	struct decoder_mmu_box *box = handle;
 	struct codec_mm_scatter *sc;
 	int i;

 	if (!box) {
 		pr_err("can't free box of NULL box!\n");
 		return -1;
 	}

 	mutex_lock(&box->mutex);
 	for (i = 0; i < box->max_sc_num; i++) {
 		sc = box->sc_list[i];
 		if (sc) {
 			codec_mm_scatter_dec_owner_user(sc, 0);
 			box->sc_list[i] = NULL;

 		}
 	}

 	codec_mm_scatter_mgt_delay_free_switch(0, 0, 0, box->tvp_mode);

 	mutex_unlock(&box->mutex);

 	decoder_mmu_box_mgr_del_box(box);
 	kfree(box);

 	return 0;
 }
 EXPORT_SYMBOL(decoder_mmu_box_free);

 void *decoder_mmu_box_get_mem_handle(void *box_handle, int idx)
 {
 	struct decoder_mmu_box *box = box_handle;

 	if (!box || idx < 0 || idx >= box->max_sc_num)
 		return NULL;
 	return  box->sc_list[idx];
 }
 EXPORT_SYMBOL(decoder_mmu_box_get_mem_handle);

 static int decoder_mmu_box_dump(struct decoder_mmu_box *box,
 				void *buf, int size)
 {
 	char *pbuf = buf;
 	char sbuf[512];
 	int tsize = 0;
 	int s;
 	int i;

 	if (!buf) {
 		pbuf = sbuf;
 		size = 512;
 	}
 	#define BUFPRINT(args...) \
 	do {\
 		s = snprintf(pbuf, size - tsize, args);\
 		tsize += s;\
 		pbuf += s; \
 	} while (0)

 	for (i = 0; i < box->max_sc_num; i++) {
 		struct codec_mm_scatter *sc = box->sc_list[i];

 		if (sc) {
 			BUFPRINT("sc mem[%d]:%p, size=%d\n",
 				i, sc,
 				sc->page_cnt << PAGE_SHIFT);
 		}
 	}
 #undef BUFPRINT
 	if (!buf)
 		pr_info("%s", sbuf);

 	return tsize;
 }

 static int decoder_mmu_box_dump_all(void *buf, int size)
 {
 	struct decoder_mmu_box_mgr *mgr = get_decoder_mmu_box_mgr();
 	char *pbuf = buf;
 	char sbuf[512];
 	int tsize = 0;
 	int s;
 	int i;
 	struct list_head *head, *list;

 	if (!pbuf) {
 		pbuf = sbuf;
 		size = 512;
 	}

 	#define BUFPRINT(args...) \
 	do {\
 		s = snprintf(pbuf, size - tsize, args);\
 		tsize += s;\
 		pbuf += s; \
 	} while (0)

 	mutex_lock(&mgr->mutex);
 	head = &mgr->box_list;
 	list = head->next;
 	i = 0;
 	while (list != head) {
 		struct decoder_mmu_box *box;
 		box = list_entry(list, struct decoder_mmu_box,
 							list);
 		BUFPRINT("box[%d]: %s, %splayer_id:%d, max_num:%d\n",
 			i,
 			box->name,
 			box->tvp_mode ? "TVP mode " : "",
 			box->channel_id,
 			box->max_sc_num);
 		if (buf) {
 			s += decoder_mmu_box_dump(box, pbuf, size - tsize);
 			if (s > 0) {
 				tsize += s;
 				pbuf += s;
 			}
 		} else {
 			pr_info("%s", sbuf);
 			pbuf = sbuf;
 			tsize += decoder_mmu_box_dump(box, NULL, 0);
 		}
 		list = list->next;
 		i++;
 	}
 	mutex_unlock(&mgr->mutex);


 #undef BUFPRINT
 	if (!buf)
 		pr_info("%s", sbuf);
 	return tsize;
 }


 static ssize_t
 box_dump_show(struct class *class,
 		       struct class_attribute *attr, char *buf)
 {
 	ssize_t ret = 0;

 	ret = decoder_mmu_box_dump_all(buf, PAGE_SIZE);
 	return ret;
 }

 static CLASS_ATTR_RO(box_dump);

 static struct attribute *decoder_mmu_box_class_attrs[] = {
 	&class_attr_box_dump.attr,
 	NULL
 };

 ATTRIBUTE_GROUPS(decoder_mmu_box_class);

 static struct class decoder_mmu_box_class = {
 	.name = "decoder_mmu_box",
 	.class_groups = decoder_mmu_box_class_groups,
 };

 int decoder_mmu_box_init(void)
 {
 	int r;

 	memset(&global_mgr, 0, sizeof(global_mgr));
 	INIT_LIST_HEAD(&global_mgr.box_list);
 	mutex_init(&global_mgr.mutex);
 	global_mgr.next_id = START_KEEP_ID;
 	r = class_register(&decoder_mmu_box_class);
 	return r;
 }
 EXPORT_SYMBOL(decoder_mmu_box_init);

 void decoder_mmu_box_exit(void)
 {
 	class_unregister(&decoder_mmu_box_class);
 	pr_info("dec mmu box exit.\n");
 }

 #if 0
 static int __init decoder_mmu_box_init(void)
 {
 	int r;

 	memset(&global_mgr, 0, sizeof(global_mgr));
 	INIT_LIST_HEAD(&global_mgr.box_list);
 	mutex_init(&global_mgr.mutex);
 	global_mgr.next_id = START_KEEP_ID;
 	r = class_register(&decoder_mmu_box_class);
 	return r;
 }

 module_init(decoder_mmu_box_init);
 #endif
	/*
	* drivers/amlogic/media/frame_provider/decoder/utils/decoder_mmu_box.c
	*
	* Copyright (C) 2016 Amlogic, Inc. All rights reserved.
	*
	* This program is free software; you can redistribute it and/or modify
	* it under the terms of the GNU General Public License 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.
	*
	*/

	#include <linux/kernel.h>
	#include <linux/module.h>
	#include <linux/types.h>
	#include <linux/errno.h>
	#include <linux/interrupt.h>
	#include <linux/semaphore.h>
	#include <linux/delay.h>
	#include <linux/timer.h>
	#include <linux/kfifo.h>
	#include <linux/kthread.h>
	#include <linux/slab.h>
	#include <linux/amlogic/media/codec_mm/codec_mm_scatter.h>
	#include <linux/platform_device.h>
	struct decoder_mmu_box {
	int max_sc_num;
	const char *name;
	int channel_id;
	int tvp_mode;
	struct mutex mutex;
	struct list_head list;
	struct codec_mm_scatter *sc_list[1];
	};
	#define MAX_KEEP_FRAME 4
	#define START_KEEP_ID 0x9
	#define MAX_KEEP_ID (INT_MAX - 1)
	struct decoder_mmu_box_mgr {
	int num;
	struct mutex mutex;
	struct codec_mm_scatter *keep_sc[MAX_KEEP_FRAME];
	int keep_id[MAX_KEEP_FRAME];
	int next_id;/id for keep & free./
	struct list_head box_list;
	};
	static struct decoder_mmu_box_mgr global_mgr;
	static struct decoder_mmu_box_mgr *get_decoder_mmu_box_mgr(void)
	{
	return &global_mgr;
	}

	static int decoder_mmu_box_mgr_add_box(struct decoder_mmu_box *box)
	{
	struct decoder_mmu_box_mgr *mgr = get_decoder_mmu_box_mgr();

	mutex_lock(&mgr->mutex);
	list_add_tail(&box->list, &mgr->box_list);
	mutex_unlock(&mgr->mutex);
	return 0;
	}

	static int decoder_mmu_box_mgr_del_box(struct decoder_mmu_box *box)
	{
	struct decoder_mmu_box_mgr *mgr = get_decoder_mmu_box_mgr();

	mutex_lock(&mgr->mutex);
	list_del(&box->list);
	mutex_unlock(&mgr->mutex);
	return 0;
	}

	int decoder_mmu_box_sc_check(void *handle, int is_tvp)
	{
	struct decoder_mmu_box *box = handle;
	if (!box) {
	pr_err("mmu box NULL !!!\n");
	return 0;
	}
	return codec_mm_scatter_size(is_tvp);
	}
	EXPORT_SYMBOL(decoder_mmu_box_sc_check);


	void decoder_mmu_box_alloc_box(const char name,
	int channel_id,
	int max_num,
	int min_size_M,
	int mem_flags)
	/min_size_M:wait alloc this size/
	{
	struct decoder_mmu_box *box;
	int size;

	pr_debug("decoder_mmu_box_alloc_box, mem_flags = 0x%x\n", mem_flags);

	size = sizeof(struct decoder_mmu_box) +
	sizeof(struct codec_mm_scatter )
	max_num;
	box = kmalloc(size, GFP_KERNEL);
	if (!box) {
	pr_err("can't alloc decoder buffers box!!!\n");
	return NULL;
	}
	memset(box, 0, size);
	box->max_sc_num = max_num;
	box->name = name;
	box->channel_id = channel_id;
	box->tvp_mode = mem_flags;

	mutex_init(&box->mutex);
	INIT_LIST_HEAD(&box->list);
	decoder_mmu_box_mgr_add_box(box);
	codec_mm_scatter_mgt_delay_free_switch(1, 2000,
	min_size_M, box->tvp_mode);
	return (void *)box;
	}
	EXPORT_SYMBOL(decoder_mmu_box_alloc_box);

	int decoder_mmu_box_alloc_idx(
	void *handle, int idx, int num_pages,
	unsigned int *mmu_index_adr)
	{
	struct decoder_mmu_box *box = handle;
	struct codec_mm_scatter *sc;
	int ret;
	int i;

	if (!box \|\| idx < 0 \|\| idx >= box->max_sc_num) {
	pr_err("can't alloc mmu box(%p),idx:%d\n",
	box, idx);
	return -1;
	}
	mutex_lock(&box->mutex);
	sc = box->sc_list[idx];
	if (sc) {
	if (sc->page_max_cnt >= num_pages)
	ret = codec_mm_scatter_alloc_want_pages(sc,
	num_pages);
	else {
	codec_mm_scatter_dec_owner_user(sc, 0);
	box->sc_list[idx] = NULL;
	sc = NULL;
	}

	}
	if (!sc) {
	sc = codec_mm_scatter_alloc(num_pages + 64, num_pages,
	box->tvp_mode);
	if (!sc) {
	mutex_unlock(&box->mutex);
	pr_err("alloc mmu failed, need pages=%d\n",
	num_pages);
	return -1;
	}
	box->sc_list[idx] = sc;
	}

	for (i = 0; i < num_pages; i++)
	mmu_index_adr[i] = PAGE_INDEX(sc->pages_list[i]);

	mutex_unlock(&box->mutex);

	return 0;
	}
	EXPORT_SYMBOL(decoder_mmu_box_alloc_idx);

	int decoder_mmu_box_free_idx_tail(
	void *handle, int idx,
	int start_release_index)
	{
	struct decoder_mmu_box *box = handle;
	struct codec_mm_scatter *sc;

	if (!box \|\| idx < 0 \|\| idx >= box->max_sc_num) {
	pr_err("can't free tail mmu box(%p),idx:%d in (%d-%d)\n",
	box, idx, 0,
	box ? (box->max_sc_num - 1) : 0);
	return -1;
	}
	mutex_lock(&box->mutex);
	sc = box->sc_list[idx];
	if (sc && start_release_index < sc->page_cnt)
	codec_mm_scatter_free_tail_pages_fast(sc,
	start_release_index);
	mutex_unlock(&box->mutex);
	return 0;
	}
	EXPORT_SYMBOL(decoder_mmu_box_free_idx_tail);

	int decoder_mmu_box_free_idx(void *handle, int idx)
	{
	struct decoder_mmu_box *box = handle;
	struct codec_mm_scatter *sc;

	if (!box \|\| idx < 0 \|\| idx >= box->max_sc_num) {
	pr_err("can't free idx of box(%p),idx:%d in (%d-%d)\n",
	box, idx, 0,
	box ? (box->max_sc_num - 1) : 0);
	return -1;
	}

	mutex_lock(&box->mutex);
	sc = box->sc_list[idx];
	if (sc && sc->page_cnt > 0) {
	codec_mm_scatter_dec_owner_user(sc, 0);
	box->sc_list[idx] = NULL;
	}

	mutex_unlock(&box->mutex);

	return 0;
	}
	EXPORT_SYMBOL(decoder_mmu_box_free_idx);

	int decoder_mmu_box_free(void *handle)
	{
	struct decoder_mmu_box *box = handle;
	struct codec_mm_scatter *sc;
	int i;

	if (!box) {
	pr_err("can't free box of NULL box!\n");
	return -1;
	}

	mutex_lock(&box->mutex);
	for (i = 0; i < box->max_sc_num; i++) {
	sc = box->sc_list[i];
	if (sc) {
	codec_mm_scatter_dec_owner_user(sc, 0);
	box->sc_list[i] = NULL;

	}
	}

	codec_mm_scatter_mgt_delay_free_switch(0, 0, 0, box->tvp_mode);

	mutex_unlock(&box->mutex);

	decoder_mmu_box_mgr_del_box(box);
	kfree(box);

	return 0;
	}
	EXPORT_SYMBOL(decoder_mmu_box_free);

	void decoder_mmu_box_get_mem_handle(void box_handle, int idx)
	{
	struct decoder_mmu_box *box = box_handle;

	if (!box \|\| idx < 0 \|\| idx >= box->max_sc_num)
	return NULL;
	return box->sc_list[idx];
	}
	EXPORT_SYMBOL(decoder_mmu_box_get_mem_handle);

	static int decoder_mmu_box_dump(struct decoder_mmu_box *box,
	void *buf, int size)
	{
	char *pbuf = buf;
	char sbuf[512];
	int tsize = 0;
	int s;
	int i;

	if (!buf) {
	pbuf = sbuf;
	size = 512;
	}
	#define BUFPRINT(args...) \
	do {\
	s = snprintf(pbuf, size - tsize, args);\
	tsize += s;\
	pbuf += s; \
	} while (0)

	for (i = 0; i < box->max_sc_num; i++) {
	struct codec_mm_scatter *sc = box->sc_list[i];

	if (sc) {
	BUFPRINT("sc mem[%d]:%p, size=%d\n",
	i, sc,
	sc->page_cnt << PAGE_SHIFT);
	}
	}
	#undef BUFPRINT
	if (!buf)
	pr_info("%s", sbuf);

	return tsize;
	}

	static int decoder_mmu_box_dump_all(void *buf, int size)
	{
	struct decoder_mmu_box_mgr *mgr = get_decoder_mmu_box_mgr();
	char *pbuf = buf;
	char sbuf[512];
	int tsize = 0;
	int s;
	int i;
	struct list_head head, list;

	if (!pbuf) {
	pbuf = sbuf;
	size = 512;
	}

	#define BUFPRINT(args...) \
	do {\
	s = snprintf(pbuf, size - tsize, args);\
	tsize += s;\
	pbuf += s; \
	} while (0)

	mutex_lock(&mgr->mutex);
	head = &mgr->box_list;
	list = head->next;
	i = 0;
	while (list != head) {
	struct decoder_mmu_box *box;
	box = list_entry(list, struct decoder_mmu_box,
	list);
	BUFPRINT("box[%d]: %s, %splayer_id:%d, max_num:%d\n",
	i,
	box->name,
	box->tvp_mode ? "TVP mode " : "",
	box->channel_id,
	box->max_sc_num);
	if (buf) {
	s += decoder_mmu_box_dump(box, pbuf, size - tsize);
	if (s > 0) {
	tsize += s;
	pbuf += s;
	}
	} else {
	pr_info("%s", sbuf);
	pbuf = sbuf;
	tsize += decoder_mmu_box_dump(box, NULL, 0);
	}
	list = list->next;
	i++;
	}
	mutex_unlock(&mgr->mutex);


	#undef BUFPRINT
	if (!buf)
	pr_info("%s", sbuf);
	return tsize;
	}



	static ssize_t
	box_dump_show(struct class *class,
	struct class_attribute attr, char buf)
	{
	ssize_t ret = 0;

	ret = decoder_mmu_box_dump_all(buf, PAGE_SIZE);
	return ret;
	}

	static CLASS_ATTR_RO(box_dump);

	static struct attribute *decoder_mmu_box_class_attrs[] = {
	&class_attr_box_dump.attr,
	NULL
	};

	ATTRIBUTE_GROUPS(decoder_mmu_box_class);

	static struct class decoder_mmu_box_class = {
	.name = "decoder_mmu_box",
	.class_groups = decoder_mmu_box_class_groups,
	};

	int decoder_mmu_box_init(void)
	{
	int r;

	memset(&global_mgr, 0, sizeof(global_mgr));
	INIT_LIST_HEAD(&global_mgr.box_list);
	mutex_init(&global_mgr.mutex);
	global_mgr.next_id = START_KEEP_ID;
	r = class_register(&decoder_mmu_box_class);
	return r;
	}
	EXPORT_SYMBOL(decoder_mmu_box_init);

	void decoder_mmu_box_exit(void)
	{
	class_unregister(&decoder_mmu_box_class);
	pr_info("dec mmu box exit.\n");
	}

	#if 0
	static int __init decoder_mmu_box_init(void)
	{
	int r;

	memset(&global_mgr, 0, sizeof(global_mgr));
	INIT_LIST_HEAD(&global_mgr.box_list);
	mutex_init(&global_mgr.mutex);
	global_mgr.next_id = START_KEEP_ID;
	r = class_register(&decoder_mmu_box_class);
	return r;
	}

	module_init(decoder_mmu_box_init);
	#endif