[linux-2.6-block.git] / sound / pci / ctxfi / ctdaio.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	ctdaio.c
 *
 * @Brief
 * This file contains the implementation of Digital Audio Input Output
 * resource management object.
 *
 * @Author	Liu Chun
 * @Date 	May 23 2008
 *
 */

#include "ctdaio.h"
#include "cthardware.h"
#include "ctimap.h"
#include <linux/slab.h>
#include <linux/kernel.h>

#define DAIO_RESOURCE_NUM	NUM_DAIOTYP
#define DAIO_OUT_MAX		SPDIFOO

union daio_usage {
	struct {
		unsigned short lineo1:1;
		unsigned short lineo2:1;
		unsigned short lineo3:1;
		unsigned short lineo4:1;
		unsigned short spdifoo:1;
		unsigned short lineim:1;
		unsigned short spdifio:1;
		unsigned short spdifi1:1;
	} bf;
	unsigned short data;
};

struct daio_rsc_idx {
	unsigned short left;
	unsigned short right;
};

struct daio_rsc_idx idx_20k1[NUM_DAIOTYP] = {
	[LINEO1] = {.left = 0x00, .right = 0x01},
	[LINEO2] = {.left = 0x18, .right = 0x19},
	[LINEO3] = {.left = 0x08, .right = 0x09},
	[LINEO4] = {.left = 0x10, .right = 0x11},
	[LINEIM] = {.left = 0x1b5, .right = 0x1bd},
	[SPDIFOO] = {.left = 0x20, .right = 0x21},
	[SPDIFIO] = {.left = 0x15, .right = 0x1d},
	[SPDIFI1] = {.left = 0x95, .right = 0x9d},
};

struct daio_rsc_idx idx_20k2[NUM_DAIOTYP] = {
	[LINEO1] = {.left = 0x40, .right = 0x41},
	[LINEO2] = {.left = 0x60, .right = 0x61},
	[LINEO3] = {.left = 0x50, .right = 0x51},
	[LINEO4] = {.left = 0x70, .right = 0x71},
	[LINEIM] = {.left = 0x45, .right = 0xc5},
	[SPDIFOO] = {.left = 0x00, .right = 0x01},
	[SPDIFIO] = {.left = 0x05, .right = 0x85},
};

static int daio_master(struct rsc *rsc)
{
	/* Actually, this is not the resource index of DAIO.
	 * For DAO, it is the input mapper index. And, for DAI,
	 * it is the output time-slot index. */
	return rsc->conj = rsc->idx;
}

static int daio_index(const struct rsc *rsc)
{
	return rsc->conj;
}

static int daio_out_next_conj(struct rsc *rsc)
{
	return rsc->conj += 2;
}

static int daio_in_next_conj_20k1(struct rsc *rsc)
{
	return rsc->conj += 0x200;
}

static int daio_in_next_conj_20k2(struct rsc *rsc)
{
	return rsc->conj += 0x100;
}

static struct rsc_ops daio_out_rsc_ops = {
	.master		= daio_master,
	.next_conj	= daio_out_next_conj,
	.index		= daio_index,
	.output_slot	= NULL,
};

static struct rsc_ops daio_in_rsc_ops_20k1 = {
	.master		= daio_master,
	.next_conj	= daio_in_next_conj_20k1,
	.index		= NULL,
	.output_slot	= daio_index,
};

static struct rsc_ops daio_in_rsc_ops_20k2 = {
	.master		= daio_master,
	.next_conj	= daio_in_next_conj_20k2,
	.index		= NULL,
	.output_slot	= daio_index,
};

static unsigned int daio_device_index(enum DAIOTYP type, struct hw *hw)
{
	switch (hw->chip_type) {
	case ATC20K1:
		switch (type) {
		case SPDIFOO:	return 0;
		case SPDIFIO:	return 0;
		case SPDIFI1:	return 1;
		case LINEO1:	return 4;
		case LINEO2:	return 7;
		case LINEO3:	return 5;
		case LINEO4:	return 6;
		case LINEIM:	return 7;
		default:	return -EINVAL;
		}
	case ATC20K2:
		switch (type) {
		case SPDIFOO:	return 0;
		case SPDIFIO:	return 0;
		case LINEO1:	return 4;
		case LINEO2:	return 7;
		case LINEO3:	return 5;
		case LINEO4:	return 6;
		case LINEIM:	return 4;
		default:	return -EINVAL;
		}
	default:
		return -EINVAL;
	}
}

static int dao_rsc_reinit(struct dao *dao, const struct dao_desc *desc);

static int dao_spdif_get_spos(struct dao *dao, unsigned int *spos)
{
	((struct hw *)dao->hw)->dao_get_spos(dao->ctrl_blk, spos);
	return 0;
}

static int dao_spdif_set_spos(struct dao *dao, unsigned int spos)
{
	((struct hw *)dao->hw)->dao_set_spos(dao->ctrl_blk, spos);
	return 0;
}

static int dao_commit_write(struct dao *dao)
{
	((struct hw *)dao->hw)->dao_commit_write(dao->hw,
		daio_device_index(dao->daio.type, dao->hw), dao->ctrl_blk);
	return 0;
}

static int dao_set_left_input(struct dao *dao, struct rsc *input)
{
	struct imapper *entry;
	struct daio *daio = &dao->daio;
	int i;

	entry = kzalloc((sizeof(*entry) * daio->rscl.msr), GFP_KERNEL);
	if (!entry)
		return -ENOMEM;

	dao->ops->clear_left_input(dao);
	/* Program master and conjugate resources */
	input->ops->master(input);
	daio->rscl.ops->master(&daio->rscl);
	for (i = 0; i < daio->rscl.msr; i++, entry++) {
		entry->slot = input->ops->output_slot(input);
		entry->user = entry->addr = daio->rscl.ops->index(&daio->rscl);
		dao->mgr->imap_add(dao->mgr, entry);
		dao->imappers[i] = entry;

		input->ops->next_conj(input);
		daio->rscl.ops->next_conj(&daio->rscl);
	}
	input->ops->master(input);
	daio->rscl.ops->master(&daio->rscl);

	return 0;
}

static int dao_set_right_input(struct dao *dao, struct rsc *input)
{
	struct imapper *entry;
	struct daio *daio = &dao->daio;
	int i;

	entry = kzalloc((sizeof(*entry) * daio->rscr.msr), GFP_KERNEL);
	if (!entry)
		return -ENOMEM;

	dao->ops->clear_right_input(dao);
	/* Program master and conjugate resources */
	input->ops->master(input);
	daio->rscr.ops->master(&daio->rscr);
	for (i = 0; i < daio->rscr.msr; i++, entry++) {
		entry->slot = input->ops->output_slot(input);
		entry->user = entry->addr = daio->rscr.ops->index(&daio->rscr);
		dao->mgr->imap_add(dao->mgr, entry);
		dao->imappers[daio->rscl.msr + i] = entry;

		input->ops->next_conj(input);
		daio->rscr.ops->next_conj(&daio->rscr);
	}
	input->ops->master(input);
	daio->rscr.ops->master(&daio->rscr);

	return 0;
}

static int dao_clear_left_input(struct dao *dao)
{
	struct imapper *entry;
	struct daio *daio = &dao->daio;
	int i;

	if (!dao->imappers[0])
		return 0;

	entry = dao->imappers[0];
	dao->mgr->imap_delete(dao->mgr, entry);
	/* Program conjugate resources */
	for (i = 1; i < daio->rscl.msr; i++) {
		entry = dao->imappers[i];
		dao->mgr->imap_delete(dao->mgr, entry);
		dao->imappers[i] = NULL;
	}

	kfree(dao->imappers[0]);
	dao->imappers[0] = NULL;

	return 0;
}

static int dao_clear_right_input(struct dao *dao)
{
	struct imapper *entry;
	struct daio *daio = &dao->daio;
	int i;

	if (!dao->imappers[daio->rscl.msr])
		return 0;

	entry = dao->imappers[daio->rscl.msr];
	dao->mgr->imap_delete(dao->mgr, entry);
	/* Program conjugate resources */
	for (i = 1; i < daio->rscr.msr; i++) {
		entry = dao->imappers[daio->rscl.msr + i];
		dao->mgr->imap_delete(dao->mgr, entry);
		dao->imappers[daio->rscl.msr + i] = NULL;
	}

	kfree(dao->imappers[daio->rscl.msr]);
	dao->imappers[daio->rscl.msr] = NULL;

	return 0;
}

static struct dao_rsc_ops dao_ops = {
	.set_spos		= dao_spdif_set_spos,
	.commit_write		= dao_commit_write,
	.get_spos		= dao_spdif_get_spos,
	.reinit			= dao_rsc_reinit,
	.set_left_input		= dao_set_left_input,
	.set_right_input	= dao_set_right_input,
	.clear_left_input	= dao_clear_left_input,
	.clear_right_input	= dao_clear_right_input,
};

static int dai_set_srt_srcl(struct dai *dai, struct rsc *src)
{
	src->ops->master(src);
	((struct hw *)dai->hw)->dai_srt_set_srcm(dai->ctrl_blk,
						src->ops->index(src));
	return 0;
}

static int dai_set_srt_srcr(struct dai *dai, struct rsc *src)
{
	src->ops->master(src);
	((struct hw *)dai->hw)->dai_srt_set_srco(dai->ctrl_blk,
						src->ops->index(src));
	return 0;
}

static int dai_set_srt_msr(struct dai *dai, unsigned int msr)
{
	unsigned int rsr;

	for (rsr = 0; msr > 1; msr >>= 1)
		rsr++;

	((struct hw *)dai->hw)->dai_srt_set_rsr(dai->ctrl_blk, rsr);
	return 0;
}

static int dai_set_enb_src(struct dai *dai, unsigned int enb)
{
	((struct hw *)dai->hw)->dai_srt_set_ec(dai->ctrl_blk, enb);
	return 0;
}

static int dai_set_enb_srt(struct dai *dai, unsigned int enb)
{
	((struct hw *)dai->hw)->dai_srt_set_et(dai->ctrl_blk, enb);
	return 0;
}

static int dai_commit_write(struct dai *dai)
{
	((struct hw *)dai->hw)->dai_commit_write(dai->hw,
		daio_device_index(dai->daio.type, dai->hw), dai->ctrl_blk);
	return 0;
}

static struct dai_rsc_ops dai_ops = {
	.set_srt_srcl		= dai_set_srt_srcl,
	.set_srt_srcr		= dai_set_srt_srcr,
	.set_srt_msr		= dai_set_srt_msr,
	.set_enb_src		= dai_set_enb_src,
	.set_enb_srt		= dai_set_enb_srt,
	.commit_write		= dai_commit_write,
};

static int daio_rsc_init(struct daio *daio,
			 const struct daio_desc *desc,
			 void *hw)
{
	int err;
	unsigned int idx_l, idx_r;

	switch (((struct hw *)hw)->chip_type) {
	case ATC20K1:
		idx_l = idx_20k1[desc->type].left;
		idx_r = idx_20k1[desc->type].right;
		break;
	case ATC20K2:
		idx_l = idx_20k2[desc->type].left;
		idx_r = idx_20k2[desc->type].right;
		break;
	default:
		return -EINVAL;
	}
	err = rsc_init(&daio->rscl, idx_l, DAIO, desc->msr, hw);
	if (err)
		return err;

	err = rsc_init(&daio->rscr, idx_r, DAIO, desc->msr, hw);
	if (err)
		goto error1;

	/* Set daio->rscl/r->ops to daio specific ones */
	if (desc->type <= DAIO_OUT_MAX) {
		daio->rscl.ops = daio->rscr.ops = &daio_out_rsc_ops;
	} else {
		switch (((struct hw *)hw)->chip_type) {
		case ATC20K1:
			daio->rscl.ops = daio->rscr.ops = &daio_in_rsc_ops_20k1;
			break;
		case ATC20K2:
			daio->rscl.ops = daio->rscr.ops = &daio_in_rsc_ops_20k2;
			break;
		default:
			break;
		}
	}
	daio->type = desc->type;

	return 0;

error1:
	rsc_uninit(&daio->rscl);
	return err;
}

static int daio_rsc_uninit(struct daio *daio)
{
	rsc_uninit(&daio->rscl);
	rsc_uninit(&daio->rscr);

	return 0;
}

static int dao_rsc_init(struct dao *dao,
			const struct daio_desc *desc,
			struct daio_mgr *mgr)
{
	struct hw *hw = mgr->mgr.hw;
	unsigned int conf;
	int err;

	err = daio_rsc_init(&dao->daio, desc, mgr->mgr.hw);
	if (err)
		return err;

	dao->imappers = kzalloc(sizeof(void *)*desc->msr*2, GFP_KERNEL);
	if (!dao->imappers) {
		err = -ENOMEM;
		goto error1;
	}
	dao->ops = &dao_ops;
	dao->mgr = mgr;
	dao->hw = hw;
	err = hw->dao_get_ctrl_blk(&dao->ctrl_blk);
	if (err)
		goto error2;

	hw->daio_mgr_dsb_dao(mgr->mgr.ctrl_blk,
			daio_device_index(dao->daio.type, hw));
	hw->daio_mgr_commit_write(hw, mgr->mgr.ctrl_blk);

	conf = (desc->msr & 0x7) | (desc->passthru << 3);
	hw->daio_mgr_dao_init(mgr->mgr.ctrl_blk,
			daio_device_index(dao->daio.type, hw), conf);
	hw->daio_mgr_enb_dao(mgr->mgr.ctrl_blk,
			daio_device_index(dao->daio.type, hw));
	hw->daio_mgr_commit_write(hw, mgr->mgr.ctrl_blk);

	return 0;

error2:
	kfree(dao->imappers);
	dao->imappers = NULL;
error1:
	daio_rsc_uninit(&dao->daio);
	return err;
}

static int dao_rsc_uninit(struct dao *dao)
{
	if (dao->imappers) {
		if (dao->imappers[0])
			dao_clear_left_input(dao);

		if (dao->imappers[dao->daio.rscl.msr])
			dao_clear_right_input(dao);

		kfree(dao->imappers);
		dao->imappers = NULL;
	}
	((struct hw *)dao->hw)->dao_put_ctrl_blk(dao->ctrl_blk);
	dao->hw = dao->ctrl_blk = NULL;
	daio_rsc_uninit(&dao->daio);

	return 0;
}

static int dao_rsc_reinit(struct dao *dao, const struct dao_desc *desc)
{
	struct daio_mgr *mgr = dao->mgr;
	struct daio_desc dsc = {0};

	dsc.type = dao->daio.type;
	dsc.msr = desc->msr;
	dsc.passthru = desc->passthru;
	dao_rsc_uninit(dao);
	return dao_rsc_init(dao, &dsc, mgr);
}

static int dai_rsc_init(struct dai *dai,
			const struct daio_desc *desc,
			struct daio_mgr *mgr)
{
	int err;
	struct hw *hw = mgr->mgr.hw;
	unsigned int rsr, msr;

	err = daio_rsc_init(&dai->daio, desc, mgr->mgr.hw);
	if (err)
		return err;

	dai->ops = &dai_ops;
	dai->hw = mgr->mgr.hw;
	err = hw->dai_get_ctrl_blk(&dai->ctrl_blk);
	if (err)
		goto error1;

	for (rsr = 0, msr = desc->msr; msr > 1; msr >>= 1)
		rsr++;

	hw->dai_srt_set_rsr(dai->ctrl_blk, rsr);
	hw->dai_srt_set_drat(dai->ctrl_blk, 0);
	/* default to disabling control of a SRC */
	hw->dai_srt_set_ec(dai->ctrl_blk, 0);
	hw->dai_srt_set_et(dai->ctrl_blk, 0); /* default to disabling SRT */
	hw->dai_commit_write(hw,
		daio_device_index(dai->daio.type, dai->hw), dai->ctrl_blk);

	return 0;

error1:
	daio_rsc_uninit(&dai->daio);
	return err;
}

static int dai_rsc_uninit(struct dai *dai)
{
	((struct hw *)dai->hw)->dai_put_ctrl_blk(dai->ctrl_blk);
	dai->hw = dai->ctrl_blk = NULL;
	daio_rsc_uninit(&dai->daio);
	return 0;
}

static int daio_mgr_get_rsc(struct rsc_mgr *mgr, enum DAIOTYP type)
{
	if (((union daio_usage *)mgr->rscs)->data & (0x1 << type))
		return -ENOENT;

	((union daio_usage *)mgr->rscs)->data |= (0x1 << type);

	return 0;
}

static int daio_mgr_put_rsc(struct rsc_mgr *mgr, enum DAIOTYP type)
{
	((union daio_usage *)mgr->rscs)->data &= ~(0x1 << type);

	return 0;
}

static int get_daio_rsc(struct daio_mgr *mgr,
			const struct daio_desc *desc,
			struct daio **rdaio)
{
	int err;
	struct dai *dai = NULL;
	struct dao *dao = NULL;
	unsigned long flags;

	*rdaio = NULL;

	/* Check whether there are sufficient daio resources to meet request. */
	spin_lock_irqsave(&mgr->mgr_lock, flags);
	err = daio_mgr_get_rsc(&mgr->mgr, desc->type);
	spin_unlock_irqrestore(&mgr->mgr_lock, flags);
	if (err) {
		printk(KERN_ERR "Can't meet DAIO resource request!\n");
		return err;
	}

	/* Allocate mem for daio resource */
	if (desc->type <= DAIO_OUT_MAX) {
		dao = kzalloc(sizeof(*dao), GFP_KERNEL);
		if (!dao) {
			err = -ENOMEM;
			goto error;
		}
		err = dao_rsc_init(dao, desc, mgr);
		if (err)
			goto error;

		*rdaio = &dao->daio;
	} else {
		dai = kzalloc(sizeof(*dai), GFP_KERNEL);
		if (!dai) {
			err = -ENOMEM;
			goto error;
		}
		err = dai_rsc_init(dai, desc, mgr);
		if (err)
			goto error;

		*rdaio = &dai->daio;
	}

	mgr->daio_enable(mgr, *rdaio);
	mgr->commit_write(mgr);

	return 0;

error:
	if (dao)
		kfree(dao);
	else if (dai)
		kfree(dai);

	spin_lock_irqsave(&mgr->mgr_lock, flags);
	daio_mgr_put_rsc(&mgr->mgr, desc->type);
	spin_unlock_irqrestore(&mgr->mgr_lock, flags);
	return err;
}

static int put_daio_rsc(struct daio_mgr *mgr, struct daio *daio)
{
	unsigned long flags;

	mgr->daio_disable(mgr, daio);
	mgr->commit_write(mgr);

	spin_lock_irqsave(&mgr->mgr_lock, flags);
	daio_mgr_put_rsc(&mgr->mgr, daio->type);
	spin_unlock_irqrestore(&mgr->mgr_lock, flags);

	if (daio->type <= DAIO_OUT_MAX) {
		dao_rsc_uninit(container_of(daio, struct dao, daio));
		kfree(container_of(daio, struct dao, daio));
	} else {
		dai_rsc_uninit(container_of(daio, struct dai, daio));
		kfree(container_of(daio, struct dai, daio));
	}

	return 0;
}

static int daio_mgr_enb_daio(struct daio_mgr *mgr, struct daio *daio)
{
	struct hw *hw = mgr->mgr.hw;

	if (DAIO_OUT_MAX >= daio->type) {
		hw->daio_mgr_enb_dao(mgr->mgr.ctrl_blk,
				daio_device_index(daio->type, hw));
	} else {
		hw->daio_mgr_enb_dai(mgr->mgr.ctrl_blk,
				daio_device_index(daio->type, hw));
	}
	return 0;
}

static int daio_mgr_dsb_daio(struct daio_mgr *mgr, struct daio *daio)
{
	struct hw *hw = mgr->mgr.hw;

	if (DAIO_OUT_MAX >= daio->type) {
		hw->daio_mgr_dsb_dao(mgr->mgr.ctrl_blk,
				daio_device_index(daio->type, hw));
	} else {
		hw->daio_mgr_dsb_dai(mgr->mgr.ctrl_blk,
				daio_device_index(daio->type, hw));
	}
	return 0;
}

static int daio_map_op(void *data, struct imapper *entry)
{
	struct rsc_mgr *mgr = &((struct daio_mgr *)data)->mgr;
	struct hw *hw = mgr->hw;

	hw->daio_mgr_set_imaparc(mgr->ctrl_blk, entry->slot);
	hw->daio_mgr_set_imapnxt(mgr->ctrl_blk, entry->next);
	hw->daio_mgr_set_imapaddr(mgr->ctrl_blk, entry->addr);
	hw->daio_mgr_commit_write(mgr->hw, mgr->ctrl_blk);

	return 0;
}

static int daio_imap_add(struct daio_mgr *mgr, struct imapper *entry)
{
	unsigned long flags;
	int err;

	spin_lock_irqsave(&mgr->imap_lock, flags);
	if (!entry->addr && mgr->init_imap_added) {
		input_mapper_delete(&mgr->imappers, mgr->init_imap,
							daio_map_op, mgr);
		mgr->init_imap_added = 0;
	}
	err = input_mapper_add(&mgr->imappers, entry, daio_map_op, mgr);
	spin_unlock_irqrestore(&mgr->imap_lock, flags);

	return err;
}

static int daio_imap_delete(struct daio_mgr *mgr, struct imapper *entry)
{
	unsigned long flags;
	int err;

	spin_lock_irqsave(&mgr->imap_lock, flags);
	err = input_mapper_delete(&mgr->imappers, entry, daio_map_op, mgr);
	if (list_empty(&mgr->imappers)) {
		input_mapper_add(&mgr->imappers, mgr->init_imap,
							daio_map_op, mgr);
		mgr->init_imap_added = 1;
	}
	spin_unlock_irqrestore(&mgr->imap_lock, flags);

	return err;
}

static int daio_mgr_commit_write(struct daio_mgr *mgr)
{
	struct hw *hw = mgr->mgr.hw;

	hw->daio_mgr_commit_write(hw, mgr->mgr.ctrl_blk);
	return 0;
}

int daio_mgr_create(void *hw, struct daio_mgr **rdaio_mgr)
{
	int err, i;
	struct daio_mgr *daio_mgr;
	struct imapper *entry;

	*rdaio_mgr = NULL;
	daio_mgr = kzalloc(sizeof(*daio_mgr), GFP_KERNEL);
	if (!daio_mgr)
		return -ENOMEM;

	err = rsc_mgr_init(&daio_mgr->mgr, DAIO, DAIO_RESOURCE_NUM, hw);
	if (err)
		goto error1;

	spin_lock_init(&daio_mgr->mgr_lock);
	spin_lock_init(&daio_mgr->imap_lock);
	INIT_LIST_HEAD(&daio_mgr->imappers);
	entry = kzalloc(sizeof(*entry), GFP_KERNEL);
	if (!entry) {
		err = -ENOMEM;
		goto error2;
	}
	entry->slot = entry->addr = entry->next = entry->user = 0;
	list_add(&entry->list, &daio_mgr->imappers);
	daio_mgr->init_imap = entry;
	daio_mgr->init_imap_added = 1;

	daio_mgr->get_daio = get_daio_rsc;
	daio_mgr->put_daio = put_daio_rsc;
	daio_mgr->daio_enable = daio_mgr_enb_daio;
	daio_mgr->daio_disable = daio_mgr_dsb_daio;
	daio_mgr->imap_add = daio_imap_add;
	daio_mgr->imap_delete = daio_imap_delete;
	daio_mgr->commit_write = daio_mgr_commit_write;

	for (i = 0; i < 8; i++) {
		((struct hw *)hw)->daio_mgr_dsb_dao(daio_mgr->mgr.ctrl_blk, i);
		((struct hw *)hw)->daio_mgr_dsb_dai(daio_mgr->mgr.ctrl_blk, i);
	}
	((struct hw *)hw)->daio_mgr_commit_write(hw, daio_mgr->mgr.ctrl_blk);

	*rdaio_mgr = daio_mgr;

	return 0;

error2:
	rsc_mgr_uninit(&daio_mgr->mgr);
error1:
	kfree(daio_mgr);
	return err;
}

int daio_mgr_destroy(struct daio_mgr *daio_mgr)
{
	unsigned long flags;

	/* free daio input mapper list */
	spin_lock_irqsave(&daio_mgr->imap_lock, flags);
	free_input_mapper_list(&daio_mgr->imappers);
	spin_unlock_irqrestore(&daio_mgr->imap_lock, flags);

	rsc_mgr_uninit(&daio_mgr->mgr);
	kfree(daio_mgr);

	return 0;
}
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 ctdaio.c
	9	*
	10	* @Brief
	11	* This file contains the implementation of Digital Audio Input Output
	12	* resource management object.
	13	*
	14	* @Author Liu Chun
	15	* @Date May 23 2008
	16	*
	17	*/
	18
	19	#include "ctdaio.h"
	20	#include "cthardware.h"
	21	#include "ctimap.h"
	22	#include <linux/slab.h>
	23	#include <linux/kernel.h>
	24
	25	#define DAIO_RESOURCE_NUM NUM_DAIOTYP
	26	#define DAIO_OUT_MAX SPDIFOO
	27
	28	union daio_usage {
	29	struct {
	30	unsigned short lineo1:1;
	31	unsigned short lineo2:1;
	32	unsigned short lineo3:1;
	33	unsigned short lineo4:1;
	34	unsigned short spdifoo:1;
	35	unsigned short lineim:1;
	36	unsigned short spdifio:1;
	37	unsigned short spdifi1:1;
	38	} bf;
	39	unsigned short data;
	40	};
	41
	42	struct daio_rsc_idx {
	43	unsigned short left;
	44	unsigned short right;
	45	};
	46
	47	struct daio_rsc_idx idx_20k1[NUM_DAIOTYP] = {
	48	[LINEO1] = {.left = 0x00, .right = 0x01},
	49	[LINEO2] = {.left = 0x18, .right = 0x19},
	50	[LINEO3] = {.left = 0x08, .right = 0x09},
	51	[LINEO4] = {.left = 0x10, .right = 0x11},
	52	[LINEIM] = {.left = 0x1b5, .right = 0x1bd},
	53	[SPDIFOO] = {.left = 0x20, .right = 0x21},
	54	[SPDIFIO] = {.left = 0x15, .right = 0x1d},
	55	[SPDIFI1] = {.left = 0x95, .right = 0x9d},
	56	};
	57
	58	struct daio_rsc_idx idx_20k2[NUM_DAIOTYP] = {
	59	[LINEO1] = {.left = 0x40, .right = 0x41},
55fe27f7	60	[LINEO2] = {.left = 0x60, .right = 0x61},
8cc72361	61	[LINEO3] = {.left = 0x50, .right = 0x51},
55fe27f7	62	[LINEO4] = {.left = 0x70, .right = 0x71},
8cc72361 WYC	63	[LINEIM] = {.left = 0x45, .right = 0xc5},
	64	[SPDIFOO] = {.left = 0x00, .right = 0x01},
	65	[SPDIFIO] = {.left = 0x05, .right = 0x85},
	66	};
	67
	68	static int daio_master(struct rsc *rsc)
	69	{
	70	/* Actually, this is not the resource index of DAIO.
	71	* For DAO, it is the input mapper index. And, for DAI,
	72	* it is the output time-slot index. */
	73	return rsc->conj = rsc->idx;
	74	}
	75
	76	static int daio_index(const struct rsc *rsc)
	77	{
	78	return rsc->conj;
	79	}
	80
	81	static int daio_out_next_conj(struct rsc *rsc)
	82	{
	83	return rsc->conj += 2;
	84	}
	85
	86	static int daio_in_next_conj_20k1(struct rsc *rsc)
	87	{
	88	return rsc->conj += 0x200;
	89	}
	90
	91	static int daio_in_next_conj_20k2(struct rsc *rsc)
	92	{
	93	return rsc->conj += 0x100;
	94	}
	95
	96	static struct rsc_ops daio_out_rsc_ops = {
	97	.master = daio_master,
	98	.next_conj = daio_out_next_conj,
	99	.index = daio_index,
	100	.output_slot = NULL,
	101	};
	102
	103	static struct rsc_ops daio_in_rsc_ops_20k1 = {
	104	.master = daio_master,
	105	.next_conj = daio_in_next_conj_20k1,
	106	.index = NULL,
	107	.output_slot = daio_index,
	108	};
	109
	110	static struct rsc_ops daio_in_rsc_ops_20k2 = {
	111	.master = daio_master,
	112	.next_conj = daio_in_next_conj_20k2,
	113	.index = NULL,
	114	.output_slot = daio_index,
	115	};
	116
	117	static unsigned int daio_device_index(enum DAIOTYP type, struct hw *hw)
	118	{
9470195a	119	switch (hw->chip_type) {
8cc72361 WYC	120	case ATC20K1:
	121	switch (type) {
	122	case SPDIFOO: return 0;
	123	case SPDIFIO: return 0;
	124	case SPDIFI1: return 1;
	125	case LINEO1: return 4;
	126	case LINEO2: return 7;
	127	case LINEO3: return 5;
	128	case LINEO4: return 6;
	129	case LINEIM: return 7;
	130	default: return -EINVAL;
	131	}
	132	case ATC20K2:
	133	switch (type) {
	134	case SPDIFOO: return 0;
	135	case SPDIFIO: return 0;
	136	case LINEO1: return 4;
	137	case LINEO2: return 7;
	138	case LINEO3: return 5;
	139	case LINEO4: return 6;
	140	case LINEIM: return 4;
	141	default: return -EINVAL;
	142	}
	143	default:
	144	return -EINVAL;
	145	}
	146	}
	147
	148	static int dao_rsc_reinit(struct dao dao, const struct dao_desc desc);
	149
	150	static int dao_spdif_get_spos(struct dao dao, unsigned int spos)
	151	{
	152	((struct hw *)dao->hw)->dao_get_spos(dao->ctrl_blk, spos);
	153	return 0;
	154	}
	155
	156	static int dao_spdif_set_spos(struct dao *dao, unsigned int spos)
	157	{
	158	((struct hw *)dao->hw)->dao_set_spos(dao->ctrl_blk, spos);
	159	return 0;
	160	}
	161
	162	static int dao_commit_write(struct dao *dao)
	163	{
	164	((struct hw *)dao->hw)->dao_commit_write(dao->hw,
	165	daio_device_index(dao->daio.type, dao->hw), dao->ctrl_blk);
	166	return 0;
	167	}
	168
	169	static int dao_set_left_input(struct dao dao, struct rsc input)
	170	{
514eef9c	171	struct imapper *entry;
8cc72361	172	struct daio *daio = &dao->daio;
514eef9c	173	int i;
8cc72361 WYC	174
8cc72361 WYC	175	entry = kzalloc((sizeof(entry) daio->rscl.msr), GFP_KERNEL);
35ebf6e7	176	if (!entry)
8cc72361 WYC	177	return -ENOMEM;
8cc72361 WYC	178
efed5f26	179	dao->ops->clear_left_input(dao);
8cc72361 WYC	180	/* Program master and conjugate resources */
	181	input->ops->master(input);
	182	daio->rscl.ops->master(&daio->rscl);
	183	for (i = 0; i < daio->rscl.msr; i++, entry++) {
	184	entry->slot = input->ops->output_slot(input);
	185	entry->user = entry->addr = daio->rscl.ops->index(&daio->rscl);
	186	dao->mgr->imap_add(dao->mgr, entry);
	187	dao->imappers[i] = entry;
	188
	189	input->ops->next_conj(input);
	190	daio->rscl.ops->next_conj(&daio->rscl);
	191	}
	192	input->ops->master(input);
	193	daio->rscl.ops->master(&daio->rscl);
	194
	195	return 0;
	196	}
	197
	198	static int dao_set_right_input(struct dao dao, struct rsc input)
	199	{
514eef9c	200	struct imapper *entry;
8cc72361	201	struct daio *daio = &dao->daio;
514eef9c	202	int i;
8cc72361 WYC	203
8cc72361 WYC	204	entry = kzalloc((sizeof(entry) daio->rscr.msr), GFP_KERNEL);
35ebf6e7	205	if (!entry)
8cc72361 WYC	206	return -ENOMEM;
8cc72361 WYC	207
efed5f26	208	dao->ops->clear_right_input(dao);
8cc72361 WYC	209	/* Program master and conjugate resources */
	210	input->ops->master(input);
	211	daio->rscr.ops->master(&daio->rscr);
	212	for (i = 0; i < daio->rscr.msr; i++, entry++) {
	213	entry->slot = input->ops->output_slot(input);
	214	entry->user = entry->addr = daio->rscr.ops->index(&daio->rscr);
	215	dao->mgr->imap_add(dao->mgr, entry);
	216	dao->imappers[daio->rscl.msr + i] = entry;
	217
	218	input->ops->next_conj(input);
	219	daio->rscr.ops->next_conj(&daio->rscr);
	220	}
	221	input->ops->master(input);
	222	daio->rscr.ops->master(&daio->rscr);
	223
	224	return 0;
	225	}
	226
	227	static int dao_clear_left_input(struct dao *dao)
	228	{
514eef9c	229	struct imapper *entry;
8cc72361	230	struct daio *daio = &dao->daio;
514eef9c	231	int i;
8cc72361	232
35ebf6e7	233	if (!dao->imappers[0])
8cc72361 WYC	234	return 0;
	235
	236	entry = dao->imappers[0];
	237	dao->mgr->imap_delete(dao->mgr, entry);
	238	/* Program conjugate resources */
	239	for (i = 1; i < daio->rscl.msr; i++) {
	240	entry = dao->imappers[i];
	241	dao->mgr->imap_delete(dao->mgr, entry);
	242	dao->imappers[i] = NULL;
	243	}
	244
	245	kfree(dao->imappers[0]);
	246	dao->imappers[0] = NULL;
	247
	248	return 0;
	249	}
	250
	251	static int dao_clear_right_input(struct dao *dao)
	252	{
514eef9c	253	struct imapper *entry;
8cc72361	254	struct daio *daio = &dao->daio;
514eef9c	255	int i;
8cc72361	256
35ebf6e7	257	if (!dao->imappers[daio->rscl.msr])
8cc72361 WYC	258	return 0;
	259
	260	entry = dao->imappers[daio->rscl.msr];
	261	dao->mgr->imap_delete(dao->mgr, entry);
	262	/* Program conjugate resources */
	263	for (i = 1; i < daio->rscr.msr; i++) {
	264	entry = dao->imappers[daio->rscl.msr + i];
	265	dao->mgr->imap_delete(dao->mgr, entry);
	266	dao->imappers[daio->rscl.msr + i] = NULL;
	267	}
	268
	269	kfree(dao->imappers[daio->rscl.msr]);
	270	dao->imappers[daio->rscl.msr] = NULL;
	271
	272	return 0;
	273	}
	274
	275	static struct dao_rsc_ops dao_ops = {
	276	.set_spos = dao_spdif_set_spos,
	277	.commit_write = dao_commit_write,
	278	.get_spos = dao_spdif_get_spos,
	279	.reinit = dao_rsc_reinit,
	280	.set_left_input = dao_set_left_input,
	281	.set_right_input = dao_set_right_input,
	282	.clear_left_input = dao_clear_left_input,
	283	.clear_right_input = dao_clear_right_input,
	284	};
	285
	286	static int dai_set_srt_srcl(struct dai dai, struct rsc src)
	287	{
	288	src->ops->master(src);
	289	((struct hw *)dai->hw)->dai_srt_set_srcm(dai->ctrl_blk,
	290	src->ops->index(src));
	291	return 0;
	292	}
	293
	294	static int dai_set_srt_srcr(struct dai dai, struct rsc src)
	295	{
	296	src->ops->master(src);
	297	((struct hw *)dai->hw)->dai_srt_set_srco(dai->ctrl_blk,
	298	src->ops->index(src));
	299	return 0;
	300	}
	301
	302	static int dai_set_srt_msr(struct dai *dai, unsigned int msr)
	303	{
514eef9c	304	unsigned int rsr;
8cc72361 WYC	305
	306	for (rsr = 0; msr > 1; msr >>= 1)
	307	rsr++;
	308
	309	((struct hw *)dai->hw)->dai_srt_set_rsr(dai->ctrl_blk, rsr);
	310	return 0;
	311	}
	312
	313	static int dai_set_enb_src(struct dai *dai, unsigned int enb)
	314	{
	315	((struct hw *)dai->hw)->dai_srt_set_ec(dai->ctrl_blk, enb);
	316	return 0;
	317	}
	318
	319	static int dai_set_enb_srt(struct dai *dai, unsigned int enb)
	320	{
	321	((struct hw *)dai->hw)->dai_srt_set_et(dai->ctrl_blk, enb);
	322	return 0;
	323	}
	324
	325	static int dai_commit_write(struct dai *dai)
	326	{
	327	((struct hw *)dai->hw)->dai_commit_write(dai->hw,
	328	daio_device_index(dai->daio.type, dai->hw), dai->ctrl_blk);
	329	return 0;
	330	}
	331
	332	static struct dai_rsc_ops dai_ops = {
	333	.set_srt_srcl = dai_set_srt_srcl,
	334	.set_srt_srcr = dai_set_srt_srcr,
	335	.set_srt_msr = dai_set_srt_msr,
	336	.set_enb_src = dai_set_enb_src,
	337	.set_enb_srt = dai_set_enb_srt,
	338	.commit_write = dai_commit_write,
	339	};
	340
	341	static int daio_rsc_init(struct daio *daio,
	342	const struct daio_desc *desc,
	343	void *hw)
	344	{
514eef9c TI	345	int err;
514eef9c TI	346	unsigned int idx_l, idx_r;
8cc72361	347
9470195a	348	switch (((struct hw *)hw)->chip_type) {
8cc72361 WYC	349	case ATC20K1:
	350	idx_l = idx_20k1[desc->type].left;
	351	idx_r = idx_20k1[desc->type].right;
	352	break;
	353	case ATC20K2:
	354	idx_l = idx_20k2[desc->type].left;
	355	idx_r = idx_20k2[desc->type].right;
	356	break;
	357	default:
	358	return -EINVAL;
	359	}
	360	err = rsc_init(&daio->rscl, idx_l, DAIO, desc->msr, hw);
	361	if (err)
	362	return err;
	363
	364	err = rsc_init(&daio->rscr, idx_r, DAIO, desc->msr, hw);
	365	if (err)
	366	goto error1;
	367
	368	/* Set daio->rscl/r->ops to daio specific ones */
	369	if (desc->type <= DAIO_OUT_MAX) {
	370	daio->rscl.ops = daio->rscr.ops = &daio_out_rsc_ops;
	371	} else {
9470195a	372	switch (((struct hw *)hw)->chip_type) {
8cc72361 WYC	373	case ATC20K1:
	374	daio->rscl.ops = daio->rscr.ops = &daio_in_rsc_ops_20k1;
	375	break;
	376	case ATC20K2:
	377	daio->rscl.ops = daio->rscr.ops = &daio_in_rsc_ops_20k2;
	378	break;
	379	default:
	380	break;
	381	}
	382	}
	383	daio->type = desc->type;
	384
	385	return 0;
	386
	387	error1:
	388	rsc_uninit(&daio->rscl);
	389	return err;
	390	}
	391
	392	static int daio_rsc_uninit(struct daio *daio)
	393	{
	394	rsc_uninit(&daio->rscl);
	395	rsc_uninit(&daio->rscr);
	396
	397	return 0;
	398	}
	399
	400	static int dao_rsc_init(struct dao *dao,
	401	const struct daio_desc *desc,
	402	struct daio_mgr *mgr)
	403	{
	404	struct hw *hw = mgr->mgr.hw;
514eef9c TI	405	unsigned int conf;
514eef9c TI	406	int err;
8cc72361 WYC	407
	408	err = daio_rsc_init(&dao->daio, desc, mgr->mgr.hw);
	409	if (err)
	410	return err;
	411
	412	dao->imappers = kzalloc(sizeof(void )desc->msr*2, GFP_KERNEL);
35ebf6e7	413	if (!dao->imappers) {
8cc72361 WYC	414	err = -ENOMEM;
	415	goto error1;
	416	}
	417	dao->ops = &dao_ops;
	418	dao->mgr = mgr;
	419	dao->hw = hw;
	420	err = hw->dao_get_ctrl_blk(&dao->ctrl_blk);
	421	if (err)
	422	goto error2;
	423
	424	hw->daio_mgr_dsb_dao(mgr->mgr.ctrl_blk,
	425	daio_device_index(dao->daio.type, hw));
	426	hw->daio_mgr_commit_write(hw, mgr->mgr.ctrl_blk);
	427
514eef9c	428	conf = (desc->msr & 0x7) \| (desc->passthru << 3);
8cc72361 WYC	429	hw->daio_mgr_dao_init(mgr->mgr.ctrl_blk,
	430	daio_device_index(dao->daio.type, hw), conf);
	431	hw->daio_mgr_enb_dao(mgr->mgr.ctrl_blk,
	432	daio_device_index(dao->daio.type, hw));
	433	hw->daio_mgr_commit_write(hw, mgr->mgr.ctrl_blk);
	434
	435	return 0;
	436
	437	error2:
	438	kfree(dao->imappers);
	439	dao->imappers = NULL;
	440	error1:
	441	daio_rsc_uninit(&dao->daio);
	442	return err;
	443	}
	444
	445	static int dao_rsc_uninit(struct dao *dao)
	446	{
35ebf6e7 TI	447	if (dao->imappers) {
35ebf6e7 TI	448	if (dao->imappers[0])
8cc72361 WYC	449	dao_clear_left_input(dao);
8cc72361 WYC	450
35ebf6e7	451	if (dao->imappers[dao->daio.rscl.msr])
8cc72361 WYC	452	dao_clear_right_input(dao);
	453
	454	kfree(dao->imappers);
	455	dao->imappers = NULL;
	456	}
	457	((struct hw *)dao->hw)->dao_put_ctrl_blk(dao->ctrl_blk);
	458	dao->hw = dao->ctrl_blk = NULL;
	459	daio_rsc_uninit(&dao->daio);
	460
	461	return 0;
	462	}
	463
	464	static int dao_rsc_reinit(struct dao dao, const struct dao_desc desc)
	465	{
	466	struct daio_mgr *mgr = dao->mgr;
	467	struct daio_desc dsc = {0};
	468
	469	dsc.type = dao->daio.type;
	470	dsc.msr = desc->msr;
	471	dsc.passthru = desc->passthru;
	472	dao_rsc_uninit(dao);
	473	return dao_rsc_init(dao, &dsc, mgr);
	474	}
	475
	476	static int dai_rsc_init(struct dai *dai,
	477	const struct daio_desc *desc,
	478	struct daio_mgr *mgr)
	479	{
514eef9c	480	int err;
8cc72361	481	struct hw *hw = mgr->mgr.hw;
514eef9c	482	unsigned int rsr, msr;
8cc72361 WYC	483
	484	err = daio_rsc_init(&dai->daio, desc, mgr->mgr.hw);
	485	if (err)
	486	return err;
	487
	488	dai->ops = &dai_ops;
	489	dai->hw = mgr->mgr.hw;
	490	err = hw->dai_get_ctrl_blk(&dai->ctrl_blk);
	491	if (err)
	492	goto error1;
	493
	494	for (rsr = 0, msr = desc->msr; msr > 1; msr >>= 1)
	495	rsr++;
	496
	497	hw->dai_srt_set_rsr(dai->ctrl_blk, rsr);
	498	hw->dai_srt_set_drat(dai->ctrl_blk, 0);
	499	/* default to disabling control of a SRC */
	500	hw->dai_srt_set_ec(dai->ctrl_blk, 0);
	501	hw->dai_srt_set_et(dai->ctrl_blk, 0); /* default to disabling SRT */
	502	hw->dai_commit_write(hw,
	503	daio_device_index(dai->daio.type, dai->hw), dai->ctrl_blk);
	504
	505	return 0;
	506
	507	error1:
	508	daio_rsc_uninit(&dai->daio);
	509	return err;
	510	}
	511
	512	static int dai_rsc_uninit(struct dai *dai)
	513	{
	514	((struct hw *)dai->hw)->dai_put_ctrl_blk(dai->ctrl_blk);
	515	dai->hw = dai->ctrl_blk = NULL;
	516	daio_rsc_uninit(&dai->daio);
	517	return 0;
	518	}
	519
	520	static int daio_mgr_get_rsc(struct rsc_mgr *mgr, enum DAIOTYP type)
	521	{
	522	if (((union daio_usage *)mgr->rscs)->data & (0x1 << type))
	523	return -ENOENT;
	524
	525	((union daio_usage *)mgr->rscs)->data \|= (0x1 << type);
	526
	527	return 0;
	528	}
	529
	530	static int daio_mgr_put_rsc(struct rsc_mgr *mgr, enum DAIOTYP type)
	531	{
	532	((union daio_usage *)mgr->rscs)->data &= ~(0x1 << type);
	533
	534	return 0;
	535	}
	536
	537	static int get_daio_rsc(struct daio_mgr *mgr,
	538	const struct daio_desc *desc,
	539	struct daio **rdaio)
	540	{
514eef9c	541	int err;
8cc72361 WYC	542	struct dai *dai = NULL;
	543	struct dao *dao = NULL;
	544	unsigned long flags;
	545
	546	*rdaio = NULL;
	547
	548	/* Check whether there are sufficient daio resources to meet request. */
	549	spin_lock_irqsave(&mgr->mgr_lock, flags);
	550	err = daio_mgr_get_rsc(&mgr->mgr, desc->type);
	551	spin_unlock_irqrestore(&mgr->mgr_lock, flags);
	552	if (err) {
	553	printk(KERN_ERR "Can't meet DAIO resource request!\n");
	554	return err;
	555	}
	556
	557	/* Allocate mem for daio resource */
	558	if (desc->type <= DAIO_OUT_MAX) {
	559	dao = kzalloc(sizeof(*dao), GFP_KERNEL);
35ebf6e7	560	if (!dao) {
8cc72361 WYC	561	err = -ENOMEM;
	562	goto error;
	563	}
	564	err = dao_rsc_init(dao, desc, mgr);
	565	if (err)
	566	goto error;
	567
	568	*rdaio = &dao->daio;
	569	} else {
	570	dai = kzalloc(sizeof(*dai), GFP_KERNEL);
35ebf6e7	571	if (!dai) {
8cc72361 WYC	572	err = -ENOMEM;
	573	goto error;
	574	}
	575	err = dai_rsc_init(dai, desc, mgr);
	576	if (err)
	577	goto error;
	578
	579	*rdaio = &dai->daio;
	580	}
	581
	582	mgr->daio_enable(mgr, *rdaio);
	583	mgr->commit_write(mgr);
	584
	585	return 0;
	586
	587	error:
35ebf6e7	588	if (dao)
8cc72361	589	kfree(dao);
35ebf6e7	590	else if (dai)
8cc72361 WYC	591	kfree(dai);
	592
	593	spin_lock_irqsave(&mgr->mgr_lock, flags);
	594	daio_mgr_put_rsc(&mgr->mgr, desc->type);
	595	spin_unlock_irqrestore(&mgr->mgr_lock, flags);
	596	return err;
	597	}
	598
	599	static int put_daio_rsc(struct daio_mgr mgr, struct daio daio)
	600	{
	601	unsigned long flags;
	602
	603	mgr->daio_disable(mgr, daio);
	604	mgr->commit_write(mgr);
	605
	606	spin_lock_irqsave(&mgr->mgr_lock, flags);
	607	daio_mgr_put_rsc(&mgr->mgr, daio->type);
	608	spin_unlock_irqrestore(&mgr->mgr_lock, flags);
	609
	610	if (daio->type <= DAIO_OUT_MAX) {
	611	dao_rsc_uninit(container_of(daio, struct dao, daio));
	612	kfree(container_of(daio, struct dao, daio));
	613	} else {
	614	dai_rsc_uninit(container_of(daio, struct dai, daio));
	615	kfree(container_of(daio, struct dai, daio));
	616	}
	617
	618	return 0;
	619	}
	620
	621	static int daio_mgr_enb_daio(struct daio_mgr mgr, struct daio daio)
	622	{
	623	struct hw *hw = mgr->mgr.hw;
	624
	625	if (DAIO_OUT_MAX >= daio->type) {
	626	hw->daio_mgr_enb_dao(mgr->mgr.ctrl_blk,
	627	daio_device_index(daio->type, hw));
	628	} else {
	629	hw->daio_mgr_enb_dai(mgr->mgr.ctrl_blk,
	630	daio_device_index(daio->type, hw));
	631	}
	632	return 0;
	633	}
	634
	635	static int daio_mgr_dsb_daio(struct daio_mgr mgr, struct daio daio)
	636	{
	637	struct hw *hw = mgr->mgr.hw;
	638
	639	if (DAIO_OUT_MAX >= daio->type) {
	640	hw->daio_mgr_dsb_dao(mgr->mgr.ctrl_blk,
	641	daio_device_index(daio->type, hw));
	642	} else {
	643	hw->daio_mgr_dsb_dai(mgr->mgr.ctrl_blk,
	644	daio_device_index(daio->type, hw));
	645	}
	646	return 0;
	647	}
	648
	649	static int daio_map_op(void data, struct imapper entry)
	650	{
	651	struct rsc_mgr mgr = &((struct daio_mgr )data)->mgr;
	652	struct hw *hw = mgr->hw;
	653
	654	hw->daio_mgr_set_imaparc(mgr->ctrl_blk, entry->slot);
655	hw->daio_mgr_set_imapnxt(mgr->ctrl_blk, entry->next);
656	hw->daio_mgr_set_imapaddr(mgr->ctrl_blk, entry->addr);
657	hw->daio_mgr_commit_write(mgr->hw, mgr->ctrl_blk);
658
659	return 0;
660	}
661
662	static int daio_imap_add(struct daio_mgr mgr, struct imapper entry)
663	{
664	unsigned long flags;
514eef9c	665	int err;
8cc72361 WYC	666
8cc72361 WYC	667	spin_lock_irqsave(&mgr->imap_lock, flags);
35ebf6e7	668	if (!entry->addr && mgr->init_imap_added) {
8cc72361 WYC	669	input_mapper_delete(&mgr->imappers, mgr->init_imap,
	670	daio_map_op, mgr);
	671	mgr->init_imap_added = 0;
	672	}
	673	err = input_mapper_add(&mgr->imappers, entry, daio_map_op, mgr);
	674	spin_unlock_irqrestore(&mgr->imap_lock, flags);
	675
	676	return err;
	677	}
	678
	679	static int daio_imap_delete(struct daio_mgr mgr, struct imapper entry)
	680	{
	681	unsigned long flags;
514eef9c	682	int err;
8cc72361 WYC	683
	684	spin_lock_irqsave(&mgr->imap_lock, flags);
	685	err = input_mapper_delete(&mgr->imappers, entry, daio_map_op, mgr);
	686	if (list_empty(&mgr->imappers)) {
	687	input_mapper_add(&mgr->imappers, mgr->init_imap,
	688	daio_map_op, mgr);
	689	mgr->init_imap_added = 1;
	690	}
	691	spin_unlock_irqrestore(&mgr->imap_lock, flags);
	692
	693	return err;
	694	}
	695
	696	static int daio_mgr_commit_write(struct daio_mgr *mgr)
	697	{
	698	struct hw *hw = mgr->mgr.hw;
	699
	700	hw->daio_mgr_commit_write(hw, mgr->mgr.ctrl_blk);
	701	return 0;
	702	}
	703
	704	int daio_mgr_create(void hw, struct daio_mgr *rdaio_mgr)
	705	{
514eef9c	706	int err, i;
8cc72361 WYC	707	struct daio_mgr *daio_mgr;
	708	struct imapper *entry;
	709
	710	*rdaio_mgr = NULL;
	711	daio_mgr = kzalloc(sizeof(*daio_mgr), GFP_KERNEL);
35ebf6e7	712	if (!daio_mgr)
8cc72361 WYC	713	return -ENOMEM;
	714
	715	err = rsc_mgr_init(&daio_mgr->mgr, DAIO, DAIO_RESOURCE_NUM, hw);
	716	if (err)
	717	goto error1;
	718
	719	spin_lock_init(&daio_mgr->mgr_lock);
	720	spin_lock_init(&daio_mgr->imap_lock);
	721	INIT_LIST_HEAD(&daio_mgr->imappers);
	722	entry = kzalloc(sizeof(*entry), GFP_KERNEL);
35ebf6e7	723	if (!entry) {
8cc72361 WYC	724	err = -ENOMEM;
	725	goto error2;
	726	}
	727	entry->slot = entry->addr = entry->next = entry->user = 0;
	728	list_add(&entry->list, &daio_mgr->imappers);
	729	daio_mgr->init_imap = entry;
	730	daio_mgr->init_imap_added = 1;
	731
	732	daio_mgr->get_daio = get_daio_rsc;
	733	daio_mgr->put_daio = put_daio_rsc;
	734	daio_mgr->daio_enable = daio_mgr_enb_daio;
	735	daio_mgr->daio_disable = daio_mgr_dsb_daio;
	736	daio_mgr->imap_add = daio_imap_add;
	737	daio_mgr->imap_delete = daio_imap_delete;
	738	daio_mgr->commit_write = daio_mgr_commit_write;
	739
	740	for (i = 0; i < 8; i++) {
	741	((struct hw *)hw)->daio_mgr_dsb_dao(daio_mgr->mgr.ctrl_blk, i);
	742	((struct hw *)hw)->daio_mgr_dsb_dai(daio_mgr->mgr.ctrl_blk, i);
	743	}
	744	((struct hw *)hw)->daio_mgr_commit_write(hw, daio_mgr->mgr.ctrl_blk);
	745
	746	*rdaio_mgr = daio_mgr;
	747
	748	return 0;
	749
	750	error2:
	751	rsc_mgr_uninit(&daio_mgr->mgr);
	752	error1:
	753	kfree(daio_mgr);
	754	return err;
	755	}
	756
	757	int daio_mgr_destroy(struct daio_mgr *daio_mgr)
	758	{
	759	unsigned long flags;
	760
	761	/* free daio input mapper list */
	762	spin_lock_irqsave(&daio_mgr->imap_lock, flags);
	763	free_input_mapper_list(&daio_mgr->imappers);
	764	spin_unlock_irqrestore(&daio_mgr->imap_lock, flags);
	765
	766	rsc_mgr_uninit(&daio_mgr->mgr);
	767	kfree(daio_mgr);
	768
	769	return 0;
	770	}
	771