[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_OUT_MAX		SPDIFOO

struct daio_usage {
	unsigned short data;
};

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

static 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},
};

static 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},
	[MIC]	 = {.left = 0x55, .right = 0xd5},
	[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 const struct rsc_ops daio_out_rsc_ops = {
	.master		= daio_master,
	.next_conj	= daio_out_next_conj,
	.index		= daio_index,
	.output_slot	= NULL,
};

static const 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 const 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;
		case MIC:	return 5;
		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)
{
	dao->hw->dao_get_spos(dao->ctrl_blk, spos);
	return 0;
}

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

static int dao_commit_write(struct dao *dao)
{
	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 const 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);
	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);
	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++;

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

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

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

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

static const 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,
			 struct hw *hw)
{
	int err;
	unsigned int idx_l, idx_r;

	switch (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 (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(array3_size(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;
	}
	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)
{
	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 (((struct daio_usage *)mgr->rscs)->data & (0x1 << type))
		return -ENOENT;

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

	return 0;
}

static int daio_mgr_put_rsc(struct rsc_mgr *mgr, enum DAIOTYP type)
{
	((struct 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;
	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) {
		dev_err(mgr->card->dev,
			"Can't meet DAIO resource request!\n");
		return err;
	}

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

		err = dao_rsc_init(dao, desc, mgr);
		if (err) {
			kfree(dao);
			goto error;
		}

		*rdaio = &dao->daio;
	} else {
		struct dai *dai = kzalloc(sizeof(*dai), GFP_KERNEL);
		if (!dai)
			goto error;

		err = dai_rsc_init(dai, desc, mgr);
		if (err) {
			kfree(dai);
			goto error;
		}

		*rdaio = &dai->daio;
	}

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

	return 0;

error:
	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(struct hw *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, NUM_DAIOTYP, 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;
	daio_mgr->card = hw->card;

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