[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;

	/* 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;

	/* 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;
	178
	179	/* Program master and conjugate resources */
	180	input->ops->master(input);
	181	daio->rscl.ops->master(&daio->rscl);
	182	for (i = 0; i < daio->rscl.msr; i++, entry++) {
	183	entry->slot = input->ops->output_slot(input);
	184	entry->user = entry->addr = daio->rscl.ops->index(&daio->rscl);
	185	dao->mgr->imap_add(dao->mgr, entry);
	186	dao->imappers[i] = entry;
	187
	188	input->ops->next_conj(input);
	189	daio->rscl.ops->next_conj(&daio->rscl);
	190	}
	191	input->ops->master(input);
	192	daio->rscl.ops->master(&daio->rscl);
	193
	194	return 0;
	195	}
	196
	197	static int dao_set_right_input(struct dao dao, struct rsc input)
	198	{
514eef9c	199	struct imapper *entry;
8cc72361	200	struct daio *daio = &dao->daio;
514eef9c	201	int i;
8cc72361 WYC	202
8cc72361 WYC	203	entry = kzalloc((sizeof(entry) daio->rscr.msr), GFP_KERNEL);
35ebf6e7	204	if (!entry)
8cc72361 WYC	205	return -ENOMEM;
	206
	207	/* Program master and conjugate resources */
	208	input->ops->master(input);
	209	daio->rscr.ops->master(&daio->rscr);
	210	for (i = 0; i < daio->rscr.msr; i++, entry++) {
	211	entry->slot = input->ops->output_slot(input);
	212	entry->user = entry->addr = daio->rscr.ops->index(&daio->rscr);
	213	dao->mgr->imap_add(dao->mgr, entry);
	214	dao->imappers[daio->rscl.msr + i] = entry;
	215
	216	input->ops->next_conj(input);
	217	daio->rscr.ops->next_conj(&daio->rscr);
	218	}
	219	input->ops->master(input);
	220	daio->rscr.ops->master(&daio->rscr);
	221
	222	return 0;
	223	}
	224
	225	static int dao_clear_left_input(struct dao *dao)
	226	{
514eef9c	227	struct imapper *entry;
8cc72361	228	struct daio *daio = &dao->daio;
514eef9c	229	int i;
8cc72361	230
35ebf6e7	231	if (!dao->imappers[0])
8cc72361 WYC	232	return 0;
	233
	234	entry = dao->imappers[0];
	235	dao->mgr->imap_delete(dao->mgr, entry);
	236	/* Program conjugate resources */
	237	for (i = 1; i < daio->rscl.msr; i++) {
	238	entry = dao->imappers[i];
	239	dao->mgr->imap_delete(dao->mgr, entry);
	240	dao->imappers[i] = NULL;
	241	}
	242
	243	kfree(dao->imappers[0]);
	244	dao->imappers[0] = NULL;
	245
	246	return 0;
	247	}
	248
	249	static int dao_clear_right_input(struct dao *dao)
	250	{
514eef9c	251	struct imapper *entry;
8cc72361	252	struct daio *daio = &dao->daio;
514eef9c	253	int i;
8cc72361	254
35ebf6e7	255	if (!dao->imappers[daio->rscl.msr])
8cc72361 WYC	256	return 0;
	257
	258	entry = dao->imappers[daio->rscl.msr];
	259	dao->mgr->imap_delete(dao->mgr, entry);
	260	/* Program conjugate resources */
	261	for (i = 1; i < daio->rscr.msr; i++) {
	262	entry = dao->imappers[daio->rscl.msr + i];
	263	dao->mgr->imap_delete(dao->mgr, entry);
	264	dao->imappers[daio->rscl.msr + i] = NULL;
	265	}
	266
	267	kfree(dao->imappers[daio->rscl.msr]);
	268	dao->imappers[daio->rscl.msr] = NULL;
	269
	270	return 0;
	271	}
	272
	273	static struct dao_rsc_ops dao_ops = {
	274	.set_spos = dao_spdif_set_spos,
	275	.commit_write = dao_commit_write,
	276	.get_spos = dao_spdif_get_spos,
	277	.reinit = dao_rsc_reinit,
	278	.set_left_input = dao_set_left_input,
	279	.set_right_input = dao_set_right_input,
	280	.clear_left_input = dao_clear_left_input,
	281	.clear_right_input = dao_clear_right_input,
	282	};
	283
	284	static int dai_set_srt_srcl(struct dai dai, struct rsc src)
	285	{
	286	src->ops->master(src);
	287	((struct hw *)dai->hw)->dai_srt_set_srcm(dai->ctrl_blk,
	288	src->ops->index(src));
	289	return 0;
	290	}
	291
	292	static int dai_set_srt_srcr(struct dai dai, struct rsc src)
	293	{
	294	src->ops->master(src);
	295	((struct hw *)dai->hw)->dai_srt_set_srco(dai->ctrl_blk,
	296	src->ops->index(src));
	297	return 0;
	298	}
	299
	300	static int dai_set_srt_msr(struct dai *dai, unsigned int msr)
	301	{
514eef9c	302	unsigned int rsr;
8cc72361 WYC	303
	304	for (rsr = 0; msr > 1; msr >>= 1)
	305	rsr++;
	306
	307	((struct hw *)dai->hw)->dai_srt_set_rsr(dai->ctrl_blk, rsr);
	308	return 0;
	309	}
	310
	311	static int dai_set_enb_src(struct dai *dai, unsigned int enb)
	312	{
	313	((struct hw *)dai->hw)->dai_srt_set_ec(dai->ctrl_blk, enb);
	314	return 0;
	315	}
	316
	317	static int dai_set_enb_srt(struct dai *dai, unsigned int enb)
	318	{
	319	((struct hw *)dai->hw)->dai_srt_set_et(dai->ctrl_blk, enb);
	320	return 0;
	321	}
	322
	323	static int dai_commit_write(struct dai *dai)
	324	{
	325	((struct hw *)dai->hw)->dai_commit_write(dai->hw,
	326	daio_device_index(dai->daio.type, dai->hw), dai->ctrl_blk);
	327	return 0;
	328	}
	329
	330	static struct dai_rsc_ops dai_ops = {
	331	.set_srt_srcl = dai_set_srt_srcl,
	332	.set_srt_srcr = dai_set_srt_srcr,
	333	.set_srt_msr = dai_set_srt_msr,
	334	.set_enb_src = dai_set_enb_src,
	335	.set_enb_srt = dai_set_enb_srt,
	336	.commit_write = dai_commit_write,
	337	};
	338
	339	static int daio_rsc_init(struct daio *daio,
	340	const struct daio_desc *desc,
	341	void *hw)
	342	{
514eef9c TI	343	int err;
514eef9c TI	344	unsigned int idx_l, idx_r;
8cc72361	345
9470195a	346	switch (((struct hw *)hw)->chip_type) {
8cc72361 WYC	347	case ATC20K1:
	348	idx_l = idx_20k1[desc->type].left;
	349	idx_r = idx_20k1[desc->type].right;
	350	break;
	351	case ATC20K2:
	352	idx_l = idx_20k2[desc->type].left;
	353	idx_r = idx_20k2[desc->type].right;
	354	break;
	355	default:
	356	return -EINVAL;
	357	}
	358	err = rsc_init(&daio->rscl, idx_l, DAIO, desc->msr, hw);
	359	if (err)
	360	return err;
	361
	362	err = rsc_init(&daio->rscr, idx_r, DAIO, desc->msr, hw);
	363	if (err)
	364	goto error1;
	365
	366	/* Set daio->rscl/r->ops to daio specific ones */
	367	if (desc->type <= DAIO_OUT_MAX) {
	368	daio->rscl.ops = daio->rscr.ops = &daio_out_rsc_ops;
	369	} else {
9470195a	370	switch (((struct hw *)hw)->chip_type) {
8cc72361 WYC	371	case ATC20K1:
	372	daio->rscl.ops = daio->rscr.ops = &daio_in_rsc_ops_20k1;
	373	break;
	374	case ATC20K2:
	375	daio->rscl.ops = daio->rscr.ops = &daio_in_rsc_ops_20k2;
	376	break;
	377	default:
	378	break;
	379	}
	380	}
	381	daio->type = desc->type;
	382
	383	return 0;
	384
	385	error1:
	386	rsc_uninit(&daio->rscl);
	387	return err;
	388	}
	389
	390	static int daio_rsc_uninit(struct daio *daio)
	391	{
	392	rsc_uninit(&daio->rscl);
	393	rsc_uninit(&daio->rscr);
	394
	395	return 0;
	396	}
	397
	398	static int dao_rsc_init(struct dao *dao,
	399	const struct daio_desc *desc,
	400	struct daio_mgr *mgr)
	401	{
	402	struct hw *hw = mgr->mgr.hw;
514eef9c TI	403	unsigned int conf;
514eef9c TI	404	int err;
8cc72361 WYC	405
	406	err = daio_rsc_init(&dao->daio, desc, mgr->mgr.hw);
	407	if (err)
	408	return err;
	409
	410	dao->imappers = kzalloc(sizeof(void )desc->msr*2, GFP_KERNEL);
35ebf6e7	411	if (!dao->imappers) {
8cc72361 WYC	412	err = -ENOMEM;
	413	goto error1;
	414	}
	415	dao->ops = &dao_ops;
	416	dao->mgr = mgr;
	417	dao->hw = hw;
	418	err = hw->dao_get_ctrl_blk(&dao->ctrl_blk);
	419	if (err)
	420	goto error2;
	421
	422	hw->daio_mgr_dsb_dao(mgr->mgr.ctrl_blk,
	423	daio_device_index(dao->daio.type, hw));
	424	hw->daio_mgr_commit_write(hw, mgr->mgr.ctrl_blk);
	425
514eef9c	426	conf = (desc->msr & 0x7) \| (desc->passthru << 3);
8cc72361 WYC	427	hw->daio_mgr_dao_init(mgr->mgr.ctrl_blk,
	428	daio_device_index(dao->daio.type, hw), conf);
	429	hw->daio_mgr_enb_dao(mgr->mgr.ctrl_blk,
	430	daio_device_index(dao->daio.type, hw));
	431	hw->daio_mgr_commit_write(hw, mgr->mgr.ctrl_blk);
	432
	433	return 0;
	434
	435	error2:
	436	kfree(dao->imappers);
	437	dao->imappers = NULL;
	438	error1:
	439	daio_rsc_uninit(&dao->daio);
	440	return err;
	441	}
	442
	443	static int dao_rsc_uninit(struct dao *dao)
	444	{
35ebf6e7 TI	445	if (dao->imappers) {
35ebf6e7 TI	446	if (dao->imappers[0])
8cc72361 WYC	447	dao_clear_left_input(dao);
8cc72361 WYC	448
35ebf6e7	449	if (dao->imappers[dao->daio.rscl.msr])
8cc72361 WYC	450	dao_clear_right_input(dao);
	451
	452	kfree(dao->imappers);
	453	dao->imappers = NULL;
	454	}
	455	((struct hw *)dao->hw)->dao_put_ctrl_blk(dao->ctrl_blk);
	456	dao->hw = dao->ctrl_blk = NULL;
	457	daio_rsc_uninit(&dao->daio);
	458
	459	return 0;
	460	}
	461
	462	static int dao_rsc_reinit(struct dao dao, const struct dao_desc desc)
	463	{
	464	struct daio_mgr *mgr = dao->mgr;
	465	struct daio_desc dsc = {0};
	466
	467	dsc.type = dao->daio.type;
	468	dsc.msr = desc->msr;
	469	dsc.passthru = desc->passthru;
	470	dao_rsc_uninit(dao);
	471	return dao_rsc_init(dao, &dsc, mgr);
	472	}
	473
	474	static int dai_rsc_init(struct dai *dai,
	475	const struct daio_desc *desc,
	476	struct daio_mgr *mgr)
	477	{
514eef9c	478	int err;
8cc72361	479	struct hw *hw = mgr->mgr.hw;
514eef9c	480	unsigned int rsr, msr;
8cc72361 WYC	481
	482	err = daio_rsc_init(&dai->daio, desc, mgr->mgr.hw);
	483	if (err)
	484	return err;
	485
	486	dai->ops = &dai_ops;
	487	dai->hw = mgr->mgr.hw;
	488	err = hw->dai_get_ctrl_blk(&dai->ctrl_blk);
	489	if (err)
	490	goto error1;
	491
	492	for (rsr = 0, msr = desc->msr; msr > 1; msr >>= 1)
	493	rsr++;
	494
	495	hw->dai_srt_set_rsr(dai->ctrl_blk, rsr);
	496	hw->dai_srt_set_drat(dai->ctrl_blk, 0);
	497	/* default to disabling control of a SRC */
	498	hw->dai_srt_set_ec(dai->ctrl_blk, 0);
	499	hw->dai_srt_set_et(dai->ctrl_blk, 0); /* default to disabling SRT */
	500	hw->dai_commit_write(hw,
	501	daio_device_index(dai->daio.type, dai->hw), dai->ctrl_blk);
	502
	503	return 0;
	504
	505	error1:
	506	daio_rsc_uninit(&dai->daio);
	507	return err;
	508	}
	509
	510	static int dai_rsc_uninit(struct dai *dai)
	511	{
	512	((struct hw *)dai->hw)->dai_put_ctrl_blk(dai->ctrl_blk);
	513	dai->hw = dai->ctrl_blk = NULL;
	514	daio_rsc_uninit(&dai->daio);
	515	return 0;
	516	}
	517
	518	static int daio_mgr_get_rsc(struct rsc_mgr *mgr, enum DAIOTYP type)
	519	{
	520	if (((union daio_usage *)mgr->rscs)->data & (0x1 << type))
	521	return -ENOENT;
	522
	523	((union daio_usage *)mgr->rscs)->data \|= (0x1 << type);
	524
	525	return 0;
	526	}
	527
	528	static int daio_mgr_put_rsc(struct rsc_mgr *mgr, enum DAIOTYP type)
	529	{
	530	((union daio_usage *)mgr->rscs)->data &= ~(0x1 << type);
	531
	532	return 0;
	533	}
	534
	535	static int get_daio_rsc(struct daio_mgr *mgr,
	536	const struct daio_desc *desc,
	537	struct daio **rdaio)
	538	{
514eef9c	539	int err;
8cc72361 WYC	540	struct dai *dai = NULL;
	541	struct dao *dao = NULL;
	542	unsigned long flags;
	543
	544	*rdaio = NULL;
	545
	546	/* Check whether there are sufficient daio resources to meet request. */
	547	spin_lock_irqsave(&mgr->mgr_lock, flags);
	548	err = daio_mgr_get_rsc(&mgr->mgr, desc->type);
	549	spin_unlock_irqrestore(&mgr->mgr_lock, flags);
	550	if (err) {
	551	printk(KERN_ERR "Can't meet DAIO resource request!\n");
	552	return err;
	553	}
	554
	555	/* Allocate mem for daio resource */
	556	if (desc->type <= DAIO_OUT_MAX) {
	557	dao = kzalloc(sizeof(*dao), GFP_KERNEL);
35ebf6e7	558	if (!dao) {
8cc72361 WYC	559	err = -ENOMEM;
	560	goto error;
	561	}
	562	err = dao_rsc_init(dao, desc, mgr);
	563	if (err)
	564	goto error;
	565
	566	*rdaio = &dao->daio;
	567	} else {
	568	dai = kzalloc(sizeof(*dai), GFP_KERNEL);
35ebf6e7	569	if (!dai) {
8cc72361 WYC	570	err = -ENOMEM;
	571	goto error;
	572	}
	573	err = dai_rsc_init(dai, desc, mgr);
	574	if (err)
	575	goto error;
	576
	577	*rdaio = &dai->daio;
	578	}
	579
	580	mgr->daio_enable(mgr, *rdaio);
	581	mgr->commit_write(mgr);
	582
	583	return 0;
	584
	585	error:
35ebf6e7	586	if (dao)
8cc72361	587	kfree(dao);
35ebf6e7	588	else if (dai)
8cc72361 WYC	589	kfree(dai);
	590
	591	spin_lock_irqsave(&mgr->mgr_lock, flags);
	592	daio_mgr_put_rsc(&mgr->mgr, desc->type);
	593	spin_unlock_irqrestore(&mgr->mgr_lock, flags);
	594	return err;
	595	}
	596
	597	static int put_daio_rsc(struct daio_mgr mgr, struct daio daio)
	598	{
	599	unsigned long flags;
	600
	601	mgr->daio_disable(mgr, daio);
	602	mgr->commit_write(mgr);
	603
	604	spin_lock_irqsave(&mgr->mgr_lock, flags);
	605	daio_mgr_put_rsc(&mgr->mgr, daio->type);
	606	spin_unlock_irqrestore(&mgr->mgr_lock, flags);
	607
	608	if (daio->type <= DAIO_OUT_MAX) {
	609	dao_rsc_uninit(container_of(daio, struct dao, daio));
	610	kfree(container_of(daio, struct dao, daio));
	611	} else {
	612	dai_rsc_uninit(container_of(daio, struct dai, daio));
	613	kfree(container_of(daio, struct dai, daio));
	614	}
	615
	616	return 0;
	617	}
	618
	619	static int daio_mgr_enb_daio(struct daio_mgr mgr, struct daio daio)
	620	{
	621	struct hw *hw = mgr->mgr.hw;
	622
	623	if (DAIO_OUT_MAX >= daio->type) {
	624	hw->daio_mgr_enb_dao(mgr->mgr.ctrl_blk,
	625	daio_device_index(daio->type, hw));
	626	} else {
	627	hw->daio_mgr_enb_dai(mgr->mgr.ctrl_blk,
	628	daio_device_index(daio->type, hw));
	629	}
	630	return 0;
	631	}
	632
	633	static int daio_mgr_dsb_daio(struct daio_mgr mgr, struct daio daio)
	634	{
	635	struct hw *hw = mgr->mgr.hw;
	636
	637	if (DAIO_OUT_MAX >= daio->type) {
	638	hw->daio_mgr_dsb_dao(mgr->mgr.ctrl_blk,
	639	daio_device_index(daio->type, hw));
	640	} else {
	641	hw->daio_mgr_dsb_dai(mgr->mgr.ctrl_blk,
	642	daio_device_index(daio->type, hw));
	643	}
	644	return 0;
	645	}
	646
	647	static int daio_map_op(void data, struct imapper entry)
	648	{
	649	struct rsc_mgr mgr = &((struct daio_mgr )data)->mgr;
	650	struct hw *hw = mgr->hw;
	651
	652	hw->daio_mgr_set_imaparc(mgr->ctrl_blk, entry->slot);
653	hw->daio_mgr_set_imapnxt(mgr->ctrl_blk, entry->next);
654	hw->daio_mgr_set_imapaddr(mgr->ctrl_blk, entry->addr);
655	hw->daio_mgr_commit_write(mgr->hw, mgr->ctrl_blk);
656
657	return 0;
658	}
659
660	static int daio_imap_add(struct daio_mgr mgr, struct imapper entry)
661	{
662	unsigned long flags;
514eef9c	663	int err;
8cc72361 WYC	664
8cc72361 WYC	665	spin_lock_irqsave(&mgr->imap_lock, flags);
35ebf6e7	666	if (!entry->addr && mgr->init_imap_added) {
8cc72361 WYC	667	input_mapper_delete(&mgr->imappers, mgr->init_imap,
	668	daio_map_op, mgr);
	669	mgr->init_imap_added = 0;
	670	}
	671	err = input_mapper_add(&mgr->imappers, entry, daio_map_op, mgr);
	672	spin_unlock_irqrestore(&mgr->imap_lock, flags);
	673
	674	return err;
	675	}
	676
	677	static int daio_imap_delete(struct daio_mgr mgr, struct imapper entry)
	678	{
	679	unsigned long flags;
514eef9c	680	int err;
8cc72361 WYC	681
	682	spin_lock_irqsave(&mgr->imap_lock, flags);
	683	err = input_mapper_delete(&mgr->imappers, entry, daio_map_op, mgr);
	684	if (list_empty(&mgr->imappers)) {
	685	input_mapper_add(&mgr->imappers, mgr->init_imap,
	686	daio_map_op, mgr);
	687	mgr->init_imap_added = 1;
	688	}
	689	spin_unlock_irqrestore(&mgr->imap_lock, flags);
	690
	691	return err;
	692	}
	693
	694	static int daio_mgr_commit_write(struct daio_mgr *mgr)
	695	{
	696	struct hw *hw = mgr->mgr.hw;
	697
	698	hw->daio_mgr_commit_write(hw, mgr->mgr.ctrl_blk);
	699	return 0;
	700	}
	701
	702	int daio_mgr_create(void hw, struct daio_mgr *rdaio_mgr)
	703	{
514eef9c	704	int err, i;
8cc72361 WYC	705	struct daio_mgr *daio_mgr;
	706	struct imapper *entry;
	707
	708	*rdaio_mgr = NULL;
	709	daio_mgr = kzalloc(sizeof(*daio_mgr), GFP_KERNEL);
35ebf6e7	710	if (!daio_mgr)
8cc72361 WYC	711	return -ENOMEM;
	712
	713	err = rsc_mgr_init(&daio_mgr->mgr, DAIO, DAIO_RESOURCE_NUM, hw);
	714	if (err)
	715	goto error1;
	716
	717	spin_lock_init(&daio_mgr->mgr_lock);
	718	spin_lock_init(&daio_mgr->imap_lock);
	719	INIT_LIST_HEAD(&daio_mgr->imappers);
	720	entry = kzalloc(sizeof(*entry), GFP_KERNEL);
35ebf6e7	721	if (!entry) {
8cc72361 WYC	722	err = -ENOMEM;
	723	goto error2;
	724	}
	725	entry->slot = entry->addr = entry->next = entry->user = 0;
	726	list_add(&entry->list, &daio_mgr->imappers);
	727	daio_mgr->init_imap = entry;
	728	daio_mgr->init_imap_added = 1;
	729
	730	daio_mgr->get_daio = get_daio_rsc;
	731	daio_mgr->put_daio = put_daio_rsc;
	732	daio_mgr->daio_enable = daio_mgr_enb_daio;
	733	daio_mgr->daio_disable = daio_mgr_dsb_daio;
	734	daio_mgr->imap_add = daio_imap_add;
	735	daio_mgr->imap_delete = daio_imap_delete;
	736	daio_mgr->commit_write = daio_mgr_commit_write;
	737
	738	for (i = 0; i < 8; i++) {
	739	((struct hw *)hw)->daio_mgr_dsb_dao(daio_mgr->mgr.ctrl_blk, i);
	740	((struct hw *)hw)->daio_mgr_dsb_dai(daio_mgr->mgr.ctrl_blk, i);
	741	}
	742	((struct hw *)hw)->daio_mgr_commit_write(hw, daio_mgr->mgr.ctrl_blk);
	743
	744	*rdaio_mgr = daio_mgr;
	745
	746	return 0;
	747
	748	error2:
	749	rsc_mgr_uninit(&daio_mgr->mgr);
	750	error1:
	751	kfree(daio_mgr);
	752	return err;
	753	}
	754
	755	int daio_mgr_destroy(struct daio_mgr *daio_mgr)
	756	{
	757	unsigned long flags;
	758
	759	/* free daio input mapper list */
	760	spin_lock_irqsave(&daio_mgr->imap_lock, flags);
	761	free_input_mapper_list(&daio_mgr->imappers);
	762	spin_unlock_irqrestore(&daio_mgr->imap_lock, flags);
	763
	764	rsc_mgr_uninit(&daio_mgr->mgr);
	765	kfree(daio_mgr);
	766
	767	return 0;
	768	}
	769