675 lines
19 KiB
C
675 lines
19 KiB
C
/**
|
|
* ${ANDROID_BUILD_TOP}/vendor/focaltech/src/chips/ft9348.c
|
|
*
|
|
* Copyright (C) 2014-2017 FocalTech Systems Co., Ltd. All Rights Reserved.
|
|
*
|
|
**/
|
|
|
|
#include <linux/delay.h>
|
|
|
|
#include "ff_log.h"
|
|
#include "ff_err.h"
|
|
#include "ff_spi.h"
|
|
#include "ff_chip.h"
|
|
|
|
#undef LOG_TAG
|
|
#define LOG_TAG "focaltech:ft9348"
|
|
|
|
/*
|
|
* Protocol commands.
|
|
*/
|
|
#define FT9348_CMD_DMA_ENTER 0x06
|
|
#define FT9348_CMD_SFR_WRITE 0x09
|
|
#define FT9348_CMD_SFR_READ 0x08
|
|
#define FT9348_CMD_SRAM_WRITE 0x05
|
|
#define FT9348_CMD_SRAM_READ 0x04
|
|
#define FT9348_CMD_INFO_WRITE 0x10
|
|
#define FT9348_CMD_INFO_READ 0x11
|
|
#define FT9348_CMD_BOOT_WRITE 0x11
|
|
|
|
/*
|
|
* App info offset in XRAM.
|
|
*/
|
|
#define FT9348_INFO_OFFSET (0x0500 * 2)
|
|
|
|
/*
|
|
* SPI exchange buffer offset in XRAM.
|
|
*/
|
|
#define FT9348_XBUF_OFFSET (0x05c0 * 2)
|
|
|
|
/*
|
|
* Boot Info data structure.
|
|
* Note: Big-endian.
|
|
*/
|
|
typedef struct __attribute__((__packed__)) {
|
|
uint8_t e_WorkState;
|
|
uint8_t e_RstType;
|
|
uint16_t e_ChipId;
|
|
uint8_t e_VendorId;
|
|
uint8_t e_FactoryId;
|
|
uint8_t e_PromVersion;
|
|
uint8_t e_AppValid;
|
|
uint8_t e_UpgradeFlg;
|
|
uint8_t e_FlashType;
|
|
uint8_t e_FwType;
|
|
uint8_t e_CheckAppValid;
|
|
uint8_t e_Dummy0;
|
|
uint8_t e_Dummy1;
|
|
uint8_t e_Reserved[147];
|
|
uint8_t e_WO_SoftReset;
|
|
uint8_t e_WO_StartApp;
|
|
uint8_t e_Dummy3;
|
|
uint8_t e_WO_EnterUpgrade;
|
|
uint8_t e_WO_VerifyApp;
|
|
} ft9348_boot_info_t;
|
|
|
|
/*
|
|
* App Info data structure.
|
|
* Note: Big-endian.
|
|
*/
|
|
typedef struct __attribute__((__packed__)) {
|
|
uint8_t e_WorkState; // 0x00
|
|
uint8_t e_ImageBitsWide;
|
|
uint8_t e_LockAgc;
|
|
uint8_t e_Agc1;
|
|
uint8_t e_Agc2;
|
|
uint8_t e_Agc3;
|
|
uint8_t e_Agc4;
|
|
uint16_t e_DAC1;
|
|
uint16_t e_DAC2;
|
|
uint16_t e_DAC_Offset;
|
|
uint32_t e_SM_Threshold;
|
|
uint8_t e_NormalScanTimes;
|
|
uint8_t e_SM_ScanTimems;
|
|
uint8_t e_SM_TrigerBlkNum;
|
|
uint8_t e_SensorX; // 0x14
|
|
uint8_t e_SensorY;
|
|
uint16_t e_ChipId; // 0x16
|
|
uint8_t e_VendorId;
|
|
uint8_t e_FactoryId;
|
|
uint8_t e_FirmwareVersion; // 0x1a
|
|
uint8_t e_HighVoltageFlag;
|
|
uint8_t e_MpIntSetLowTime;
|
|
uint8_t e_FingerOnSensorFlag; // 0x1d
|
|
uint8_t e_AutoPowerAdjust; // 0x1e
|
|
uint8_t e_PlatformFeatureEn; // 0x1f
|
|
uint16_t e_McuFreeFlag; // 0x20
|
|
uint8_t e_AutoPowerTimeWdsD;
|
|
uint8_t e_AutoPowerTimeWdsU;
|
|
uint8_t e_FastSfrAddr;
|
|
uint8_t e_FastSfrValue;
|
|
uint8_t e_FastSfrRWFlag;
|
|
uint8_t e_OtpAddrR;
|
|
uint8_t e_OtpNumR;
|
|
uint8_t e_OtpReadEn;
|
|
uint8_t e_OtpBuff[10];
|
|
uint8_t e_InternalIoVcc;
|
|
uint8_t e_InternalIoVccLock;
|
|
uint8_t e_SMThresholdUpdateEn;
|
|
uint8_t e_AutoSetTeeFuntion;
|
|
uint8_t e_SMThresholdVirtTouch;
|
|
uint8_t e_SMThresholdVirtTouchDef;
|
|
uint16_t e_GestureStatus; // 0x3a
|
|
uint8_t e_AgcVersion; // 0x3c
|
|
uint8_t e_AutoPowerFastEn;
|
|
uint8_t e_FactoryIdleStopMode;
|
|
uint8_t e_ImageFingerFuntEn;
|
|
uint8_t e_TeeWorkMode; // 0x40
|
|
uint8_t e_SMScanRate;
|
|
uint8_t e_SmartSmStable; // 0x42
|
|
uint8_t e_GestureSupport;
|
|
uint8_t e_ImageEccEn;
|
|
uint16_t e_ImageEcc;
|
|
uint8_t e_SmSmartAreaBlkNum;
|
|
uint8_t e_SmSmartAreaContinueCnt;
|
|
uint8_t e_SmSmartAreaActionCnt;
|
|
uint8_t e_SmTriggerNum[2];
|
|
uint8_t e_SmTotalValue[8];
|
|
uint8_t e_FastEnterAPA; // 0x54
|
|
uint8_t e_Reserved[11];
|
|
uint16_t e_AppInfoAddr; // 0x60
|
|
uint16_t e_BadPixelThrUpper;
|
|
uint16_t e_BadPixelThrLower;
|
|
uint8_t e_BadPixelNum;
|
|
uint8_t e_RepairBadPixelEn;
|
|
uint8_t e_PollingScanEn;
|
|
uint8_t e_SpecialAldoSetEn;
|
|
uint8_t e_BadPixelAddrX[6];
|
|
uint8_t e_BadPixelAddrY[6];
|
|
uint8_t e_Dummy0;
|
|
uint8_t e_Dummy1;
|
|
uint8_t e_Dummy0_H;
|
|
uint8_t e_Dummy0_L;
|
|
uint8_t e_Dummy1_H;
|
|
uint8_t e_Dummy1_L;
|
|
} ft9348_app_info_t;
|
|
|
|
/*
|
|
* The singleton instance of 'ft9348_context_t'.
|
|
*/
|
|
typedef struct {
|
|
ff_device_t device;
|
|
ft9348_boot_info_t boot_info;
|
|
ft9348_app_info_t app_info;
|
|
ff_device_mode_t work_mode;
|
|
} ft9348_context_t;
|
|
static ft9348_context_t ft9348_context = {
|
|
.device.info.chip_id = 0x95a8,
|
|
.work_mode = FF_DEVICE_MODE_IDLE,
|
|
}, *g_context = &ft9348_context;
|
|
|
|
|
|
extern uint16_t fw93xx_chipid_get(void);
|
|
int ft9348_write_sfr(uint8_t addr, uint8_t data)
|
|
{
|
|
ff_sfr_buf_t tx_buf;
|
|
int err = FF_SUCCESS;
|
|
FF_LOGV("'%s' enter.", __func__);
|
|
|
|
tx_buf.cmd[0] = (uint8_t)( FT9348_CMD_SFR_WRITE);
|
|
tx_buf.cmd[1] = (uint8_t)(~FT9348_CMD_SFR_WRITE);
|
|
tx_buf.addr = addr;
|
|
tx_buf.tx_byte = data;
|
|
FF_CHECK_ERR(ff_spi_write_buf(&tx_buf, 4));
|
|
|
|
FF_LOGV("'%s' leave.", __func__);
|
|
return err;
|
|
}
|
|
|
|
int ft9348_read_sfr(uint8_t addr, uint8_t *data)
|
|
{
|
|
ff_sfr_buf_t tx_buf;
|
|
int err = FF_SUCCESS;
|
|
FF_LOGV("'%s' enter.", __func__);
|
|
|
|
tx_buf.cmd[0] = (uint8_t)( FT9348_CMD_SFR_READ);
|
|
tx_buf.cmd[1] = (uint8_t)(~FT9348_CMD_SFR_READ);
|
|
tx_buf.addr = addr;
|
|
FF_CHECK_ERR(ff_spi_write_then_read_buf(&tx_buf, 4, data, 1));
|
|
|
|
FF_LOGV("'%s' leave.", __func__);
|
|
return err;
|
|
}
|
|
|
|
int ft9348_write_sram(uint16_t addr, const void *data, uint16_t length)
|
|
{
|
|
int err = FF_SUCCESS, remain = length, tx_len;
|
|
int dlen, stride = MAX_XFER_BUF_SIZE - sizeof(ff_sram_buf_t);
|
|
bool b_in_pram = (addr == 0x0000);
|
|
uint16_t offset = addr;
|
|
static uint8_t tx_buffer[MAX_XFER_BUF_SIZE] = {0, };
|
|
ff_sram_buf_t *tx_buf = TYPE_OF(ff_sram_buf_t, tx_buffer);
|
|
uint8_t *p_data = TYPE_OF(uint8_t, data);
|
|
FF_LOGV("'%s' enter.", __func__);
|
|
|
|
/* Sign the package. */
|
|
tx_buf->cmd[0] = (uint8_t)( FT9348_CMD_SRAM_WRITE);
|
|
tx_buf->cmd[1] = (uint8_t)(~FT9348_CMD_SRAM_WRITE);
|
|
|
|
/* Write it repeatedly. */
|
|
while (remain > 0) {
|
|
/* The last package? */
|
|
if (remain < stride) {
|
|
stride = remain;
|
|
}
|
|
|
|
/* HW specific protocol. */
|
|
addr = b_in_pram ? (offset / 2) : 0x8000 | (offset / 2);
|
|
dlen = stride / 2 - 1;
|
|
if (dlen < 0) {
|
|
dlen = 0;
|
|
}
|
|
|
|
/* Packing. */
|
|
tx_buf->addr = u16_swap_endian(addr);
|
|
tx_buf->dlen = u16_swap_endian(dlen);
|
|
tx_len = sizeof(ff_sram_buf_t) + stride;
|
|
memcpy(tx_buf->data, p_data, stride);
|
|
|
|
/* Low-level transfer. */
|
|
FF_CHECK_ERR(ff_spi_write_buf(tx_buf, tx_len));
|
|
|
|
/* Next package. */
|
|
offset += stride;
|
|
p_data += stride;
|
|
remain -= stride;
|
|
}
|
|
|
|
FF_LOGV("'%s' leave.", __func__);
|
|
return err;
|
|
}
|
|
|
|
int ft9348_read_sram(uint16_t addr, void *data, uint16_t length)
|
|
{
|
|
int err = FF_SUCCESS, remain = length, tx_len;
|
|
int dlen, stride = MAX_XFER_BUF_SIZE - sizeof(ff_sram_buf_t);
|
|
bool b_in_pram = (addr == 0x0000);
|
|
uint16_t offset = addr;
|
|
ff_sram_buf_t tx_buffer, *tx_buf = &tx_buffer;
|
|
uint8_t *p_data = TYPE_OF(uint8_t, data);
|
|
FF_LOGV("'%s' enter.", __func__);
|
|
|
|
/* Sign the package. */
|
|
tx_buf->cmd[0] = (uint8_t)( FT9348_CMD_SRAM_READ);
|
|
tx_buf->cmd[1] = (uint8_t)(~FT9348_CMD_SRAM_READ);
|
|
|
|
/* Read it repeatedly. */
|
|
while (remain > 0) {
|
|
/* The last package? */
|
|
if (remain < stride) {
|
|
stride = remain;
|
|
}
|
|
|
|
/* HW specific protocol. */
|
|
addr = b_in_pram ? (offset / 2) : 0x8000 | (offset / 2);
|
|
dlen = stride / 2 - 1;
|
|
if (dlen < 0) {
|
|
dlen = 0;
|
|
}
|
|
|
|
/* Packing. */
|
|
tx_buf->addr = u16_swap_endian(addr);
|
|
tx_buf->dlen = u16_swap_endian(dlen);
|
|
tx_len = sizeof(ff_sram_buf_t);
|
|
|
|
/* Low-level transfer. */
|
|
FF_CHECK_ERR(ff_spi_write_then_read_buf(tx_buf, tx_len, p_data, stride));
|
|
|
|
/* Next package. */
|
|
offset += stride;
|
|
p_data += stride;
|
|
remain -= stride;
|
|
}
|
|
|
|
FF_LOGV("'%s' leave.", __func__);
|
|
return err;
|
|
}
|
|
|
|
int ft9348_write_inf(uint8_t addr, uint8_t data)
|
|
{
|
|
ff_info_buf_t info;
|
|
int err = FF_SUCCESS;
|
|
FF_LOGV("'%s' enter.", __func__);
|
|
|
|
/* 2-1: Write the info parameters. */
|
|
info.cmd[0] = (uint8_t)( FT9348_CMD_INFO_WRITE);
|
|
info.cmd[1] = (uint8_t)(~FT9348_CMD_INFO_WRITE);
|
|
|
|
info.addr = addr;
|
|
info.dlen = data;
|
|
err = ft9348_write_sram(FT9348_XBUF_OFFSET, &info, sizeof(ff_info_buf_t));
|
|
FF_CHECK_ERR(err);
|
|
|
|
/* 2-2: Triger the operation. */
|
|
FF_CHECK_ERR(ft9348_write_sfr(0xa4, 0x01));
|
|
|
|
FF_LOGV("'%s' leave.", __func__);
|
|
return err;
|
|
}
|
|
|
|
static int ft9348_write_info(uint8_t addr, uint8_t data, bool in_boot)
|
|
{
|
|
ff_info_buf_t info;
|
|
int err = FF_SUCCESS;
|
|
FF_LOGV("'%s' enter.", __func__);
|
|
|
|
/* 2-1: Write the info parameters. */
|
|
if (in_boot) {
|
|
info.cmd[0] = (uint8_t)( FT9348_CMD_BOOT_WRITE);
|
|
info.cmd[1] = (uint8_t)(~FT9348_CMD_BOOT_WRITE);
|
|
} else {
|
|
info.cmd[0] = (uint8_t)( FT9348_CMD_INFO_WRITE);
|
|
info.cmd[1] = (uint8_t)(~FT9348_CMD_INFO_WRITE);
|
|
}
|
|
info.addr = in_boot ? (addr | 0x80) : addr;
|
|
info.dlen = data;
|
|
err = ft9348_write_sram(FT9348_XBUF_OFFSET, &info, sizeof(ff_info_buf_t));
|
|
FF_CHECK_ERR(err);
|
|
|
|
/* 2-2: Triger the operation. */
|
|
FF_CHECK_ERR(ft9348_write_sfr(0xa4, 0x01));
|
|
|
|
FF_LOGV("'%s' leave.", __func__);
|
|
return err;
|
|
}
|
|
|
|
static int ft9348_read_info_indirectly(uint8_t offset, void *data, uint8_t dlen)
|
|
{
|
|
ff_info_buf_t info;
|
|
int err = FF_SUCCESS;
|
|
FF_LOGV("'%s' enter.", __func__);
|
|
|
|
/* 3-1: Write the info parameters. */
|
|
info.cmd[0] = (uint8_t)( FT9348_CMD_INFO_READ);
|
|
info.cmd[1] = (uint8_t)(~FT9348_CMD_INFO_READ);
|
|
info.addr = offset;
|
|
info.dlen = dlen;
|
|
err = ft9348_write_sram(FT9348_XBUF_OFFSET, &info, sizeof(ff_info_buf_t));
|
|
FF_CHECK_ERR(err);
|
|
|
|
/* 3-2: Triger the operation. */
|
|
FF_CHECK_ERR(ft9348_write_sfr(0xa4, 0x01));
|
|
|
|
/* 3-3: Read out the result. */
|
|
FF_CHECK_ERR(ft9348_read_sram(FT9348_XBUF_OFFSET, data, dlen));
|
|
|
|
FF_LOGV("'%s' leave.", __func__);
|
|
return err;
|
|
}
|
|
|
|
/* Note: APP space only. */
|
|
static int ft9348_read_info_directly(uint8_t offset, void *data, uint8_t dlen)
|
|
{
|
|
uint16_t addr = FT9348_INFO_OFFSET + offset;
|
|
int err = FF_SUCCESS;
|
|
FF_LOGV("'%s' enter.", __func__);
|
|
|
|
// FIXME: Reading from an odd offset.
|
|
if (addr % 2) {
|
|
data = ((uint8_t *)data) - 1;
|
|
dlen += 1;
|
|
}
|
|
FF_CHECK_ERR(ft9348_read_sram(addr, data, dlen));
|
|
|
|
FF_LOGV("'%s' leave.", __func__);
|
|
return err;
|
|
}
|
|
|
|
/*
|
|
* Note: Only 1 byte can be written.
|
|
*/
|
|
#define ft9348_write_boot_info(member) \
|
|
do { \
|
|
uint8_t offset = (uint8_t)((void *)&member - (void *)&g_context->boot_info); \
|
|
FF_CHECK_ERR(ft9348_write_info(offset, member, true)); \
|
|
} while (0)
|
|
|
|
/*
|
|
* Note: Only 2 bytes can be read.
|
|
*/
|
|
#define ft9348_read_boot_info(member) \
|
|
do { \
|
|
uint8_t offset = (uint8_t)((void *)&member - (void *)&g_context->boot_info); \
|
|
uint8_t length = (uint8_t)sizeof(member); \
|
|
FF_CHECK_ERR(ft9348_read_info_indirectly(offset, &member, length)); \
|
|
} while (0)
|
|
|
|
#define ft9348_write_app_info(member) \
|
|
do { \
|
|
uint8_t offset = (uint8_t)((void *)&member - (void *)&g_context->app_info); \
|
|
FF_CHECK_ERR(ft9348_write_info(offset, member, false)); \
|
|
} while (0)
|
|
|
|
#define ft9348_read_app_info_indirectly(member) \
|
|
do { \
|
|
uint8_t offset = (uint8_t)((void *)&member - (void *)&g_context->app_info); \
|
|
uint8_t length = (uint8_t)sizeof(member); \
|
|
FF_CHECK_ERR(ft9348_read_info_indirectly(offset, &member, length)); \
|
|
} while (0)
|
|
|
|
#define ft9348_read_app_info_directly(member) \
|
|
do { \
|
|
uint8_t offset = (uint8_t)((void *)&member - (void *)&g_context->app_info); \
|
|
uint8_t length = (uint8_t)sizeof(member); \
|
|
FF_CHECK_ERR(ft9348_read_info_directly(offset, &member, length)); \
|
|
} while (0)
|
|
|
|
/*---8<-------------------------------------------------------------------------*/
|
|
|
|
int ft9348_query_event_status(void)
|
|
{
|
|
int err = FF_SUCCESS;
|
|
FF_LOGV("'%s' enter.", __func__);
|
|
|
|
// TODO:
|
|
UNUSED_VAR(err);
|
|
|
|
FF_LOGV("'%s' leave.", __func__);
|
|
return err;
|
|
}
|
|
|
|
int ft9348_query_device_status(void)
|
|
{
|
|
ff_device_status_t stat = FF_DEVICE_STAT_IDLE;
|
|
FF_LOGV("'%s' enter.", __func__);
|
|
|
|
ft9348_read_app_info_directly(g_context->app_info.e_McuFreeFlag);
|
|
if (g_context->app_info.e_McuFreeFlag != 0x5aa5) {
|
|
stat = FF_DEVICE_STAT_BUSY;
|
|
}
|
|
|
|
FF_LOGV("'%s' leave. ", __func__);
|
|
return stat;
|
|
}
|
|
|
|
int ft9348_query_finger_status(void)
|
|
{
|
|
int err = FF_SUCCESS;
|
|
FF_LOGV("'%s' enter.", __func__);
|
|
|
|
// TODO:
|
|
UNUSED_VAR(err);
|
|
|
|
FF_LOGV("'%s' leave.", __func__);
|
|
return err;
|
|
}
|
|
|
|
int ft9348_query_gesture_status(void)
|
|
{
|
|
FF_LOGV("'%s' enter.", __func__);
|
|
|
|
ft9348_read_app_info_directly(g_context->app_info.e_GestureStatus);
|
|
FF_LOGD("fw gesture_code = 0x%x.", g_context->app_info.e_GestureStatus);
|
|
|
|
FF_LOGV("'%s' leave.", __func__);
|
|
return (int)g_context->app_info.e_GestureStatus;
|
|
}
|
|
|
|
int ft9348_check_alive(void)
|
|
{
|
|
int err = FF_SUCCESS;
|
|
FF_LOGV("'%s' enter.", __func__);
|
|
|
|
ft9348_read_app_info_directly(g_context->app_info.e_AutoPowerAdjust);
|
|
if (g_context->app_info.e_AutoPowerAdjust != 0x01) {
|
|
return FF_ERR_DEAD_DEVICE;
|
|
}
|
|
|
|
FF_LOGV("'%s' leave.", __func__);
|
|
return err;
|
|
}
|
|
|
|
static int ft9348_init_sleep_mode(void)
|
|
{
|
|
ff_device_status_t stat = FF_DEVICE_STAT_BUSY;
|
|
int err = FF_SUCCESS, tries = 50;
|
|
FF_LOGV("'%s' enter.", __func__);
|
|
|
|
/* TODO: Algorithm has wrote these two info registers already. */
|
|
g_context->app_info.e_PlatformFeatureEn = 0x01; // 0x1f
|
|
ft9348_write_app_info(g_context->app_info.e_PlatformFeatureEn);
|
|
g_context->app_info.e_TeeWorkMode = 0x01; // 0x40
|
|
ft9348_write_app_info(g_context->app_info.e_TeeWorkMode);
|
|
|
|
g_context->app_info.e_AutoPowerAdjust = 0x01; // 0x1e
|
|
ft9348_write_app_info(g_context->app_info.e_AutoPowerAdjust);
|
|
|
|
/* Wait for the device to be IDLE state. */
|
|
do {
|
|
mdelay(3);
|
|
stat = ft9348_query_device_status();
|
|
} while (stat != FF_DEVICE_STAT_IDLE && --tries);
|
|
FF_LOGV("tries remainder = %d", tries);
|
|
|
|
/* INT pin shall pull down after reading the 0x1d info. */
|
|
ft9348_read_app_info_indirectly(g_context->app_info.e_FingerOnSensorFlag);
|
|
|
|
/* Verify that the device has been in the sensor mode. */
|
|
stat = ft9348_query_device_status();
|
|
if (stat != FF_DEVICE_STAT_BUSY) {
|
|
FF_LOGE("failed to init sensor mode.");
|
|
err = FF_ERR_INTERNAL;
|
|
}
|
|
|
|
FF_LOGV("'%s' leave.", __func__);
|
|
return err;
|
|
}
|
|
|
|
int ft9348_config_power_mode(ff_power_mode_t mode)
|
|
{
|
|
int err = FF_SUCCESS, tries = 10;
|
|
FF_LOGV("'%s' enter.", __func__);
|
|
|
|
switch (mode) {
|
|
case FF_POWER_MODE_WAKEUP: {
|
|
ff_device_status_t stat = ft9348_query_device_status();
|
|
if (stat != FF_DEVICE_STAT_IDLE) {
|
|
/* Try to wakeup the device. */
|
|
do {
|
|
ff_sfr_buf_t tx_buf;
|
|
tx_buf.cmd[0] = 0x70;
|
|
FF_CHECK_ERR(ff_spi_write_buf(&tx_buf, 1));
|
|
mdelay(5);
|
|
FF_CHECK_ERR(ff_spi_write_buf(&tx_buf, 1));
|
|
mdelay(20);
|
|
stat = ft9348_query_device_status();
|
|
} while (stat != FF_DEVICE_STAT_IDLE && --tries);
|
|
FF_LOGV("tries remainder = %d", tries);
|
|
if (stat == FF_DEVICE_STAT_BUSY) {
|
|
FF_LOGE("can't wake up the device.");
|
|
FF_CHECK_ERR(FF_ERR_BUSY);
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
case FF_POWER_MODE_INIT_SLEEP: {
|
|
FF_FAILURE_RETRY(ft9348_init_sleep_mode(), 3);
|
|
break;
|
|
}
|
|
case FF_POWER_MODE_AUTO_SLEEP: {
|
|
g_context->app_info.e_WorkState = 0x00;
|
|
ft9348_write_app_info(g_context->app_info.e_WorkState);
|
|
|
|
g_context->app_info.e_FastEnterAPA = 0x01;
|
|
ft9348_write_app_info(g_context->app_info.e_FastEnterAPA);
|
|
break;
|
|
}
|
|
case FF_POWER_MODE_DEEP_SLEEP:
|
|
FF_LOGI("switch to 'FF_POWER_MODE_DEEP_SLEEP' mode.");
|
|
err = ft9348_config_power_mode(FF_POWER_MODE_WAKEUP);
|
|
g_context->app_info.e_WorkState = 0x73;
|
|
ft9348_write_app_info(g_context->app_info.e_WorkState);
|
|
break;
|
|
case FF_POWER_MODE_LOST_POWER:
|
|
// TODO:
|
|
break;
|
|
default:
|
|
FF_LOGW("unknown power mode.");
|
|
break;
|
|
}
|
|
|
|
FF_LOGV("'%s' leave.", __func__);
|
|
return err;
|
|
}
|
|
|
|
int ft9348_config_device_mode(ff_device_mode_t mode)
|
|
{
|
|
const char *hint = "switch to '%s' mode.";
|
|
int err = FF_SUCCESS;
|
|
FF_LOGV("'%s' enter.", __func__);
|
|
|
|
switch (mode) {
|
|
#if 0
|
|
case FF_DEVICE_MODE_IDLE: {
|
|
err = ft9348_config_power_mode(FF_POWER_MODE_WAKEUP);
|
|
/* Enter deep sleep mode instead of idle mode. */
|
|
err = ft9348_config_power_mode(FF_POWER_MODE_DEEP_SLEEP);
|
|
break;
|
|
}
|
|
#endif
|
|
case FF_DEVICE_MODE_SCAN_IMAGE: {
|
|
FF_LOGI(hint, "FF_DEVICE_MODE_SCAN_IMAGE");
|
|
// FIXME: There is no this mode for ft9348.
|
|
break;
|
|
}
|
|
case FF_DEVICE_MODE_GESTURE: {
|
|
// TODO:
|
|
break;
|
|
}
|
|
case FF_DEVICE_MODE_WAIT_TOUCH:
|
|
case FF_DEVICE_MODE_WAIT_LEAVE:
|
|
case FF_DEVICE_MODE_WAIT_IMAGE:
|
|
case FF_DEVICE_MODE_IDLE:
|
|
default:
|
|
FF_LOGI(hint, "FF_DEVICE_MODE_SENSOR");
|
|
err = ft9348_config_power_mode(FF_POWER_MODE_WAKEUP);
|
|
err = ft9348_config_power_mode(FF_POWER_MODE_AUTO_SLEEP);
|
|
break;
|
|
}
|
|
|
|
g_context->work_mode = mode;
|
|
FF_LOGV("'%s' leave.", __func__);
|
|
return err;
|
|
}
|
|
|
|
/*---8<-----------------------------------------------------------------------*/
|
|
/* See plat-xxxx.c for platform dependent implementation. */
|
|
extern int ff_ctl_reset_device(void);
|
|
|
|
int ft9348_hw_reset(void)
|
|
{
|
|
ff_sfr_buf_t tx_buf;
|
|
int err = FF_SUCCESS;
|
|
FF_LOGV("'%s' enter.", __func__);
|
|
|
|
/* 3-1: HW reset. */
|
|
err = ff_ctl_reset_device();
|
|
|
|
/* 3-2: Wait PROM ready. */
|
|
mdelay(20);
|
|
|
|
/* 3-3: Enter SPI DMA mode. */
|
|
tx_buf.cmd[0] = (uint8_t)( FT9348_CMD_DMA_ENTER);
|
|
tx_buf.cmd[1] = (uint8_t)(~FT9348_CMD_DMA_ENTER);
|
|
tx_buf.addr = 0x00;
|
|
err = ff_spi_write_buf(&tx_buf, 3);
|
|
if (err) {
|
|
FF_LOGE("failed to enter DMA mode.");
|
|
FF_CHECK_ERR(err);
|
|
}
|
|
|
|
FF_LOGV("'%s' leave.", __func__);
|
|
return err;
|
|
}
|
|
|
|
/*---8<-----------------------------------------------------------------------*/
|
|
|
|
|
|
int ff_chip_init(void)
|
|
{
|
|
uint16_t device_id = 0x0000;
|
|
int err = FF_SUCCESS;
|
|
FF_LOGV("'%s' enter.", __func__);
|
|
|
|
/* Try another way: Reset to PROM space and read boot info. */
|
|
FF_LOGD("try to read the chip id in bootloader...");
|
|
FF_CHECK_ERR(ft9348_hw_reset());
|
|
mdelay(26);
|
|
#if NEED_READ_CHIPID
|
|
device_id = fw93xx_chipid_get();
|
|
FF_LOGD("chip id is = : 0x%04x ", device_id);
|
|
return device_id;
|
|
#endif
|
|
/* Sensor dimensions. */
|
|
ft9348_read_app_info_directly(g_context->app_info.e_SensorX);
|
|
ft9348_read_app_info_directly(g_context->app_info.e_SensorY);
|
|
FF_LOGI("sensor resolution: %d x %d.", g_context->app_info.e_SensorX, g_context->app_info.e_SensorY);
|
|
|
|
/* Enter SensorMode. */
|
|
FF_CHECK_ERR(ft9348_config_power_mode(FF_POWER_MODE_INIT_SLEEP));
|
|
FF_CHECK_ERR(ft9348_config_power_mode(FF_POWER_MODE_AUTO_SLEEP));
|
|
FF_LOGV("'%s' leave.", __func__);
|
|
return err;
|
|
}
|
|
|