path: root/drivers/media/tdmb/tcc3170/src/tcbd_api_common.c

/*
 * tcbd_api_common.c
 *
 * Author:  <linux@telechips.com>
 * Description: Telechips broadcast driver
 *
 * Copyright (c) Telechips, Inc.
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 2 as
 * published by the Free Software Foundation.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 */

#include "tcpal_os.h"
#include "tcpal_debug.h"

#include "tcbd_feature.h"
#include "tcbd_api_common.h"
#include "tcbd_drv_ip.h"
#include "tcbd_drv_io.h"
#include "tcbd_drv_rf.h"

#include "tcc317x_boot_tdmb.h"

s32 tcbd_device_start(
	struct tcbd_device *_device, enum tcbd_clock_type _clock_type)
{
	s32 ret = 0, ver;
	u8 *dsp_rom = TCC317X_BOOT_DATA_TDMB;
	s32 size = TCC317X_BOOT_SIZE_TDMB;

	/* Initialize PLL */
	tcbd_init_pll(_device, _clock_type);
	tcbd_init_buffer_region(_device);
	tcbd_init_div_io(_device, DIV_IO_TYPE_SINGLE);
	tcbd_enable_buffer(_device);
	tcbd_enable_peri(_device);
	ret = tcbd_init_dsp(_device, dsp_rom, size);
	if (ret < 0) {
		tcbd_debug(DEBUG_ERROR,
			"failed to initialize dsp!! error:%d\n", ret);
		return -TCERR_FATAL_ERROR;
	} else {
		tcbd_get_rom_version(_device, &ver);
		tcbd_debug(DEBUG_API_COMMON,
			"device start success!! version:0x%X\n", ver);
	}
	return 0;
}

s32 tcbd_enable_irq(struct tcbd_device *_device, u8 _en_bit)
{
	s32 ret = 0;

	if (!_device->is_pal_irq_en) {
		tcpal_irq_enable();
		_device->is_pal_irq_en = 1;
	}
	ret |= tcbd_reg_write(_device, TCBD_IRQ_STAT_CLR, TCBD_IRQ_STATCLR_ALL);
	ret |= tcbd_reg_write(_device, TCBD_IRQ_EN, _en_bit);
	_device->enabled_irq = _en_bit;
	return ret;
}

s32 tcbd_disable_irq(struct tcbd_device *_device, u8 _mask)
{
	s32 ret = 0;

	if (_device->is_pal_irq_en) {
		tcpal_irq_disable();
		_device->is_pal_irq_en = 0;
	}
	ret |= tcbd_reg_write(_device, TCBD_IRQ_STAT_CLR, TCBD_IRQ_STATCLR_ALL);
	ret |= tcbd_reg_write(_device, TCBD_IRQ_EN, _mask);
	return ret;
}

s32 tcbd_read_irq_status(
	struct tcbd_device *_device,
	u8 *_irq_status,
	u8 *_err_status)
{
	s32 ret = 0;
	short status;

	ret = tcbd_reg_write(_device, TCBD_IRQ_LATCH, 0x5E);
	ret |= tcbd_reg_read_burst_cont(
		_device, TCBD_IRQ_STAT_CLR, (u8 *)&status, 2);
	*_irq_status = status & 0xFF;
	*_err_status = (status >> 8) & 0xFF;
	return ret;
}

s32 tcbd_clear_irq(struct tcbd_device *_device, u8 _status)
{
	return tcbd_reg_write(_device, TCBD_IRQ_STAT_CLR, _status);
}

s32 tcbd_change_irq_mode(
	struct tcbd_device *_device, enum tcbd_intr_mode _mode)
{
	u8 mode = TCBD_IRQ_MODE_PAD_ENABLE;
	switch (_mode) {
	case INTR_MODE_LEVEL_HIGH:
		mode |= TCBD_IRQ_MODE_LEVEL | TCBD_IRQ_MODE_RISING;
		break;
	case INTR_MODE_LEVEL_LOW:
		mode |= TCBD_IRQ_MODE_LEVEL | TCBD_IRQ_MODE_FALLING;
		break;
	case INTR_MODE_EDGE_RISING:
		mode |= TCBD_IRQ_MODE_TRIGER | TCBD_IRQ_MODE_RISING;
		break;
	case INTR_MODE_EDGE_FALLING:
		mode |= TCBD_IRQ_MODE_TRIGER | TCBD_IRQ_MODE_FALLING;
		break;
	default:
		mode |= TCBD_IRQ_MODE_LEVEL | TCBD_IRQ_MODE_FALLING;
		break;
	}
	return tcbd_reg_write(_device, TCBD_IRQ_MODE, mode);
}

s32 tcbd_init_stream_data_config(
	struct tcbd_device *_device,
	u8 _use_cmd_fifo,
	u8 _buffer_mask,
	u32 _threshold)
{
	s32 ret = 0;
	u16 threshold = SWAP16((_threshold>>2));

	/* Disable internal buffer */
	ret |= tcbd_reg_write(_device, TCBD_STREAM_CFG0, 0);
	/* Change interrupt threshold */
	ret |= tcbd_reg_write_burst_cont(
		_device, TCBD_STREAM_CFG1, (u8 *)&threshold, 2);

	if (_use_cmd_fifo == ENABLE_CMD_FIFO)
		ret |= tcbd_reg_write(_device, TCBD_STREAM_CFG3, 0x12);
	else
		ret |= tcbd_reg_write(_device, TCBD_STREAM_CFG3, 0x10);

	tcbd_reset_ip(_device, TCBD_SYS_COMP_ALL, TCBD_SYS_COMP_EP);

	/* Enable internal buffer */
	ret |= tcbd_reg_write(_device, TCBD_STREAM_CFG0, _buffer_mask);

	_device->intr_threshold = _threshold;
	_device->selected_buff = _buffer_mask;
	_device->en_cmd_fifo = _use_cmd_fifo;

#if defined(__READ_VARIABLE_LENGTH__)
	_device->size_more_read = 0;
#endif /*__READ_VARIABLE_LENGTH__*/
	return ret;
}

#if defined(__READ_FIXED_LENGTH__)
s32 tcbd_read_stream(
	struct tcbd_device *_device, u8 *_buff,	s32 *_size)
{
	u32 bytes_read = _device->intr_threshold;

	if (bytes_read <= 0 || _buff == NULL)
		return -TCERR_INVALID_ARG;
/*
	tcbd_reg_write(_device, TCBD_STREAM_CFG3, 0x22);
	tcbd_reg_read_burst_cont(
		_device, TCBD_STREAM_CFG1, (u8 *)&bytes_remain, 2);
	bytes_remain = SWAP16(bytes_remain) << 2;

	tcbd_debug(DEBUG_STREAM_READ, "%d bytes read, %d bytes remain\n",
		bytes_read, bytes_remain);
*/
	*_size = bytes_read;

	return tcbd_reg_read_burst_fix(
		_device, TCBD_STREAM_CFG4, _buff, bytes_read);
}
#else /* __READ_VARIABLE_LENGTH__ */
s32 tcbd_read_stream(
	struct tcbd_device *_device, u8 *_buff,	s32 *_size)
{
	u32 bytes_remain = 0;
	u32 bytes_read = _device->intr_threshold;

	if (bytes_read <= 0 || _buff == NULL)
		return -TCERR_INVALID_ARG;

	tcbd_reg_write(_device, TCBD_STREAM_CFG3, 0x22);
	tcbd_reg_read_burst_cont(
		_device, TCBD_STREAM_CFG1, (u8 *)&bytes_remain, 2);

	/* bytes_remain is word count. x4 needed */
	bytes_remain = SWAP16(bytes_remain) << 2;
	bytes_read = bytes_read + bytes_remain - _device->size_more_read;
	tcbd_debug(DEBUG_STREAM_READ, "%d bytes remain, real data size:%d\n",
		bytes_remain, bytes_read);

	if ((_device->intr_threshold << 1) < bytes_read) {
		tcbd_debug(DEBUG_ERROR, "Could not read data over "
					"TCBD_MAX_THRESHOLD(%d)\n",
					bytes_read);
		return -TCERR_FATAL_ERROR;
	}
	_device->size_more_read = bytes_remain;
	*_size = bytes_read;
	return tcbd_reg_read_burst_fix(
		_device, TCBD_STREAM_CFG4, _buff, bytes_read);
}
#endif

s32 tcbd_tune_frequency(
	struct tcbd_device *_device, u32 _freq_khz, s32 _bw_khz)
{
	s32 ret = 0;
	u64 tick;

	tcbd_debug(DEBUG_API_COMMON, "freq:%d, bw:%d\n", _freq_khz, _bw_khz);

	memset(&_device->mult_service, 0, sizeof(_device->mult_service));
	tick = tcpal_get_time();
	if (_freq_khz < 1000000)
		_device->curr_band = BAND_TYPE_BAND3;
	else
		_device->curr_band = BAND_TYPE_LBAND;
	ret |= tcbd_reset_ip(
			_device, TCBD_SYS_COMP_ALL, TCBD_SYS_COMP_ALL);

	ret |= tcbd_rf_tune_frequency(_device, _freq_khz, _bw_khz);
	if (ret < 0) {
		tcbd_debug(DEBUG_ERROR,
			"failed to tune frequency to RF!! ret:%d\n", ret);
		return ret;
	}

	if (_device->peri_type == PERI_TYPE_SPI_ONLY) {
		/* enable fic buffer only*/
		ret |= tcbd_init_stream_data_config(
				_device,
				ENABLE_CMD_FIFO,
				STREAM_DATA_ENABLE |
					STREAM_HEADER_ON |
					STREAM_MASK_BUFFERA,
				TCBD_THRESHOLD_FIC);
	}
	tcbd_init_status_manager();

	ret |= tcbd_demod_tune_frequency(_device, _freq_khz, _bw_khz);
	if (ret < 0) {
		tcbd_debug(DEBUG_ERROR,
			"failed to tune frequency "
			"to demodulator!! ret:%d\n", ret);
		return ret;
	}
	_device->prev_band = _device->curr_band;
	_device->frequency = _freq_khz;

#if defined(__READ_VARIABLE_LENGTH__)
	_device->size_more_read = 0;
#endif /*__READ_VARIABLE_LENGTH__*/
	tcbd_debug(DEBUG_API_COMMON,
		" # Frequency set time :%lld\n", tcpal_diff_time(tick));

	return ret;
}

s32 tcbd_wait_tune(struct tcbd_device *_device, u8 *_status)
{
	s32 ret = 0;
	u8 cto, cfo, ofdm;
	u64 time_tick, time_tune_wait;

	time_tune_wait = TDMB_OFDMDETECT_LOCK * TDMB_OFDMDETECT_RETRY;
	time_tick = tcpal_get_time();
	do {
		ret = tcbd_reg_read(_device, TCBD_PROGRAMID, _status);
		if (ret < 0)
			goto exit_wait_tune;

		cto = ((*_status) >> 1) & 0x01;
		cfo = ((*_status) >> 2) & 0x01;
		if (cto && cfo)
			goto exit_wait_tune;

		ofdm = ((*_status) >> 5) & 0x01;
		if (ofdm)
			break;
	} while (tcpal_diff_time(time_tick) < time_tune_wait);

	if (ofdm == 0) {
		ret = -TCERR_TUNE_FAILED;
		goto exit_wait_tune;
	}

	time_tune_wait = (TDMB_CTO_LOCK * TDMB_CTO_RETRY) +
				   (TDMB_CTO_LOCK + TDMB_CFO_LOCK) *
				   TDMB_CFO_RETRY;
	time_tick = tcpal_get_time();
	do {
		ret = tcbd_reg_read(_device, TCBD_PROGRAMID, _status);
		if (ret < 0)
			goto exit_wait_tune;

		cto = ((*_status) >> 1) & 0x01;
		cfo = ((*_status) >> 2) & 0x01;
		if (cto && cfo)
			break;
	} while (tcpal_diff_time(time_tick) < time_tune_wait);

	if (cto && cfo)
		tcbd_debug(DEBUG_API_COMMON,
			"lock status : 0x%02X\n", *_status);
	else
		ret = -TCERR_TUNE_FAILED;

exit_wait_tune:
	return ret;
}

static inline s32 tcbd_calc_threshold(struct tcbd_service *_service)
{
	s32 threshold = 0;
	s32 uep_bitrate[] = {
		32, 48, 56, 64, 80, 96, 112, 128, 160, 192, 224, 256, 320, 384};

	switch (_service->ptype) {
	case PROTECTION_TYPE_UEP:
		threshold = (uep_bitrate[_service->bitrate] * 6) << 2;
		break;
	case PROTECTION_TYPE_EEP:
		threshold = (_service->bitrate * 6) << 5;
		break;
	}

	if (TCBD_MAX_THRESHOLD < threshold)
		threshold  = TCBD_MAX_THRESHOLD;

	tcbd_debug(DEBUG_API_COMMON,
		"ptype:%s, bitrate :%d, interrupt threshold:%d\n",
			(_service->ptype) ? "EEP" : "UEP",
			 _service->bitrate, threshold);

	return threshold;
}

static inline s32 tcbd_find_empty_slot(
	struct tcbd_multi_service *_multi_svc)
{
	s32 i;

	for (i = 0; i < TCBD_MAX_NUM_SERVICE; i++) {
		if (_multi_svc->on_air[i] == 0)
			return i;
	}
	return -1;
}

static inline s32 tcbd_find_used_slot(
	struct tcbd_multi_service *_multi_svc, u8 _subch_id)
{
	s32 i;
	u32 *service_info = _multi_svc->service_info;

	if (_multi_svc->service_count == 0)
		return -1;

	for (i = 0; i < TCBD_MAX_NUM_SERVICE; i++) {
		if (((service_info[i * 2] >> 20) & 0x3F) == _subch_id)
			return i;
	}
	return -1;
}

static inline s32 tcbd_set_service(
	struct tcbd_device *_device, struct tcbd_service *_service)
{
	s32 ret = 0;
	u32 threshold, sel_buff = 0, sel_stream = 0;
	u8 en_cmd_fifo = 0;

	switch (_device->peri_type) {
	case PERI_TYPE_SPI_ONLY:
#if defined(__CALC_INTRRUPT_THRESHOLD__)
		threshold = tcbd_calc_threshold(_service);
		sel_stream = STREAM_SET_GARBAGE(threshold) |
				STREAM_TYPE_ALL;
#else /* __CALC_INTRRUPT_THRESHOLD__ */
		threshold = TCBD_MAX_THRESHOLD;
		sel_stream = STREAM_SET_GARBAGE(TCBD_MAX_THRESHOLD) |
				STREAM_TYPE_ALL;
#endif /* __CALC_INTRRUPT_THRESHOLD__ */
		tcbd_debug(DEBUG_API_COMMON, "threshold : %d\n", threshold);
		en_cmd_fifo = ENABLE_CMD_FIFO;
		sel_buff = STREAM_DATA_ENABLE |
			STREAM_HEADER_ON |
			STREAM_MASK_BUFFERA |
			STREAM_MASK_BUFFERB;
		break;
	case PERI_TYPE_STS:
		en_cmd_fifo = DISABLE_CMD_FIFO;
		sel_stream = STREAM_TYPE_ALL;
		sel_buff = STREAM_DATA_ENABLE |
			STREAM_MASK_BUFFERA |
			STREAM_MASK_BUFFERB;
		break;
	default:
		tcbd_debug(DEBUG_ERROR, "not implemented!\n");
		return -1;
	}

#if !defined(__ALWAYS_FIC_ON__)
	sel_stream &= ~(STREAM_TYPE_FIC);
#endif /*__ALWAYS_FIC_ON__*/

#if defined(__STATUS_IN_REGISTER__)
	sel_stream &= ~(STREAM_TYPE_STATUS);
#endif /* __STATUS_IN_REGISTER__ */

#if defined(__READ_VARIABLE_LENGTH__)
	_device->size_more_read = 0;
#endif /*__READ_VARIABLE_LENGTH__*/

	ret |= tcbd_change_stream_type(_device, sel_stream);
	ret |= tcbd_init_stream_data_config(
		_device, en_cmd_fifo, sel_buff, threshold);

	ret |= tcbd_send_service_info(_device);
	ret |= tcbd_enable_irq(_device, _device->enabled_irq);
	return ret;
}

s32 tcbd_register_service(
	struct tcbd_device *_device, u8 _subch_id, u8 _data_mode)
{
	s32 empty_slot, empty_slot2x;
	struct tcbd_service service = {0, };
	struct tcbd_multi_service *mult_service = &_device->mult_service;
	u32 *service_info = mult_service->service_info;

	if (tcbd_find_used_slot(mult_service, _subch_id) >= 0) {
		tcbd_debug(DEBUG_ERROR,
			"aready registerd service! "
			"subch_id:%d\n", _subch_id);
		return -TCERR_AREADY_REGISTERED;
	}

	empty_slot = tcbd_find_empty_slot(mult_service);
	if (empty_slot < 0) {
		tcbd_debug(DEBUG_ERROR, "Exceed maxinum number of service!!\n");
		return -TCERR_MAX_NUM_SERVICE;
	}
	service.subch_id = _subch_id;
	empty_slot2x = empty_slot << 1;
	mult_service->on_air[empty_slot] = 1;
	mult_service->service_count++;

	tcbd_debug(DEBUG_API_COMMON, "sub channel:%d, data mode:%d\n",
		_subch_id, _data_mode);
	service_info[empty_slot2x] =
		(_subch_id << 20) |
		(2 << 26);
	service_info[empty_slot2x + 1] =
		(empty_slot << 20) |
		(_data_mode << 16);

	return tcbd_set_service(_device, &service);
}

s32 tcbd_register_service_long(
	struct tcbd_device *_device, struct tcbd_service *_service)
{
	s32 empty_slot, empty_slot2x;
	u32 data_mode = 0;
	struct tcbd_multi_service *mult_service = &_device->mult_service;
	u32 *service_info = mult_service->service_info;

	if (tcbd_find_used_slot(mult_service, _service->subch_id) >= 0) {
		tcbd_debug(DEBUG_ERROR,
					"aready registerd service! "
					"subch_id:%d\n", _service->subch_id);
		return -TCERR_AREADY_REGISTERED;
	}

	empty_slot = tcbd_find_empty_slot(mult_service);
	if (empty_slot < 0) {
		tcbd_debug(DEBUG_ERROR, "Exceed maxinum number of service!!\n");
		return -TCERR_MAX_NUM_SERVICE;
	}

	switch (_service->type) {
	case SERVICE_TYPE_DAB:
	case SERVICE_TYPE_DABPLUS:
	case SERVICE_TYPE_DATA:
		data_mode = 0; break;
	case SERVICE_TYPE_DMB:
		data_mode = 1; break;
	default:
		data_mode = 2; break;
	}

	empty_slot2x = empty_slot << 1;
	mult_service->on_air[empty_slot] = 1;
	mult_service->service_count++;

	service_info[empty_slot2x]  =
		(_service->reconfig << 26) |
		(_service->subch_id << 20) |
		(_service->size_cu << 10) |
		_service->start_cu;
	service_info[empty_slot2x + 1] =
		(empty_slot << 20) |
		/*(0 << 18) |*/
		(data_mode << 16) |
		(_service->ptype << 11) |
		(_service->plevel << 8) |
		_service->bitrate;

	return tcbd_set_service(_device, _service);
}

s32 tcbd_unregister_service(
	struct tcbd_device *_device, u8 _subch_id)
{
	s32 ret = 0;
	s32 service_idx;
	struct tcbd_multi_service *mult_service = &_device->mult_service;
	u32 *service_info = mult_service->service_info;

	tcbd_disable_irq(_device, 0);
	service_idx = tcbd_find_used_slot(mult_service, _subch_id);
	if (service_idx < 0) {
		tcbd_debug(DEBUG_ERROR, "not registered service!\n");
		return -TCERR_SERVICE_NOT_FOUND;
	}
	/*tcbd_disable_peri(_device);*/

	service_info[service_idx * 2] = 0x00;
	service_info[service_idx * 2 + 1] = 0x00;
	mult_service->on_air[service_idx] = 0;
	mult_service->service_count--;

	ret |= tcbd_send_service_info(_device);
	return ret;
}

s32 tcbd_read_fic_data(
	struct tcbd_device *_device, u8 *_buff,	s32 _size)
{
	s32 ret = 0;
	u32 addr_fic_buff;
	u8 status, err_status;
	u64 tick;

	if (_size != TCBD_FIC_SIZE) {
		tcbd_debug(DEBUG_ERROR, "wrong fic size! %d\n", _size);
		return -TCERR_INVALID_ARG;
	}

	ret = tcbd_read_irq_status(_device, &status, &err_status);
	if (status & TCBD_IRQ_STAT_FIFOAINIT) {
		addr_fic_buff = PHY_MEM_ADDR_A_START;
		tick = tcpal_get_time();
		tcbd_debug(0, "status:0x%02X, err:0x%02X, %lld elapsed\n",
				status, err_status, tcpal_diff_time(tick));

		ret = tcbd_mem_read(_device, addr_fic_buff, _buff, _size);
		ret |= tcbd_clear_irq(_device, status);
	} else {
		ret |= -TCERR_NO_FIC_DATA;
	}

	ret |= tcbd_clear_irq(_device, status);
	return ret;
}

s32 tcbd_read_signal_info(
	struct tcbd_device *_device,
	struct tcbd_status_data *_status_data)
{
	s32 ret = 0;
#if defined(__STATUS_IN_REGISTER__)
	u8 status[32] = {0, };
#endif /*__STATUS_IN_REGISTER__*/

	if (!_status_data)
		return -TCERR_INVALID_ARG;

#if defined(__STATUS_IN_REGISTER__)
	ret = tcbd_reg_write(_device, TCBD_OP_STATUS0, 0x1);
	ret |= tcbd_reg_read_burst_fix(_device,
		TCBD_OP_STATUS1, status, TCBD_STATUS_SIZE);
	tcbd_update_status(status, TCBD_STATUS_SIZE, _status_data);
#elif defined(__STATUS_IN_STREAM__)

	tcbd_update_status(NULL, 0, _status_data);
#endif /*__STATUS_IN_STREAM__*/
	return ret;
}