marvell/services/audio/libacm/acm/src/acm_elba.c

/*
* All Rights Reserved
*
* MARVELL CONFIDENTIAL
* Copyright 2012 Marvell International Ltd All Rights Reserved.
* The source code contained or described herein and all documents related to
* the source code ("Material") are owned by Marvell International Ltd or its
* suppliers or licensors. Title to the Material remains with Marvell International Ltd
* or its suppliers and licensors. The Material contains trade secrets and
* proprietary and confidential information of Marvell or its suppliers and
* licensors. The Material is protected by worldwide copyright and trade secret
* laws and treaty provisions. No part of the Material may be used, copied,
* reproduced, modified, published, uploaded, posted, transmitted, distributed,
* or disclosed in any way without Marvell's prior express written permission.
*
* No license under any patent, copyright, trade secret or other intellectual
* property right is granted to or conferred upon you by disclosure or delivery
* of the Materials, either expressly, by implication, inducement, estoppel or
* otherwise. Any license under such intellectual property rights must be
* express and approved by Marvell in writing.
*
*/

#define LOG_TAG "acm_ach_elba"
#define LOG_NDEBUG 0

#include <cutils/log.h>
#include "acm_elba.h"

int codec_reg_num = NUM_OF_REGS;

static void Elba_Enable(void);
static void Elba_Disable(void);
static void Elba_Reset(void);
static void Elba_GetTypeAndID(int *type, unsigned char *id);
static ACH_ReturnCode Elba_Handle(void *setting);

ACH_ComponentHandler elba_handler = {
    COMPONENT_INACTIVE,
    0,
    Elba_Enable,
    Elba_Disable,
    Elba_Reset,
    Elba_GetTypeAndID,
    Elba_Handle,
};

extern int I2CInit(void);
extern int I2CDeInit(void);
extern void I2CWrite(unsigned char numid, unsigned short value);
extern void I2CBurstWrite(unsigned char numid, unsigned char size, unsigned char *value);
extern void I2CRead(unsigned char numid, unsigned char *value);
extern void I2CBurstRead(unsigned char numid, unsigned char *value, int size, int offset);

#ifdef PXA1826_AUDIO
#ifndef ACM_ALSA_INIT
#define ACM_ALSA_INIT
#endif
#endif

#ifdef DEBUG_FAKE_ACH
#undef ACM_ALSA_INIT
#endif


static void Elba_RegSet(unsigned char numid, unsigned short value) {
#ifndef DEBUG_FAKE_ACH
    I2CWrite(numid, value);
#else
	LOGD(Elba_RegSet, "  FAKE_ACH: %s(0x%x, 0x%x)", __FUNCTION__, numid, value);
#endif
}

static void Elba_RegBurstSet(unsigned char numid, unsigned char size, unsigned char *value) {
#ifndef DEBUG_FAKE_ACH
    I2CBurstWrite(numid, size, value);
#else
	LOGD(Elba_RegBurstSet, "  FAKE_ACH: %s(0x%x, 0x%x, ..)", __FUNCTION__, numid, size);
#endif
}

void Elba_RegGet(unsigned char numid, unsigned char *value) {
#ifndef DEBUG_FAKE_ACH
    I2CRead(numid, value);
#else
	LOGD(Elba_RegGet, "  FAKE_ACH: %s(0x%x, ..)", __FUNCTION__, numid);
#endif
}

void Elba_RegBurstGet(unsigned char numid, unsigned char *value, int size, int offset) {
#ifndef DEBUG_FAKE_ACH
    I2CBurstRead(numid, value, size, offset);
#else
	LOGD(Elba_RegBurstGet, "  FAKE_ACH: %s(0x%x, .., 0x%x, 0x%x)", __FUNCTION__, numid, size, offset);
#endif
}

static void Elba_ResetRegCache() {
    int size = sizeof(reg_cache) / sizeof(reg_cache[0]);
    int i = 0;

    for (i = 0; i < size; i++) {
        reg_cache[i].reg_value = reg_cache[i].reg_default;
    }
}

unsigned char Elba_GetRegNumId(unsigned char reg_index) {
    unsigned char i = 0;

    for (i = 0; i < NUM_OF_REGS; i++) {
        if (reg_cache[i].reg_index == reg_index) {
            return REG_NUMID_BASE + i;
        }
    }

    return 0;
}

//--------------------------------------------------------------
//-------- External ACH APIs
//--------------------------------------------------------------
#ifdef ACM_ALSA_INIT
// NOTE about pair Enable/Disable
//  On startup Disable could be called without Enable as Init/Reset sequence
//  Let's "force" I2CInit() for first only Disable without Enable
//
static int _acm_initialized = 0;
#endif

static void Elba_Enable(void) {
    LOGI(Elba_Enable, "%s: enable elba component", __FUNCTION__);

    unsigned char elba_pu = 0;
    unsigned int elba_max_boot_count = 100;

#ifdef ACM_ALSA_INIT
    LOGI(Elba_Enable, "%s: _acm_initialized=%d!", __FUNCTION__, _acm_initialized);
	_acm_initialized = 1;
	I2CInit(); //adaptor to alsa-mixer
#endif
    reg_cache[ELBA_MAIN_POWERUP_ID].reg_value = 0x03;
    Elba_RegSet(ELBA_MAIN_POWERUP_ID, 0x03);
    Elba_RegGet(ELBA_AUTO_SEQUENCE_STS_1, &elba_pu);
    while (!(elba_pu & (1 << ELBA_SEQ_PU_READY)) && elba_max_boot_count) {
        usleep(1000);
        Elba_RegGet(ELBA_AUTO_SEQUENCE_STS_1, &elba_pu);
        elba_max_boot_count--;
    }

    if (!elba_max_boot_count) {
        LOGE(Elba_Enable1, "%s: power up elba failed", __FUNCTION__);
    } else {
        // Disable HP short autorecovery.
        // Register 0x0A = 0x02.
        reg_cache[ELBA_HP_SHRT_AR_ID].reg_value = 0x02;
        Elba_RegSet(ELBA_HP_SHRT_AR_ID, 0x02);
    }
}

static void Elba_Disable(void) {
    LOGI(Elba_Disable, "%s: disable elba component", __FUNCTION__);

#ifdef ACM_ALSA_INIT
	if (!_acm_initialized) {
		_acm_initialized = 1;
		I2CInit(); //adaptor to alsa-mixer
	}
#endif
    reg_cache[ELBA_MAIN_POWERUP_ID].reg_value = 0;
    Elba_RegSet(ELBA_MAIN_POWERUP_ID, 0);
    usleep(2000);
#ifdef ACM_ALSA_INIT
	I2CDeInit(); //adaptor to alsa-mixer
#endif
}

static void Elba_Reset(void) {
    LOGI(Elba_Reset, "%s: Reset elba registers!", __FUNCTION__);
    int size = sizeof(reg_cache) / sizeof(reg_cache[0]);
    int size_col = sizeof(reg_cache[0]) / sizeof(unsigned char);
    int i, k = 0;
    unsigned char j, numid, value, cache_idx;
    Elba_RegisterCache reg_cache_inorder[size];

#ifdef ACM_ALSA_INIT
	I2CInit(); //make sure to enable mixer before and close after this operation
#endif
    for (j = 0x0; j <= 0xff; j++){
        if (k == size){
            LOGI(Elba_Reset1, "%s: copy completed !", __FUNCTION__);
            break;
        }

        for (i = 0; i < size; i++) {
            if (reg_cache[i].reg_prior == j) {
                memcpy(&reg_cache_inorder[k], &reg_cache[i], size_col);
                k++;
            }
        }
    }

    for (k = 0; k < size; k++) {
        if (reg_cache_inorder[k].reg_prior == 0x0) {
            continue;
        } else {
            break;
        }
    }

    for (; k < size; k++) {
        numid = Elba_GetRegNumId(reg_cache_inorder[k].reg_index);
        if (numid == 0 || numid == ELBA_COEFF_ID) {
            LOGW(Elba_Reset2, "%s: Invalid or useless numid = %d!", __FUNCTION__, numid);
            continue;
        }

        if (numid == ELBA_MAIN_POWERUP_ID) {
            value = 0x03;
        } else {
            value = reg_cache_inorder[k].reg_default;
        }

        cache_idx = numid - REG_NUMID_BASE;
        if (cache_idx < size)
            reg_cache[cache_idx].reg_value = value;
        Elba_RegSet(numid, value);
#ifdef DEBUG_ELBA
        LOGI(Elba_Reset3, "%s: resets elba register 0x%lx to value --> 0x%lx",
            __FUNCTION__,
            reg_cache_inorder[k].reg_index,
            value);
#endif
    }

    Elba_RegSet(ELBA_MAIN_POWERUP_ID, 0x00);
#ifdef ACM_ALSA_INIT
	I2CDeInit(); //make sure to enable mixer before and close after this operation
#endif
}

static void Elba_GetTypeAndID(int *type, unsigned char *id) {
#ifdef ACM_ALSA_INIT
	I2CInit(); //make sure to enable mixer before and close after this operation
#endif
    LOGI(Elba_GetTypeAndID, "%s: Get type and ID for elba component", __FUNCTION__);
    *type = COMPONENT_TYPE_CODEC;
    Elba_RegGet(ELBA_ID_REG, id);
#ifdef ACM_ALSA_INIT
	I2CDeInit(); //make sure to enable mixer before and close after this operation
#endif
}

static ACH_ReturnCode Elba_Handle(void *setting) {
    ACH_ComponentParameter *param = (ACH_ComponentParameter *)setting;
    unsigned short i = 0;
    unsigned short numid, value, cache_idx;

    if (param && param->i2c.reg_value) {
        numid = Elba_GetRegNumId(param->i2c.reg_index);

        LOGI(Elba_Handle, "%s: REG_NUMID_BASE=%d, numid=%d. set register 0x%lx values:0x%lx ",
                    __FUNCTION__, REG_NUMID_BASE, numid, param->i2c.reg_index,  *(param->i2c.reg_value));

        if (numid > 0) {
            if (param->i2c.length == 2) {
                //compare with register cache
                cache_idx = numid - REG_NUMID_BASE;
                value = (reg_cache[cache_idx].reg_value & ~param->i2c.reg_mask) | (*param->i2c.reg_value);

                if (((reg_cache[cache_idx].reg_value & param->i2c.reg_mask) != (*param->i2c.reg_value)) ||
                    // For HP short start reset
                    ((reg_cache[cache_idx].reg_index) == 0x28))
                {
#ifdef DEBUG_ELBA
                    LOGI(Elba_Handle, "%s: cache_idx=%d, numid=%d. set register 0x%lx [0x%lx --> 0x%lx]",
                        __FUNCTION__,
                        cache_idx,
                        numid,
                        param->i2c.reg_index,
                        reg_cache[cache_idx].reg_value,
                        value);
#endif
                    reg_cache[cache_idx].reg_value = value;
                    //Elba_RegSet(numid, reg_cache[cache_idx].reg_value);
                    Elba_RegSet(numid, value);
                } else {
#ifdef DEBUG_ELBA
                    LOGI(Elba_Handle1, "%s: set register 0x%lx [0x%lx --> 0x%lx] (unchanged)",
                        __FUNCTION__,
                        param->i2c.reg_index,
                        reg_cache[cache_idx].reg_value,
                        reg_cache[cache_idx].reg_value);
#endif
                }
            } else if (param->i2c.length > 2) {
                //FIXME current no register cache is provided for mixer/eq configuration
#ifdef DEBUG_ELBA
                LOGI(Elba_Handle2, "%s: numid=%d. set register 0x%lx values:", __FUNCTION__, numid, param->i2c.reg_index);
                for (i = 0; i < param->i2c.length; i++) {
                    LOGI(Elba_Handle3, "%s: \t\t\t    -->0x%lx", __FUNCTION__, param->i2c.reg_value[i]);
                }
#endif

                Elba_RegBurstSet(numid, param->i2c.length, param->i2c.reg_value);
            }
        }
    }

    return ACH_RC_OK;
}