Ejemplos de bbm_read en C++ (Cpp)

Ejemplo n.º 1

Archivo: fc8180_isr.c Proyecto: MikeForeskin/Vindicator-S6

void fc8180_isr(HANDLE handle)
{
#ifdef BBM_AUX_INT
	u8 aux_int_status = 0;
#endif

#ifndef BBM_I2C_TSIF
	u8 buf_int_status = 0;
	bbm_read(handle, BBM_BUF_STATUS, &buf_int_status);
	if (buf_int_status) {
		bbm_write(handle, BBM_BUF_STATUS, buf_int_status);
		fc8180_data(handle, buf_int_status);
	}

	/* Overrun */
	buf_int_status = 0;
	bbm_read(handle, BBM_BUF_STATUS, &buf_int_status);
	if (buf_int_status) {
		bbm_write(handle, BBM_BUF_STATUS, buf_int_status);
		fc8180_data(handle, buf_int_status);
	}
#endif

#ifdef BBM_AUX_INT
	bbm_byte_read(handle, BBM_AUX_STATUS_CLEAR, &aux_int_status);

	if (aux_int_status) {
		bbm_byte_write(handle, BBM_AUX_STATUS_CLEAR, aux_int_status);

		fc8180_aux_int(handle, aux_int_status);
	}
#endif
}

Ejemplo n.º 2

Archivo: fci_i2c.c Proyecto: VanirAOSP/kernel_lge_f320k

static int WaitForXfer (HANDLE hDevice)
{
	int res = I2C_OK;
#ifdef FEATURE_SIMPLE_INTERFACE
	udelay(30);
#else
	int i;
	u8 status;

	i = I2C_TIMEOUT * 20000;
	// wait for transfer complete
	do {
		bbm_read(hDevice, BBM_I2C_SR, &status);
		i--;
	} while ((i > 0) && (status & I2CSTAT_TIP));

	// check time out or nack
	if(status & I2CSTAT_TIP) {
		res = I2C_NOK_TOUT;
	} else {
		bbm_read(hDevice, BBM_I2C_SR, &status);
		if(status & I2CSTAT_NACK) res = I2C_NACK;
		else res = I2C_OK;
	}
#endif
	return res;
}

Ejemplo n.º 3

Archivo: fci_i2c.c Proyecto: CM11MOD/android_kernel_pantech_ef60s

static int WaitForXfer (HANDLE hDevice)
{
  int i;
  int res = I2C_OK;
  u8 status;

  i = I2C_TIMEOUT * 10000;
  // wait for transfer complete
  do {
    bbm_read(hDevice, BBM_I2C_SR, &status);
    i--;
  } while ((i > 0) && (status & I2CSTAT_TIP));

  // check time out or nack
  if(status & I2CSTAT_TIP)
  {
    res = I2C_NOK_TOUT;
  }
  else
  {
    bbm_read(hDevice, BBM_I2C_SR, &status);
    if(status & I2CSTAT_NACK) res = I2C_NACK;
    else res = I2C_OK;
  }

  return res;
}

Ejemplo n.º 4

Archivo: fc8101_bb.c Proyecto: TeamRegular/android_kernel_lge_iproj

int fc8101_scan_status(HANDLE hDevice)
{
	int res = BBM_NOK;
	int i;
	unsigned char lock_data;
	unsigned char first_timeout = 6;
	unsigned char second_timeout = 70;

	for(i=0; i<first_timeout; i++)
	{
		res = bbm_read(hDevice, BBM_STATEF, &lock_data);

		if(res)
			return res;

		if(lock_data >= 0x4)
		{
			res = BBM_OK;
			break;
		}

		msWait(10);
	}

	if(i == first_timeout)
		return BBM_NOK;

	for(i=0; i<second_timeout; i++)
	{
		res = bbm_read(hDevice, BBM_STATEF, &lock_data);
		
		if(res)
			return res;

		if(lock_data == 0xA)
		{
			res = BBM_OK;
			break;
		}
		msWait(10);
	}

	if(i == second_timeout)
		return BBM_NOK;

	return res;
}

Ejemplo n.º 5

Archivo: bbm.c Proyecto: LGaljo/android_kernel_samsung_s3ve3g

s32 bbm_com_read(HANDLE handle, DEVICEID devid, u16 addr, u8 *data)
{
	s32 res;

	res = bbm_read(handle, devid, addr, data);

	return res;
}

Ejemplo n.º 6

Archivo: bbm.c Proyecto: iTechnoguy/kernel-nk1-negalite-lt02ltespr

int bbm_com_read(HANDLE hDevice, u16 addr, u8 *data)
{
    int res;

    res = bbm_read(hDevice, addr, data);

    return res;
}

Ejemplo n.º 7

Archivo: bbm.c Proyecto: CL0SeY/i957kernel

int BBM_READ(HANDLE hDevice, u16 addr, u8 *data)
{
	int res;

	res = bbm_read(hDevice, addr, data);

	return res;
}

Ejemplo n.º 8

Archivo: fc8300_tun.c Proyecto: GalaxyTab4/android_kernel_samsung_matissewifi.bak

static s32 fc8300_bb_read(HANDLE handle, DEVICEID devid, u16 addr, u8 *data)
{
	s32 res;

	res = bbm_read(handle, devid, addr, data);

	return res;
}

Ejemplo n.º 9

Archivo: bbm.c Proyecto: LEPT-Development/Android_kernel_lge_C50

fci_s32 bbm_com_read(HANDLE handle, fci_u16 addr, fci_u8 *data)
{
    fci_s32 res;

    res = bbm_read(handle, addr, data);

    return res;
}

Ejemplo n.º 10

Archivo: fc8150_isr.c Proyecto: AbdulrahmanAmir/Dorimanx-LG-G2-D802-Kernel

void fc8150_isr(HANDLE hDevice)
{
	u8 bufIntStatus = 0;

	bbm_read(hDevice, BBM_BUF_STATUS, &bufIntStatus);
	if(bufIntStatus) {
		bbm_write(hDevice, BBM_BUF_STATUS, bufIntStatus);
		fc8150_data(hDevice, bufIntStatus);
	}

	bufIntStatus = 0;
	bbm_read(hDevice, BBM_BUF_STATUS, &bufIntStatus);
	if(bufIntStatus) {
		bbm_write(hDevice, BBM_BUF_STATUS, bufIntStatus);
		fc8150_data(hDevice, bufIntStatus);
	}
}

Ejemplo n.º 11

Archivo: fc8150_isr.c Proyecto: adis1313/android_kernel_samsung_msm8974

void fc8150_isr(HANDLE hDevice)
{
	u8 bufIntStatus = 0;

	bbm_read(hDevice, BBM_BUF_STATUS, &bufIntStatus);
	PRINTF(0, "(SJINU %s) bufIntStatus\%d\n", __func__, bufIntStatus);
	if (bufIntStatus) {
		bbm_write(hDevice, BBM_BUF_STATUS, bufIntStatus);
		fc8150_data(hDevice, bufIntStatus);
	}

	bufIntStatus = 0;
	bbm_read(hDevice, BBM_BUF_STATUS, &bufIntStatus);
	if (bufIntStatus) {
		bbm_write(hDevice, BBM_BUF_STATUS, bufIntStatus);
		fc8150_data(hDevice, bufIntStatus);
	}
}

Ejemplo n.º 12

Archivo: fc8050_isr.c Proyecto: regit66/android_kernel_lge_geehrc

void fc8050_isr_interruptclear(void)
{
	fci_u8	extIntStatus = 0;
	HANDLE hDevice = NULL;

	bbm_read(hDevice, BBM_COM_INT_STATUS, &extIntStatus);
	bbm_write(hDevice, BBM_COM_INT_STATUS, extIntStatus);
	bbm_write(hDevice, BBM_COM_INT_STATUS, 0x00);
}

Ejemplo n.º 13

Archivo: fc8150_isr.c Proyecto: ChangYeoun/10.1

void fc8150_isr(HANDLE hDevice)
{
	u8 IntStatus = 0;
	u8 bufIntStatus = 0;
	
	bbm_read(hDevice, BBM_INT_STATUS, &IntStatus);
	bbm_write(hDevice, BBM_INT_STATUS, IntStatus);
	if(lge_get_board_revno() < HW_REV_C)
		bbm_write(hDevice, BBM_INT_STATUS, 0);
	
	bbm_read(hDevice, BBM_BUF_STATUS, &bufIntStatus);
	if(bufIntStatus) {
		bbm_write(hDevice, BBM_BUF_STATUS, bufIntStatus);
		if(lge_get_board_revno() < HW_REV_C)
			bbm_write(hDevice, BBM_BUF_STATUS, 0);
			
		fc8150_data(hDevice, bufIntStatus);
	}
}

Ejemplo n.º 14

Archivo: fc8080_bb.c Proyecto: GAXUSXX/G935FGaXusKernel2

s32 fc8080_channel_deselect(HANDLE handle, u8 subch_id, u8 buf_id)
{
	u8 buf_en = 0;

	bbm_read(handle, BBM_BUF_ENABLE, &buf_en);
	bbm_write(handle, BBM_BUF_ENABLE, buf_en & (~(1 << buf_id)));
	bbm_write(handle, BBM_SCH0_SET_IDI + buf_id, 0);

	return BBM_OK;
}

Ejemplo n.º 15

Archivo: fc8080_bb.c Proyecto: MH2033/VIPER_KERNEL_LP_D802

fci_s32 fc8080_channel_select(HANDLE handle, fci_u8 subch_id, fci_u8 buf_id)
{
	fci_u8 buf_en = 0;

	bbm_read(handle, BBM_BUF_ENABLE, &buf_en);
	bbm_write(handle, BBM_BUF_ENABLE, buf_en | (1 << buf_id));

	bbm_write(handle, BBM_SCH0_SET_IDI + buf_id, 0x40 | subch_id);

	return BBM_OK;
}

Ejemplo n.º 16

Archivo: fc8150_isr.c Proyecto: DAGr8/kernel_samsung_hltecan

void fc8150_isr(HANDLE hDevice)
{
#ifdef FEATURE_INT_AUTO_MODE
	fc8150_data(hDevice, 1);
#else
	u8 bufIntStatus = 0;
	bbm_read(hDevice, BBM_BUF_STATUS, &bufIntStatus);
	if (bufIntStatus) {
		bbm_write(hDevice, BBM_BUF_STATUS, bufIntStatus);
		fc8150_data(hDevice, bufIntStatus);
	}

	/* Overrun */
	bufIntStatus = 0;
	bbm_read(hDevice, BBM_BUF_STATUS, &bufIntStatus);
	if (bufIntStatus) {
		bbm_write(hDevice, BBM_BUF_STATUS, bufIntStatus);
		fc8150_data(hDevice, bufIntStatus);
	}
#endif
}

Ejemplo n.º 17

Archivo: fc8080_bb.c Proyecto: GAXUSXX/G935FGaXusKernel2

s32 fc8080_video_deselect(HANDLE handle, u8 subch_id, u8 buf_id, u8 cdi_id)
{
	u16 fec_en = 0;
	u8 buf_en = 0;

	bbm_write(handle, BBM_BUF_CH0_SUBID + buf_id, 0x00);
	bbm_word_read(handle, BBM_MSC_CFG_SCH0, &fec_en);

	if (!((fec_en & 0xff00) && (fec_en & 0x00ff) && cdi_id == 0))
		bbm_write(handle, BBM_MSC_CFG_SCH0 + cdi_id, 0x00);

	if (fc8080_channel_deselect(handle, subch_id, buf_id) != BBM_OK)
		return BBM_NOK;

	bbm_read(handle, BBM_BUF_CH0_SUBID, &buf_en);

	if (buf_en == 0 && (fec_en & 0xff00) && cdi_id == 1)
		bbm_write(handle, BBM_MSC_CFG_SCH0, 0x00);

	return BBM_OK;
}

Ejemplo n.º 18

Archivo: fc8080_isr.c Proyecto: Eudemony/note4_kernel_test

static void fc8080_data(HANDLE handle, u16 status)
{
	u16 size;
	s32 i;
	if (status & 0x0100) {
		bbm_word_read(handle, BBM_BUF_FIC_THR, &size);
		size++;

		bbm_data(handle, BBM_RD_FIC, &fic_buffer[0], size);
#ifdef CONFIG_TDMB_SPI
		if (fic_callback)
			(*fic_callback)(fic_user_data, &fic_buffer[4], size);
#else
		if (fic_callback)
			(*fic_callback)(fic_user_data, &fic_buffer[0], size);
#endif
	}

	for (i = 0; i < 3; i++) {
		u8 subch_id;

		if (!(status & (1 << i)))
			continue;
		bbm_word_read(handle, BBM_BUF_CH0_THR + i * 2, &size);
		size++;
		bbm_read(handle, BBM_BUF_CH0_SUBID + i, &subch_id);
		subch_id &= 0x3f;
		bbm_data(handle, (BBM_RD_BUF0 + i), &msc_buffer[0], size);
#ifdef CONFIG_TDMB_SPI
		if (msc_callback)
			(*msc_callback)(msc_user_data, subch_id, &msc_buffer[4],
						size);
#else
		if (msc_callback)
			(*msc_callback)(msc_user_data, subch_id, &msc_buffer[0],
						size);
#endif
	}
}

Ejemplo n.º 19

Archivo: fc8050_bb.c Proyecto: adyjl/DORIMANX_LG_STOCK_LP_KERNEL

int fc8050_scan_status(HANDLE hDevice) {
    int i, res = BBM_NOK;
    fci_u8  mode = 0, status = 0, sync_status = 0;
    int slock_cnt, flock_cnt, dlock_cnt;

    bbm_read(hDevice, BBM_SYNC_DET_CNTRL, &mode);

    if((mode & 0x01) == 0x01) {
        slock_cnt = SLOCK_MAX_TIME / LOCK_TIME_TICK;
        flock_cnt = FLOCK_MAX_TIME / LOCK_TIME_TICK;
        dlock_cnt = DLOCK_MAX_TIME / LOCK_TIME_TICK;

        // OFDM Detect
        for(i = 0; i < slock_cnt; i++) {
            if(!msWait(LOCK_TIME_TICK))
                return BBM_NOK;

            bbm_read(hDevice, BBM_SYNC_DET_STATUS, &status);

            if(status & 0x01)
                break;
        }

        if(i == slock_cnt)
            return BBM_NOK;

        if((status & 0x02) == 0x00)
            return BBM_NOK;

        // FRS
        for(i += 1; i < flock_cnt; i++) {
            if(!msWait(LOCK_TIME_TICK))
                return BBM_NOK;

            bbm_read(hDevice, BBM_SYNC_STATUS, &sync_status);

            if(sync_status & 0x01)
                break;
        }

        if (i == flock_cnt)
            return BBM_NOK;

        // Digital Lock
        for(i += 1; i < dlock_cnt; i++) {
            if(!msWait(LOCK_TIME_TICK))
                return BBM_NOK;

            bbm_read(hDevice, BBM_SYNC_STATUS, &sync_status);

            if(sync_status & 0x20)
                return BBM_OK;
        }
    } else {
        dlock_cnt = DLOCK_MAX_TIME / LOCK_TIME_TICK;

        for(i = 0; i < dlock_cnt; i++) {
            if(!msWait(LOCK_TIME_TICK))
                return BBM_NOK;

            bbm_read(hDevice, BBM_SYNC_STATUS, &sync_status);
            if(sync_status & 0x20) {
                return BBM_OK;
            }
        }
    }

    return res;
}

Ejemplo n.º 20

Archivo: fc8300_isr.c Proyecto: LGaljo/android_kernel_samsung_s3ve3g

static void fc8300_data(HANDLE handle, DEVICEID devid, u8 buf_int_status)
{
	u32 size = 0;
	s32 i;
	u8 overrun;

	ISDB_PR_DBG("FC8300_DATA buf_int : 0x%x \n", buf_int_status);
	for (i = 0; (i < 4) && (buf_int_status & 0x0f); i++) {
		if (buf_int_status & (1 << i)) {
			bbm_word_read(handle, devid,
					BBM_BUF_TS0_THR + (i << 1),
					(u16 *) &size);

			ISDB_PR_DBG("ThSize[%d] : %d \n", i, (size + 1) << 1);

			if (size == 0)
				continue;

			size = (size + 1) << 1;

			if ((size > 188*320))
				continue;

			bbm_data(handle, devid,
					BBM_TS0_DATA + i, &ts_buffer[0], size);
			ISDB_PR_DBG("fc8300_data size : %d, [0x%x][0x%x][0x%x][0x%x]\n"
				, size, ts_buffer[0], ts_buffer[1], ts_buffer[2], ts_buffer[3]);

			if (fc8300_ts_callback)
			{
				ISDB_PR_DBG("fc8300_ts_callback\n");
				(*fc8300_ts_callback)(fc8300_ts_user_data,
						i, &ts_buffer[0], size);
			}			
		}
	}
#if 0			//Fix PLM P140206-02359
	for (i = 4; i < 8 && (buf_int_status & 0xf0); i++) {
		if (buf_int_status & (1 << i)) {
			bbm_word_read(handle, devid,
					BBM_BUF_TS0_THR + (i << 1),
					(u16 *) &size);

			if (size == 0)
				continue;

			size = (size + 1) << 1;

			bbm_data(handle, devid,
					BBM_TS0_DATA + i, &ac_buffer[0], size);

			if (fc8300_ac_callback)
			{
				ISDB_PR_DBG("fc8300_ac_callback\n");
				(*fc8300_ac_callback)(fc8300_ac_user_data,
						i, &ac_buffer[0], size);
			}			
		}
	}
#endif

	bbm_read(handle, DIV_BROADCAST, BBM_BUF_OVERRUN, &overrun);
	if (overrun)
		bbm_write(handle, DIV_BROADCAST, BBM_BUF_OVERRUN, overrun);
		ISDB_PR_DBG("ISR OVR : 0x%x, INT : 0x%x, SIZE : %d \n"
			, overrun, buf_int_status, size);

}

Ejemplo n.º 21

Archivo: fci_i2c.c Proyecto: VanirAOSP/kernel_lge_f320k

static int fci_i2c_transfer (HANDLE hDevice, u8 cmd_type, u8 chip, u8 addr[], u8 addr_len, u8 data[], u8 data_len)
{
	int i;	
	int result = I2C_OK;
#ifdef FEATURE_SIMPLE_INTERFACE
	u16 cmd;
#endif

	switch (cmd_type) {
		case I2C_WRITE:
#ifdef FEATURE_SIMPLE_INTERFACE
			cmd = (I2C_CR_STA | I2C_CR_WR);
			cmd = (cmd<<8) | (chip | cmd_type);
			bbm_word_write(hDevice, BBM_I2C_TXR, cmd);
#else
			bbm_write(hDevice, BBM_I2C_TXR, chip | cmd_type);
			bbm_write(hDevice, BBM_I2C_CR, I2C_CR_STA | I2C_CR_WR /*0x90*/);
#endif
			result = WaitForXfer(hDevice);
			if(result != I2C_OK) return result;
			
			if (addr && addr_len) {
				i = 0;
				while ((i < addr_len) && (result == I2C_OK)) {
#ifdef FEATURE_SIMPLE_INTERFACE
					cmd = (I2C_CR_WR);
					cmd = (cmd<<8) | (addr[i]);
					bbm_word_write(hDevice, BBM_I2C_TXR, cmd);
#else
					bbm_write(hDevice, BBM_I2C_TXR, addr[i]);
					bbm_write(hDevice, BBM_I2C_CR, I2C_CR_WR /*0x10*/);
#endif
					result = WaitForXfer(hDevice);
					if(result != I2C_OK) return result;
					i++;
				}
			}
			
			i = 0;
			while ((i < data_len) && (result == I2C_OK)) {
#ifdef FEATURE_SIMPLE_INTERFACE
				cmd = (I2C_CR_WR);
				cmd = (cmd<<8) | (data[i]);
				bbm_word_write(hDevice, BBM_I2C_TXR, cmd);
#else
				bbm_write(hDevice, BBM_I2C_TXR, data[i]);
				bbm_write(hDevice, BBM_I2C_CR, I2C_CR_WR /*0x10*/);
#endif
				
				result = WaitForXfer(hDevice);
				if(result != I2C_OK) return result;
				i++;
			}

			bbm_write(hDevice, BBM_I2C_CR, I2C_CR_STO /*0x40*/);
			result = WaitForXfer(hDevice);
			if(result != I2C_OK) return result;
			break;
		case I2C_READ:
			if (addr && addr_len) {
#ifdef FEATURE_SIMPLE_INTERFACE
				cmd = (I2C_CR_STA | I2C_CR_WR);
				cmd = (cmd<<8) | (chip | I2C_WRITE);
				bbm_word_write(hDevice, BBM_I2C_TXR, cmd);
#else
				bbm_write(hDevice, BBM_I2C_TXR, chip | I2C_WRITE);
				bbm_write(hDevice, BBM_I2C_CR, I2C_CR_STA | I2C_CR_WR /*0x90*/); // send start
#endif
				result = WaitForXfer(hDevice);
				if(result != I2C_OK) {
					return result;
				}
			
				i = 0;
				while ((i < addr_len) && (result == I2C_OK)) {
#ifdef FEATURE_SIMPLE_INTERFACE
					cmd = (I2C_CR_WR);
					cmd = (cmd<<8) | (addr[i]);
					bbm_word_write(hDevice, BBM_I2C_TXR, cmd);
#else
					bbm_write(hDevice, BBM_I2C_TXR, addr[i]);
					bbm_write(hDevice, BBM_I2C_CR, I2C_CR_WR /*0x10*/);
#endif	
					result = WaitForXfer(hDevice);
					if(result != I2C_OK) {
						return result;
					}
					i++;
				}
			}
#ifdef FEATURE_SIMPLE_INTERFACE
			cmd = (I2C_CR_STA | I2C_CR_WR);
			cmd = (cmd<<8) | (chip | I2C_READ);
			bbm_word_write(hDevice, BBM_I2C_TXR, cmd);
#else
			bbm_write(hDevice, BBM_I2C_TXR, chip | I2C_READ);
			bbm_write(hDevice, BBM_I2C_CR, I2C_CR_STA | I2C_CR_WR /*0x90*/); // resend start
#endif
			
			result = WaitForXfer(hDevice);
			if(result != I2C_OK) {
				return result;
			}	

			i = 0;
			while ((i < data_len) && (result == I2C_OK)) {
				if (i == data_len - 1) {
					bbm_write(hDevice, BBM_I2C_CR, I2C_CR_RD|I2C_CR_NACK/*0x28*/);	// No Ack Read
					result = WaitForXfer(hDevice);
					if((result != I2C_NACK) && (result != I2C_OK)){
						PRINTF(hDevice, "NACK4-0[%02x]\n", result);
						return result;
					}
				} else {
					bbm_write(hDevice, BBM_I2C_CR, I2C_CR_RD /*0x20*/);	// Ack Read
					result = WaitForXfer(hDevice);
					if(result != I2C_OK){
						PRINTF(hDevice, "NACK4-1[%02x]\n", result);
						return result;
					}
				}
				bbm_read(hDevice, BBM_I2C_RXR, &data[i]);
				i++;
			}	

			bbm_write(hDevice, BBM_I2C_CR, I2C_CR_STO /*0x40*/);		// send stop
			result = WaitForXfer(hDevice);
			if((result != I2C_NACK) && (result != I2C_OK)) {
				PRINTF(hDevice, "NACK5[%02X]\n", result);
				return result;
			}
			break;
		default:
			return I2C_NOK;
	}

	return I2C_OK;
}

Ejemplo n.º 22

Archivo: fc8080_bb.c Proyecto: GAXUSXX/G935FGaXusKernel2

s32 fc8080_scan_status(HANDLE handle)
{
	s32 i, res = BBM_NOK;
	u8  mode = 0, status = 0, sync_status = 0;
	s32 slock_cnt, flock_cnt, dlock_cnt;

	bbm_read(handle, BBM_OFDM_DET, &mode);

	if ((mode & 0x01) == 0x01) {
		slock_cnt = SLOCK_MAX_TIME / LOCK_TIME_TICK;
		flock_cnt = FLOCK_MAX_TIME / LOCK_TIME_TICK;
		dlock_cnt = DLOCK_MAX_TIME / LOCK_TIME_TICK;

		/* OFDM Detect */
		for (i = 0; i < slock_cnt; i++) {
			ms_wait(LOCK_TIME_TICK);

			bbm_read(handle, BBM_DETECT_OFDM, &status);

			if (status & 0x01)
				break;
		}

		if (i == slock_cnt) {
			printk(KERN_DEBUG "TDMB :status(0x%x) s(%d)\n",
				status, slock_cnt);
			return BBM_NOK;
		}

		if ((status & 0x02) == 0x00) {
			printk(KERN_DEBUG "TDMB %s : status(0x%x)\n",
				__func__, status);
			return BBM_NOK;
		}

		/* FRS */
		for (i += 1; i < flock_cnt; i++) {
			ms_wait(LOCK_TIME_TICK);

			bbm_read(handle, BBM_SYNC_STAT, &sync_status);

			if (sync_status & 0x01)
				break;
		}

		if (i == flock_cnt) {
			printk(KERN_DEBUG "TDMB %s : flock_cnt(0x%x)\n"
						, __func__
						, flock_cnt);
			return BBM_NOK;
		}

		/* Digital Lock */
		for (i += 1; i < dlock_cnt; i++) {
			ms_wait(LOCK_TIME_TICK);

			bbm_read(handle, BBM_SYNC_STAT, &sync_status);

			if (sync_status & 0x20) {
				printk(KERN_DEBUG "TDMB :sync_status(0x%x)\n",
					sync_status);
				return BBM_OK;
		}
		}
	} else {
		dlock_cnt = DLOCK_MAX_TIME / LOCK_TIME_TICK;

		for (i = 0; i < dlock_cnt; i++) {
			ms_wait(LOCK_TIME_TICK);

			bbm_read(handle, BBM_SYNC_STAT, &sync_status);
			if (sync_status & 0x20) {
				printk(KERN_DEBUG "TDMB :sync_status(0x%x)\n",
					sync_status);
				return BBM_OK;
		}
	}
	}

	printk(KERN_DEBUG "TDMB %s : res(0x%x)\n"
						, __func__, res);

	return res;
}

Ejemplo n.º 23

Archivo: fc8050_isr.c Proyecto: Adrioid83/jflte_xxx

void fc8050_isr(HANDLE hDevice)
{
	u8	ext_int_status = 0;

	bbm_read(hDevice, BBM_COM_INT_STATUS, &ext_int_status);
	bbm_write(hDevice, BBM_COM_INT_STATUS, ext_int_status);
	bbm_write(hDevice, BBM_COM_INT_STATUS, 0x00);

	if (ext_int_status & BBM_MF_INT) {
		u16	buf_int_status = 0;
		u16	size;
		int	i;

		bbm_word_read(hDevice, BBM_BUF_STATUS, &buf_int_status);
		bbm_word_write(hDevice, BBM_BUF_STATUS, buf_int_status);
		bbm_word_write(hDevice, BBM_BUF_STATUS, 0x0000);

		if (buf_int_status & 0x0100) {
			bbm_word_read(hDevice, BBM_BUF_FIC_THR, &size);
			size += 1;
			if (size-1) {
				bbm_data(hDevice, BBM_COM_FIC_DATA
					, &fic_buffer[0], size);

#ifdef CONFIG_TDMB_SPI
				if (fic_callback)
					(*fic_callback)(fic_user_data
					, &fic_buffer[2], size);
#else
				if (fic_callback)
					(*fic_callback)(fic_user_data
					, &fic_buffer[0], size);
#endif
			}
		}

		for (i = 0; i < 8; i++) {
			if (buf_int_status & (1 << i)) {
				bbm_word_read(hDevice
					, BBM_BUF_CH0_THR+i*2, &size);
				size += 1;

				if (size-1) {
					u8  sub_ch_id;

					bbm_read(hDevice, BBM_BUF_CH0_SUBCH+i
						, &sub_ch_id);
					sub_ch_id = sub_ch_id & 0x3f;

					bbm_data(hDevice, (BBM_COM_CH0_DATA+i)
						, &msc_buffer[0], size);

#ifdef CONFIG_TDMB_SPI
					if (msc_callback)
						(*msc_callback)(
						msc_user_data
						, sub_ch_id
						, &msc_buffer[2]
						, size);
#else
					if (msc_callback)
						(*msc_callback)(
						msc_user_data
						, sub_ch_id
						, &msc_buffer[0]
						, size);
#endif
				}
			}
		}

	}

}

Ejemplo n.º 24

Archivo: fc8050_bb.c Proyecto: CL0SeY/i957kernel

int fc8050_scan_status(HANDLE hDevice) {
	int i, res = BBM_NOK;
 	u8  mode = 0, status = 0, sync_status = 0;
	int slock_cnt, flock_cnt, dlock_cnt;

	bbm_read(hDevice, BBM_SYNC_DET_CNTRL, &mode);

	if((mode & 0x01) == 0x01) {
		slock_cnt = SLOCK_MAX_TIME / LOCK_TIME_TICK;
		flock_cnt = FLOCK_MAX_TIME / LOCK_TIME_TICK;
		dlock_cnt = DLOCK_MAX_TIME / LOCK_TIME_TICK;

		// OFDM Detect
		for(i = 0; i < slock_cnt; i++) {
			msWait(LOCK_TIME_TICK);
			
			bbm_read(hDevice, BBM_SYNC_DET_STATUS, &status);
			
			if(status & 0x01)
				break;
		}

		if(i == slock_cnt) {
        	printk("tdmb %s : status(0x%x) slock_cnt(%d)\n", __func__, status, slock_cnt);
			return BBM_NOK;
      		}			

		if((status & 0x02) == 0x00) {
        	printk("tdmb %s : status(0x%x)\n", __func__, status);		
			return BBM_NOK;
		}			

		// FRS
		for(i += 1; i < flock_cnt; i++) {
			msWait(LOCK_TIME_TICK);
			
			bbm_read(hDevice, BBM_SYNC_STATUS, &sync_status);
			
			if(sync_status & 0x01)
				break;
		}
		
		if (i == flock_cnt) {
        	printk("tdmb %s : flock_cnt(0x%x)\n", __func__, flock_cnt);		
			return BBM_NOK;
      		}			    

		// Digital Lock
		for(i += 1; i < dlock_cnt; i++) {
			msWait(LOCK_TIME_TICK);
			
			bbm_read(hDevice, BBM_SYNC_STATUS, &sync_status);
			
			if(sync_status & 0x20) {
            			printk("tdmb %s : sync_status1(0x%x)\n", __func__, sync_status);		
				return BBM_OK;
			}
		}
	} else {
		dlock_cnt = DLOCK_MAX_TIME / LOCK_TIME_TICK;

		for(i = 0; i < dlock_cnt; i++) {
			msWait(LOCK_TIME_TICK);

			bbm_read(hDevice, BBM_SYNC_STATUS, &sync_status);
			if(sync_status & 0x20) {
           		 	printk("tdmb %s : sync_status2(0x%x)\n", __func__, sync_status);					
				return BBM_OK;
			}
		}		
	}

	printk("tdmb %s : res(0x%x)\n", __func__, res);					

	return res;
}

Ejemplo n.º 25

Archivo: fci_i2c.c Proyecto: HONO/Bell_V20f_kernel_mod

static int fci_i2c_transfer (HANDLE hDevice, fci_u8 cmd_type, fci_u8 chip, fci_u8 addr[], fci_u8 addr_len, fci_u8 data[], fci_u8 data_len)
{
	int i;	
	int result = I2C_OK;

	switch (cmd_type) {
		case I2C_WRITE:
			bbm_write(hDevice, BBM_I2C_TXR, chip | cmd_type);
			bbm_write(hDevice, BBM_I2C_CR, I2C_CR_STA | I2C_CR_WR /*0x90*/);
			result = WaitForXfer(hDevice);
			if(result != I2C_OK) return result;
			
			if (addr && addr_len) {
				i = 0;
				while ((i < addr_len) && (result == I2C_OK)) {
					bbm_write(hDevice, BBM_I2C_TXR, addr[i]);
					bbm_write(hDevice, BBM_I2C_CR, I2C_CR_WR /*0x10*/);
					result = WaitForXfer(hDevice);
					if(result != I2C_OK) return result;
					i++;
				}
			}
			
			i = 0;
			while ((i < data_len) && (result == I2C_OK)) {
				bbm_write(hDevice, BBM_I2C_TXR, data[i]);
				bbm_write(hDevice, BBM_I2C_CR, I2C_CR_WR /*0x10*/);
				result = WaitForXfer(hDevice);
				if(result != I2C_OK) return result;
				i++;
			}

			bbm_write(hDevice, BBM_I2C_CR, I2C_CR_STO /*0x40*/);
			result = WaitForXfer(hDevice);
			if(result != I2C_OK) return result;
			break;
		case I2C_READ:
			if (addr && addr_len) {
				bbm_write(hDevice, BBM_I2C_TXR, chip | I2C_WRITE);
				bbm_write(hDevice, BBM_I2C_CR, I2C_CR_STA | I2C_CR_WR /*0x90*/); // send start
				result = WaitForXfer(hDevice);
				if(result != I2C_OK) {
					return result;
				}
			
				i = 0;
				while ((i < addr_len) && (result == I2C_OK)) {
					bbm_write(hDevice, BBM_I2C_TXR, addr[i]);
					bbm_write(hDevice, BBM_I2C_CR, I2C_CR_WR /*0x10*/);
					result = WaitForXfer(hDevice);
					if(result != I2C_OK) {
						return result;
					}
					i++;
				}
			}
			
			bbm_write(hDevice, BBM_I2C_TXR, chip | I2C_READ);
			bbm_write(hDevice, BBM_I2C_CR, I2C_CR_STA | I2C_CR_WR /*0x90*/); // resend start
			result = WaitForXfer(hDevice);
			if(result != I2C_OK) {
				return result;
			}	

			i = 0;
			while ((i < data_len) && (result == I2C_OK)) {
				if (i == data_len - 1) {
					bbm_write(hDevice, BBM_I2C_CR, I2C_CR_RD|I2C_CR_NACK/*0x28*/);	// No Ack Read
					result = WaitForXfer(hDevice);
					if((result != I2C_NACK) && (result != I2C_OK)){
						PRINTF(hDevice, "NACK4-0[%02x]\n\r", result);
						return result;
					}
				} else {
					bbm_write(hDevice, BBM_I2C_CR, I2C_CR_RD /*0x20*/);	// Ack Read
					result = WaitForXfer(hDevice);
					if(result != I2C_OK){
						PRINTF(hDevice, "NACK4-1[%02x]\n\r", result);
						return result;
					}
				}
				bbm_read(hDevice, BBM_I2C_RXR, &data[i]);
				i++;
			}	

			bbm_write(hDevice, BBM_I2C_CR, I2C_CR_STO /*0x40*/);		// send stop
			result = WaitForXfer(hDevice);
			if((result != I2C_NACK) && (result != I2C_OK)) {
				PRINTF(hDevice, "NACK5[%02X]\n\r", result);
				return result;
			}
			break;
		default:
			return I2C_NOK;
	}

	return I2C_OK;
}

Ejemplo n.º 26

Archivo: fc8050_isr.c Proyecto: regit66/android_kernel_lge_geehrc

void fc8050_isr(HANDLE hDevice)
{
	fci_u8	extIntStatus = 0;

	//bbm_write(hDevice, BBM_COM_INT_ENABLE, 0);
	bbm_read(hDevice, BBM_COM_INT_STATUS, &extIntStatus);
	bbm_write(hDevice, BBM_COM_INT_STATUS, extIntStatus);
	bbm_write(hDevice, BBM_COM_INT_STATUS, 0x00);

	if(extIntStatus & BBM_MF_INT) {
		fci_u16	mfIntStatus = 0;
		fci_u16	size;
		int  	i;

		bbm_word_read(hDevice, BBM_BUF_STATUS, &mfIntStatus);
		//bbm_word_write(hDevice, BBM_BUF_STATUS, mfIntStatus);
		//bbm_word_write(hDevice, BBM_BUF_STATUS, 0x0000);
	
		if(mfIntStatus & 0x0100) {
			bbm_word_read(hDevice, BBM_BUF_FIC_THR, &size);

			//wonhee.jeong test 
			if(size > 516)
			{
				printk("FIC Data size is bigger than 516.\n");
			}
			//
			
			size += 1;
			
			if(size-1) {
				bbm_data(hDevice, BBM_COM_FIC_DATA, &ficBuffer[0], size);

				if(pFicCallback) 
					(*pFicCallback)((fci_u32) hDevice, &ficBuffer[0], size);
				
			} 
		}

		for(i=0; i<8; i++) {
			if(mfIntStatus & (1<<i)) {
				bbm_word_read(hDevice, BBM_BUF_CH0_THR+i*2, &size);

				//wonhee.jeong test 
				if(size > 8196)
				{
					printk("MSC Data size is bigger than 8196.\n");
				}
				//
				
				size += 1;

				if(size-1) {
					fci_u8  subChId;
					
					bbm_read(hDevice, BBM_BUF_CH0_SUBCH+i, &subChId);
					subChId = subChId & 0x3f;
					
					{
						fci_u8 rsSubChId;

						bbm_read(hDevice, BBM_CDI0_SUBCH_EN, &rsSubChId);

						rsSubChId &= 0x3F;

						if(rsSubChId == subChId)
							tp_total_cnt += size/188;
					}

					bbm_data(hDevice, (BBM_COM_CH0_DATA+i), &mscBuffer[0], size);

					if(size>384)
					{
						if(pMscCallback)
							(*pMscCallback)(gMscUserData, subChId, &mscBuffer[2], size);
					}
					else
					{
						if(pMscCallback)
							(*pMscCallback)(gMscUserData, subChId, &mscBuffer[0], size);
					}
						
				}
			}
		}

		bbm_word_write(hDevice, BBM_BUF_STATUS, mfIntStatus);
		bbm_word_write(hDevice, BBM_BUF_STATUS, 0x0000);
	}

	//bbm_write(hDevice, BBM_COM_INT_ENABLE, ENABLE_INT_MASK);
}

Ejemplo n.º 27

Archivo: fc8080_bb.c Proyecto: MH2033/VIPER_KERNEL_LP_D802

fci_s32 fc8080_scan_status(HANDLE handle)
{
	fci_s32 i, res = BBM_NOK;
	fci_u8  mode = 0, status = 0, sync_status = 0;
	fci_s32 dlock_cnt;

	bbm_read(handle, BBM_OFDM_DET, &mode);

	if ((mode & 0x01) == 0x01) {
		fci_s32 slock_cnt, flock_cnt;
		slock_cnt = SLOCK_MAX_TIME / LOCK_TIME_TICK;
		flock_cnt = FLOCK_MAX_TIME / LOCK_TIME_TICK;
		dlock_cnt = DLOCK_MAX_TIME / LOCK_TIME_TICK;

		for (i = 0; i < slock_cnt; i++) {
			if(!ms_wait(LOCK_TIME_TICK))
				return BBM_NOK;

			bbm_read(handle, BBM_DETECT_OFDM, &status);
#ifdef FEATURE_DEBUG_LOG
			printk("OFDM Detect Status 0x%x \n", status);
#endif
			if (status & 0x01)
				break;
		}

		if (i == slock_cnt)
			return BBM_NOK;

		if ((status & 0x02) == 0x00)
			return BBM_NOK;

		for (i += 1; i < flock_cnt; i++) {
			if(!ms_wait(LOCK_TIME_TICK))
				return BBM_NOK;
			bbm_read(handle, BBM_SYNC_STAT, &sync_status);
#ifdef FEATURE_DEBUG_LOG
			printk("FRS Status 0x%x \n", sync_status);
#endif

			if (sync_status & 0x01)
				break;
		}

		if (i == flock_cnt)
			return BBM_NOK;

		for (i += 1; i < dlock_cnt; i++) {
			if(!ms_wait(LOCK_TIME_TICK))
				return BBM_NOK;

			bbm_read(handle, BBM_SYNC_STAT, &sync_status);
#ifdef FEATURE_DEBUG_LOG
			printk("Digital Lock Status 0x%x \n", sync_status);
#endif

			if (sync_status & 0x20)
				return BBM_OK;
		}
	} else {
		dlock_cnt = DLOCK_MAX_TIME / LOCK_TIME_TICK;

		for (i = 0; i < dlock_cnt; i++) {
			if(!ms_wait(LOCK_TIME_TICK))
				return BBM_NOK;

			bbm_read(handle, BBM_SYNC_STAT, &sync_status);
			if (sync_status & 0x20)
				return BBM_OK;
		}
	}

	return res;
}