[net-next-2.6.git] / sound / pci / ctxfi / ctvmem.c

/**
 * Copyright (C) 2008, Creative Technology Ltd. All Rights Reserved.
 *
 * This source file is released under GPL v2 license (no other versions).
 * See the COPYING file included in the main directory of this source
 * distribution for the license terms and conditions.
 *
 * @File    ctvmem.c
 *
 * @Brief
 * This file contains the implementation of virtual memory management object
 * for card device.
 *
 * @Author Liu Chun
 * @Date Apr 1 2008
 */

#include "ctvmem.h"
#include <linux/slab.h>
#include <linux/mm.h>
#include <linux/io.h>
#include <sound/pcm.h>

#define CT_PTES_PER_PAGE (CT_PAGE_SIZE / sizeof(void *))
#define CT_ADDRS_PER_PAGE (CT_PTES_PER_PAGE * CT_PAGE_SIZE)

/* *
 * Find or create vm block based on requested @size.
 * @size must be page aligned.
 * */
static struct ct_vm_block *
get_vm_block(struct ct_vm *vm, unsigned int size)
{
	struct ct_vm_block *block = NULL, *entry;
	struct list_head *pos;

	size = CT_PAGE_ALIGN(size);
	if (size > vm->size) {
		printk(KERN_ERR "ctxfi: Fail! No sufficient device virtural "
				  "memory space available!\n");
		return NULL;
	}

	mutex_lock(&vm->lock);
	list_for_each(pos, &vm->unused) {
		entry = list_entry(pos, struct ct_vm_block, list);
		if (entry->size >= size)
			break; /* found a block that is big enough */
	}
	if (pos == &vm->unused)
		goto out;

	if (entry->size == size) {
		/* Move the vm node from unused list to used list directly */
		list_del(&entry->list);
		list_add(&entry->list, &vm->used);
		vm->size -= size;
		block = entry;
		goto out;
	}

	block = kzalloc(sizeof(*block), GFP_KERNEL);
	if (!block)
		goto out;

	block->addr = entry->addr;
	block->size = size;
	list_add(&block->list, &vm->used);
	entry->addr += size;
	entry->size -= size;
	vm->size -= size;

 out:
	mutex_unlock(&vm->lock);
	return block;
}

static void put_vm_block(struct ct_vm *vm, struct ct_vm_block *block)
{
	struct ct_vm_block *entry, *pre_ent;
	struct list_head *pos, *pre;

	block->size = CT_PAGE_ALIGN(block->size);

	mutex_lock(&vm->lock);
	list_del(&block->list);
	vm->size += block->size;

	list_for_each(pos, &vm->unused) {
		entry = list_entry(pos, struct ct_vm_block, list);
		if (entry->addr >= (block->addr + block->size))
			break; /* found a position */
	}
	if (pos == &vm->unused) {
		list_add_tail(&block->list, &vm->unused);
		entry = block;
	} else {
		if ((block->addr + block->size) == entry->addr) {
			entry->addr = block->addr;
			entry->size += block->size;
			kfree(block);
		} else {
			__list_add(&block->list, pos->prev, pos);
			entry = block;
		}
	}

	pos = &entry->list;
	pre = pos->prev;
	while (pre != &vm->unused) {
		entry = list_entry(pos, struct ct_vm_block, list);
		pre_ent = list_entry(pre, struct ct_vm_block, list);
		if ((pre_ent->addr + pre_ent->size) > entry->addr)
			break;

		pre_ent->size += entry->size;
		list_del(pos);
		kfree(entry);
		pos = pre;
		pre = pos->prev;
	}
	mutex_unlock(&vm->lock);
}

/* Map host addr (kmalloced/vmalloced) to device logical addr. */
static struct ct_vm_block *
ct_vm_map(struct ct_vm *vm, struct snd_pcm_substream *substream, int size)
{
	struct ct_vm_block *block;
	unsigned int pte_start;
	unsigned i, pages;
	unsigned long *ptp;

	block = get_vm_block(vm, size);
	if (block == NULL) {
		printk(KERN_ERR "ctxfi: No virtual memory block that is big "
				  "enough to allocate!\n");
		return NULL;
	}

	ptp = (unsigned long *)vm->ptp[0].area;
	pte_start = (block->addr >> CT_PAGE_SHIFT);
	pages = block->size >> CT_PAGE_SHIFT;
	for (i = 0; i < pages; i++) {
		unsigned long addr;
		addr = snd_pcm_sgbuf_get_addr(substream, i << CT_PAGE_SHIFT);
		ptp[pte_start + i] = addr;
	}

	block->size = size;
	return block;
}

static void ct_vm_unmap(struct ct_vm *vm, struct ct_vm_block *block)
{
	/* do unmapping */
	put_vm_block(vm, block);
}

/* *
 * return the host physical addr of the @index-th device
 * page table page on success, or ~0UL on failure.
 * The first returned ~0UL indicates the termination.
 * */
static dma_addr_t
ct_get_ptp_phys(struct ct_vm *vm, int index)
{
	dma_addr_t addr;

	addr = (index >= CT_PTP_NUM) ? ~0UL : vm->ptp[index].addr;

	return addr;
}

int ct_vm_create(struct ct_vm **rvm, struct pci_dev *pci)
{
	struct ct_vm *vm;
	struct ct_vm_block *block;
	int i, err = 0;

	*rvm = NULL;

	vm = kzalloc(sizeof(*vm), GFP_KERNEL);
	if (!vm)
		return -ENOMEM;

	mutex_init(&vm->lock);

	/* Allocate page table pages */
	for (i = 0; i < CT_PTP_NUM; i++) {
		err = snd_dma_alloc_pages(SNDRV_DMA_TYPE_DEV,
					  snd_dma_pci_data(pci),
					  PAGE_SIZE, &vm->ptp[i]);
		if (err < 0)
			break;
	}
	if (err < 0) {
		/* no page table pages are allocated */
		ct_vm_destroy(vm);
		return -ENOMEM;
	}
	vm->size = CT_ADDRS_PER_PAGE * i;
	vm->map = ct_vm_map;
	vm->unmap = ct_vm_unmap;
	vm->get_ptp_phys = ct_get_ptp_phys;
	INIT_LIST_HEAD(&vm->unused);
	INIT_LIST_HEAD(&vm->used);
	block = kzalloc(sizeof(*block), GFP_KERNEL);
	if (NULL != block) {
		block->addr = 0;
		block->size = vm->size;
		list_add(&block->list, &vm->unused);
	}

	*rvm = vm;
	return 0;
}

/* The caller must ensure no mapping pages are being used
 * by hardware before calling this function */
void ct_vm_destroy(struct ct_vm *vm)
{
	int i;
	struct list_head *pos;
	struct ct_vm_block *entry;

	/* free used and unused list nodes */
	while (!list_empty(&vm->used)) {
		pos = vm->used.next;
		list_del(pos);
		entry = list_entry(pos, struct ct_vm_block, list);
		kfree(entry);
	}
	while (!list_empty(&vm->unused)) {
		pos = vm->unused.next;
		list_del(pos);
		entry = list_entry(pos, struct ct_vm_block, list);
		kfree(entry);
	}

	/* free allocated page table pages */
	for (i = 0; i < CT_PTP_NUM; i++)
		snd_dma_free_pages(&vm->ptp[i]);

	vm->size = 0;

	kfree(vm);
}
Commit	Line	Data
8cc72361 WYC	1	/**
	2	* Copyright (C) 2008, Creative Technology Ltd. All Rights Reserved.
	3	*
	4	* This source file is released under GPL v2 license (no other versions).
	5	* See the COPYING file included in the main directory of this source
	6	* distribution for the license terms and conditions.
	7	*
	8	* @File ctvmem.c
	9	*
	10	* @Brief
	11	* This file contains the implementation of virtual memory management object
	12	* for card device.
	13	*
	14	* @Author Liu Chun
	15	* @Date Apr 1 2008
	16	*/
	17
	18	#include "ctvmem.h"
	19	#include <linux/slab.h>
	20	#include <linux/mm.h>
8cc72361	21	#include <linux/io.h>
c76157d9	22	#include <sound/pcm.h>
8cc72361	23
cd391e20 TI	24	#define CT_PTES_PER_PAGE (CT_PAGE_SIZE / sizeof(void *))
cd391e20 TI	25	#define CT_ADDRS_PER_PAGE (CT_PTES_PER_PAGE * CT_PAGE_SIZE)
8cc72361 WYC	26
	27	/* *
	28	* Find or create vm block based on requested @size.
	29	* @size must be page aligned.
	30	* */
	31	static struct ct_vm_block *
	32	get_vm_block(struct ct_vm *vm, unsigned int size)
	33	{
514eef9c TI	34	struct ct_vm_block block = NULL, entry;
514eef9c TI	35	struct list_head *pos;
8cc72361	36
c76157d9 TI	37	size = CT_PAGE_ALIGN(size);
	38	if (size > vm->size) {
	39	printk(KERN_ERR "ctxfi: Fail! No sufficient device virtural "
	40	"memory space available!\n");
	41	return NULL;
	42	}
	43
8a4259bf	44	mutex_lock(&vm->lock);
8cc72361 WYC	45	list_for_each(pos, &vm->unused) {
	46	entry = list_entry(pos, struct ct_vm_block, list);
	47	if (entry->size >= size)
	48	break; /* found a block that is big enough */
	49	}
	50	if (pos == &vm->unused)
8a4259bf	51	goto out;
8cc72361 WYC	52
	53	if (entry->size == size) {
	54	/* Move the vm node from unused list to used list directly */
	55	list_del(&entry->list);
	56	list_add(&entry->list, &vm->used);
	57	vm->size -= size;
8a4259bf TI	58	block = entry;
8a4259bf TI	59	goto out;
8cc72361 WYC	60	}
	61
	62	block = kzalloc(sizeof(*block), GFP_KERNEL);
35ebf6e7	63	if (!block)
8a4259bf	64	goto out;
8cc72361 WYC	65
	66	block->addr = entry->addr;
	67	block->size = size;
	68	list_add(&block->list, &vm->used);
	69	entry->addr += size;
	70	entry->size -= size;
	71	vm->size -= size;
	72
8a4259bf TI	73	out:
8a4259bf TI	74	mutex_unlock(&vm->lock);
8cc72361 WYC	75	return block;
	76	}
	77
	78	static void put_vm_block(struct ct_vm vm, struct ct_vm_block block)
	79	{
514eef9c TI	80	struct ct_vm_block entry, pre_ent;
514eef9c TI	81	struct list_head pos, pre;
8cc72361	82
c76157d9 TI	83	block->size = CT_PAGE_ALIGN(block->size);
c76157d9 TI	84
8a4259bf	85	mutex_lock(&vm->lock);
8cc72361 WYC	86	list_del(&block->list);
	87	vm->size += block->size;
	88
	89	list_for_each(pos, &vm->unused) {
	90	entry = list_entry(pos, struct ct_vm_block, list);
	91	if (entry->addr >= (block->addr + block->size))
	92	break; /* found a position */
	93	}
	94	if (pos == &vm->unused) {
	95	list_add_tail(&block->list, &vm->unused);
	96	entry = block;
	97	} else {
	98	if ((block->addr + block->size) == entry->addr) {
	99	entry->addr = block->addr;
	100	entry->size += block->size;
	101	kfree(block);
	102	} else {
	103	__list_add(&block->list, pos->prev, pos);
	104	entry = block;
	105	}
	106	}
	107
	108	pos = &entry->list;
	109	pre = pos->prev;
	110	while (pre != &vm->unused) {
	111	entry = list_entry(pos, struct ct_vm_block, list);
	112	pre_ent = list_entry(pre, struct ct_vm_block, list);
	113	if ((pre_ent->addr + pre_ent->size) > entry->addr)
	114	break;
	115
	116	pre_ent->size += entry->size;
	117	list_del(pos);
	118	kfree(entry);
	119	pos = pre;
	120	pre = pos->prev;
	121	}
8a4259bf	122	mutex_unlock(&vm->lock);
8cc72361 WYC	123	}
	124
	125	/* Map host addr (kmalloced/vmalloced) to device logical addr. */
	126	static struct ct_vm_block *
c76157d9	127	ct_vm_map(struct ct_vm vm, struct snd_pcm_substream substream, int size)
8cc72361	128	{
c76157d9 TI	129	struct ct_vm_block *block;
	130	unsigned int pte_start;
	131	unsigned i, pages;
8cc72361 WYC	132	unsigned long *ptp;
8cc72361 WYC	133
c76157d9	134	block = get_vm_block(vm, size);
8cc72361	135	if (block == NULL) {
b3e0afe6	136	printk(KERN_ERR "ctxfi: No virtual memory block that is big "
8cc72361 WYC	137	"enough to allocate!\n");
	138	return NULL;
	139	}
	140
21956b61	141	ptp = (unsigned long *)vm->ptp[0].area;
cd391e20	142	pte_start = (block->addr >> CT_PAGE_SHIFT);
c76157d9 TI	143	pages = block->size >> CT_PAGE_SHIFT;
	144	for (i = 0; i < pages; i++) {
	145	unsigned long addr;
	146	addr = snd_pcm_sgbuf_get_addr(substream, i << CT_PAGE_SHIFT);
	147	ptp[pte_start + i] = addr;
	148	}
8cc72361	149
8cc72361	150	block->size = size;
8cc72361 WYC	151	return block;
	152	}
	153
	154	static void ct_vm_unmap(struct ct_vm vm, struct ct_vm_block block)
	155	{
	156	/* do unmapping */
8cc72361 WYC	157	put_vm_block(vm, block);
	158	}
	159
	160	/* *
21956b61 JK	161	* return the host physical addr of the @index-th device
	162	* page table page on success, or ~0UL on failure.
	163	* The first returned ~0UL indicates the termination.
8cc72361	164	* */
21956b61 JK	165	static dma_addr_t
21956b61 JK	166	ct_get_ptp_phys(struct ct_vm *vm, int index)
8cc72361	167	{
21956b61	168	dma_addr_t addr;
8cc72361	169
21956b61	170	addr = (index >= CT_PTP_NUM) ? ~0UL : vm->ptp[index].addr;
8cc72361 WYC	171
	172	return addr;
	173	}
	174
21956b61	175	int ct_vm_create(struct ct_vm *rvm, struct pci_dev pci)
8cc72361 WYC	176	{
	177	struct ct_vm *vm;
	178	struct ct_vm_block *block;
21956b61	179	int i, err = 0;
8cc72361 WYC	180
	181	*rvm = NULL;
	182
	183	vm = kzalloc(sizeof(*vm), GFP_KERNEL);
35ebf6e7	184	if (!vm)
8cc72361 WYC	185	return -ENOMEM;
8cc72361 WYC	186
8a4259bf TI	187	mutex_init(&vm->lock);
8a4259bf TI	188
8cc72361 WYC	189	/* Allocate page table pages */
8cc72361 WYC	190	for (i = 0; i < CT_PTP_NUM; i++) {
21956b61 JK	191	err = snd_dma_alloc_pages(SNDRV_DMA_TYPE_DEV,
	192	snd_dma_pci_data(pci),
	193	PAGE_SIZE, &vm->ptp[i]);
	194	if (err < 0)
8cc72361 WYC	195	break;
8cc72361 WYC	196	}
21956b61	197	if (err < 0) {
8cc72361	198	/* no page table pages are allocated */
21956b61	199	ct_vm_destroy(vm);
8cc72361 WYC	200	return -ENOMEM;
	201	}
	202	vm->size = CT_ADDRS_PER_PAGE * i;
8cc72361 WYC	203	vm->map = ct_vm_map;
8cc72361 WYC	204	vm->unmap = ct_vm_unmap;
21956b61	205	vm->get_ptp_phys = ct_get_ptp_phys;
8cc72361 WYC	206	INIT_LIST_HEAD(&vm->unused);
	207	INIT_LIST_HEAD(&vm->used);
	208	block = kzalloc(sizeof(*block), GFP_KERNEL);
	209	if (NULL != block) {
	210	block->addr = 0;
	211	block->size = vm->size;
	212	list_add(&block->list, &vm->unused);
	213	}
	214
	215	*rvm = vm;
	216	return 0;
	217	}
	218
	219	/* The caller must ensure no mapping pages are being used
	220	* by hardware before calling this function */
	221	void ct_vm_destroy(struct ct_vm *vm)
	222	{
	223	int i;
514eef9c TI	224	struct list_head *pos;
514eef9c TI	225	struct ct_vm_block *entry;
8cc72361 WYC	226
	227	/* free used and unused list nodes */
	228	while (!list_empty(&vm->used)) {
	229	pos = vm->used.next;
	230	list_del(pos);
	231	entry = list_entry(pos, struct ct_vm_block, list);
	232	kfree(entry);
	233	}
	234	while (!list_empty(&vm->unused)) {
	235	pos = vm->unused.next;
	236	list_del(pos);
	237	entry = list_entry(pos, struct ct_vm_block, list);
	238	kfree(entry);
	239	}
	240
	241	/* free allocated page table pages */
	242	for (i = 0; i < CT_PTP_NUM; i++)
21956b61	243	snd_dma_free_pages(&vm->ptp[i]);
8cc72361 WYC	244
	245	vm->size = 0;
	246
	247	kfree(vm);
	248	}