Google Git
Sign in
android / kernel / bcm / 22adcc80b26809fe7b2e751c8f2c1bb17a9b05ed / . / drivers / input / touchscreen / bcmtch15xxx.c
blob: 4e5c7d1f0fdd26e5b1d5551e63dd551ab1b1330c [file] [log] [blame]
/*
* Copyright 2013 Broadcom Corporation
*
* 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 (the "GPL").
*
* 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.
*
* A copy of the GPL is available at
* http://www.broadcom.com/licenses/GPLv2.php, or by writing to the Free
* Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
* 02111-1307, USA.
*/
#include <linux/module.h>
#include <linux/init.h>
#include <linux/kernel.h>
#include <linux/interrupt.h>
#include <linux/wait.h>
#include <linux/delay.h>
#include <linux/platform_device.h>
#include <linux/freezer.h>
#include <linux/proc_fs.h>
#include <linux/clk.h>
#include <linux/i2c.h>
#include <linux/gpio.h>
#include <linux/device.h>
#include <linux/cdev.h>
#include <linux/io.h>
#include <linux/uaccess.h>
#include <linux/poll.h>
#include <linux/kfifo.h>
#include <linux/version.h>
#include <linux/input.h>
#include <linux/irq.h>
#include <linux/firmware.h>
#include <linux/input/mt.h>
#include <linux/time.h>
#include <linux/err.h>
#include <linux/of.h>
#include <linux/of_irq.h>
#include <linux/of_gpio.h>
#include <linux/slab.h>
#include <linux/vmalloc.h>
#ifdef CONFIG_REGULATOR
#include <linux/regulator/consumer.h>
#endif
#include <linux/timer.h>
#ifdef CONFIG_HAS_EARLYSUSPEND
#include <linux/earlysuspend.h>
#endif
#include <linux/i2c/bcmtch15xxx.h>
#include <linux/i2c/bcmtch15xxx_settings.h>
#undef CONFIG_OF
/* -------------------------------------- */
/* - BCM Touch Controller Driver Macros - */
/* -------------------------------------- */
/* -- driver version -- */
#define BCMTCH_DRIVER_VERSION "1.4.4.00"
#define BCMTCH_DRIVER_BUILD_DATE __DATE__
#define BCMTCH_DRIVER_BUILD_TIME __TIME__
/* -- SPM addresses -- */
#define BCMTCH_SPM_REG_REVISIONID 0x40
#define BCMTCH_SPM_REG_CHIPID0 0x41
#define BCMTCH_SPM_REG_CHIPID1 0x42
#define BCMTCH_SPM_REG_CHIPID2 0x43
#define BCMTCH_SPM_REG_SPI_I2C_SEL 0x44
#define BCMTCH_SPM_REG_I2CS_CHIPID 0x45
#define BCMTCH_SPM_REG_PSR 0x48
#define BCMTCH_SPM_REG_MSG_FROM_HOST 0x49
#define BCMTCH_SPM_REG_MSG_FROM_HOST_1 0x4a
#define BCMTCH_SPM_REG_MSG_FROM_HOST_2 0x4b
#define BCMTCH_SPM_REG_MSG_FROM_HOST_3 0x4c
#define BCMTCH_SPM_REG_RQST_FROM_HOST 0x4d
#define BCMTCH_SPM_REG_MSG_TO_HOST 0x4e
#define BCMTCH_SPM_REG_PMU_CONTROL2 0x52
#define BCMTCH_SPM_REG_SOFT_RESETS 0x59
#define BCMTCH_SPM_REG_FLL_STATUS 0x5c
#define BCMTCH_SPM_REG_ALFO_CTRL 0x60
#define BCMTCH_SPM_REG_LPLFO_CTRL 0x61
#define BCMTCH_SPM_REG_DMA_ADDR 0x80
#define BCMTCH_SPM_REG_DMA_STATUS 0x89
#define BCMTCH_SPM_REG_DMA_WFIFO 0x92
#define BCMTCH_SPM_REG_DMA_RFIFO 0xa2
/* -- SYS addresses -- */
#define BCMTCH_ADDR_BASE 0x30000000
#define BCMTCH_ADDR_SPM_BASE (BCMTCH_ADDR_BASE + 0x00100000)
#define BCMTCH_ADDR_SPM_PWR_CTRL (BCMTCH_ADDR_SPM_BASE + 0x1c)
#define BCMTCH_ADDR_SPM_LPLFO_CTRL_RO (BCMTCH_ADDR_SPM_BASE + 0xa0)
#define BCMTCH_ADDR_SPM_REMAP (BCMTCH_ADDR_SPM_BASE + 0x100)
#define BCMTCH_ADDR_SPM_STICKY_BITS (BCMTCH_ADDR_SPM_BASE + 0x144)
#define BCMTCH_ADDR_COMMON_BASE (BCMTCH_ADDR_BASE + 0x00110000)
#define BCMTCH_ADDR_COMMON_ARM_REMAP (BCMTCH_ADDR_COMMON_BASE + 0x00)
#define BCMTCH_ADDR_COMMON_SYS_HCLK_CTRL (BCMTCH_ADDR_COMMON_BASE + 0x20)
#define BCMTCH_ADDR_COMMON_CLOCK_ENABLE (BCMTCH_ADDR_COMMON_BASE + 0x48)
#define BCMTCH_ADDR_COMMON_FLL_CTRL0 (BCMTCH_ADDR_COMMON_BASE + 0x104)
#define BCMTCH_ADDR_COMMON_FLL_LPF_CTRL2 (BCMTCH_ADDR_COMMON_BASE + 0x114)
#define BCMTCH_ADDR_COMMON_FLL_TEST_CTRL1 (BCMTCH_ADDR_COMMON_BASE + 0x144)
#define BCMTCH_ADDR_TCH_BASE (BCMTCH_ADDR_BASE + 0x00300000)
#define BCMTCH_ADDR_TCH_VER (BCMTCH_ADDR_TCH_BASE + 0x00)
/* -- SYS MEM addresses -- */
#define BCMTCH_ADDR_VECTORS 0x00000000
#define BCMTCH_ADDR_CODE 0x10000000
#define BCMTCH_ADDR_DATA 0x10009000
#define BCMTCH_ADDR_TOC_BASE 0x0020c000
/* -- guards -- */
#define BCMTCH_STATE_PROTOCOL 1
/* -- constants -- */
#define BCMTCH_MAX_TOUCH 10
#define BCMTCH_MAX_BUTTONS 16
#define BCMTCH_AXIS_MAX 4095
#define BCMTCH_AXIS_SHIFT_BITS 4
#define BCMTCH_MAX_PRESSURE 500
#define BCMTCH_MIN_ORIENTATION -512
#define BCMTCH_MAX_ORIENTATION 511
#define BCMTCH_DMA_MODE_READ 1
#define BCMTCH_DMA_MODE_WRITE 3
#define BCMTCH_IF_I2C_SEL 0
#define BCMTCH_IF_SPI_SEL 1
#define BCMTCH_DEFAULT_I2C_ADDR_SYS 0x68
#define BCMTCH_IF_I2C_COMMON_CLOCK 0x387B
#define BCMTCH_IF_SPI_COMMON_CLOCK 0x387F
#define BCMTCH_COMMON_CLOCK_USE_FLL (0x1 << 18)
#define BCMTCH_POWER_STATE_SLEEP 0
#define BCMTCH_POWER_STATE_RETENTION 1
#define BCMTCH_POWER_STATE_IDLE 3
#define BCMTCH_POWER_STATE_ACTIVE 4
#define BCMTCH_POWER_MODE_SLEEP 0x01
#define BCMTCH_POWER_MODE_WAKE 0x02
#define BCMTCH_POWER_MODE_NOWAKE 0x00
#define BCMTCH_PMU_CNTL2_DLDO_1_1V 0x08
#define BCMTCH_RESET_MODE_SOFT_CLEAR 0x00
#define BCMTCH_RESET_MODE_SOFT_CHIP 0x01
#define BCMTCH_RESET_MODE_SOFT_ARM 0x02
#define BCMTCH_RESET_MODE_HARD 0x04
#define BCMTCH_MEM_REMAP_ADDR BCMTCH_ADDR_SPM_REMAP
#define BCMTCH_MEM_ROM_BOOT 0x00
#define BCMTCH_MEM_RAM_BOOT 0x01
#define BCMTCH_MEM_MAP_1000 0x00
#define BCMTCH_MEM_MAP_3000 0x02
#define BCMTCH_FW_READY_WAIT 1000
#define BCMTCH_SPM_STICKY_BITS_PIN_RESET 0x02
/* development and test */
#define BCMPFX "BCMTCH:"
#define BCMTCH_USE_PRINTK 0
#if BCMTCH_USE_PRINTK
#define BCMTCH_INFO(fmt, arg...) printk(BCMPFX fmt, ##arg)
#define BCMTCH_ERR(fmt, arg...) printk(BCMPFX fmt, ##arg)
#define BCMTCH_DBG(flag, fmt, arg...) \
{if (bcmtch_debug_flag & flag) printk(BCMPFX fmt, ##arg); }
#else
#define BCMTCH_INFO(fmt, arg...) pr_info(BCMPFX fmt, ##arg)
#define BCMTCH_ERR(fmt, arg...) pr_err(BCMPFX fmt, ##arg)
#define BCMTCH_DBG(flag, fmt, arg...) pr_debug(BCMPFX fmt, ##arg)
#endif
#define PROGRESS() (BCMTCH_INFO("%s : %d\n", __func__, __LINE__))
/* -------------------------------------- */
/* - Touch Firmware Environment (ToFE) - */
/* -------------------------------------- */
#define TOFE_MESSAGE_SUCCESS 0x12
#define TOFE_MESSAGE_SOC_REBOOT_PENDING 0x16
#define TOFE_MESSAGE_COMMAND_ECHO 0x20
#define TOFE_MESSAGE_FW_READY 0x80
#define TOFE_MESSAGE_FW_READY_INTERRUPT 0x81
#define TOFE_MESSAGE_FW_READY_OVERRIDE 0x82
#define TOFE_MESSAGE_FW_READY_INTERRUPT_OVERRIDE 0x83
enum tofe_command {
TOFE_COMMAND_NO_COMMAND = 0,
TOFE_COMMAND_INTERRUPT_ACK,
TOFE_COMMAND_SCAN_START,
TOFE_COMMAND_SCAN_STOP,
TOFE_COMMAND_SCAN_SET_RATE,
TOFE_COMMAND_SET_MODE,
TOFE_COMMAND_CALIBRATE,
TOFE_COMMAND_AFEREGREAD,
TOFE_COMMAND_AFEREGWRITE,
TOFE_COMMAND_RUN_SEM,
TOFE_COMMAND_SET_LOG_MASK,
TOFE_COMMAND_SET_LOG_MASK_FWID_ALL,
TOFE_COMMAND_GET_LOG_MASK,
TOFE_COMMAND_INIT_POST_BOOT_PATCHES,
TOFE_COMMAND_SET_POWER_MODE,
TOFE_COMMAND_POWER_MODE_SUSPEND,
TOFE_COMMAND_POWER_MODE_RESUME,
TOFE_COMMAND_HOST_OVERRIDE_REQ,
TOFE_COMMAND_HOST_OVERRIDE_REL,
TOFE_COMMAND_REBOOT_APPROVED,
TOFE_COMMAND_LAST,
TOFE_COMMAND_MAX = 0xff
};
enum bcmtch_status {
BCMTCH_STATUS_SUCCESS = 0, /* Success */
BCMTCH_STATUS_ERR_FAIL, /* Generic failure */
BCMTCH_STATUS_ERR_NOMEM, /* Memory error */
BCMTCH_STATUS_ERR_NOARG, /* No proper arguments */
BCMTCH_STATUS_ERR_BADARG, /* Bad argument */
BCMTCH_STATUS_ERR_TOUT, /* Timeout */
BCMTCH_STATUS_ERR_IO, /* I/O error */
BCMTCH_STATUS_ERR_NOCFG, /* No configuration */
BCMTCH_STATUS_ERR_NOCHN, /* No required channel */
};
/**
@ struct tofe_command_response
@ brief Entry structure for command channel.
*/
struct tofe_command_response {
uint8_t flags;
uint8_t command;
uint16_t result;
uint32_t data;
};
#define TOFE_COMMAND_FLAG_COMMAND_PROCESSED (1 << 0)
#define TOFE_COMMAND_FLAG_REQUEST_RESULT (1 << 7)
/* ToFE Signature */
#define TOFE_SIGNATURE_MAGIC_SIZE 8
#define TOFE_MAGIC {'B', 'C', 'M', 'N', 'A', 'P', 'A', '\0'}
struct tofe_version {
uint8_t generation;
uint8_t spin;
uint8_t major;
uint8_t minor;
};
enum tofe_chip_variant {
TOFE_CHIP_VARIANT_INVALID,
TOFE_CHIP_VARIANT_PHONE,
TOFE_CHIP_VARIANT_TABLET,
};
/**
@struct tofe_signature
@brief Firmware ROM image signature structure.
*/
#pragma pack(push, 1)
struct tofe_signature {
char magic[TOFE_SIGNATURE_MAGIC_SIZE];
struct tofe_version version;
uint64_t commit;
uint32_t build;
uint16_t compatibility;
uint8_t variant; /* tofe_chip_variant */
uint8_t release_type;
uint8_t release_number;
uint8_t _pad;
uint16_t cust_release_num;
};
#pragma pack(pop)
#define TOFE_SIGNATURE_SIZE sizeof(struct tofe_signature)
/**
@enum tofe_channel_flag
@brief Channel flag field bit assignment.
*/
enum tofe_channel_flag {
TOFE_CHANNEL_FLAG_STATUS_OVERFLOW = 1 << 0,
TOFE_CHANNEL_FLAG_STATUS_LEVEL_TRIGGER = 1 << 1,
TOFE_CHANNEL_FLAG_FWDMA_BUFFER = 1 << 3,
TOFE_CHANNEL_FLAG_FWDMA_ENABLE = 1 << 4,
TOFE_CHANNEL_FLAG_INTERRUPT_ENABLE = 1 << 5,
TOFE_CHANNEL_FLAG_OVERFLOW_STALL = 1 << 6,
TOFE_CHANNEL_FLAG_INBOUND = 1 << 7,
};
enum tofe_toc_index {
TOFE_TOC_INDEX_CHANNEL = 2,
TOFE_TOC_INDEX_TCH = 3,
TOFE_TOC_INDEX_DETECT = 6,
};
enum tofe_channel_id {
TOFE_CHANNEL_ID_TOUCH,
TOFE_CHANNEL_ID_COMMAND,
TOFE_CHANNEL_ID_RESPONSE,
TOFE_CHANNEL_ID_LOG,
};
struct tofe_dmac_header {
uint16_t min_size;
uint16_t size;
};
struct tofe_channel_buffer_header {
struct tofe_dmac_header dmac;
uint8_t channel_id:4;
uint8_t flags:4;
uint8_t seq_number;
uint8_t entry_size;
uint8_t entry_count;
};
struct tofe_channel_buffer {
struct tofe_channel_buffer_header header;
uint32_t data[256];
};
struct tofe_channel_header {
/* Channel ID */
uint8_t channel_id;
/* Number of entries. Limited to 255 entries. */
uint8_t entry_num;
/* Entry size in bytes. Limited to 255 bytes. */
uint8_t entry_size;
/* Number of entries in channel to trigger notification */
uint8_t trig_level;
/* Bit definitions shared with configuration. */
uint8_t flags;
/* Number of datat buffers for this channel */
uint8_t buffer_num;
/* Select the buffer to write [0 .. buffer_num-1]. */
uint8_t buffer_idx;
/* Count the number of buffer swapped for debug. */
uint8_t seq_count;
struct tofe_channel_buffer *buffer[2];
};
struct tofe_channel_instance_cfg {
uint8_t entry_num; /* Must be > 0. */
uint8_t entry_size; /* Range [1..255]. */
uint8_t trig_level; /* 0 - entry_num */
uint8_t flags;
uint8_t buffer_num; /* Number of buffers for this channel */
uint8_t _pad8;
uint16_t offset;
struct tofe_channel_header *channel_header;
void *channel_data;
};
#pragma pack(push, 1)
struct mtc_detect_cfg {
/* compressed structure definition */
uint16_t _pad[17];
int16_t scaling_x_offset;
uint16_t scaling_x_gain;
uint16_t scaling_x_range;
int16_t scaling_y_offset;
uint16_t scaling_y_gain;
uint16_t scaling_y_range;
uint16_t class_finger_gate;
uint16_t _pad0;
uint16_t class_stylus_gate;
};
#pragma pack(pop)
struct tofe_log_msg {
uint16_t log_code;
uint16_t param_0;
uint32_t params[2];
uint32_t timestamp;
};
struct combi_entry {
uint32_t offset;
uint32_t addr;
uint32_t length;
uint32_t flags;
};
/* ------------------------------------- */
/* - BCM Touch Controller Driver Enums - */
/* ------------------------------------- */
enum bcmtch_channel_id {
/* NOTE : see above tofe_channel_id */
BCMTCH_CHANNEL_TOUCH,
BCMTCH_CHANNEL_COMMAND,
BCMTCH_CHANNEL_RESPONSE,
BCMTCH_CHANNEL_LOG,
/* last */
BCMTCH_CHANNEL_MAX
};
enum bcmtch_channel_set {
BCMTCH_RAM_CHANNELS = 0,
BCMTCH_ROM_CHANNELS = 1,
BCMTCH_MAX_CHANNEL_SET
};
/* event kinds from BCM Touch Controller */
enum bcmtch_event_kind {
BCMTCH_EVENT_KIND_RESERVED, /* Avoiding zero, but you may use it. */
BCMTCH_EVENT_KIND_FRAME,
BCMTCH_EVENT_KIND_TOUCH,
BCMTCH_EVENT_KIND_TOUCH_END,
BCMTCH_EVENT_KIND_BUTTON,
BCMTCH_EVENT_KIND_GESTURE,
BCMTCH_EVENT_KIND_EXTENSION = 7,
BCMTCH_EVENT_KIND_MAX = BCMTCH_EVENT_KIND_EXTENSION,
};
enum _bcmtch_touch_status {
BCMTCH_TOUCH_STATUS_INACTIVE,
BCMTCH_TOUCH_STATUS_UP,
BCMTCH_TOUCH_STATUS_MOVE,
BCMTCH_TOUCH_STATUS_MOVING,
};
/* -------------------------------------- */
/* - BCM Touch Controller Device Tables - */
/* -------------------------------------- */
static const uint32_t const BCMTCH_CHIP_IDS[] = {
0x15200,
0x15300,
0x15500,
};
/* ------------------------------------------ */
/* - BCM Touch Controller Driver Parameters - */
/* ------------------------------------------ */
#define BCMTCH_BF_HARD_RESET_ON_LOAD 0x00000001
#define BCMTCH_BF_SOFT_RESET_ON_LOAD 0x00000002
#define BCMTCH_BF_VERIFY_CHIP 0x00000004
#define BCMTCH_BF_DISABLE_POST_BOOT 0x00000008
#define BCMTCH_BF_CHECK_INTERRUPT 0x00000010
#define BCMTCH_BF_SUSPEND_COLD_BOOT 0x00000020
#define BCMTCH_BF_FW_RESET_ON_WD 0x00000040
#define BCMTCH_BF_STATE_PROTOCOL 0x00000080
#if BCMTCH_STATE_PROTOCOL
#define BCMTCH_BF_STATE_SHORT_SLOT 0x00000100
#define BCMTCH_BF_STATE_SYNC_MODE 0x00000200
#endif /* BCMTCH_STATE_PROTOCOL */
#define BCMTCH_BF_RESET_ON_LOAD_MASK \
(BCMTCH_BF_HARD_RESET_ON_LOAD \
| BCMTCH_BF_SOFT_RESET_ON_LOAD)
static int bcmtch_boot_flag =
(BCMTCH_BF_SOFT_RESET_ON_LOAD
| BCMTCH_BF_SUSPEND_COLD_BOOT
| BCMTCH_BF_FW_RESET_ON_WD
#if BCMTCH_STATE_PROTOCOL
| BCMTCH_BF_STATE_SYNC_MODE
#endif
| BCMTCH_BF_VERIFY_CHIP
);
module_param_named(boot_flag, bcmtch_boot_flag, int, S_IRUGO);
MODULE_PARM_DESC(boot_flag, "Boot bit-fields [RAM|RESET]");
/*-*/
#define BCMTCH_CHANNEL_FLAG_USE_TOUCH 0x00000001
#define BCMTCH_CHANNEL_FLAG_USE_CMD_RESP 0x00000002
#define BCMTCH_CHANNEL_FLAG_USE_LOG 0x00000004
static int bcmtch_channel_flag = BCMTCH_CHANNEL_FLAG_USE_TOUCH
| BCMTCH_CHANNEL_FLAG_USE_CMD_RESP;
module_param_named(channel_flag, bcmtch_channel_flag, int, S_IRUGO);
MODULE_PARM_DESC(channel_flag, "Channels allowed bit-fields [L|C/R|T]");
/*-*/
#define BCMTCH_EVENT_FLAG_TOUCH_SIZE 0x00000001
#define BCMTCH_EVENT_FLAG_TOOL_SIZE 0x00000002
#define BCMTCH_EVENT_FLAG_PRESSURE 0x00000004
#define BCMTCH_EVENT_FLAG_ORIENTATION 0x00000008
static int bcmtch_event_flag = BCMTCH_EVENT_FLAG_TOUCH_SIZE
| BCMTCH_EVENT_FLAG_ORIENTATION
| BCMTCH_EVENT_FLAG_PRESSURE;
module_param_named(event_flag, bcmtch_event_flag, int, S_IRUGO);
MODULE_PARM_DESC(event_flag, "Extension events bit-fields [ORIEN|PRESSURE|TOOL_SIZE|TOUCH_SIZE]");
/*- firmware -*/
#define BCMTCH_FIRMWARE_FLAGS_CODE 0x0
#define BCMTCH_FIRMWARE_FLAGS_CONFIGS 0x01
#define BCMTCH_FIRMWARE_FLAGS_POST_BOOT 0x02
#define BCMTCH_FIRMWARE_FLAGS_POST_BOOT_CODE 0x02
#define BCMTCH_FIRMWARE_FLAGS_POST_BOOT_CONFIGS 0x03
#define BCMTCH_FIRMWARE_FLAGS_MASK 0x03
#define BCMTCH_FIRMWARE_FLAGS_ROM_BOOT 0x04
#define BCMTCH_FIRMWARE_FLAGS_POST_BOOT_PATCH 0x08
#define BCMTCH_FIRMWARE_FLAGS_COMBI 0x10
static int bcmtch_firmware_flag = BCMTCH_FIRMWARE_FLAGS_COMBI;
module_param_named(firmware_flag, bcmtch_firmware_flag, int, S_IRUGO);
MODULE_PARM_DESC(firmware_flag, "Firmware flag bit-fields (combi = 0x10 config = 0x01");
static char *bcmtch_firmware;
module_param_named(firmware, bcmtch_firmware, charp, S_IRUGO);
MODULE_PARM_DESC(firmware, "Filename of firmware to load");
static int bcmtch_firmware_addr = 0x0;
module_param_named(firmware_addr, bcmtch_firmware_addr, int, S_IRUGO);
MODULE_PARM_DESC(firmware_addr, "Address to load firmware");
/*- post boot -*/
#define BCMTCH_POST_BOOT_RATE_HIGH (1<<10)
#define BCMTCH_POST_BOOT_RATE_LOW 80
static int bcmtch_post_boot_rate_high = BCMTCH_POST_BOOT_RATE_HIGH;
module_param_named(
pbr_high,
bcmtch_post_boot_rate_high,
int,
S_IRUGO | S_IWUSR);
MODULE_PARM_DESC(pbr_high, "Post Boot Download Rate - High");
static int bcmtch_post_boot_rate_low = BCMTCH_POST_BOOT_RATE_LOW;
module_param_named(pbr_low, bcmtch_post_boot_rate_low, int, S_IRUGO | S_IWUSR);
MODULE_PARM_DESC(pbr_low, "Post Boot Download Rate - Low");
/*- watch dog duration -*/
/* x milliseconds in jiffies */
#define BCMTCH_WATCHDOG_NORMAL 5000
#define BCMTCH_WATCHDOG_POST_BOOT 50
static uint32_t bcmtch_watchdog_normal = BCMTCH_WATCHDOG_NORMAL;
module_param_named(
wdg_normal,
bcmtch_watchdog_normal,
uint,
S_IRUGO | S_IWUSR);
MODULE_PARM_DESC(wdg_normal, "Watch dog rate in normal operation (ms)");
static uint32_t bcmtch_watchdog_post_boot = BCMTCH_WATCHDOG_POST_BOOT;
module_param_named(
wdg_post_boot,
bcmtch_watchdog_post_boot,
uint,
S_IRUGO | S_IWUSR);
MODULE_PARM_DESC(wdg_post_boot, "Watch dog rate at post boot download (ms)");
/*- debug flag -*/
#define BCMTCH_DF_MV 0x00000001 /* touch MOVE event */
#define BCMTCH_DF_UP 0x00000002 /* touch UP event */
#define BCMTCH_DF_TE 0x00000004 /* touch extension events */
#define BCMTCH_DF_BT 0x00000008 /* BUTTON event */
#define BCMTCH_DF_CH 0x00000010 /* channel protocol */
#define BCMTCH_DF_ST 0x00000020 /* state protocol */
#define BCMTCH_DF_RC 0x00000040 /* rm */
#define BCMTCH_DF_RF 0x00000080 /* rf */
#define BCMTCH_DF_FR 0x00000100 /* frame events */
#define BCMTCH_DF_FE 0x00000200 /* frame extension events */
#define BCMTCH_DF_PB 0x00000400 /* post-boot */
#define BCMTCH_DF_DT 0x00000800 /* device tree */
#define BCMTCH_DF_HO 0x00001000 /* host override */
#define BCMTCH_DF_PM 0x00002000 /* power management */
#define BCMTCH_DF_WD 0x00004000 /* watch dog */
#define BCMTCH_DF_IH 0x00008000 /* interrupt */
#define BCMTCH_DF_I2C 0x00010000 /* i2c */
#define BCMTCH_DF_INFO 0x00020000 /* info */
static int bcmtch_debug_flag; /* = 0; */
module_param_named(debug_flag, bcmtch_debug_flag, int, S_IRUGO | S_IWUSR);
MODULE_PARM_DESC(debug_flag, "Debug Bit-Flag");
/* ---------------------------------------- */
/* - BCM Touch Controller Firmware Tables - */
/* ---------------------------------------- */
#define BCMTCHWC 0x9999
struct firmware_load_info_t {
uint32_t chip_id;
uint32_t chip_rev;
uint8_t *filename;
uint32_t addr;
uint32_t flags;
};
static const struct firmware_load_info_t BCMTCH_BINARIES[] = {
/* MUST ALWAYS START WITH WILDCARD */
{BCMTCHWC, BCMTCHWC, "bcmtchfw_bin", 0, BCMTCH_FIRMWARE_FLAGS_COMBI},
/*
* ADD CHIP SPECIFIC BINARIES HERE
*/
/* CHIP ID specific */
{0x15200,
BCMTCHWC,
"bcmtchfw15200_bin",
0,
BCMTCH_FIRMWARE_FLAGS_COMBI},
{0x15300,
BCMTCHWC,
"bcmtchfw15300_bin",
0,
BCMTCH_FIRMWARE_FLAGS_COMBI},
/*
** CHIP ID & CHIP REV specific
*
*/
};
/* ------------------------------------------ */
/* - BCM Touch Controller Driver Structures - */
/* ------------------------------------------ */
/*- work queue enum -*/
enum bcmtch_work_process_function {
BCMTCH_WP_CHANNEL,
BCMTCH_WP_PATCH_INIT,
BCMTCH_WP_STATE,
BCMTCH_WP_NUMBER
};
/*- bcmtch channel structures -*/
struct bcmtch_channel {
struct tofe_channel_instance_cfg cfg;
struct tofe_channel_header hdr;
uint16_t queued;
uint8_t active;
/* intentional pad - may use for i2c tranactions */
uint8_t _pad8;
uint32_t data;
};
/**
@ struct bcmtch_response_wait
@ brief storage of the results from response channel.
*/
struct bcmtch_response_wait {
bool wait;
uint32_t resp_data;
};
struct bcmtch_event {
uint32_t event_kind:3;
uint32_t _pad:29;
};
enum bcmtch_event_frame_extension_kind {
BCMTCH_EVENT_FRAME_EXTENSION_KIND_TIMESTAMP,
BCMTCH_EVENT_FRAME_EXTENSION_KIND_CHECKSUM,
BCMTCH_EVENT_FRAME_EXTENSION_KIND_HEARTBEAT,
BCMTCH_EVENT_FRAME_EXTENSION_KIND_MAX = 7 /* 3 bits */
};
struct bcmtch_event_frame {
uint32_t event_kind:3;
uint32_t _pad:1;
uint32_t frame_id:12;
uint32_t timestamp:16;
};
struct bcmtch_event_frame_extension {
uint32_t event_kind:3;
uint32_t frame_kind:3;
uint32_t _pad:26;
};
struct bcmtch_event_frame_extension_timestamp {
uint32_t event_kind:3;
uint32_t frame_kind:3;
uint32_t _pad:2;
uint32_t scan_end:8;
uint32_t mtc_start:8;
uint32_t mtc_end:8;
};
struct bcmtch_event_frame_extension_checksum {
uint32_t event_kind:3;
uint32_t frame_kind:3;
uint32_t _pad:10;
uint32_t hash:16;
};
struct bcmtch_event_frame_extension_heartbeat {
uint32_t event_kind:3;
uint32_t frame_kind:3;
uint32_t _pad:2;
uint32_t timestamp:24; /* 100 us units, free running */
};
enum bcmtch_event_touch_extension_kind {
BCMTCH_EVENT_TOUCH_EXTENSION_KIND_DETAIL,
BCMTCH_EVENT_TOUCH_EXTENSION_KIND_BLOB,
BCMTCH_EVENT_TOUCH_EXTENSION_KIND_SIZE,
BCMTCH_EVENT_TOUCH_EXTENSION_KIND_HOVER,
BCMTCH_EVENT_TOUCH_EXTENSION_KIND_TOOL,
BCMTCH_EVENT_TOUCH_EXTENSION_KIND_MAX = 7 /* 3 bits */
};
enum bcmtch_event_touch_tool {
BCMTCH_EVENT_TOUCH_TOOL_FINGER,
BCMTCH_EVENT_TOUCH_TOOL_STYLUS,
};
struct bcmtch_event_touch {
uint32_t event_kind:3;
uint32_t track_tag:5;
uint32_t x:12;
uint32_t y:12;
};
struct bcmtch_event_touch_end {
uint32_t event_kind:3;
uint32_t track_tag:5;
uint32_t _pad:24;
};
struct bcmtch_event_touch_extension {
uint32_t event_kind:3;
uint32_t touch_kind:3;
uint32_t _pad:26;
};
struct bcmtch_event_touch_extension_detail {
uint32_t event_kind:3;
uint32_t touch_kind:3;
uint32_t confident:1;
uint32_t suppressed:1;
uint32_t hover:1;
uint32_t tool:1;
uint32_t large_touch:1;
uint32_t _pad:1;
uint32_t pressure:8;
uint32_t orientation:12;
};
struct bcmtch_event_touch_extension_blob {
uint32_t event_kind:3;
uint32_t touch_kind:3;
uint32_t area:8;
uint32_t total_cap:18;
};
#define BCMTCH_EVENT_TOUCH_EXTENSION_AREA_MAX 255
struct bcmtch_event_touch_extension_size {
uint32_t event_kind:3;
uint32_t touch_kind:3;
uint32_t _pad:6;
uint32_t major_axis:10;
uint32_t minor_axis:10;
};
struct bcmtch_event_touch_extension_hover {
uint32_t event_kind:3;
uint32_t touch_kind:3;
uint32_t _pad:16;
uint32_t height:10;
};
struct bcmtch_event_touch_extension_tool {
uint32_t event_kind:3;
uint32_t touch_kind:3;
uint32_t _pad:6;
uint32_t width_major:10;
uint32_t width_minor:10;
};
enum bcmtch_event_button_kind {
BCMTCH_EVENT_BUTTON_KIND_CONTACT,
BCMTCH_EVENT_BUTTON_KIND_HOVER,
BCMTCH_EVENT_BUTTON_KIND_MAX = 1
};
struct bcmtch_event_button {
uint32_t event_kind:3;
uint32_t button_kind:1;
uint32_t _pad:12;
uint32_t status:16;
};
/* driver structure for a single touch point */
struct bcmtch_touch {
uint16_t x; /* X Coordinate */
uint16_t y; /* Y Coordinate */
uint16_t major_axis;
uint16_t minor_axis;
uint16_t width_major;
uint16_t width_minor;
uint8_t type;
uint8_t pressure;
int16_t orientation;
/* Touch status: Down, Move, Up (Inactive) */
enum _bcmtch_touch_status status;
enum bcmtch_event_kind event; /* Touch Event Kind */
};
#if BCMTCH_STATE_PROTOCOL
/* ---------------------------- */
/* - State Protocol Constants - */
/* ---------------------------- */
enum bcmtch_state_protocol_cmd {
BCMTCH_CMD_LONG = 0x20,
BCMTCH_CMD_START_SCAN = 0x21,
BCMTCH_CMD_STOP_SCAN = 0x22,
BCMTCH_CMD_SUSPEND = 0x23,
BCMTCH_CMD_RESUME = 0x24,
BCMTCH_CMD_SLEEP = 0x28,
BCMTCH_CMD_SINGLE_SCAN = 0x30,
BCMTCH_CMD_READ_RAM = 0x31,
BCMTCH_CMD_WRITE_RAM = 0x32,
};
enum bcmtch_state_slot_type {
STATE_SLOT_TYPE_EMPTY = 0,
STATE_SLOT_TYPE_BUTTON = 1,
STATE_SLOT_TYPE_STYLUS = 2,
STATE_SLOT_TYPE_FINGER = 8,
STATE_SLOT_TYPE_RESERVED = 96,
};
#define TOFE_HOST_CMD_BUF_SIZE 512
#define TOFE_HOST_CMD_SHORT_SIZE 4
#define TOFE_HOST_MAX_NUM_SLOTS 15
#define TOFE_HOST_TOUCH_SLOT_SMALL_SIZE 4
#define TOFE_HOST_TOUCH_SLOT_BIG_SIZE 8
#define TOFE_HOST_LOG_SLOT_SIZE 12
#define TOFE_HOST_SLOT_AREA_MIN 1
#define TOFE_HOST_EXCEPTION_REGS 24
#define TOFE_HOST_RSP_BUF_SIZE \
(BCMTCH_MAX_TOUCH \
* TOFE_HOST_TOUCH_SLOT_BIG_SIZE + 1)
/*- State protocol RAM access configuration */
struct bcmtch_state_cfg_rw {
uint16_t cfg_size;
uint16_t max_read_size;
uint16_t max_write_size;
uint16_t patch_cfg_max_size;
uint32_t patch_cfg_addr;
};
#pragma pack(push, 1)
struct bcmtch_state_rw_params {
uint32_t addr;
uint16_t len;
};
#pragma pack(pop)
/*- Touch scan command/response format. -*/
union bcmtch_state_cmd_start_scan {
struct {
uint32_t touch_slot_format:3;
uint32_t sync_mode:1;
uint32_t max_slot_number:4;
};
uint8_t reg;
};
union bcmtch_state_ret_start_scan {
struct {
uint32_t slots:4;
uint32_t frame:3;
uint32_t done:1;
};
uint8_t reg;
};
struct bcmtch_state_start_scan {
union bcmtch_state_cmd_start_scan cmd;
union bcmtch_state_ret_start_scan status;
uint8_t touch_slot_size;
uint8_t touch_slot_num;
uint8_t log_slot_num;
};
union bcmtch_state_resp_slot {
uint8_t type:7;
uint8_t frame:1;
struct {
uint32_t type:7;
uint32_t frame:1;
uint32_t x:12;
uint32_t y:12;
uint32_t pressure:8;
uint32_t orientation:8;
uint32_t major:8;
uint32_t minor:8;
} long_slot;
struct {
uint32_t type:7;
uint32_t frame:1;
uint32_t x:12;
uint32_t y:12;
} short_slot;
struct {
uint32_t pad:8;
uint32_t buttons:24;
} button_slot;
struct {
uint32_t code_low:7;
uint32_t frame:1;
uint32_t code_hi:8;
uint32_t param0:16;
uint32_t param1;
uint32_t param2;
} log_slot;
};
#endif /* BCMTCH_STATE_PROTOCOL */
struct bcmtch_data {
/* core 0S elements */
/* Work queue structure for defining work queue handler */
struct work_struct work;
/* Work queue structure for transaction handling */
struct workqueue_struct *p_workqueue;
/* The table of worker process functions */
void (*bcmtch_dev_process_table[BCMTCH_WP_NUMBER])
(struct bcmtch_data *);
/* The index of the process function table */
uint8_t work_process_index;
/* Critical Section : Mutex : */
struct mutex mutex_work;
/* Pointer to allocated memory for input device */
struct input_dev *p_input_device;
struct device *p_device;
/* I2C 0S elements */
/* SPM I2C Client structure pointer */
struct i2c_client *p_i2c_client_spm;
/* SYS I2C Client structure pointer */
struct i2c_client *p_i2c_client_sys;
/* Local copy of platform data structure */
struct bcmtch_platform_data platform_data;
/* BCM Touch elements */
struct bcmtch_channel *p_channels
[BCMTCH_MAX_CHANNEL_SET][BCMTCH_CHANNEL_MAX];
/* BCMTCH touch structure */
struct bcmtch_touch touch[BCMTCH_MAX_TOUCH];
uint32_t touch_count;
uint8_t touch_event_track_id;
/* Response storage */
struct bcmtch_response_wait bcmtch_cmd_response[TOFE_COMMAND_LAST];
/* BCM Button elements */
uint16_t button_status;
#ifdef CONFIG_OF
const int32_t bcmtch_button_map[BCMTCH_MAX_BUTTONS];
#endif
/* DMA transfer mode */
bool has_dma_channel;
bool host_override;
uint32_t fw_dma_buffer_size;
void *fw_dma_buffer;
/* Interrupts */
bool irq_pending;
bool irq_enabled;
#ifdef CONFIG_REGULATOR
struct regulator *regulator_avdd33;
struct regulator *regulator_vddo;
struct regulator *regulator_avdd_adldo;
#endif
/* Power Management */
uint32_t power_on_delay_us; /* us wait time after power on */
/* Watchdog Timer */
uint32_t watchdog_expires;
struct timer_list watchdog;
/* Post Boot Downloads */
uint8_t channel_set; /* ROM/RAM channels */
uint8_t post_boot_pending;
uint8_t *post_boot_buffer;
uint8_t *post_boot_data;
uint32_t post_boot_addr;
uint16_t post_boot_left;
uint16_t post_boot_sections;
uint16_t post_boot_section;
uint16_t post_boot_patches;
uint32_t postboot_cfg_addr;
uint32_t postboot_cfg_length;
/* Axis Limits */
uint16_t axis_x_max;
uint16_t axis_x_min;
uint16_t axis_y_max;
uint16_t axis_y_min;
uint16_t axis_h_max;
uint16_t axis_h_min;
/* Thresholds */
uint16_t threshold_gate_finger;
uint16_t threshold_gate_stylus;
/* FW Signature */
struct tofe_signature fw_signature;
/* BCMTCH chip ID */
uint32_t chip_id;
/* BCMTCH revision ID */
uint8_t rev_id;
/* ROM boot */
bool boot_from_rom;
#ifdef CONFIG_HAS_EARLYSUSPEND
/* Early suspend */
struct early_suspend bcmtch_early_suspend_desc;
#endif
#if BCMTCH_STATE_PROTOCOL
struct bcmtch_state_cfg_rw ram_rw_cfg;
struct bcmtch_state_start_scan scan_data;
uint32_t exception_buffer[TOFE_HOST_EXCEPTION_REGS];
uint8_t bcmtch_state_cmd_buffer[TOFE_HOST_CMD_BUF_SIZE];
uint8_t bcmtch_state_resp_buffer[TOFE_HOST_RSP_BUF_SIZE];
#endif /* BCMTCH_STATE_PROTOCOL */
/* sysfs ABI data */
struct mutex mutex_abi;
uint8_t abi_spm_addr;
uint32_t abi_sys_addr;
uint16_t abi_sys_size;
bool abi_suspend;
};
/* -------------------------------------------- */
/* - BCM Touch Controller Function Prototypes - */
/* -------------------------------------------- */
/* DEV Prototypes */
static void bcmtch_dev_process(
struct bcmtch_data *);
static void bcmtch_dev_process_pb_patch_init(
struct bcmtch_data *);
static int32_t bcmtch_dev_reset(struct bcmtch_data *,
uint8_t);
static int32_t bcmtch_dev_suspend(
struct bcmtch_data *);
static int32_t bcmtch_dev_resume(
struct bcmtch_data *);
static int32_t bcmtch_dev_request_power_mode(
struct bcmtch_data *,
uint8_t, enum tofe_command);
static int32_t bcmtch_dev_send_command(
struct bcmtch_data *,
enum tofe_command, uint32_t, uint16_t, uint8_t);
static inline bool bcmtch_dev_verify_buffer_header(
struct bcmtch_data *,
struct tofe_channel_buffer_header*);
static int32_t bcmtch_dev_post_boot_download(
struct bcmtch_data *bcmtch_data_ptr,
int16_t data_rate);
static int32_t bcmtch_dev_post_boot_get_section(
struct bcmtch_data *);
static void bcmtch_dev_watchdog_work(unsigned long int data);
static void bcmtch_dev_watchdog_start(
struct bcmtch_data *);
static int32_t bcmtch_dev_watchdog_reset(
struct bcmtch_data *);
static int32_t bcmtch_dev_watchdog_stop(
struct bcmtch_data *);
static int32_t bcmtch_dev_watchdog_restart(
struct bcmtch_data *, uint32_t);
static int32_t bcmtch_dev_watchdog_check(
struct bcmtch_data *);
static int32_t bcmtch_dev_power_init(
struct bcmtch_data *);
static int32_t bcmtch_dev_power_enable(
struct bcmtch_data *,
bool);
static int32_t bcmtch_dev_power_free(
struct bcmtch_data *);
static void bcmtch_dev_reset_events(
struct bcmtch_data *bcmtch_data_ptr);
static int32_t bcmtch_dev_sync_event_frame(
struct bcmtch_data *bcmtch_data_ptr);
#if BCMTCH_STATE_PROTOCOL
static void bcmtch_dev_init_state(
struct bcmtch_data *);
static void bcmtch_dev_process_state_touches(
struct bcmtch_data *);
static int32_t bcmtch_state_start_scan(
struct bcmtch_data *);
static int32_t bcmtch_state_stop_scan(
struct bcmtch_data *);
static int32_t bcmtch_state_sleep(
struct bcmtch_data *);
static int32_t bcmtch_state_suspend(
struct bcmtch_data *);
static int32_t bcmtch_state_resume(
struct bcmtch_data *);
static int32_t bcmtch_state_write_ram(
struct bcmtch_data *, uint32_t, uint16_t, uint8_t *);
static int32_t bcmtch_state_read_ram(
struct bcmtch_data *, uint32_t, uint16_t, uint8_t *);
static int32_t bcmtch_state_check_command_status(
struct bcmtch_data *, uint8_t);
static int32_t bcmtch_state_i2c_send_command(
struct bcmtch_data *, uint8_t, uint8_t*, int);
#endif /* BCMTCH_STATE_PROTOCOL */
/* COM Prototypes */
static int32_t bcmtch_com_init(struct bcmtch_data *);
static int32_t bcmtch_com_read_spm(
struct bcmtch_data *, uint8_t, uint8_t*);
static int32_t bcmtch_com_write_spm(
struct bcmtch_data *, uint8_t, uint8_t);
static int32_t bcmtch_com_read_sys(
struct bcmtch_data *, uint32_t, uint16_t, uint8_t*);
static int32_t bcmtch_com_write_sys(
struct bcmtch_data *, uint32_t, uint16_t, uint8_t*);
static int32_t bcmtch_com_read_dma(
struct bcmtch_data *, uint16_t, uint8_t*);
/* COM Helper */
static inline int32_t bcmtch_com_fast_write_spm(
struct bcmtch_data *, uint8_t, uint8_t*, uint8_t*);
static inline int32_t bcmtch_com_write_sys32(
struct bcmtch_data *, uint32_t, uint32_t);
/* OS Prototypes */
static void bcmtch_reset(struct bcmtch_data *);
static int32_t bcmtch_interrupt_enable(
struct bcmtch_data *);
static void bcmtch_interrupt_disable(
struct bcmtch_data *);
static void bcmtch_deferred_worker(
struct work_struct *work);
static void bcmtch_clear_deferred_worker(
struct bcmtch_data *);
#ifdef CONFIG_PM
#ifndef CONFIG_HAS_EARLYSUSPEND
static int bcmtch_suspend(
struct i2c_client *p_client,
pm_message_t mesg);
static int bcmtch_resume(struct i2c_client *p_client);
#endif
#endif
/* OS I2C Prototypes */
static int32_t bcmtch_i2c_probe(
struct i2c_client*,
const struct i2c_device_id *);
static int32_t bcmtch_i2c_remove(struct i2c_client *);
static int32_t bcmtch_i2c_read_spm(struct i2c_client*, uint8_t, uint8_t*);
static int32_t bcmtch_i2c_write_spm(struct i2c_client*, uint8_t, uint8_t);
static int32_t bcmtch_i2c_fast_write_spm(
struct i2c_client*,
uint8_t,
uint8_t*,
uint8_t*);
static int32_t bcmtch_i2c_read_sys(
struct i2c_client*,
uint32_t,
uint16_t,
uint8_t*);
static int32_t bcmtch_i2c_write_sys(
struct i2c_client*,
uint32_t,
uint16_t,
uint8_t*);
static int32_t bcmtch_i2c_init_clients(struct i2c_client *);
static void bcmtch_i2c_free_clients(struct bcmtch_data *);
static int32_t bcmtch_i2c_read_dma(
struct i2c_client*,
uint16_t,
uint8_t*);
/* ------------------------------------------------- */
/* - BCM Touch Controller SysFs ABI Implementation - */
/* ------------------------------------------------- */
/* -- SYS peek/poke ABI -- */
static ssize_t bcmtch_os_abi_sys_addr_show(
struct device *dev,
struct device_attribute *devattr,
char *buf)
{
int count = 0;
struct bcmtch_data *bcmtch_data_ptr =
dev_get_drvdata(dev);
count += snprintf(buf + count, PAGE_SIZE - count,
"0x%04X %u\n",
bcmtch_data_ptr->abi_sys_addr,
bcmtch_data_ptr->abi_sys_size);
return count;
}
static ssize_t bcmtch_os_abi_sys_addr_store(
struct device *dev,
struct device_attribute *devattr,
const char *buf,
size_t count)
{
int ret_val = 0;
struct bcmtch_data *bcmtch_data_ptr =
dev_get_drvdata(dev);
uint32_t addr;
unsigned int len;
ret_val = sscanf(buf, "0x%x %u", &addr, &len);
if (ret_val != 2) {
BCMTCH_ERR(
"format: 0x<32bit address> <memory chunk size in bytes>\n");
return -EINVAL;
}
mutex_lock(&bcmtch_data_ptr->mutex_abi);
bcmtch_data_ptr->abi_sys_addr = addr;
bcmtch_data_ptr->abi_sys_size = (uint16_t)len;
mutex_unlock(&bcmtch_data_ptr->mutex_abi);
return count;
}
static DEVICE_ATTR(sys_addr, 0664,
bcmtch_os_abi_sys_addr_show,
bcmtch_os_abi_sys_addr_store);
static ssize_t bcmtch_os_abi_sys_data_show(
struct device *dev,
struct device_attribute *devattr,
char *buf)
{
int count = 0;
int32_t ret_val = 0;
struct bcmtch_data *bcmtch_data_ptr =
dev_get_drvdata(dev);
int i;
uint8_t r8[512];
if (bcmtch_data_ptr->abi_sys_size > 512)
return -EINVAL;
mutex_lock(&bcmtch_data_ptr->mutex_work);
#if BCMTCH_STATE_PROTOCOL
if (bcmtch_data_ptr->work_process_index >= BCMTCH_WP_STATE)
ret_val = bcmtch_state_read_ram(
bcmtch_data_ptr,
bcmtch_data_ptr->abi_sys_addr,
bcmtch_data_ptr->abi_sys_size,
r8);
else
#endif
ret_val = bcmtch_com_read_sys(
bcmtch_data_ptr,
bcmtch_data_ptr->abi_sys_addr,
bcmtch_data_ptr->abi_sys_size,
r8);
mutex_unlock(&bcmtch_data_ptr->mutex_work);
if (!ret_val) {
for (i = 0; i < bcmtch_data_ptr->abi_sys_size; i++) {
count += snprintf(buf + count, PAGE_SIZE - count,
"%02X ", r8[i]);
}
count += snprintf(buf + count,
PAGE_SIZE - count, "\n");
}
return count;
}
static ssize_t bcmtch_os_abi_sys_data_store(
struct device *dev,
struct device_attribute *devattr,
const char *buf,
size_t count)
{
int ret_val = 0;
struct bcmtch_data *bcmtch_data_ptr =
dev_get_drvdata(dev);
char tok[5] = "0xff";
unsigned int in_data;
uint8_t r8[512];
int i, j, k;
for (i = 0, j = 0, k = 0; i < count; i++) {
if (buf[i] == ' ' || buf[i] == '\t' || buf[i] == '\n') {
if (j) {
tok[j] = '\0';
ret_val = kstrtouint(tok, 16, &in_data);
if (!ret_val)
r8[k++] = (uint8_t)in_data;
}
j = 0;
continue;
}
tok[j++] = buf[i];
if (j > 4) {
j = 0;
continue;
}
}
if (k < bcmtch_data_ptr->abi_sys_size) {
BCMTCH_ERR("ERROR: only read %u out of %u data\n",
k, bcmtch_data_ptr->abi_sys_size);
return -EINVAL;
}
mutex_lock(&bcmtch_data_ptr->mutex_work);
#if BCMTCH_STATE_PROTOCOL
if (bcmtch_data_ptr->work_process_index >= BCMTCH_WP_STATE)
bcmtch_state_write_ram(
bcmtch_data_ptr,
bcmtch_data_ptr->abi_sys_addr,
bcmtch_data_ptr->abi_sys_size,
r8);
else
#endif
bcmtch_com_write_sys(
bcmtch_data_ptr,
bcmtch_data_ptr->abi_sys_addr,
bcmtch_data_ptr->abi_sys_size,
r8);
mutex_unlock(&bcmtch_data_ptr->mutex_work);
return count;
}
static DEVICE_ATTR(sys_data, 0664,
bcmtch_os_abi_sys_data_show,
bcmtch_os_abi_sys_data_store);
/* -- SPM peek/poke ABI -- */
static ssize_t bcmtch_os_abi_spm_addr_show(
struct device *dev,
struct device_attribute *devattr,
char *buf)
{
int count = 0;
struct bcmtch_data *bcmtch_data_ptr =
dev_get_drvdata(dev);
count += snprintf(buf + count, PAGE_SIZE - count,
"0x%02x\n", bcmtch_data_ptr->abi_spm_addr);
return count;
}
static ssize_t bcmtch_os_abi_spm_addr_store(
struct device *dev,
struct device_attribute *devattr,
const char *buf,
size_t count)
{
int ret_val = 0;
struct bcmtch_data *bcmtch_data_ptr =
dev_get_drvdata(dev);
unsigned int addr;
ret_val = kstrtouint(buf, 16, &addr);
if (ret_val)
return ret_val;
mutex_lock(&bcmtch_data_ptr->mutex_abi);
bcmtch_data_ptr->abi_spm_addr = (uint8_t)addr;
mutex_unlock(&bcmtch_data_ptr->mutex_abi);
return count;
}
static DEVICE_ATTR(spm_addr, 0664,
bcmtch_os_abi_spm_addr_show,
bcmtch_os_abi_spm_addr_store);
static ssize_t bcmtch_os_abi_spm_data_show(
struct device *dev,
struct device_attribute *devattr,
char *buf)
{
int count = 0;
struct bcmtch_data *bcmtch_data_ptr =
dev_get_drvdata(dev);
uint8_t r8;
mutex_lock(&bcmtch_data_ptr->mutex_work);
bcmtch_com_read_spm(bcmtch_data_ptr,
bcmtch_data_ptr->abi_spm_addr, &r8);
mutex_unlock(&bcmtch_data_ptr->mutex_work);
count += snprintf(buf + count, PAGE_SIZE - count,
"0x%02x\n", r8);
return count;
}
static ssize_t bcmtch_os_abi_spm_data_store(
struct device *dev,
struct device_attribute *devattr,
const char *buf,
size_t count)
{
int ret_val = 0;
struct bcmtch_data *bcmtch_data_ptr =
dev_get_drvdata(dev);
unsigned int in_data;
ret_val = kstrtouint(buf, 16, &in_data);
if (ret_val)
return ret_val;
mutex_lock(&bcmtch_data_ptr->mutex_work);
bcmtch_com_write_spm(bcmtch_data_ptr,
bcmtch_data_ptr->abi_spm_addr,
(uint8_t)in_data);
mutex_unlock(&bcmtch_data_ptr->mutex_work);
return count;
}
static DEVICE_ATTR(spm_data, 0664,
bcmtch_os_abi_spm_data_show,
bcmtch_os_abi_spm_data_store);
/* -- Finger threshold ABI -- */
static ssize_t bcmtch_os_abi_finger_threshold(
struct device *dev,
struct device_attribute *devattr,
char *buf)
{
int count = 0;
struct bcmtch_data *bcmtch_data_ptr =
dev_get_drvdata(dev);
count += snprintf(buf + count, PAGE_SIZE - count,
"%u\n", bcmtch_data_ptr->threshold_gate_finger);
return count;
}
static DEVICE_ATTR(
finger_threshold,
0444,
bcmtch_os_abi_finger_threshold,
NULL);
/* -- Stylus threshold ABI -- */
static ssize_t bcmtch_os_abi_stylus_threshold(
struct device *dev,
struct device_attribute *devattr,
char *buf)
{
int count = 0;
struct bcmtch_data *bcmtch_data_ptr =
dev_get_drvdata(dev);
count += snprintf(buf + count, PAGE_SIZE - count,
"%u\n", bcmtch_data_ptr->threshold_gate_stylus);
return count;
}
static DEVICE_ATTR(
stylus_threshold,
0444,
bcmtch_os_abi_stylus_threshold,
NULL);
/* -- Suspend ABI -- */
static ssize_t bcmtch_os_abi_suspend_show(
struct device *dev,
struct device_attribute *devattr,
char *buf)
{
int count = 0;
struct bcmtch_data *bcmtch_data_ptr =
dev_get_drvdata(dev);
count += snprintf(buf + count, PAGE_SIZE - count,
"%u\n",
bcmtch_data_ptr->abi_suspend ? 1 : 0);
return count;
}
static ssize_t bcmtch_os_abi_suspend_store(
struct device *dev,
struct device_attribute *devattr,
const char *buf,
size_t count)
{
int ret_val = 0;
struct bcmtch_data *bcmtch_data_ptr =
dev_get_drvdata(dev);
unsigned int val;
ret_val = kstrtouint(buf, 10, &val);
if (ret_val)
goto abi_suspend_error;
switch (val) {
case 0:
if (bcmtch_data_ptr->abi_suspend)
bcmtch_dev_resume(bcmtch_data_ptr);
break;
case 1:
if (!bcmtch_data_ptr->abi_suspend)
bcmtch_dev_suspend(bcmtch_data_ptr);
break;
default:
goto abi_suspend_error;
}
return count;
abi_suspend_error:
BCMTCH_ERR("ERROR: suspend ABI - set 0 or 1\n");
return -EINVAL;
}
static DEVICE_ATTR(suspend, 0664,
bcmtch_os_abi_suspend_show,
bcmtch_os_abi_suspend_store);
static struct attribute *bcmtch_abi_attrs[] = {
&dev_attr_spm_addr.attr,
&dev_attr_spm_data.attr,
&dev_attr_sys_addr.attr,
&dev_attr_sys_data.attr,
&dev_attr_finger_threshold.attr,
&dev_attr_stylus_threshold.attr,
&dev_attr_suspend.attr,
NULL
};
static const struct attribute_group bcmtch_attr_group = {
.attrs = bcmtch_abi_attrs,
};
static int32_t bcmtch_os_init_abi(struct device *p_device)
{
int32_t ret_val = 0;
struct bcmtch_data *bcmtch_data_ptr =
dev_get_drvdata(p_device);
ret_val = sysfs_create_group(&p_device->kobj, &bcmtch_attr_group);
if (ret_val)
BCMTCH_ERR(
"ERROR: %s() - device_create_file() failed!\n",
__func__);
bcmtch_data_ptr->abi_suspend = false;
return ret_val;
}
static inline void bcmtch_os_free_abi(struct device *p_device)
{
sysfs_remove_group(&p_device->kobj, &bcmtch_attr_group);
}
/* ------------------------------------------- */
/* - BCM Touch Controller CLI Implementation - */
/* ------------------------------------------- */
static void bcmtch_os_cli_versions(
struct bcmtch_data *bcmtch_data_ptr)
{
/* Return driver and firmware version info */
BCMTCH_INFO("Driver: %s : %s : %s\n",
BCMTCH_DRIVER_VERSION,
BCMTCH_DRIVER_BUILD_DATE,
BCMTCH_DRIVER_BUILD_TIME);
BCMTCH_INFO("F/W Version: %d.%d.%d.%d\n",
bcmtch_data_ptr->fw_signature.version.generation,
bcmtch_data_ptr->fw_signature.version.spin,
bcmtch_data_ptr->fw_signature.version.major,
bcmtch_data_ptr->fw_signature.version.minor);
BCMTCH_INFO("F/W Commit: %016llx\n",
bcmtch_data_ptr->fw_signature.commit);
BCMTCH_INFO(
"F/W Build:%d Compatibility:%d Variant:%d\n",
bcmtch_data_ptr->fw_signature.build,
bcmtch_data_ptr->fw_signature.compatibility,
bcmtch_data_ptr->fw_signature.variant);
BCMTCH_INFO(
"F/W ReleaseType:%c ReleaseNum:%d CustReleaseNum:%d\n",
bcmtch_data_ptr->fw_signature.release_type,
bcmtch_data_ptr->fw_signature.release_number,
bcmtch_data_ptr->fw_signature.cust_release_num);
}
static void bcmtch_os_cli_logmask_get(
struct bcmtch_data *bcmtch_data_ptr,
uint32_t in_logmask)
{
struct bcmtch_response_wait *p_resp;
uint32_t logmask;
uint32_t ret_val;
BCMTCH_INFO("get logmask module_id=0x%04x\n",
in_logmask);
logmask = (uint32_t)(in_logmask << 16);
p_resp = (struct bcmtch_response_wait *)
&(bcmtch_data_ptr->bcmtch_cmd_response
[TOFE_COMMAND_GET_LOG_MASK]);
p_resp->wait = 1;
mutex_lock(&bcmtch_data_ptr->mutex_work);
ret_val = bcmtch_dev_send_command(
bcmtch_data_ptr,
TOFE_COMMAND_GET_LOG_MASK,
logmask,
0,
TOFE_COMMAND_FLAG_REQUEST_RESULT);
if (ret_val != 0) {
BCMTCH_ERR("send_command error [%d] cmd=%x\n",
ret_val,
TOFE_COMMAND_GET_LOG_MASK);
}
mutex_unlock(&bcmtch_data_ptr->mutex_work);
}
static void bcmtch_os_cli_logmask_set(
struct bcmtch_data *bcmtch_data_ptr,
uint32_t in_logmask)
{
struct bcmtch_response_wait *p_resp;
BCMTCH_INFO("set logmask mask=0x%08x . . .\n",
in_logmask);
p_resp = (struct bcmtch_response_wait *)
&(bcmtch_data_ptr->bcmtch_cmd_response
[TOFE_COMMAND_SET_LOG_MASK]);
p_resp->wait = 1;
mutex_lock(&bcmtch_data_ptr->mutex_work);
bcmtch_dev_send_command(
bcmtch_data_ptr,
TOFE_COMMAND_SET_LOG_MASK,
in_logmask,
0,
TOFE_COMMAND_FLAG_REQUEST_RESULT);
mutex_unlock(&bcmtch_data_ptr->mutex_work);
}
static void bcmtch_os_cli_spm_poke(
struct bcmtch_data *bcmtch_data_ptr,
uint8_t in_addr,
uint8_t in_data)
{
mutex_lock(&bcmtch_data_ptr->mutex_work);
bcmtch_com_write_spm(bcmtch_data_ptr,
in_addr, in_data);
mutex_unlock(&bcmtch_data_ptr->mutex_work);
BCMTCH_INFO("poke spm Reg=%08x data=%08x\n",
in_addr, in_data);
}
static void bcmtch_os_cli_spm_peek(
struct bcmtch_data *bcmtch_data_ptr,
uint8_t in_addr)
{
uint8_t r8;
mutex_lock(&bcmtch_data_ptr->mutex_work);
bcmtch_com_read_spm(bcmtch_data_ptr, in_addr, &r8);
mutex_unlock(&bcmtch_data_ptr->mutex_work);
BCMTCH_INFO("peek spm reg=0x%02x data=0x%02x\n",
in_addr, r8);
}
static void bcmtch_os_cli_sys_poke(
struct bcmtch_data *bcmtch_data_ptr,
uint32_t in_addr,
uint32_t in_data)
{
mutex_lock(&bcmtch_data_ptr->mutex_work);
#if BCMTCH_STATE_PROTOCOL
if (bcmtch_data_ptr->work_process_index >= BCMTCH_WP_STATE)
bcmtch_state_write_ram(
bcmtch_data_ptr,
in_addr,
sizeof(uint32_t),
(uint8_t *)&in_data);
else
#endif
bcmtch_com_write_sys32(bcmtch_data_ptr, in_addr, in_data);
mutex_unlock(&bcmtch_data_ptr->mutex_work);
BCMTCH_INFO("poke sys addr=0x%08x data=0x%08x\n",
in_addr, in_data);
}
static void bcmtch_os_cli_sys_peek(
struct bcmtch_data *bcmtch_data_ptr,
uint32_t in_addr,
uint32_t in_count)
{
uint32_t r_buf[8];
uint32_t addr = in_addr;
uint32_t count = in_count;
memset(r_buf, 0, 8 * sizeof(uint32_t));
BCMTCH_INFO("peek sys addr=0x%08x len=0x%08x\n",
in_addr, in_count);
mutex_lock(&bcmtch_data_ptr->mutex_work);
while (count) {
#if BCMTCH_STATE_PROTOCOL
if (bcmtch_data_ptr->work_process_index >= BCMTCH_WP_STATE)
bcmtch_state_read_ram(
bcmtch_data_ptr,
addr,
8 * sizeof(uint32_t),
(uint8_t *)r_buf);
else
#endif
bcmtch_com_read_sys(bcmtch_data_ptr,
addr, 8 * sizeof(uint32_t),
(uint8_t *)r_buf);
BCMTCH_INFO(
"0x%08x: 0x%08x 0x%08x 0x%08x 0x%08x 0x%08x 0x%08x 0x%08x 0x%08x\n",
addr,
r_buf[0], r_buf[1], r_buf[2], r_buf[3],
r_buf[4], r_buf[5], r_buf[6], r_buf[7]);
count =
(count > (8 * sizeof(uint32_t))) ?
(count - (8 * sizeof(uint32_t))) :
0;
addr += (8 * sizeof(uint32_t));
}
mutex_unlock(&bcmtch_data_ptr->mutex_work);
}
static ssize_t bcmtch_os_cli(
struct device *dev,
struct device_attribute *devattr,
const char *buf,
size_t count)
{
uint32_t in_addr = 0;
uint32_t in_value_count = 0;
struct bcmtch_data *bcmtch_data_ptr =
dev_get_drvdata(dev);
/* We are now checking for exact number of matches
* to the format. Buf and format are const.
* sscanf will return 0 on first mismatch.
* We don't anticipate buf to be NULL here
* Annotate this if coverity flags it
*/
/* In future, we should also veriify that address
* is valid. We might change this interface in
* near future so leave that part as is
*/
if ((count > strlen("poke sys 0x 0x")) &&
sscanf(buf, "poke sys %x %x", &in_addr,
&in_value_count) == 2) {
bcmtch_os_cli_sys_poke(bcmtch_data_ptr,
in_addr, in_value_count);
} else if ((count > strlen("peek sys 0x 0x")) &&
sscanf(buf, "peek sys %x %x", &in_addr,
&in_value_count) == 2) {
bcmtch_os_cli_sys_peek(bcmtch_data_ptr,
in_addr, in_value_count);
} else if ((count > strlen("poke spm 0x 0x")) &&
sscanf(buf, "poke spm %x %x", &in_addr,
&in_value_count) == 2) {
bcmtch_os_cli_spm_poke(bcmtch_data_ptr,
in_addr & 0xff, in_value_count & 0xff);
} else if ((count > strlen("peek spm 0x")) &&
sscanf(buf, "peek spm %x",
&in_addr) == 1) {
bcmtch_os_cli_spm_peek(bcmtch_data_ptr,
in_addr & 0xff);
} else if ((count > strlen("set logmask 0x")) &&
sscanf(buf, "set logmask %x",
&in_value_count) == 1) {
bcmtch_os_cli_logmask_set(bcmtch_data_ptr,
in_value_count);
} else if ((count > strlen("get logmask 0x")) &&
sscanf(buf, "get logmask %x",
&in_value_count) == 1) {
bcmtch_os_cli_logmask_get(bcmtch_data_ptr,
in_value_count);
}
#if defined(CONFIG_PM)
else if (strncmp(buf, "suspend", strlen("suspend")) == 0) {
BCMTCH_INFO("cli --> suspend\n");
bcmtch_dev_suspend(bcmtch_data_ptr);
} else if (strncmp(buf, "resume", strlen("resume")) == 0) {
BCMTCH_INFO("cli --> resume\n");
bcmtch_dev_resume(bcmtch_data_ptr);
}
#endif
else if (strncmp(buf, "threshold finger",
strlen("threshold finger")) == 0) {
BCMTCH_INFO("finger threshold = %u\n",
bcmtch_data_ptr->threshold_gate_finger);
} else if (strncmp(buf, "threshold stylus",
strlen("threshold stylus")) == 0) {
BCMTCH_INFO("stylus threshold = %u\n",
bcmtch_data_ptr->threshold_gate_stylus);
} else if (strncmp(buf, "versions", strlen("versions")) == 0) {
bcmtch_os_cli_versions(bcmtch_data_ptr);
} else {
BCMTCH_INFO("Usage:\n");
BCMTCH_INFO("poke sys 0x<addr> 0x<data>\n");
BCMTCH_INFO("peek sys 0x<addr> 0x<len>\n");
BCMTCH_INFO("poke spm 0x<reg> 0x<data>\n");
BCMTCH_INFO("peek spm 0x<reg>\n");
BCMTCH_INFO("set logmask 0x<module>\n");
BCMTCH_INFO("get logmask 0x<mask - bitmap>\n");
#if defined(CONFIG_PM)
BCMTCH_INFO("suspend\n");
BCMTCH_INFO("resume\n");
#endif
BCMTCH_INFO("threshold finger\n");
BCMTCH_INFO("threshold stylus\n");
BCMTCH_INFO("versions\n");
}
return count;
}
static struct device_attribute bcmtch_cli_attr =
__ATTR(cli, S_IWUSR|S_IWGRP, NULL, bcmtch_os_cli);
/* ------------------------------------------- */
/* - BCM Touch Controller Internal Functions - */
/* ------------------------------------------- */
static inline
unsigned bcmtch_channel_num_queued(
struct tofe_channel_header *channel)
{
return (unsigned)channel->
buffer[0]->header.entry_count;
}
/*
Note: Internal use only function.
*/
static inline char *
_bcmtch_inline_channel_entry(
struct tofe_channel_header *channel,
uint32_t byte_index)
{
return (char *)channel->buffer[0]->data
+ byte_index;
}
/*
Note: Internal use only function.
*/
static inline size_t
_bcmtch_inline_channel_byte_index(
struct tofe_channel_header *channel,
uint8_t entry_index)
{
return entry_index * channel->entry_size;
}
/**
Check if a channel is empty.
Events are not considered read or writen until the transaction is
complete. Therefore, a channel is empty even when in the middle of a
set of writes.
@param
[in] channel Pointer to channel object.
@retval
bool True if channel is empty.
*/
static inline bool
bcmtch_inline_channel_is_empty(struct tofe_channel_header *channel)
{
return (channel->buffer[0]->header.entry_count == 0);
}
/**
Read a single entry from a channel. This function must be called during
a read transaction.
The pointer returned by this function points into the channel object itself.
Callers should not modify or reuse this memory. Callers may not free the
memory.
@param
[in] channel Pointer to channel object.
@retval
void * Pointer to returned entry.
*/
static inline void *bcmtch_inline_channel_read(
struct tofe_channel_header *channel,
uint16_t index)
{
size_t byte_index;
struct tofe_channel_buffer *buff = channel->buffer[0];
/* Validate that channel has entries. */
if (buff->header.entry_count == 0)
return NULL;
/* Check if buffer data corrupted */
if (buff->header.entry_size != channel->entry_size)
return NULL;
/* Check if read end. */
if (index >= buff->header.entry_count)
return NULL;
/* Find entry in the channel. */
byte_index = _bcmtch_inline_channel_byte_index(channel, index);
return (void *)((char *)channel->buffer[0]->data
+ byte_index);
}
static inline void
tofe_channel_write_begin(struct tofe_channel_header *channel)
{
struct tofe_channel_buffer_header *buff =
&channel->buffer[0]->header;
if (channel->flags & TOFE_CHANNEL_FLAG_INBOUND)
buff->entry_count = 0;
}
static inline uint32_t
tofe_channel_write(struct tofe_channel_header *channel, void *entry)
{
struct tofe_channel_buffer_header *buff =
&channel->buffer[0]->header;
size_t byte_index =
channel->entry_size * buff->entry_count;
char *p_data = _bcmtch_inline_channel_entry(
channel,
byte_index);
if ((channel->flags & TOFE_CHANNEL_FLAG_INBOUND) == 0)
return -EINVAL;
if (buff->entry_count >= channel->entry_num)
return -ENOMEM;
memcpy(p_data, entry, channel->entry_size);
buff->entry_count++;
return 0;
}
static
uint16_t bcmtch_max_h_axis(uint16_t x, uint16_t y)
{
uint16_t i;
uint16_t res = 0;
uint16_t add = 0x8000;
uint32_t g = (x * x) + (y * y);
for (i = 0; i < 16 ; i++) {
uint16_t temp = res | add;
uint32_t g2 = temp * temp;
if (g >= g2)
res = temp;
add >>= 1;
}
return res;
}
/* ------------------------------------------- */
/* - BCM Touch Controller DEV Functions - */
/* ------------------------------------------- */
static int32_t bcmtch_dev_alloc(struct i2c_client *p_i2c_client)
{
int32_t ret_val = 0;
struct bcmtch_data *bcmtch_data_ptr;
bcmtch_data_ptr =
kzalloc(sizeof(struct bcmtch_data), GFP_KERNEL);
if (bcmtch_data_ptr == NULL) {
BCMTCH_ERR("%s: failed to alloc mem.\n", __func__);
ret_val = -ENOMEM;
}
mutex_init(&bcmtch_data_ptr->mutex_work);
mutex_init(&bcmtch_data_ptr->mutex_abi);
i2c_set_clientdata(p_i2c_client, (void *)bcmtch_data_ptr);
bcmtch_data_ptr->p_device = &p_i2c_client->dev;
return ret_val;
}
static void bcmtch_dev_free(struct i2c_client *p_i2c_client)
{
struct bcmtch_data *local_bcmtch_data_p =
(struct bcmtch_data *)
i2c_get_clientdata(p_i2c_client);
kfree(local_bcmtch_data_p);
i2c_set_clientdata(p_i2c_client, NULL);
}
static int32_t bcmtch_dev_init_clocks(
struct bcmtch_data *bcmtch_data_ptr)
{
int32_t ret_val = 0;
uint32_t val32;
/* setup LPLFO - read OTP and set from value */
bcmtch_com_read_sys(
bcmtch_data_ptr,
BCMTCH_ADDR_SPM_LPLFO_CTRL_RO,
4,
(uint8_t *)&val32);
val32 &= 0xF0000000;
val32 >>= 28;
bcmtch_com_write_spm(
bcmtch_data_ptr,
BCMTCH_SPM_REG_LPLFO_CTRL,
(uint8_t)val32 | 0x10);
return ret_val;
}
static int32_t bcmtch_dev_init_memory(
struct bcmtch_data *bcmtch_data_ptr)
{
int32_t ret_val = 0;
uint32_t mem_map;
mem_map = (bcmtch_data_ptr->boot_from_rom) ?
BCMTCH_MEM_ROM_BOOT : BCMTCH_MEM_RAM_BOOT;
bcmtch_data_ptr->channel_set =
(bcmtch_data_ptr->boot_from_rom) ?
BCMTCH_ROM_CHANNELS : BCMTCH_RAM_CHANNELS;
if (mem_map)
ret_val =
bcmtch_com_write_sys32(
bcmtch_data_ptr,
BCMTCH_MEM_REMAP_ADDR, mem_map);
return ret_val;
}
static inline void
tofe_channel_header_init(
struct bcmtch_data *bcmtch_data_ptr,
struct bcmtch_channel *p_channel,
struct tofe_channel_instance_cfg *p_chan_cfg)
{
struct tofe_channel_header *hdr = &p_channel->hdr;
struct tofe_channel_buffer_header *buff;
hdr->entry_num = p_chan_cfg->entry_num;
hdr->entry_size = p_chan_cfg->entry_size;
hdr->trig_level = p_chan_cfg->trig_level;
hdr->flags = p_chan_cfg->flags;
hdr->buffer_num = p_chan_cfg->buffer_num;
hdr->buffer_idx = 0;
hdr->seq_count = 0;
hdr->buffer[0] = (struct tofe_channel_buffer *)&p_channel->data;
hdr->buffer[1] = (struct tofe_channel_buffer *)&p_channel->data;
if (hdr->flags & TOFE_CHANNEL_FLAG_FWDMA_ENABLE) {
bcmtch_data_ptr->has_dma_channel = true;
buff = &hdr->buffer[1]->header;
buff->channel_id = hdr->channel_id;
buff->entry_count = 0;
buff->entry_size = hdr->entry_size;
bcmtch_data_ptr->fw_dma_buffer_size +=
sizeof(struct tofe_channel_buffer_header)
+ (hdr->entry_num * hdr->entry_size);
}
}
static int32_t bcmtch_dev_init_channel(
struct bcmtch_data *bcmtch_data_ptr,
uint8_t chan_set,
enum bcmtch_channel_id chan_id,
struct tofe_channel_instance_cfg *p_chan_cfg,
uint8_t active)
{
int32_t ret_val = 0;
uint32_t channel_size;
struct bcmtch_channel *p_channel;
if (active) {
channel_size =
/* channel data size */
sizeof(struct tofe_channel_buffer_header)
+ (p_chan_cfg->flags &
TOFE_CHANNEL_FLAG_FWDMA_ENABLE ? 0 :
p_chan_cfg->entry_num
* p_chan_cfg->entry_size)
/* channel header size */
+ sizeof(struct tofe_channel_header)
/* channel config size */
+ sizeof(struct tofe_channel_instance_cfg)
/* sizes for added elements: queued, pad */
+ (sizeof(uint16_t) * 2);
} else {
channel_size =
/* channel header size */
sizeof(struct tofe_channel_header)
/* channel config size */
+ sizeof(struct tofe_channel_instance_cfg)
/* sizes for added elements: queued, pad */
+ (sizeof(uint16_t) * 2);
}
p_channel = kzalloc(channel_size, GFP_KERNEL);
if (p_channel) {
p_channel->cfg = *p_chan_cfg;
/* Initialize Header */
p_channel->hdr.channel_id = (uint8_t)chan_id;
p_channel->active = active;
tofe_channel_header_init(bcmtch_data_ptr,
p_channel, p_chan_cfg);
bcmtch_data_ptr->p_channels[chan_set][chan_id] = p_channel;
} else if (active) {
ret_val = -ENOMEM;
bcmtch_data_ptr->p_channels[chan_set][chan_id] = NULL;
}
return ret_val;
}
static void bcmtch_dev_free_channels(
struct bcmtch_data *bcmtch_data_ptr)
{
uint32_t chan = 0;
uint8_t chan_set = 0;
kfree(bcmtch_data_ptr->fw_dma_buffer);
bcmtch_data_ptr->fw_dma_buffer = NULL;
while (chan_set < BCMTCH_MAX_CHANNEL_SET) {
while (chan < BCMTCH_CHANNEL_MAX) {
if (bcmtch_data_ptr->p_channels[chan_set][chan]) {
kfree(bcmtch_data_ptr->
p_channels[chan_set][chan]);
bcmtch_data_ptr->
p_channels[chan_set][chan] = NULL;
}
chan++;
}
chan_set++;
}
}
static int32_t bcmtch_dev_init_channels(
struct bcmtch_data *bcmtch_data_ptr,
uint32_t mem_addr,
uint8_t *mem_data,
uint8_t chan_set)
{
int32_t ret_val = 0;
void *p_buffer = NULL;
uint32_t *p_cfg = NULL;
struct tofe_channel_instance_cfg *p_chan_cfg = NULL;
/* find channel configs */
p_cfg = (uint32_t *)(mem_data + TOFE_SIGNATURE_SIZE);
p_chan_cfg =
(struct tofe_channel_instance_cfg *)
((uint32_t)mem_data + p_cfg[TOFE_TOC_INDEX_CHANNEL] - mem_addr);
/* check if processing channel(s) - add */
ret_val = bcmtch_dev_init_channel(
bcmtch_data_ptr,
chan_set,
BCMTCH_CHANNEL_TOUCH,
&p_chan_cfg[TOFE_CHANNEL_ID_TOUCH],
bcmtch_channel_flag & BCMTCH_CHANNEL_FLAG_USE_TOUCH);
if (ret_val) {
BCMTCH_ERR("%s: [%d] Touch Event Channel not initialized!\n",
__func__, ret_val);
}
/* Command & response channels */
if (!ret_val) {
ret_val = bcmtch_dev_init_channel(
bcmtch_data_ptr,
chan_set,
BCMTCH_CHANNEL_COMMAND,
&p_chan_cfg[TOFE_CHANNEL_ID_COMMAND],
bcmtch_channel_flag &
BCMTCH_CHANNEL_FLAG_USE_CMD_RESP);
ret_val |= bcmtch_dev_init_channel(
bcmtch_data_ptr,
chan_set,
BCMTCH_CHANNEL_RESPONSE,
&p_chan_cfg[TOFE_CHANNEL_ID_RESPONSE],
bcmtch_channel_flag &
BCMTCH_CHANNEL_FLAG_USE_CMD_RESP);
if (ret_val)
BCMTCH_ERR(
"%s: [%d] C/R Channel initialization failed!\n",
__func__, ret_val);
}
/* Log channel */
if (!ret_val) {
ret_val = bcmtch_dev_init_channel(
bcmtch_data_ptr,
chan_set,
BCMTCH_CHANNEL_LOG,
&p_chan_cfg[TOFE_CHANNEL_ID_LOG],
bcmtch_channel_flag &
BCMTCH_CHANNEL_FLAG_USE_LOG);
if (ret_val)
BCMTCH_ERR(
"%s: [%d] Log Channel initialization failed!\n",
__func__, ret_val);
}
/* Initialize DMA buffer if there is any DMA mode channel */
if (!ret_val &&
bcmtch_data_ptr->has_dma_channel) {
BCMTCH_DBG(
BCMTCH_DF_CH,
"CH:%s() dma buffer size=%d\n",
__func__,
bcmtch_data_ptr->fw_dma_buffer_size);
p_buffer =
kzalloc(
bcmtch_data_ptr->fw_dma_buffer_size,
GFP_KERNEL);
if (p_buffer) {
bcmtch_data_ptr->fw_dma_buffer = p_buffer;
} else {
BCMTCH_ERR("%s: [%d] DMA buffer allocation failed!\n",
__func__, ret_val);
bcmtch_data_ptr->fw_dma_buffer = NULL;
ret_val = -ENOMEM;
}
}
return ret_val;
}
static int32_t bcmtch_dev_write_channel(
struct bcmtch_data *bcmtch_data_ptr,
struct bcmtch_channel *chan)
{
int32_t ret_val = 0;
int16_t write_size;
uint32_t sys_addr;
/* read channel header and data all-at-once : need combined size */
write_size = sizeof(struct tofe_channel_buffer_header)
+ (chan->cfg.entry_num * chan->cfg.entry_size);
sys_addr = (uint32_t)chan->cfg.channel_data;
/* write channel header & channel data buffer */
ret_val = bcmtch_com_write_sys(
bcmtch_data_ptr,
sys_addr,
write_size,
(uint8_t *)chan->hdr.buffer[0]);
if (ret_val) {
BCMTCH_ERR("BCMTOUCH: %s() write_sys err addr=0x%08x, rv=%d\n",
__func__,
sys_addr,
ret_val);
}
return ret_val;
}
static int32_t bcmtch_dev_sync_channel(
struct bcmtch_data *bcmtch_data_ptr,
struct bcmtch_channel *chan)
{
int32_t ret_val = 0;
uint16_t read_size;
uint32_t sys_addr;
struct tofe_channel_header sync_hdr;
/* Read channel header from firmware */
read_size = sizeof(struct tofe_channel_header);
sys_addr = (uint32_t)chan->cfg.channel_header;
ret_val = bcmtch_com_read_sys(
bcmtch_data_ptr,
(uint32_t)chan->cfg.channel_header,
read_size,
(uint8_t *)&sync_hdr);
if (ret_val) {
BCMTCH_ERR("BCMTOUCH: %s() read hdr err addr=0x%08x, rv=%d\n",
__func__,
sys_addr,
ret_val);
return ret_val;
}
/* Read channel */
read_size = sizeof(struct tofe_channel_buffer_header)
+ (chan->cfg.entry_num * chan->cfg.entry_size);
sys_addr = (uint32_t)(sync_hdr.buffer_idx > 0 ?
(char *)chan->cfg.channel_data :
(char *)chan->cfg.channel_data
+ chan->cfg.offset);
ret_val = bcmtch_com_read_sys(
bcmtch_data_ptr,
sys_addr,
read_size,
(uint8_t *)chan->hdr.buffer[0]);
if (ret_val) {
BCMTCH_ERR(
"BCMTOUCH: %s() read buffer err addr=0x%08x, rv=%d\n",
__func__,
sys_addr,
ret_val);
return ret_val;
}
chan->queued = bcmtch_channel_num_queued(&chan->hdr);
/* Sync the channel header */
chan->hdr.buffer_idx = sync_hdr.buffer_idx;
if (bcmtch_data_ptr->channel_set == BCMTCH_ROM_CHANNELS)
chan->hdr.seq_count = sync_hdr.seq_count;
else
chan->hdr.seq_count = sync_hdr.seq_count + 1;
return ret_val;
}
static int32_t bcmtch_dev_read_channel(
struct bcmtch_data *bcmtch_data_ptr,
struct bcmtch_channel *chan)
{
int32_t ret_val = 0;
uint8_t buffer_idx = chan->hdr.buffer_idx;
uint8_t seq_count = chan->hdr.seq_count;
struct tofe_channel_buffer_header *buff =
&chan->hdr.buffer[1]->header;
uint16_t read_size;
uint32_t sys_addr;
/* channel buffer size: buffer header + entries */
read_size = sizeof(struct tofe_channel_buffer_header)
+ (chan->cfg.entry_num * chan->cfg.entry_size);
sys_addr = (uint32_t)(buffer_idx == 0 ?
(char *)chan->cfg.channel_data :
(char *)chan->cfg.channel_data
+ chan->cfg.offset);
/* read channel header & channel data buffer */
ret_val = bcmtch_com_read_sys(
bcmtch_data_ptr,
sys_addr,
read_size,
(uint8_t *)chan->hdr.buffer[1]);
if (ret_val) {
BCMTCH_ERR("BCMTOUCH: %s() read_sys err addr=0x%08x, rv=%d\n",
__func__,
sys_addr,
ret_val);
return ret_val;
}
/* check if data corrupted */
if (!bcmtch_dev_verify_buffer_header(bcmtch_data_ptr,
buff)) {
BCMTCH_DBG(
BCMTCH_DF_CH,
"CH:%s() ch=%d buffer data corrupted!\n",
__func__,
chan->hdr.channel_id);
return -EIO;
}
if (buff->flags & TOFE_CHANNEL_FLAG_STATUS_OVERFLOW)
BCMTCH_DBG(
BCMTCH_DF_CH,
"CH:%s() ch=%d channel overflow\n",
__func__,
chan->hdr.channel_id);
if (buff->seq_number != seq_count) {
BCMTCH_DBG(
BCMTCH_DF_CH,
"CH:%s() host ch=%d seq=%d, fw seq=%d NOT Matched!!\n",
__func__,
buff->channel_id,
seq_count,
buff->seq_number);
/* sync channel */
ret_val =
bcmtch_dev_sync_channel(bcmtch_data_ptr, chan);
return ret_val;
}
/* Update channel header */
chan->hdr.seq_count++;
chan->hdr.buffer_idx = (buffer_idx > 0 ? 0 : 1);
/* get count */
chan->queued = bcmtch_channel_num_queued(&chan->hdr);
return ret_val;
}
static uint32_t bcmtch_dev_read_dma_buffer(
struct bcmtch_data *bcmtch_data_ptr)
{
uint32_t read_size = 0;
uint32_t dma_buff_size = bcmtch_data_ptr->fw_dma_buffer_size;
uint8_t dma_reg = BCMTCH_SPM_REG_DMA_RFIFO;
uint8_t *dma_buff = (uint8_t *)bcmtch_data_ptr->fw_dma_buffer;
struct i2c_client *p_i2c = bcmtch_data_ptr->p_i2c_client_sys;
struct tofe_dmac_header *p_dmac;
/* setup I2C messages for DMA read request transaction */
struct i2c_msg dma_request[2] = {
/* write the RFIFO address */
{.addr = p_i2c->addr,
.flags = 0,
.len = 1,
.buf = &dma_reg},
/* read RFIFO data */
{.addr = p_i2c->addr,
.flags = I2C_M_RD,
.len = (uint32_t)sizeof(struct tofe_dmac_header),
.buf = dma_buff}
};
/* Set I2C master to read from RFIFO */
if (dma_buff_size && dma_buff) {
/* 1st I2C read dmac header */
if (i2c_transfer(p_i2c->adapter, dma_request, 2) != 2) {
BCMTCH_ERR("%s: I2C transfer error.\n",
__func__);
return 0;
} else {
p_dmac = (struct tofe_dmac_header *)dma_buff;
read_size = (uint32_t)p_dmac->size;
BCMTCH_DBG(
BCMTCH_DF_CH,
"CH:DMA buffer read size=%d min_size=%d.\n",
read_size,
p_dmac->min_size);
if (read_size > dma_buff_size) {
BCMTCH_ERR(
"%s: DMA read overflow buffer [%d].\n",
__func__,
dma_buff_size);
return 0;
} else if (read_size <
sizeof(struct tofe_dmac_header))
return 0;
/* 2nd I2C read entire DMA buffer */
dma_request[1].len =
read_size
- sizeof(struct tofe_dmac_header);
dma_request[1].buf =
(uint8_t *)dma_buff
+ sizeof(struct tofe_dmac_header);
if (i2c_transfer(p_i2c->adapter, dma_request, 2) != 2) {
BCMTCH_ERR("%s: I2C transfer error.\n",
__func__);
return 0;
}
}
} else {
BCMTCH_ERR("%s: DMA buffer/size is NULL.\n",
__func__);
}
return read_size;
}
static inline bool bcmtch_dev_verify_buffer_header(
struct bcmtch_data *bcmtch_data_ptr,
struct tofe_channel_buffer_header *buff)
{
uint8_t channel;
uint8_t chan_set = bcmtch_data_ptr->channel_set;
struct bcmtch_channel *p_chan;
bool ret_val = true;
p_chan = NULL;
channel = (uint8_t)buff->channel_id;
if (channel >= BCMTCH_CHANNEL_MAX)
ret_val = false;
else {
p_chan = bcmtch_data_ptr->p_channels[chan_set][channel];
if (!p_chan ||
(buff->entry_size != p_chan->cfg.entry_size))
ret_val = false;
}
if (ret_val == false)
BCMTCH_DBG(
BCMTCH_DF_CH,
"CH:ERROR : id=%d entry_size=%d [%d]\n",
buff->channel_id,
buff->entry_size,
(p_chan) ? p_chan->cfg.entry_size : -1);
return ret_val;
}
static int32_t bcmtch_dev_read_dma_channels(
struct bcmtch_data *bcmtch_data_ptr)
{
int32_t ret_val = 0;
uint32_t read_size;
uint32_t read_head;
uint32_t offset;
uint32_t channel;
uint8_t *p_dma = (uint8_t *)bcmtch_data_ptr->fw_dma_buffer;
uint8_t chan_set = bcmtch_data_ptr->channel_set;
struct tofe_channel_buffer_header *buff;
struct tofe_channel_header *hdr;
/* Read DMA buffer via I2C */
read_size = bcmtch_dev_read_dma_buffer(bcmtch_data_ptr);
BCMTCH_DBG(BCMTCH_DF_CH, "CH:%s: read DMA buffer %d bytes.\n",
__func__,
read_size);
if (read_size > bcmtch_data_ptr->fw_dma_buffer_size) {
BCMTCH_ERR("%s: Invalid DMA data read size %d.\n",
__func__,
read_size);
return -EIO;
}
/* Parse DMA buffer for channels */
read_head = 0;
while (read_head < read_size) {
buff = (struct tofe_channel_buffer_header *)p_dma;
if (!bcmtch_dev_verify_buffer_header(bcmtch_data_ptr,
buff)) {
BCMTCH_ERR(
"%s: corrupted buffer header in DMA channel!\n",
__func__);
return -EIO;
}
channel = buff->channel_id;
BCMTCH_DBG(
BCMTCH_DF_CH,
"CH:%s: parsing channel [%d] min_size=%d\n",
__func__,
channel,
buff->dmac.min_size);
hdr = &bcmtch_data_ptr->p_channels[chan_set][channel]->hdr;
if (hdr->flags & TOFE_CHANNEL_FLAG_FWDMA_ENABLE)
hdr->buffer[0] = (struct tofe_channel_buffer *)p_dma;
offset = (uint32_t)(buff->dmac.min_size ? buff->dmac.min_size :
(buff->entry_size * buff->entry_count)
+ sizeof(struct tofe_channel_buffer_header));
read_head += offset;
p_dma += offset;
}
return ret_val;
}
#if BCMTCH_STATE_PROTOCOL
static int32_t bcmtch_dev_parse_response_data(
struct bcmtch_data *bcmtch_data_ptr,
uint8_t *data,
uint16_t data_size)
{
int32_t ret_val = 0;
uint32_t slot_size =
(uint32_t)
bcmtch_data_ptr->scan_data.touch_slot_size;
uint32_t slot_num =
(uint32_t)
bcmtch_data_ptr->scan_data.status.slots;
/* Touch slot format - 0: long slot, 1: short slot */
uint8_t slot_format =
bcmtch_data_ptr->scan_data.cmd
.touch_slot_format;
struct input_dev *input_dev_ptr =
bcmtch_data_ptr->p_input_device;
uint32_t button_index = 0;
uint8_t *data_ptr = data;
uint8_t slot_type;
uint16_t tmp_axis;
uint16_t button_check;
uint16_t evt_status;
uint16_t btn_status;
uint32_t touch_index;
union bcmtch_state_resp_slot *slot;
struct bcmtch_touch *touch_ptr;
int32_t ao_flag =
bcmtch_data_ptr->platform_data.axis_orientation_flag;
for (touch_index = 0;
touch_index < slot_num;
data_ptr += slot_size,
touch_index++) {
slot = (union bcmtch_state_resp_slot *) data_ptr;
touch_ptr = &bcmtch_data_ptr->touch[touch_index];
/* Categorize slot type */
if (slot->type > 7) {
slot_type = STATE_SLOT_TYPE_FINGER;
touch_ptr->type = MT_TOOL_FINGER;
} else if (slot->type > 1) {
slot_type = STATE_SLOT_TYPE_STYLUS;
touch_ptr->type = MT_TOOL_PEN;
} else if (slot->type == 1)
slot_type = STATE_SLOT_TYPE_BUTTON;
else
slot_type = STATE_SLOT_TYPE_EMPTY;
/* Process slots */
switch (slot_type) {
case STATE_SLOT_TYPE_EMPTY:
touch_ptr->status = BCMTCH_TOUCH_STATUS_UP;
break;
case STATE_SLOT_TYPE_BUTTON:
btn_status = bcmtch_data_ptr->button_status;
evt_status = (uint16_t)(slot->button_slot.buttons);
if (btn_status != evt_status) {
BCMTCH_DBG(
BCMTCH_DF_ST,
"ST:BTN: 0x%0x\n",
evt_status);
while (button_index < bcmtch_data_ptr->
platform_data.ext_button_count) {
button_check = (0x1 << button_index);
if ((btn_status & button_check) !=
(evt_status & button_check)) {
input_report_key(
input_dev_ptr,
bcmtch_data_ptr->
platform_data.
ext_button_map
[button_index],
(evt_status &
button_check));
}
button_index++;
}
/* Update status */
bcmtch_data_ptr->button_status = evt_status;
}
break;
case STATE_SLOT_TYPE_STYLUS:
/* Not support yet */
case STATE_SLOT_TYPE_FINGER:
if (slot_format) {
/* short slot */
touch_ptr->x = slot->short_slot.x;
touch_ptr->y = slot->short_slot.y;
touch_ptr->pressure = 0;
touch_ptr->orientation = 0;
touch_ptr->major_axis = 0;
touch_ptr->minor_axis = 0;
} else {
/* long slot */
touch_ptr->x = slot->long_slot.x;
touch_ptr->y = slot->long_slot.y;
touch_ptr->pressure = slot->long_slot.pressure;
touch_ptr->orientation =
slot->long_slot.orientation;
touch_ptr->major_axis =
slot->long_slot.major
<< BCMTCH_AXIS_SHIFT_BITS;
touch_ptr->minor_axis =
slot->long_slot.minor
<< BCMTCH_AXIS_SHIFT_BITS;
}
/* axis reverse adjust */
if (ao_flag & BCMTCH_AXIS_FLAG_X_REVERSED_MASK)
touch_ptr->x =
bcmtch_data_ptr->axis_x_max
- touch_ptr->x;
if (ao_flag & BCMTCH_AXIS_FLAG_Y_REVERSED_MASK)
touch_ptr->y =
bcmtch_data_ptr->axis_y_max
- touch_ptr->y;
if (ao_flag & BCMTCH_AXIS_FLAG_X_Y_SWAPPED_MASK) {
tmp_axis = touch_ptr->x;
touch_ptr->x = touch_ptr->y;
touch_ptr->y = tmp_axis;
}
if (bcmtch_data_ptr->chip_id == 0x015200) {
touch_ptr->y =
bcmtch_data_ptr->axis_y_max
- touch_ptr->y;
}
touch_ptr->status = BCMTCH_TOUCH_STATUS_MOVING;
BCMTCH_DBG(
BCMTCH_DF_ST,
"ST: SLOT %d: X=%d Y=%d P=%d O=%d MAJX=%d MINX=%d T=%d\n",
touch_index,
touch_ptr->x,
touch_ptr->y,
touch_ptr->pressure,
touch_ptr->orientation,
touch_ptr->major_axis,
touch_ptr->minor_axis,
touch_ptr->type);
break;
default:
BCMTCH_ERR("ST: SLOT %d: Unknown",
touch_index);
}
}
/* Report touch event to kernel */
ret_val = bcmtch_dev_sync_event_frame(bcmtch_data_ptr);
return ret_val;
}
static int32_t bcmtch_dev_read_scan_touches(
struct bcmtch_data *bcmtch_data_ptr,
uint8_t slots)
{
int32_t ret_val = 0;
uint16_t data_size;
uint8_t *dma_buff = bcmtch_data_ptr->bcmtch_state_resp_buffer;
if (!slots)
return ret_val;
data_size = slots * bcmtch_data_ptr->scan_data.touch_slot_size;
if (data_size > TOFE_HOST_RSP_BUF_SIZE) {
BCMTCH_ERR(
"ST: data size to read exceed response buffer.");
BCMTCH_ERR(
"ST: slots=%d data_size=%d resp_buf_size=%d",
slots,
data_size,
TOFE_HOST_RSP_BUF_SIZE);
return -EINVAL;
}
memset(dma_buff, 0, data_size);
BCMTCH_DBG(
BCMTCH_DF_ST,
"ST: %s read %d touch slots size=%d",
__func__,
slots,
data_size);
ret_val =
bcmtch_com_read_dma(
bcmtch_data_ptr,
data_size + 1,
dma_buff);
if (ret_val) {
BCMTCH_ERR("%s: DMA read error.\n", __func__);
return ret_val;
}
/* parse touch data: Slot 0 ... Slot N-1 */
bcmtch_dev_parse_response_data(
bcmtch_data_ptr,
&dma_buff[1],
data_size);
return ret_val;
}
#endif /* BCMTCH_STATE_PROTOCOL */
static int32_t bcmtch_dev_read_channels(
struct bcmtch_data *bcmtch_data_ptr)
{
int32_t ret_val = 0;
uint32_t channel = 0;
uint8_t chan_set = bcmtch_data_ptr->channel_set;
while (channel < BCMTCH_CHANNEL_MAX) {
if (bcmtch_data_ptr->p_channels[chan_set][channel]->active &&
!(bcmtch_data_ptr->
p_channels[chan_set][channel]->cfg.flags &
(TOFE_CHANNEL_FLAG_INBOUND
| TOFE_CHANNEL_FLAG_FWDMA_ENABLE))) {
ret_val = bcmtch_dev_read_channel(
bcmtch_data_ptr,
bcmtch_data_ptr->p_channels[chan_set][channel]);
}
channel++;
}
return ret_val;
}
static int32_t bcmtch_dev_process_event_frame(
struct bcmtch_data *bcmtch_data_ptr,
struct bcmtch_event_frame *p_frame_event)
{
int32_t ret_val = 0;
BCMTCH_DBG(BCMTCH_DF_FR, "FR:T=%d ID=%d TS=%d\n",
bcmtch_data_ptr->touch_count,
p_frame_event->frame_id,
p_frame_event->timestamp);
return ret_val;
}
static int32_t bcmtch_dev_process_event_frame_extension(
struct bcmtch_event_frame_extension
*p_frame_event_extension)
{
int32_t ret_val = 0;
struct bcmtch_event_frame_extension_timestamp *timestamp;
struct bcmtch_event_frame_extension_checksum *checksum;
switch (p_frame_event_extension->frame_kind) {
case BCMTCH_EVENT_FRAME_EXTENSION_KIND_TIMESTAMP:
timestamp = (struct bcmtch_event_frame_extension_timestamp *)
p_frame_event_extension;
BCMTCH_DBG(
BCMTCH_DF_FE,
"FE:Time offsets. %d %d %d",
timestamp->scan_end,
timestamp->mtc_start,
timestamp->mtc_end);
break;
case BCMTCH_EVENT_FRAME_EXTENSION_KIND_CHECKSUM:
checksum =
(struct bcmtch_event_frame_extension_checksum *)
p_frame_event_extension;
BCMTCH_DBG(
BCMTCH_DF_FE,
"FE:ERROR: Checksum not supported. %#x",
checksum->hash);
break;
case BCMTCH_EVENT_FRAME_EXTENSION_KIND_HEARTBEAT:
BCMTCH_DBG(
BCMTCH_DF_FE,
"FE:ERROR: Heartbeat not supported.");
break;
default:
BCMTCH_DBG(
BCMTCH_DF_FE,
"FE:Invalid frame extension. %d",
p_frame_event_extension->frame_kind);
break;
}
return ret_val;
}
static int32_t bcmtch_dev_sync_event_frame(
struct bcmtch_data *bcmtch_data_ptr)
{
int32_t ret_val = 0;
struct input_dev *input_dev_ptr =
bcmtch_data_ptr->p_input_device;
struct bcmtch_touch *touch_ptr;
uint32_t num_touches = 0;
uint32_t touch_index = 0;
for (touch_index = 0; touch_index < ARRAY_SIZE(bcmtch_data_ptr->touch);
touch_index++) {
touch_ptr =
(struct bcmtch_touch *)
&bcmtch_data_ptr->touch[touch_index];
input_mt_slot(input_dev_ptr, touch_index);
input_mt_report_slot_state(
input_dev_ptr,
touch_ptr->type,
(touch_ptr->status > BCMTCH_TOUCH_STATUS_UP));
if (touch_ptr->status > BCMTCH_TOUCH_STATUS_UP) {
/* Count both of STATUS_MOVE and STATUS_MOVING */
num_touches++;
if (touch_ptr->status > BCMTCH_TOUCH_STATUS_MOVE) {
input_report_abs(
input_dev_ptr,
ABS_MT_POSITION_X,
touch_ptr->x);
input_report_abs(
input_dev_ptr,
ABS_MT_POSITION_Y,
touch_ptr->y);
if (bcmtch_event_flag &
BCMTCH_EVENT_FLAG_PRESSURE) {
input_report_abs(
input_dev_ptr,
ABS_MT_PRESSURE,
touch_ptr->pressure);
}
if (bcmtch_event_flag &
BCMTCH_EVENT_FLAG_TOUCH_SIZE) {
input_report_abs(
input_dev_ptr,
ABS_MT_TOUCH_MAJOR,
touch_ptr->major_axis);
input_report_abs(
input_dev_ptr,
ABS_MT_TOUCH_MINOR,
touch_ptr->minor_axis);
}
if (bcmtch_event_flag &
BCMTCH_EVENT_FLAG_ORIENTATION) {
input_report_abs(
input_dev_ptr,
ABS_MT_ORIENTATION,
touch_ptr->orientation);
}
if (bcmtch_event_flag &
BCMTCH_EVENT_FLAG_TOOL_SIZE) {
input_report_abs(
input_dev_ptr,
ABS_MT_WIDTH_MAJOR,
touch_ptr->width_major);
input_report_abs(
input_dev_ptr,
ABS_MT_WIDTH_MINOR,
touch_ptr->width_minor);
}
/* reset the status from MOVING to MOVE. */
touch_ptr->status = BCMTCH_TOUCH_STATUS_MOVE;
}
}
}
input_report_key(input_dev_ptr, BTN_TOUCH, (num_touches > 0));
input_sync(input_dev_ptr);
/* remember */
bcmtch_data_ptr->touch_count = num_touches;
return ret_val;
}
static void
bcmtch_dev_process_event_touch_extension(
struct bcmtch_data *bcmtch_data_ptr,
struct bcmtch_event_touch_extension *extension,
uint8_t track_id)
{
char *tool_str;
struct bcmtch_event_touch_extension_detail *detail;
struct bcmtch_event_touch_extension_blob *blob;
struct bcmtch_event_touch_extension_size *size;
struct bcmtch_event_touch_extension_tool *tool;
struct bcmtch_touch *touch_ptr =
(struct bcmtch_touch *)&bcmtch_data_ptr->touch[track_id];
switch (extension->touch_kind) {
case BCMTCH_EVENT_TOUCH_EXTENSION_KIND_DETAIL:
detail =
(struct bcmtch_event_touch_extension_detail *)
extension;
/* logic is inverted */
if (detail->tool == BCMTCH_EVENT_TOUCH_TOOL_FINGER) {
touch_ptr->type = MT_TOOL_PEN;
tool_str = "stylus";
} else {
touch_ptr->type = MT_TOOL_FINGER;
tool_str = "finger";
}
BCMTCH_DBG(
BCMTCH_DF_TE,
"TE:C%d:S%d:H%d %s(%d) Pres=%d Ornt=%#x",
detail->confident,
detail->suppressed,
detail->hover,
tool_str,
detail->tool,
detail->pressure,
detail->orientation);
/**
* ABS_MT_TOOL_TYPE
* - MT_TOOL_FINGER
* - MT_TOOL_PEN
**/
touch_ptr->pressure = detail->pressure;
/* get orientation
* - handle int12 to int16 conversion
*/
touch_ptr->orientation = detail->orientation;
if (touch_ptr->orientation & (1<<11))
touch_ptr->orientation -= 1<<12;
break;
case BCMTCH_EVENT_TOUCH_EXTENSION_KIND_BLOB:
blob =
(struct bcmtch_event_touch_extension_blob *)
extension;
BCMTCH_DBG(BCMTCH_DF_TE, "TE:Area=%d TCap=%d",
blob->area, blob->total_cap);
/**
* ABS_MT_BLOB_ID
*/
break;
case BCMTCH_EVENT_TOUCH_EXTENSION_KIND_SIZE:
size =
(struct bcmtch_event_touch_extension_size *)
extension;
BCMTCH_DBG(
BCMTCH_DF_TE,
"TE:Track %d:\tMajor=%d Minor=%d",
track_id,
size->major_axis,
size->minor_axis);
/**
* ABS_MT_MAJOR/MINOR_AXIS
*/
touch_ptr->major_axis =
size->major_axis << BCMTCH_AXIS_SHIFT_BITS;
touch_ptr->minor_axis =
size->minor_axis << BCMTCH_AXIS_SHIFT_BITS;
break;
case BCMTCH_EVENT_TOUCH_EXTENSION_KIND_HOVER:
BCMTCH_DBG(
BCMTCH_DF_TE,
"TE:ERROR:Hover not supported.");
break;
case BCMTCH_EVENT_TOUCH_EXTENSION_KIND_TOOL:
tool =
(struct bcmtch_event_touch_extension_tool *)
extension;
BCMTCH_DBG(
BCMTCH_DF_TE,
"TE:Track %d:\tMajor=%d Minor=%d",
track_id,
tool->width_major,
tool->width_minor);
/**
* ABS_MT_MAJOR/MINOR_AXIS
*/
touch_ptr->width_major = tool->width_major;
touch_ptr->width_minor = tool->width_minor;
break;
default:
BCMTCH_DBG(
BCMTCH_DF_TE,
"TE:Invalid touch extension. %d",
extension->touch_kind);
break;
}
}
static int32_t bcmtch_dev_process_event_touch(
struct bcmtch_data *bcmtch_data_ptr,
struct bcmtch_event_touch *p_touch_event)
{
int axis_orientation_flag;
int32_t ret_val = 0;
struct bcmtch_touch *p_touch;
enum bcmtch_event_kind kind;
if (p_touch_event->track_tag < BCMTCH_MAX_TOUCH) {
axis_orientation_flag =
bcmtch_data_ptr->platform_data.axis_orientation_flag;
p_touch =
(struct bcmtch_touch *)
&bcmtch_data_ptr->touch[p_touch_event->track_tag];
if (axis_orientation_flag & BCMTCH_AXIS_FLAG_X_REVERSED_MASK)
p_touch_event->x =
bcmtch_data_ptr->axis_x_max - p_touch_event->x;
if ((axis_orientation_flag & BCMTCH_AXIS_FLAG_Y_REVERSED_MASK)
||
(bcmtch_data_ptr->chip_id == 0x015200))
p_touch_event->y =
bcmtch_data_ptr->axis_y_max - p_touch_event->y;
if (axis_orientation_flag & BCMTCH_AXIS_FLAG_X_Y_SWAPPED_MASK) {
p_touch->y = p_touch_event->x;
p_touch->x = p_touch_event->y;
} else {
p_touch->x = p_touch_event->x;
p_touch->y = p_touch_event->y;
}
kind = (enum bcmtch_event_kind)p_touch_event->event_kind;
switch (kind) {
case BCMTCH_EVENT_KIND_TOUCH:
p_touch->event = kind;
p_touch->status = BCMTCH_TOUCH_STATUS_MOVING;
BCMTCH_DBG(
BCMTCH_DF_MV,
"MV:T%d: (%04x , %04x)\n",
p_touch_event->track_tag,
p_touch->x,
p_touch->y);
break;
case BCMTCH_EVENT_KIND_TOUCH_END:
p_touch->event = kind;
p_touch->status = BCMTCH_TOUCH_STATUS_UP;
BCMTCH_DBG(
BCMTCH_DF_UP,
"UP:T%d: (%04x , %04x)\n",
p_touch_event->track_tag,
p_touch->x,
p_touch->y);
break;
default:
BCMTCH_ERR("%s: Invalid touch event", __func__);
break;
}
}
return ret_val;
}
static int32_t bcmtch_dev_process_event_button(
struct bcmtch_data *bcmtch_data_ptr,
struct bcmtch_event_button *p_button_event)
{
int32_t ret_val = 0;
uint16_t evt_status = p_button_event->status;
uint16_t btn_status = bcmtch_data_ptr->button_status;
struct input_dev *input_dev_ptr =
bcmtch_data_ptr->p_input_device;
enum bcmtch_event_kind kind = p_button_event->button_kind;
uint32_t button_index = 0;
uint16_t button_check;
if (btn_status != evt_status) {
switch (kind) {
case BCMTCH_EVENT_BUTTON_KIND_CONTACT:
while (button_index < bcmtch_data_ptr->
platform_data.ext_button_count) {
button_check = (0x1 << button_index);
if ((btn_status & button_check) !=
(evt_status & button_check)) {
input_report_key(
input_dev_ptr,
bcmtch_data_ptr->platform_data.
ext_button_map[button_index],
(evt_status & button_check));
}
button_index++;
}
BCMTCH_DBG(BCMTCH_DF_BT, "BT:%s %#04x\n",
"press",
evt_status);
break;
case BCMTCH_EVENT_BUTTON_KIND_HOVER:
BCMTCH_DBG(BCMTCH_DF_BT, "BT:%s %#04x\n",
"hover",
evt_status);
break;
default:
BCMTCH_ERR("%s: Invalid button kind %d\n",
__func__,
kind);
break;
}
/* Report SYNC */
input_sync(input_dev_ptr);
/* Update status */
bcmtch_data_ptr->button_status = evt_status;
} else {
BCMTCH_DBG(
BCMTCH_DF_BT,
"BT:unchanged. status=0x%04x\n",
btn_status);
}
return ret_val;
}
/**
* To process whole frames of data this variable should
* be made global because one frame can be split across
* two invocations of the function process_channel_touch().
*/
static enum bcmtch_event_kind top_level_kind = BCMTCH_EVENT_KIND_EXTENSION;
static int32_t bcmtch_dev_process_channel_touch(
struct bcmtch_data *bcmtch_data_ptr,
struct bcmtch_channel *chan)
{
int32_t ret_val = 0;
bool syn_report_pending = false;
uint16_t read_idx;
struct bcmtch_event *ptch_event;
enum bcmtch_event_kind kind;
struct bcmtch_event_touch *ptouch_event = NULL;
struct tofe_channel_header *chan_hdr =
(struct tofe_channel_header *)&chan->hdr;
uint32_t frames_in = 0;
read_idx = 0;
while ((ptch_event = (struct bcmtch_event *)
bcmtch_inline_channel_read(chan_hdr,
read_idx++))) {
kind = (enum bcmtch_event_kind)ptch_event->event_kind;
if (kind != BCMTCH_EVENT_KIND_EXTENSION) {
top_level_kind = kind;
if (syn_report_pending) {
/**
* The end of frame extension events.
* Send the SYN_REPORT for the frame.
*/
bcmtch_dev_sync_event_frame(bcmtch_data_ptr);
syn_report_pending = false;
if (frames_in)
usleep_range(1000, 1500);
}
}
switch (kind) {
case BCMTCH_EVENT_KIND_FRAME:
/**
* Only set the flag to wait for the following frame extension events
* rather than directly send SYN_REPORT message.
*/
frames_in++;
syn_report_pending = true;
bcmtch_dev_process_event_frame(
bcmtch_data_ptr,
(struct bcmtch_event_frame *)
ptch_event);
break;
case BCMTCH_EVENT_KIND_TOUCH:
case BCMTCH_EVENT_KIND_TOUCH_END:
ptouch_event =
(struct bcmtch_event_touch *)ptch_event;
bcmtch_data_ptr->touch_event_track_id =
ptouch_event->track_tag;
bcmtch_dev_process_event_touch(
bcmtch_data_ptr,
ptouch_event);
break;
case BCMTCH_EVENT_KIND_BUTTON:
bcmtch_dev_process_event_button(
bcmtch_data_ptr,
(struct bcmtch_event_button *)ptch_event);
break;
case BCMTCH_EVENT_KIND_GESTURE:
BCMTCH_INFO("ERROR: Gesture: NOT SUPPORTED\n");
break;
case BCMTCH_EVENT_KIND_EXTENSION:
switch (top_level_kind) {
case BCMTCH_EVENT_KIND_FRAME:
bcmtch_dev_process_event_frame_extension(
(struct bcmtch_event_frame_extension *)
ptch_event);
break;
case BCMTCH_EVENT_KIND_TOUCH:
bcmtch_dev_process_event_touch_extension(
bcmtch_data_ptr,
(struct bcmtch_event_touch_extension *)
ptch_event,
bcmtch_data_ptr->touch_event_track_id);
break;
default:
BCMTCH_INFO(
"ERROR: Improper event extension for: tlk=%d k=%d\n",
top_level_kind, kind);
break;
}
break;
default:
BCMTCH_INFO("ERROR: Invalid event kind: %d\n", kind);
}
}
/**
* The last event in the channel is a frame (extension) event.
* Send the SYN_REPORT for the frame.
*/
if (syn_report_pending) {
bcmtch_dev_sync_event_frame(bcmtch_data_ptr);
syn_report_pending = false;
}
BCMTCH_DBG(BCMTCH_DF_FR, "FR:%d", frames_in);
return ret_val;
}
static int32_t bcmtch_dev_process_channel_response(
struct bcmtch_data *bcmtch_data_ptr,
struct bcmtch_channel *chan)
{
int32_t ret_val = 0;
uint16_t read_idx;
struct bcmtch_response_wait *p_resp;
struct tofe_command_response *resp_event;
struct tofe_channel_header *chan_hdr =
(struct tofe_channel_header *)&chan->hdr;
BCMTCH_DBG(
BCMTCH_DF_CH,
"CH:%s() - swap count=%d response evt count=%d.\n",
__func__,
chan_hdr->seq_count,
chan->queued);
read_idx = 0;
/* Process response events */
while ((resp_event =
(struct tofe_command_response *)
bcmtch_inline_channel_read(chan_hdr,
read_idx++))) {
if (resp_event->flags &
TOFE_COMMAND_FLAG_COMMAND_PROCESSED) {
if (resp_event->command > TOFE_COMMAND_LAST)
continue;
/* Save the response result */
p_resp = (struct bcmtch_response_wait *)
&(bcmtch_data_ptr->bcmtch_cmd_response
[resp_event->command]);
p_resp->wait = 0;
p_resp->resp_data = resp_event->data;
}
BCMTCH_DBG(
BCMTCH_DF_CH,
"CH:Response - command=0x%02x result=0x%04x data=0x%08x.\n",
resp_event->command,
resp_event->result,
resp_event->data);
}
return ret_val;
}
/**
Log routine for printing log message in TOFE
@param
[in] code 16-bit log code
[in] param_0 16-bit parameter
[in] param_1 32-bit parameter
[in] param_2 32-bit parameter
@retval
none
*/
static void bcmtch_log_str_print(uint16_t code, uint16_t param0,
uint32_t param1,
uint32_t param2,
uint32_t timestamp)
{
BCMTCH_INFO(
" code:0x%04x para0:0x%04x para1:0x%08x para2:0x%08x ts:0x%08x\n",
code,
param0,
param1,
param2,
timestamp);
}
static int32_t bcmtch_dev_process_channel_log(struct bcmtch_channel *chan)
{
int32_t ret_val = 0;
uint16_t read_idx;
struct tofe_log_msg *log_msg;
struct tofe_channel_header *chan_hdr =
(struct tofe_channel_header *)&chan->hdr;
read_idx = 0;
while ((log_msg =
(struct tofe_log_msg *)
bcmtch_inline_channel_read(chan_hdr,
read_idx++))) {
bcmtch_log_str_print(log_msg->log_code,
log_msg->param_0,
log_msg->params[0],
log_msg->params[1],
log_msg->timestamp);
}
return ret_val;
}
static int32_t bcmtch_dev_process_channels(
struct bcmtch_data *bcmtch_data_ptr)
{
int32_t ret_val = 0;
uint32_t channel = 0;
uint8_t chan_set = bcmtch_data_ptr->channel_set;
struct bcmtch_channel *p_chan = NULL;
while (channel < BCMTCH_CHANNEL_MAX) {
p_chan = bcmtch_data_ptr->p_channels[chan_set][channel];
if (!p_chan->active) {
channel++;
continue;
}
switch (channel) {
case BCMTCH_CHANNEL_TOUCH:
bcmtch_dev_process_channel_touch(
bcmtch_data_ptr,
p_chan);
break;
case BCMTCH_CHANNEL_COMMAND:
break;
case BCMTCH_CHANNEL_RESPONSE:
bcmtch_dev_process_channel_response(
bcmtch_data_ptr,
p_chan);
break;
case BCMTCH_CHANNEL_LOG:
bcmtch_dev_process_channel_log(p_chan);
break;
default:
break;
}
if (p_chan->cfg.flags & TOFE_CHANNEL_FLAG_FWDMA_ENABLE)
p_chan->hdr.buffer[0] = p_chan->hdr.buffer[1];
channel++;
}
return ret_val;
}
static int32_t bcmtch_dev_wait_for_firmware_ready(
struct bcmtch_data *bcmtch_data_ptr,
int32_t count)
{
int32_t ret_val = 0;
uint8_t ready;
do {
ret_val =
bcmtch_com_read_spm(
bcmtch_data_ptr,
BCMTCH_SPM_REG_MSG_TO_HOST, &ready);
} while ((!ret_val) && !(ready & TOFE_MESSAGE_FW_READY) && (count--));
if (count <= 0) {
BCMTCH_ERR(
"ERROR: Failed to communicate with Napa FW. Error: 0x%x\n",
ready);
ret_val = -1;
}
return ret_val;
}
static int32_t bcmtch_dev_run_firmware(
struct bcmtch_data *bcmtch_data_ptr)
{
int32_t ret_val = 0;
ret_val = bcmtch_dev_reset(bcmtch_data_ptr,
BCMTCH_RESET_MODE_SOFT_CLEAR);
/* set DLDO output */
if (!ret_val)
ret_val = bcmtch_com_write_spm(
bcmtch_data_ptr,
BCMTCH_SPM_REG_PMU_CONTROL2,
BCMTCH_PMU_CNTL2_DLDO_1_1V);
if (bcmtch_dev_wait_for_firmware_ready(
bcmtch_data_ptr,
BCMTCH_FW_READY_WAIT)) {
uint8_t xaddr = 0x40;
uint8_t xdata;
while (xaddr <= 0x61) {
bcmtch_com_read_spm(bcmtch_data_ptr,
xaddr, &xdata);
BCMTCH_ERR("%s: addr = 0x%02x data = 0x%02x\n",
__func__,
xaddr++,
xdata);
}
}
return ret_val;
}
static int32_t bcmtch_dev_parse_firmware(
struct bcmtch_data *bcmtch_data_ptr,
const struct firmware *p_fw)
{
int32_t ret_val = 0;
uint32_t entry_id = 1;
uint32_t *p_cfg = NULL;
uint8_t *mem_data = NULL;
struct tofe_signature *p_tofe_sig = NULL;
struct mtc_detect_cfg *p_mtc_cfg = NULL;
struct combi_entry *p_entry = (struct combi_entry *) p_fw->data;
while (p_entry[entry_id].length) {
if (p_entry[entry_id].flags & BCMTCH_FIRMWARE_FLAGS_ROM_BOOT)
bcmtch_data_ptr->boot_from_rom = true;
switch (p_entry[entry_id].flags & BCMTCH_FIRMWARE_FLAGS_MASK) {
case BCMTCH_FIRMWARE_FLAGS_POST_BOOT_CONFIGS:
mem_data = (uint8_t *)
((uint32_t)p_fw->data
+ p_entry[entry_id].offset);
p_cfg = (uint32_t *)(mem_data + TOFE_SIGNATURE_SIZE);
p_tofe_sig = (struct tofe_signature *)mem_data;
/* Parse F/W Signature */
bcmtch_data_ptr->fw_signature = *p_tofe_sig;
/* Parse MTC parameters */
p_mtc_cfg =
(struct mtc_detect_cfg *)
((uint32_t)mem_data
+ p_cfg[TOFE_TOC_INDEX_DETECT]
- BCMTCH_ADDR_TOC_BASE);
if (p_mtc_cfg) {
bcmtch_data_ptr->axis_x_max =
(p_mtc_cfg->scaling_x_range
> BCMTCH_AXIS_MAX) ?
BCMTCH_AXIS_MAX :
p_mtc_cfg->scaling_x_range - 1;
bcmtch_data_ptr->axis_y_max =
(p_mtc_cfg->scaling_y_range
> BCMTCH_AXIS_MAX) ?
BCMTCH_AXIS_MAX :
p_mtc_cfg->scaling_y_range - 1;
bcmtch_data_ptr->axis_h_max =
bcmtch_max_h_axis(
bcmtch_data_ptr->axis_x_max,
bcmtch_data_ptr->axis_y_max);
bcmtch_data_ptr->threshold_gate_finger =
p_mtc_cfg->class_finger_gate;
bcmtch_data_ptr->threshold_gate_stylus =
p_mtc_cfg->class_stylus_gate;
}
/* Check channel/state protocol mode */
if (!p_cfg[TOFE_TOC_INDEX_CHANNEL])
bcmtch_boot_flag |= BCMTCH_BF_STATE_PROTOCOL;
else
bcmtch_boot_flag &= ~BCMTCH_BF_STATE_PROTOCOL;
break;
case BCMTCH_FIRMWARE_FLAGS_POST_BOOT_CODE:
break;
case BCMTCH_FIRMWARE_FLAGS_CONFIGS:
mem_data = (uint8_t *)
((uint32_t)p_fw->data
+ p_entry[entry_id].offset);
p_cfg = (uint32_t *)(mem_data + TOFE_SIGNATURE_SIZE);
p_tofe_sig = (struct tofe_signature *)mem_data;
/* Parse F/W Signature */
bcmtch_data_ptr->fw_signature = *p_tofe_sig;
/* Parse MTC parameters */
p_mtc_cfg =
(struct mtc_detect_cfg *)
((uint32_t)mem_data
+ p_cfg[TOFE_TOC_INDEX_DETECT]
- p_entry[entry_id].addr);
if (p_mtc_cfg) {
bcmtch_data_ptr->axis_x_max =
(p_mtc_cfg->scaling_x_range
> BCMTCH_AXIS_MAX) ?
BCMTCH_AXIS_MAX :
p_mtc_cfg->scaling_x_range - 1;
bcmtch_data_ptr->axis_y_max =
(p_mtc_cfg->scaling_y_range
> BCMTCH_AXIS_MAX) ?
BCMTCH_AXIS_MAX :
p_mtc_cfg->scaling_y_range - 1;
bcmtch_data_ptr->axis_h_max =
bcmtch_max_h_axis(
bcmtch_data_ptr->axis_x_max,
bcmtch_data_ptr->axis_y_max);
bcmtch_data_ptr->threshold_gate_finger =
p_mtc_cfg->class_finger_gate;
bcmtch_data_ptr->threshold_gate_stylus =
p_mtc_cfg->class_stylus_gate;
}
/* Check channel/state protocol mode */
if (!p_cfg[TOFE_TOC_INDEX_CHANNEL])
bcmtch_boot_flag |= BCMTCH_BF_STATE_PROTOCOL;
else
bcmtch_boot_flag &= ~BCMTCH_BF_STATE_PROTOCOL;
break;
case BCMTCH_FIRMWARE_FLAGS_CODE:
break;
default:
BCMTCH_INFO("UNKNOWN BFF!!! : %d\n", entry_id);
break;
}
/* next */
entry_id++;
}
return ret_val;
}
static unsigned char bcmtchfw15200_bin[] = {
#include "bcmtchfw15200_bin.i"
};
static unsigned char bcmtchfw15300_bin[] = {
#include "bcmtchfw15300_bin.i"
};
struct firmware bcmtchfw15200_fw = {
.data = bcmtchfw15200_bin,
.size = sizeof(bcmtchfw15200_bin)
};
struct firmware bcmtchfw15300_fw = {
.data = bcmtchfw15300_bin,
.size = sizeof(bcmtchfw15300_bin)
};
static int32_t bcmtch_dev_download_firmware(
struct bcmtch_data *bcmtch_data_ptr,
uint8_t *fw_name,
uint32_t fw_addr,
uint32_t fw_flags)
{
struct firmware *p_fw;
int32_t ret_val = 0;
uint32_t entry_id = 1;
struct combi_entry *p_entry = NULL;
struct combi_entry default_entry[] = {
{.addr = fw_addr, .flags = fw_flags,},
{0, 0, 0, 0},
};
if (strncmp("bcmtchfw15200_bin", fw_name, 13) == 0) {
p_fw = &bcmtchfw15200_fw;
BCMTCH_INFO("choosiing fw bcmtchfw15200_bin fw_size = %d\n",
p_fw->size);
} else if (strncmp("bcmtchfw15300_bin", fw_name, 13) == 0) {
p_fw = &bcmtchfw15300_fw;
BCMTCH_INFO("choosiing fw bcmtchfw15300_bin fw_size = %d\n",
p_fw->size);
} else {
ret_val = -1;
BCMTCH_ERR("cannot find a matching firmware\n");
}
if (ret_val) {
BCMTCH_ERR("%s: Firmware request failed (%d) for %s\n",
__func__,
ret_val,
fw_name);
} else {
BCMTCH_DBG(
BCMTCH_DF_INFO,
"INFO: FIRMWARE: %s\n",
fw_name);
BCMTCH_DBG(
BCMTCH_DF_PB,
"PB:f/w size= 0x%x\n",
p_fw->size);
/* pre-process binary according to flags */
if (fw_flags & BCMTCH_FIRMWARE_FLAGS_COMBI) {
p_entry = (struct combi_entry *) p_fw->data;
} else {
p_entry = default_entry;
p_entry[entry_id].length = p_fw->size;
}
/* Parse firmware section flags and set mode */
bcmtch_dev_parse_firmware(
bcmtch_data_ptr,
p_fw);
/* init memory */
ret_val = bcmtch_dev_init_memory(bcmtch_data_ptr);
if (ret_val)
return ret_val;
while (p_entry[entry_id].length && !ret_val) {
switch (p_entry[entry_id].flags &
BCMTCH_FIRMWARE_FLAGS_MASK) {
case BCMTCH_FIRMWARE_FLAGS_POST_BOOT_CONFIGS:
BCMTCH_DBG(
BCMTCH_DF_PB,
"PB:entry_id=%d PB CONFIG\n",
entry_id);
BCMTCH_DBG(
BCMTCH_DF_PB,
"PB:pb chans init addr=0x%08x\n",
p_entry[entry_id].addr);
bcmtch_data_ptr->postboot_cfg_addr =
p_entry[entry_id].addr;
bcmtch_data_ptr->postboot_cfg_length =
p_entry[entry_id].length;
#if BCMTCH_STATE_PROTOCOL
if (!(bcmtch_boot_flag &
BCMTCH_BF_STATE_PROTOCOL))
#endif
ret_val =
bcmtch_dev_init_channels(
bcmtch_data_ptr,
BCMTCH_ADDR_TOC_BASE,
(uint8_t *)
((uint32_t)p_fw->data +
p_entry[entry_id].
offset),
BCMTCH_RAM_CHANNELS);
case BCMTCH_FIRMWARE_FLAGS_POST_BOOT_CODE:
if (!bcmtch_data_ptr->post_boot_sections)
bcmtch_data_ptr->post_boot_buffer =
(uint8_t *) p_fw->data;
bcmtch_data_ptr->post_boot_sections++;
if (p_entry[entry_id].flags &
BCMTCH_FIRMWARE_FLAGS_POST_BOOT_PATCH)
bcmtch_data_ptr->post_boot_patches++;
BCMTCH_DBG(
BCMTCH_DF_PB,
"PB:entry_id=%d PB pb_sec=%d\n",
entry_id,
bcmtch_data_ptr->
post_boot_sections);
break;
case BCMTCH_FIRMWARE_FLAGS_CONFIGS:
#if BCMTCH_STATE_PROTOCOL
if ((bcmtch_data_ptr->boot_from_rom) ||
!(bcmtch_boot_flag &
BCMTCH_BF_STATE_PROTOCOL)) {
/* Channel protocol */
bcmtch_data_ptr->work_process_index =
BCMTCH_WP_CHANNEL;
#endif /* BCMTCH_STATE_PROTOCOL */
/* Initialize channels */
BCMTCH_DBG(
BCMTCH_DF_PB,
"PB:entry_id=%d CONFIG\n",
entry_id);
BCMTCH_DBG(
BCMTCH_DF_PB,
"PB:%s chan init addr=0x%08x\n",
(bcmtch_data_ptr->channel_set) ?
"rom" : "ram",
p_entry[entry_id].addr);
ret_val =
bcmtch_dev_init_channels(
bcmtch_data_ptr,
p_entry[entry_id].addr,
(uint8_t *)
((uint32_t)p_fw->data
+ p_entry[entry_id].
offset),
(bcmtch_data_ptr->
channel_set) ?
BCMTCH_ROM_CHANNELS :
BCMTCH_RAM_CHANNELS);
#if BCMTCH_STATE_PROTOCOL
} else {
/* State protocol */
bcmtch_data_ptr->work_process_index =
BCMTCH_WP_STATE;
}
#endif
default:
BCMTCH_DBG(
BCMTCH_DF_PB,
"PB:entry_id=%d PREBOOT\n",
entry_id);
/** download to chip **/
ret_val = bcmtch_com_write_sys(
bcmtch_data_ptr,
p_entry[entry_id].addr,
p_entry[entry_id].length,
(uint8_t *)((uint32_t)p_fw->data +
p_entry[entry_id].offset));
}
/* next */
entry_id++;
}
}
if (bcmtch_boot_flag &
BCMTCH_BF_DISABLE_POST_BOOT)
bcmtch_data_ptr->post_boot_sections = 0;
if (bcmtch_data_ptr->post_boot_sections) {
/* setup first section for download */
if (!bcmtch_dev_post_boot_get_section(bcmtch_data_ptr))
bcmtch_data_ptr->post_boot_sections = 0;
}
BCMTCH_DBG(BCMTCH_DF_INFO, "INFO: FIRMWARE: loaded\n");
return ret_val;
}
static int32_t bcmtch_dev_find_firmware(
struct bcmtch_data *bcmtch_data_ptr)
{
int32_t ret_file = -ENOENT;
uint8_t file = 0;
bool found_chip_id = false;
uint32_t id = bcmtch_data_ptr->chip_id;
uint32_t rev = bcmtch_data_ptr->rev_id;
while (file < ARRAY_SIZE(BCMTCH_BINARIES)) {
/* find matching chip id */
if (BCMTCH_BINARIES[file].chip_id == id) {
found_chip_id = true;
/* if chip id found find matching chip rev */
if (BCMTCH_BINARIES[file].chip_rev == rev) {
ret_file = file;
break;
} else if (BCMTCH_BINARIES[file].chip_rev == BCMTCHWC) {
ret_file = file;
}
} else if (BCMTCH_BINARIES[file].chip_id == BCMTCHWC) {
if (!found_chip_id)
ret_file = file;
}
file++;
}
if (ret_file < 0)
BCMTCH_ERR(
" firmware not configured:chip=0x%8x rev=0x%x\n",
id,
rev);
return ret_file;
}
static int32_t bcmtch_dev_init_firmware(
struct bcmtch_data *bcmtch_data_ptr)
{
int32_t ret_val = 0;
uint8_t bin_file = 0;
if (bcmtch_firmware) {
ret_val =
bcmtch_dev_download_firmware(
bcmtch_data_ptr,
bcmtch_firmware,
bcmtch_firmware_addr,
bcmtch_firmware_flag);
} else {
bin_file = bcmtch_dev_find_firmware(bcmtch_data_ptr);
if (bin_file >= 0) {
ret_val =
bcmtch_dev_download_firmware(
bcmtch_data_ptr,
BCMTCH_BINARIES[bin_file].filename,
BCMTCH_BINARIES[bin_file].addr,
BCMTCH_BINARIES[bin_file].flags);
} else
ret_val = bin_file;
}
#if BCMTCH_STATE_PROTOCOL
/* init state protocol data structures. */
if ((bcmtch_boot_flag & BCMTCH_BF_STATE_PROTOCOL)
&& (!bcmtch_data_ptr->boot_from_rom))
bcmtch_dev_init_state(bcmtch_data_ptr);
#endif
if (!ret_val)
ret_val = bcmtch_dev_run_firmware(bcmtch_data_ptr);
#if BCMTCH_STATE_PROTOCOL
if (bcmtch_data_ptr->work_process_index >= BCMTCH_WP_STATE) {
if (!ret_val)
ret_val =
bcmtch_state_resume(
bcmtch_data_ptr);
if (!ret_val) {
ret_val =
bcmtch_state_start_scan(
bcmtch_data_ptr);
}
}
#endif /* BCMTCH_STATE_PROTOCOL */
return ret_val;
}
static int32_t bcmtch_dev_init_platform(struct device *p_device)
{
int32_t ret_val = 0;
struct bcmtch_data *local_bcmtch_data_p = NULL;
#ifdef CONFIG_OF
int32_t idx;
int32_t btn_count;
int32_t of_ret_val;
struct device_node *np;
enum of_gpio_flags gpio_flags;
#else
struct bcmtch_platform_data *p_platform_data = NULL;
#endif
if (p_device) {
local_bcmtch_data_p =
dev_get_drvdata(p_device);
#ifdef CONFIG_OF
np = p_device->of_node;
if (!np) {
BCMTCH_ERR(
" Device tree (DT) error! of_node is NULL.\n");
ret_val = -ENODEV;
return ret_val;
}
/*
* Obtain the address of the SYS/AHB on I2C bus.
*/
of_ret_val =
of_property_read_u32(np, "addr-sys",
&local_bcmtch_data_p
->platform_data.i2c_addr_sys);
if (of_ret_val) {
BCMTCH_ERR("DT property addr-sys not found!\n");
goto of_read_error;
}
BCMTCH_DBG(BCMTCH_DF_DT, "DT:addr-sys = 0x%x\n",
local_bcmtch_data_p->platform_data.i2c_addr_sys);
/*
* Obtain the GPIO reset pin.
*/
if (!of_find_property(np, "reset-gpios", NULL)) {
BCMTCH_ERR(
" DT property reset-gpios not found!\n");
ret_val = of_ret_val;
local_bcmtch_data_p->
platform_data.gpio_reset_pin = -1;
local_bcmtch_data_p->
platform_data.gpio_reset_polarity = -1;
} else {
local_bcmtch_data_p->
platform_data.gpio_reset_pin =
of_get_named_gpio_flags(
np,
"reset-gpios",
0,
&gpio_flags);
BCMTCH_DBG(
BCMTCH_DF_DT,
"DT:gpio-reset-pin = 0x%x\n",
local_bcmtch_data_p->platform_data
.gpio_reset_pin);
local_bcmtch_data_p->
platform_data.gpio_reset_polarity =
gpio_flags & OF_GPIO_ACTIVE_LOW;
BCMTCH_DBG(
BCMTCH_DF_DT,
"DT:gpio-reset-polarity = 0x%x\n",
local_bcmtch_data_p->platform_data
.gpio_reset_polarity);
/*
* Obtain the GPIO reset time in ms.
*/
of_ret_val = of_property_read_u32(np, "reset-time-ms",
&local_bcmtch_data_p
->platform_data
.gpio_reset_time_ms);
if (of_ret_val) {
/* set default value */
local_bcmtch_data_p->
platform_data.
gpio_reset_time_ms = 100;
}
BCMTCH_DBG(
BCMTCH_DF_DT,
"DT:gpio-reset-time = %u\n",
local_bcmtch_data_p->platform_data
.gpio_reset_time_ms);
}
/*
* Obtain the interrupt pin.
*/
local_bcmtch_data_p->platform_data.touch_irq =
irq_of_parse_and_map(np, 0);
if (local_bcmtch_data_p->platform_data.touch_irq) {
BCMTCH_DBG(BCMTCH_DF_DT, "DT: irq = 0x%x",
local_bcmtch_data_p->platform_data.touch_irq);
local_bcmtch_data_p->
platform_data.gpio_interrupt_pin = -1;
local_bcmtch_data_p->
platform_data.gpio_interrupt_trigger =
IRQF_TRIGGER_NONE;
} else {
BCMTCH_ERR(
"DT: interrupts (irq) request failed!\n");
of_ret_val = -ENOENT;
goto of_read_error;
}
/*
* Setup function pointers for axis coordinates.
*/
of_ret_val =
of_property_read_u32(np,
"axis-orientation-flag",
&local_bcmtch_data_p->platform_data
.axis_orientation_flag);
if (of_ret_val) {
pr_warn(" DT property axis-orientation-flag not found!\n");
local_bcmtch_data_p->platform_data
.axis_orientation_flag = 0;
}
BCMTCH_DBG(
BCMTCH_DF_DT,
"DT:axis-orientation-flag = 0x%02x\n",
local_bcmtch_data_p->platform_data
.axis_orientation_flag);
/*
* Obtain the key map.
*/
of_ret_val =
of_property_read_u32(np, "ext-button-count",
&btn_count);
if (of_ret_val) {
BCMTCH_INFO(
"DT property ext-button-count not found!\n");
btn_count = 0;
}
if (btn_count) {
BCMTCH_DBG(
BCMTCH_DF_DT,
"DT:ext-button-count = %d\n",
btn_count);
/* Allocate array */
local_bcmtch_data_p
->platform_data.ext_button_map =
(const int *)local_bcmtch_data_p
->bcmtch_button_map;
/* Read array data from device tree */
of_ret_val =
of_property_read_u32_array(
np, "ext-button-map",
(u32 *)local_bcmtch_data_p
->platform_data
.ext_button_map,
btn_count);
if (of_ret_val) {
BCMTCH_ERR(
" DT property ext-button-map read failed!\n");
local_bcmtch_data_p->platform_data
.ext_button_count = 0;
} else {
local_bcmtch_data_p->platform_data
.ext_button_count = btn_count;
BCMTCH_DBG(
BCMTCH_DF_DT,
"DT:ext-button-map =");
for (idx = 0; idx < btn_count; idx++)
BCMTCH_DBG(
BCMTCH_DF_DT,
"DT: %d",
local_bcmtch_data_p
->platform_data
.ext_button_map[idx]);
}
}
#else /* CONFIG_OF */
p_platform_data =
(struct bcmtch_platform_data *)p_device->platform_data;
local_bcmtch_data_p->platform_data.i2c_addr_sys =
p_platform_data->i2c_addr_sys;
local_bcmtch_data_p->platform_data.i2c_addr_spm =
p_platform_data->i2c_addr_spm;
local_bcmtch_data_p->platform_data.gpio_reset_pin =
p_platform_data->gpio_reset_pin;
local_bcmtch_data_p->platform_data.gpio_reset_polarity =
p_platform_data->gpio_reset_polarity;
local_bcmtch_data_p->platform_data.gpio_reset_time_ms =
p_platform_data->gpio_reset_time_ms;
local_bcmtch_data_p->platform_data.gpio_interrupt_pin =
p_platform_data->gpio_interrupt_pin;
local_bcmtch_data_p->platform_data.gpio_interrupt_trigger =
p_platform_data->gpio_interrupt_trigger;
local_bcmtch_data_p->platform_data.touch_irq = gpio_to_irq(
p_platform_data->gpio_interrupt_pin);
local_bcmtch_data_p->platform_data.ext_button_count =
p_platform_data->ext_button_count;
local_bcmtch_data_p->platform_data.ext_button_map =
p_platform_data->ext_button_map;
local_bcmtch_data_p->platform_data.axis_orientation_flag =
p_platform_data->axis_orientation_flag;
#endif /* CONFIG_OF */
/*
* FIXME - these values would come from DT or FW or insmod
*
* NAPA POR is 4ms == 4000us
* - Value should NOT be less than 5000us
*/
local_bcmtch_data_p->power_on_delay_us = 60000; /* >= 5000 */
} else {
BCMTCH_ERR("%s() error, platform data == NULL\n",
__func__);
ret_val = -ENODATA;
}
return ret_val;
#ifdef CONFIG_OF
of_read_error:
if (!ret_val)
ret_val = -ENODEV;
return ret_val;
#endif
}
static int32_t bcmtch_dev_request_power_mode(
struct bcmtch_data *bcmtch_data_ptr,
uint8_t mode, enum tofe_command command)
{
int32_t ret_val = 0;
uint8_t regs[5];
uint8_t data[5];
regs[0] = BCMTCH_SPM_REG_MSG_FROM_HOST;
data[0] = command;
regs[1] = BCMTCH_SPM_REG_RQST_FROM_HOST;
data[1] = 0;
switch (mode) {
case BCMTCH_POWER_MODE_SLEEP:
data[1] = BCMTCH_POWER_MODE_SLEEP;
break;
case BCMTCH_POWER_MODE_WAKE:
data[1] = BCMTCH_POWER_MODE_WAKE;
break;
case BCMTCH_POWER_MODE_NOWAKE:
data[1] = BCMTCH_POWER_MODE_NOWAKE;
break;
default:
PROGRESS();
break;
}
ret_val = bcmtch_com_fast_write_spm(bcmtch_data_ptr, 2, regs, data);
return ret_val;
}
static int32_t bcmtch_dev_get_power_state(
struct bcmtch_data *bcmtch_data_ptr)
{
int32_t ret_val = 0;
uint8_t power_state;
ret_val = bcmtch_com_read_spm(bcmtch_data_ptr,
BCMTCH_SPM_REG_PSR, &power_state);
return (ret_val) ? (ret_val) : ((uint32_t)power_state);
}
static int32_t bcmtch_dev_set_power_state(
struct bcmtch_data *bcmtch_data_ptr,
uint8_t power_state)
{
int32_t ret_val = 0;
switch (power_state) {
case BCMTCH_POWER_STATE_SLEEP:
ret_val =
bcmtch_dev_request_power_mode(
bcmtch_data_ptr,
BCMTCH_POWER_MODE_SLEEP,
TOFE_COMMAND_NO_COMMAND);
break;
case BCMTCH_POWER_STATE_RETENTION:
PROGRESS();
break;
case BCMTCH_POWER_STATE_IDLE:
PROGRESS();
break;
case BCMTCH_POWER_STATE_ACTIVE:
PROGRESS();
break;
default:
PROGRESS();
break;
}
return ret_val;
}
static int32_t bcmtch_dev_check_power_state(
struct bcmtch_data *bcmtch_data_ptr,
uint8_t power_state,
uint8_t wait_count)
{
int32_t ret_val = -EAGAIN;
int32_t read_state;
do {
read_state = bcmtch_dev_get_power_state(bcmtch_data_ptr);
if (read_state == power_state) {
ret_val = 0;
break;
}
} while (wait_count--);
return ret_val;
}
static enum bcmtch_status bcmtch_dev_request_host_override(
struct bcmtch_data *bcmtch_data_ptr,
enum tofe_command command)
{
enum bcmtch_status ret_val = BCMTCH_STATUS_ERR_FAIL;
int32_t count = 250;
uint8_t m2h;
/* Request channel & wakeup the firmware */
ret_val = bcmtch_dev_request_power_mode(
bcmtch_data_ptr,
BCMTCH_POWER_MODE_WAKE,
command);
if (!ret_val)
ret_val = bcmtch_dev_check_power_state(
bcmtch_data_ptr,
BCMTCH_POWER_STATE_ACTIVE,
25);
if (ret_val) {
BCMTCH_ERR("%s: [%d] wake firmware failed.\n",
__func__,
ret_val);
} else {
/* Wait till FW OVERRIDE is ready */
do {
ret_val = bcmtch_com_read_spm(
bcmtch_data_ptr,
BCMTCH_SPM_REG_MSG_TO_HOST,
&m2h);
switch (m2h) {
case TOFE_MESSAGE_FW_READY_OVERRIDE:
case TOFE_MESSAGE_FW_READY_INTERRUPT_OVERRIDE:
bcmtch_data_ptr->host_override = true;
BCMTCH_DBG(
BCMTCH_DF_HO,
"HO: Request m=0x%0x ho=%d",
m2h,
bcmtch_data_ptr->host_override);
break;
case TOFE_MESSAGE_FW_READY_INTERRUPT:
BCMTCH_DBG(
BCMTCH_DF_HO,
"HO: Request m=0x%0x ho=%d -> interrupt",
m2h,
bcmtch_data_ptr->host_override);
bcmtch_dev_process(bcmtch_data_ptr);
case TOFE_MESSAGE_FW_READY:
default:
BCMTCH_DBG(
BCMTCH_DF_HO,
"HO: Request m=0x%0x ho=%d",
m2h,
bcmtch_data_ptr->host_override);
break;
}
} while (!bcmtch_data_ptr->host_override && count--);
if (bcmtch_data_ptr->host_override)
ret_val = BCMTCH_STATUS_SUCCESS;
}
return ret_val;
}
static enum bcmtch_status bcmtch_dev_release_host_override(
struct bcmtch_data *bcmtch_data_ptr,
enum tofe_command command)
{
enum bcmtch_status ret_val = BCMTCH_STATUS_ERR_FAIL;
int32_t count = 250;
uint8_t m2h;
/* this should release hostOverride - do we need to check */
/* Release channel */
ret_val = bcmtch_dev_request_power_mode(
bcmtch_data_ptr,
BCMTCH_POWER_MODE_NOWAKE,
command);
/* Wait till FW is ready */
do {
ret_val = bcmtch_com_read_spm(bcmtch_data_ptr,
BCMTCH_SPM_REG_MSG_TO_HOST, &m2h);
switch (m2h) {
case TOFE_MESSAGE_FW_READY_INTERRUPT_OVERRIDE:
BCMTCH_DBG(
BCMTCH_DF_HO,
"HO: Release m=0x%0x ho=%d -> interrupt",
m2h,
bcmtch_data_ptr->host_override);
bcmtch_dev_process(bcmtch_data_ptr);
case TOFE_MESSAGE_FW_READY_OVERRIDE:
default:
BCMTCH_DBG(
BCMTCH_DF_HO,
"HO: Release m=0x%0x ho=%d",
m2h,
bcmtch_data_ptr->host_override);
break;
case TOFE_MESSAGE_FW_READY_INTERRUPT:
case TOFE_MESSAGE_FW_READY:
bcmtch_data_ptr->host_override = false;
BCMTCH_DBG(
BCMTCH_DF_HO,
"HO: Release m=0x%0x ho=%d",
m2h,
bcmtch_data_ptr->host_override);
break;
}
} while (bcmtch_data_ptr->host_override && count--);
if (!bcmtch_data_ptr->host_override)
ret_val = BCMTCH_STATUS_SUCCESS;
return ret_val;
}
static int32_t bcmtch_dev_send_command(
struct bcmtch_data *bcmtch_data_ptr,
enum tofe_command command,
uint32_t data,
uint16_t data16,
uint8_t flags)
{
int32_t ret_val = 0;
struct tofe_command_response cmd;
struct bcmtch_channel *chan;
uint8_t chan_set = bcmtch_data_ptr->channel_set;
if (command == TOFE_COMMAND_NO_COMMAND) {
BCMTCH_ERR("%s: no_command.\n",
__func__);
return -EINVAL;
}
chan =
bcmtch_data_ptr->p_channels[chan_set][TOFE_CHANNEL_ID_COMMAND];
if (chan == NULL) {
BCMTCH_ERR(
"%s: command channel has not initialized!\n",
__func__);
return -ENXIO;
}
if (bcmtch_dev_request_host_override(
bcmtch_data_ptr, command) ==
BCMTCH_STATUS_SUCCESS) {
/* Setup the command entry */
memset(
(void *)(&cmd),
0,
sizeof(struct tofe_command_response));
cmd.flags = flags;
cmd.command = command;
cmd.data = data;
cmd.result = data16;
/* Write sys to command channel */
tofe_channel_write_begin(&chan->hdr);
ret_val = tofe_channel_write(&chan->hdr, &cmd);
if (ret_val) {
BCMTCH_ERR("%s: [%d] cmd channel write failed.\n",
__func__,
ret_val);
goto send_command_exit;
}
ret_val = bcmtch_dev_write_channel(bcmtch_data_ptr,
chan);
if (ret_val) {
BCMTCH_ERR(
"%s: [%d] cmd channel write back FW failed.\n",
__func__,
ret_val);
goto send_command_exit;
}
}
bcmtch_dev_release_host_override(bcmtch_data_ptr,
command);
send_command_exit:
return ret_val;
}
static int32_t bcmtch_dev_reset(
struct bcmtch_data *bcmtch_data_ptr,
uint8_t mode)
{
int32_t ret_val = 0;
switch (mode) {
case BCMTCH_RESET_MODE_HARD:
bcmtch_reset(bcmtch_data_ptr);
break;
case BCMTCH_RESET_MODE_SOFT_CHIP:
bcmtch_com_write_spm(
bcmtch_data_ptr,
BCMTCH_SPM_REG_SOFT_RESETS,
BCMTCH_RESET_MODE_SOFT_CHIP);
break;
case BCMTCH_RESET_MODE_SOFT_ARM:
bcmtch_com_write_spm(
bcmtch_data_ptr,
BCMTCH_SPM_REG_SOFT_RESETS,
BCMTCH_RESET_MODE_SOFT_ARM);
break;
case (BCMTCH_RESET_MODE_SOFT_CHIP | BCMTCH_RESET_MODE_SOFT_ARM):
bcmtch_com_write_spm(
bcmtch_data_ptr,
BCMTCH_SPM_REG_SOFT_RESETS,
BCMTCH_RESET_MODE_SOFT_CHIP);
bcmtch_com_write_spm(
bcmtch_data_ptr,
BCMTCH_SPM_REG_SOFT_RESETS,
BCMTCH_RESET_MODE_SOFT_ARM);
break;
case BCMTCH_RESET_MODE_SOFT_CLEAR:
ret_val = bcmtch_com_write_spm(
bcmtch_data_ptr,
BCMTCH_SPM_REG_SOFT_RESETS,
BCMTCH_RESET_MODE_SOFT_CLEAR);
break;
default:
break;
}
return ret_val;
}
static int32_t bcmtch_dev_get_rev_id(
struct bcmtch_data *bcmtch_data_ptr)
{
int32_t ret_val = -ENXIO;
if (bcmtch_data_ptr) {
ret_val =
bcmtch_com_read_spm(bcmtch_data_ptr,
BCMTCH_SPM_REG_REVISIONID,
&bcmtch_data_ptr->rev_id);
}
return ret_val;
}
static int32_t bcmtch_dev_get_chip_id(
struct bcmtch_data *bcmtch_data_ptr)
{
int32_t ret_val = -ENXIO;
if (bcmtch_data_ptr) {
uint8_t id[3];
ret_val =
bcmtch_com_read_spm(bcmtch_data_ptr,
BCMTCH_SPM_REG_CHIPID0, &id[0]);
ret_val |=
bcmtch_com_read_spm(bcmtch_data_ptr,
BCMTCH_SPM_REG_CHIPID1, &id[1]);
ret_val |=
bcmtch_com_read_spm(bcmtch_data_ptr,
BCMTCH_SPM_REG_CHIPID2, &id[2]);
bcmtch_data_ptr->chip_id = ((((uint32_t)id[2]) << 16)
| (((uint32_t)id[1]) << 8)
| (uint32_t)id[0]);
}
return ret_val;
}
static int32_t bcmtch_dev_verify_chip_version(
struct bcmtch_data *bcmtch_data_ptr)
{
int32_t ret_val = 0;
uint32_t idx = 0;
uint32_t *chips_ptr = (uint32_t *)BCMTCH_CHIP_IDS;
/* Get Chip ID AFTER Power On due to OTP */
ret_val = bcmtch_dev_get_chip_id(bcmtch_data_ptr);
if (!ret_val)
ret_val = bcmtch_dev_get_rev_id(bcmtch_data_ptr);
if (!ret_val) {
ret_val = -ENXIO;
for (idx = 0;
idx < ARRAY_SIZE(BCMTCH_CHIP_IDS);
idx++) {
if (chips_ptr[idx] ==
bcmtch_data_ptr->chip_id) {
/* Found a match in above search */
ret_val = 0;
BCMTCH_DBG(
BCMTCH_DF_INFO,
"INFO: chip_id = 0x%06X rev = 0x%2X : %s\n",
bcmtch_data_ptr->chip_id,
bcmtch_data_ptr->rev_id,
"Verified");
}
}
}
if (ret_val)
BCMTCH_ERR(
" chip_id = 0x%06X rev = 0x%2X : %s : 0x%x\n",
bcmtch_data_ptr->chip_id,
bcmtch_data_ptr->rev_id,
"Error - Unknown device",
ret_val);
return ret_val;
}
static void bcmtch_dev_init_worker_process(
struct bcmtch_data *bcmtch_data_ptr)
{
/* Channel protocol process function. */
bcmtch_data_ptr->bcmtch_dev_process_table
[BCMTCH_WP_CHANNEL] = bcmtch_dev_process;
/* State protocol process function. */
#if BCMTCH_STATE_PROTOCOL
bcmtch_data_ptr->bcmtch_dev_process_table
[BCMTCH_WP_STATE] =
bcmtch_dev_process_state_touches;
#endif /* BCMTCH_STATE_PROTOCOL */
/* The process function during the post boot patch
* switch (boot from ROM to boot from RAM). */
bcmtch_data_ptr->bcmtch_dev_process_table
[BCMTCH_WP_PATCH_INIT] =
bcmtch_dev_process_pb_patch_init;
/* Set the default work process function. */
bcmtch_data_ptr->work_process_index =
BCMTCH_WP_CHANNEL;
}
#if BCMTCH_STATE_PROTOCOL
static void bcmtch_dev_init_state(
struct bcmtch_data *bcmtch_data_ptr)
{
if (bcmtch_boot_flag & BCMTCH_BF_STATE_PROTOCOL) {
bcmtch_data_ptr->scan_data.cmd.touch_slot_format =
(bcmtch_boot_flag & BCMTCH_BF_STATE_SHORT_SLOT) ?
1 : 0;
bcmtch_data_ptr->scan_data.cmd.sync_mode =
(bcmtch_boot_flag & BCMTCH_BF_STATE_SYNC_MODE) ?
0 : 1;
bcmtch_data_ptr->scan_data.cmd.max_slot_number =
BCMTCH_MAX_TOUCH;
bcmtch_data_ptr->scan_data.touch_slot_size =
(bcmtch_boot_flag & BCMTCH_BF_STATE_SHORT_SLOT) ?
TOFE_HOST_TOUCH_SLOT_SMALL_SIZE
: TOFE_HOST_TOUCH_SLOT_BIG_SIZE;
memset(&bcmtch_data_ptr->ram_rw_cfg, 0,
sizeof(struct bcmtch_state_cfg_rw));
bcmtch_data_ptr->work_process_index =
BCMTCH_WP_STATE;
BCMTCH_DBG(
BCMTCH_DF_ST,
"ST:%s() p0=0x%x slot_format %d sync_mode %d resp_buff_size %d max_slot_number %d\n",
__func__,
bcmtch_data_ptr->scan_data.cmd.reg,
bcmtch_data_ptr->scan_data.cmd.touch_slot_format,
bcmtch_data_ptr->scan_data.cmd.sync_mode,
TOFE_HOST_RSP_BUF_SIZE,
bcmtch_data_ptr->scan_data.cmd.max_slot_number);
} else {
bcmtch_data_ptr->work_process_index =
BCMTCH_WP_CHANNEL;
}
}
#endif /* BCMTCH_STATE_PROTOCOL */
static int32_t bcmtch_dev_init(
struct bcmtch_data *bcmtch_data_ptr)
{
int32_t ret_val = 0;
/* init com */
if (!ret_val)
ret_val = bcmtch_com_init(bcmtch_data_ptr);
/* wakeup */
if (!ret_val)
ret_val = bcmtch_dev_request_power_mode(
bcmtch_data_ptr,
BCMTCH_POWER_MODE_WAKE,
TOFE_COMMAND_NO_COMMAND);
if (!ret_val)
ret_val = bcmtch_dev_check_power_state(
bcmtch_data_ptr,
BCMTCH_POWER_STATE_ACTIVE,
25);
/* init clocks */
if (!ret_val)
ret_val = bcmtch_dev_init_clocks(bcmtch_data_ptr);
/* read chip version and id with power on */
if (!ret_val && (BCMTCH_BF_VERIFY_CHIP & bcmtch_boot_flag))
ret_val = bcmtch_dev_verify_chip_version(bcmtch_data_ptr);
/* download and run */
if (!ret_val)
ret_val = bcmtch_dev_init_firmware(bcmtch_data_ptr);
return ret_val;
}
static void bcmtch_dev_process(
struct bcmtch_data *bcmtch_data_ptr)
{
int32_t ret_val = 0;
uint8_t m2h;
if (bcmtch_boot_flag & BCMTCH_BF_CHECK_INTERRUPT) {
/* Check msg2host */
bcmtch_com_read_spm(bcmtch_data_ptr,
BCMTCH_SPM_REG_MSG_TO_HOST, &m2h);
if ((m2h & TOFE_MESSAGE_FW_READY_INTERRUPT) !=
TOFE_MESSAGE_FW_READY_INTERRUPT) {
BCMTCH_INFO("False interrupt\n");
return;
}
}
/* read DMA buffer */
if (bcmtch_data_ptr->has_dma_channel &&
!bcmtch_data_ptr->host_override) {
ret_val =
bcmtch_dev_read_dma_channels(bcmtch_data_ptr);
}
/* read channels */
ret_val = bcmtch_dev_read_channels(bcmtch_data_ptr);
/* release memory */
bcmtch_dev_request_power_mode(
bcmtch_data_ptr,
BCMTCH_POWER_MODE_NOWAKE,
TOFE_COMMAND_NO_COMMAND);
/* process channels */
ret_val = bcmtch_dev_process_channels(bcmtch_data_ptr);
}
static void bcmtch_dev_process_pb_patch_init(
struct bcmtch_data *bcmtch_data_ptr)
{
uint8_t m2h;
/* Check post boot init req TOFE_MESSAGE_SOC_REBOOT_PENDING */
if (bcmtch_data_ptr->post_boot_pending) {
bcmtch_com_read_spm(bcmtch_data_ptr,
BCMTCH_SPM_REG_MSG_TO_HOST, &m2h);
if (m2h == TOFE_MESSAGE_SOC_REBOOT_PENDING) {
/* Reset post boot pending */
bcmtch_data_ptr->post_boot_pending = 0;
/* Send command TOFE_COMMAND_REBOOT_APPROVED */
bcmtch_dev_request_power_mode(
bcmtch_data_ptr,
BCMTCH_POWER_MODE_NOWAKE,
TOFE_COMMAND_REBOOT_APPROVED);
BCMTCH_DBG(
BCMTCH_DF_PB,
"PB:sent REBOOT_APPROVED\n");
#if BCMTCH_STATE_PROTOCOL
if (bcmtch_boot_flag &
BCMTCH_BF_STATE_PROTOCOL) {
/* Switch to state protocol
work process function.*/
bcmtch_dev_init_state(bcmtch_data_ptr);
bcmtch_state_resume(bcmtch_data_ptr);
bcmtch_state_start_scan(
bcmtch_data_ptr);
} else {
#endif
/* Switch channel mode. */
bcmtch_data_ptr->work_process_index =
BCMTCH_WP_CHANNEL;
bcmtch_data_ptr->channel_set =
BCMTCH_RAM_CHANNELS;
bcmtch_dev_reset_events(bcmtch_data_ptr);
#if BCMTCH_STATE_PROTOCOL
}
#endif
return;
}
}
/* Process the ROM channel */
bcmtch_dev_process(bcmtch_data_ptr);
}
#if BCMTCH_STATE_PROTOCOL
static inline int32_t bcmtch_state_start_scan(
struct bcmtch_data *bcmtch_data_ptr)
{
int32_t ret_val = 0;
uint8_t parameters[TOFE_HOST_CMD_SHORT_SIZE];
parameters[0] = bcmtch_data_ptr->scan_data.cmd.reg;
ret_val = bcmtch_state_i2c_send_command(
bcmtch_data_ptr,
BCMTCH_CMD_START_SCAN,
parameters,
1);
BCMTCH_DBG(BCMTCH_DF_ST, "ST: SCAN START: (p0=0x%x) = %d\n",
bcmtch_data_ptr->scan_data.cmd.reg,
ret_val);
return ret_val;
}
static inline int32_t bcmtch_state_stop_scan(
struct bcmtch_data *bcmtch_data_ptr)
{
int32_t ret_val = 0;
ret_val = bcmtch_state_i2c_send_command(
bcmtch_data_ptr,
BCMTCH_CMD_STOP_SCAN,
NULL,
0);
BCMTCH_DBG(BCMTCH_DF_ST, "ST: SCAN STOP: = %d\n", ret_val);
return ret_val;
}
static inline int32_t bcmtch_state_suspend(
struct bcmtch_data *bcmtch_data_ptr)
{
int32_t ret_val = 0;
ret_val = bcmtch_state_stop_scan(bcmtch_data_ptr);
if (ret_val)
return ret_val;
ret_val = bcmtch_state_i2c_send_command(
bcmtch_data_ptr,
BCMTCH_CMD_SUSPEND,
NULL,
0);
if (!ret_val) {
/* check command status */
ret_val = bcmtch_state_check_command_status(
bcmtch_data_ptr,
100);
BCMTCH_DBG(BCMTCH_DF_ST, "ST: CMD SUSPEND - 0x%x\n",
bcmtch_data_ptr->bcmtch_state_resp_buffer[0]);
}
return ret_val;
}
static inline int32_t bcmtch_state_sleep(
struct bcmtch_data *bcmtch_data_ptr)
{
int32_t ret_val = 0;
ret_val = bcmtch_state_stop_scan(bcmtch_data_ptr);
if (ret_val)
return ret_val;
ret_val = bcmtch_state_i2c_send_command(
bcmtch_data_ptr,
BCMTCH_CMD_SLEEP,
NULL,
0);
if (!ret_val) {
/* check command status */
ret_val = bcmtch_state_check_command_status(
bcmtch_data_ptr,
100);
BCMTCH_DBG(BCMTCH_DF_ST, "ST: CMD SLEEP - 0x%x\n",
bcmtch_data_ptr->bcmtch_state_resp_buffer[0]);
}
return ret_val;
}
static inline int32_t bcmtch_state_resume(
struct bcmtch_data *bcmtch_data_ptr)
{
int32_t ret_val = 0;
ret_val = bcmtch_state_stop_scan(bcmtch_data_ptr);
if (ret_val)
return ret_val;
ret_val = bcmtch_state_i2c_send_command(
bcmtch_data_ptr,
BCMTCH_CMD_RESUME,
NULL,
0);
if (!ret_val) {
/* check command status */
ret_val = bcmtch_state_check_command_status(
bcmtch_data_ptr,
100);
BCMTCH_DBG(BCMTCH_DF_ST, "ST: CMD RESUME - 0x%x\n",
bcmtch_data_ptr->bcmtch_state_resp_buffer[0]);
}
return ret_val;
}
static int32_t bcmtch_state_rw_cfg_init(
struct bcmtch_data *bcmtch_data_ptr)
{
int32_t ret_val = 0;
uint8_t *parameters =
bcmtch_data_ptr->bcmtch_state_resp_buffer;
uint8_t *dma_buff =
bcmtch_data_ptr->bcmtch_state_resp_buffer;
struct bcmtch_state_rw_params *header =
(struct bcmtch_state_rw_params *)
bcmtch_data_ptr->bcmtch_state_resp_buffer;
/* The Write RAM command returns configuration when
* the data size is set to zero.
*/
header->len = 0;
ret_val = bcmtch_state_i2c_send_command(
bcmtch_data_ptr,
BCMTCH_CMD_WRITE_RAM,
parameters,
sizeof(struct bcmtch_state_rw_params));
if (ret_val) {
BCMTCH_ERR("ST: %s send cmd error! (%d)\n",
__func__,
ret_val);
return ret_val;
}
/* check command status */
ret_val = bcmtch_state_check_command_status(
bcmtch_data_ptr,
5);
if (!ret_val)
ret_val = bcmtch_com_read_dma(
bcmtch_data_ptr,
sizeof(struct bcmtch_state_cfg_rw) + 1,
dma_buff);
if (!ret_val)
memcpy(&bcmtch_data_ptr->ram_rw_cfg,
&dma_buff[1],
sizeof(struct bcmtch_state_cfg_rw));
BCMTCH_INFO("ST: RAM RW cfg init: max_r=%d max_w=%d\n",
bcmtch_data_ptr->ram_rw_cfg.max_read_size,
bcmtch_data_ptr->ram_rw_cfg.max_write_size);
/* Resume the touch scan */
bcmtch_state_start_scan(bcmtch_data_ptr);
return ret_val;
}
static int32_t bcmtch_state_read_ram(
struct bcmtch_data *bcmtch_data_ptr,
uint32_t addr,
uint16_t len,
uint8_t *out)
{
int32_t ret_val = 0;
uint8_t *parameters =
bcmtch_data_ptr->bcmtch_state_resp_buffer;
uint8_t *dma_buff =
bcmtch_data_ptr->bcmtch_state_resp_buffer;
struct bcmtch_state_rw_params *header =
(struct bcmtch_state_rw_params *)
bcmtch_data_ptr->bcmtch_state_resp_buffer;
/* Check the initialization of the read/write config. */
if (bcmtch_data_ptr->ram_rw_cfg.cfg_size == 0) {
ret_val =
bcmtch_state_rw_cfg_init(bcmtch_data_ptr);
if (ret_val)
return ret_val;
}
if (len > bcmtch_data_ptr->ram_rw_cfg.max_read_size)
return -EINVAL;
ret_val = bcmtch_state_stop_scan(bcmtch_data_ptr);
if (ret_val)
return ret_val;
header->addr = addr;
header->len = len;
ret_val = bcmtch_state_i2c_send_command(
bcmtch_data_ptr,
BCMTCH_CMD_READ_RAM,
parameters,
sizeof(struct bcmtch_state_rw_params));
if (ret_val) {
BCMTCH_ERR("ST: %s send cmd error! (%d)\n",
__func__,
ret_val);
return ret_val;
}
/* check command status */
ret_val = bcmtch_state_check_command_status(
bcmtch_data_ptr,
5);
BCMTCH_DBG(
BCMTCH_DF_ST,
"ST: CMD R RAM - (%d) addr=0x%08x size=%d\n",
bcmtch_data_ptr->bcmtch_state_resp_buffer[0],
addr,
len);
/* read response data */
if (!ret_val)
ret_val = bcmtch_com_read_dma(
bcmtch_data_ptr,
len + 1,
dma_buff);
/* copy the RAM content */
memcpy(out, &dma_buff[1], len);
/* Resume the touch scan */
bcmtch_state_start_scan(bcmtch_data_ptr);
return ret_val;
}
static int32_t bcmtch_state_write_ram(
struct bcmtch_data *bcmtch_data_ptr,
uint32_t addr,
uint16_t len,
uint8_t *data)
{
int32_t ret_val = 0;
uint8_t *parameters =
bcmtch_data_ptr->bcmtch_state_resp_buffer;
struct bcmtch_state_rw_params *header =
(struct bcmtch_state_rw_params *)
bcmtch_data_ptr->bcmtch_state_resp_buffer;
uint16_t data_size = len
+ sizeof(struct bcmtch_state_rw_params);
/* Check the initialization of the read/write config. */
if (bcmtch_data_ptr->ram_rw_cfg.cfg_size == 0) {
ret_val =
bcmtch_state_rw_cfg_init(bcmtch_data_ptr);
if (ret_val)
return ret_val;
}
if (data_size > bcmtch_data_ptr->ram_rw_cfg.max_write_size)
return -EINVAL;
header->addr = addr;
header->len = len;
memcpy(parameters + sizeof(struct bcmtch_state_rw_params),
data, len);
ret_val = bcmtch_state_stop_scan(bcmtch_data_ptr);
if (ret_val)
return ret_val;
ret_val = bcmtch_state_i2c_send_command(
bcmtch_data_ptr,
BCMTCH_CMD_WRITE_RAM,
parameters,
data_size);
if (ret_val) {
BCMTCH_ERR("ST: %s send cmd error! (%d)\n",
__func__,
ret_val);
return ret_val;
}
/* check command status */
ret_val = bcmtch_state_check_command_status(
bcmtch_data_ptr,
5);
BCMTCH_DBG(
BCMTCH_DF_ST,
"ST: CMD W RAM - (%d) addr=0x%08x size=%d\n",
bcmtch_data_ptr->bcmtch_state_resp_buffer[0],
addr,
len);
/* Resume the touch scan */
bcmtch_state_start_scan(bcmtch_data_ptr);
return ret_val;
}
#if BCMTCH_STATE_PROTOCOL
static void bcmtch_state_check_fw_exception(
struct bcmtch_data *bcmtch_data_ptr,
uint8_t fw_exception)
{
char *msg[] = {
"Reset", "Reset", "NMI", "HardFault",
"MemManage", "BusFault", "UsageFault",
};
uint32_t read_size =
ARRAY_SIZE(bcmtch_data_ptr->exception_buffer)
* sizeof(uint32_t);
uint32_t *ex_buf = bcmtch_data_ptr->exception_buffer;
if (fw_exception < ARRAY_SIZE(msg))
BCMTCH_ERR("FWE:Critical error %d [%s]\n",
fw_exception, msg[fw_exception]);
else
BCMTCH_ERR("FWE:Critical error %d\n", fw_exception);
if (bcmtch_data_ptr->work_process_index >= BCMTCH_WP_STATE) {
memset(ex_buf, 0, read_size);
bcmtch_com_read_dma(
bcmtch_data_ptr, read_size, (uint8_t *)ex_buf);
if (ex_buf[15] == 0xDEADBEEF || ex_buf[15] == 0xDEADBEEB) {
BCMTCH_ERR(
"FWE:R0 = 0x%08X\n",
ex_buf[0]);
BCMTCH_ERR(
"FWE:R1 = 0x%08X\n",
ex_buf[1]);
BCMTCH_ERR(
"FWE:R2 = 0x%08X\n",
ex_buf[2]);
BCMTCH_ERR(
"FWE:R3 = 0x%08X\n",
ex_buf[3]);
BCMTCH_ERR(
"FWE:R12 = 0x%08X\n",
ex_buf[4]);
BCMTCH_ERR(
"FWE:LR = 0x%08X\n",
ex_buf[5]);
BCMTCH_ERR(
"FWE:PC = 0x%08X\n",
ex_buf[6]);
BCMTCH_ERR(
"FWE:PSR = 0x%08X\n",
ex_buf[7]);
BCMTCH_ERR(
"FWE:SP = 0x%08X\n",
ex_buf[8]);
BCMTCH_ERR(
"FWE:SCB_CCR = 0x%08X\n",
ex_buf[9]);
BCMTCH_ERR(
"FWE:SCB_SHCSR = 0x%08X\n",
ex_buf[10]);
BCMTCH_ERR(
"FWE:SCB_CFS = 0x%08X\n",
ex_buf[11]);
BCMTCH_ERR(
"FWE:SCB_HFSR = 0x%08X\n",
ex_buf[12]);
BCMTCH_ERR(
"FWE:SCB_MMFAR = 0x%08X\n",
ex_buf[13]);
BCMTCH_ERR(
"FWE:SCB_BFAR = 0x%08X\n",
ex_buf[14]);
if (ex_buf[15] == 0xDEADBEEB) {
BCMTCH_ERR(
"FWE:Stack[0] = 0x%08X\n",
ex_buf[16]);
BCMTCH_ERR(
"FWE:Stack[1] = 0x%08X\n",
ex_buf[17]);
BCMTCH_ERR(
"FWE:Stack[2] = 0x%08X\n",
ex_buf[18]);
BCMTCH_ERR(
"FWE:Stack[3] = 0x%08X\n",
ex_buf[19]);
BCMTCH_ERR(
"FWE:Stack[4] = 0x%08X\n",
ex_buf[20]);
BCMTCH_ERR(
"FWE:Stack[5] = 0x%08X\n",
ex_buf[21]);
BCMTCH_ERR(
"FWE:Stack[6] = 0x%08X\n",
ex_buf[22]);
BCMTCH_ERR(
"FWE:Stack[7] = 0x%08X\n",
ex_buf[23]);
}
}
}
}
#endif
static int32_t bcmtch_state_check_command_status(
struct bcmtch_data *bcmtch_data_ptr,
uint8_t timeout_ms)
{
uint8_t timeout = timeout_ms;
uint8_t m2h;
int32_t ret_val = 0;
do {
ret_val =
bcmtch_com_read_spm(
bcmtch_data_ptr,
BCMTCH_SPM_REG_MSG_TO_HOST,
&m2h);
if (ret_val)
return ret_val;
if ((m2h > 0x1) && (m2h < TOFE_MESSAGE_SUCCESS)) {
ret_val = m2h;
#if BCMTCH_STATE_PROTOCOL
bcmtch_state_check_fw_exception(
bcmtch_data_ptr,
m2h);
#else
BCMTCH_ERR("exception = 0x%x\n", m2h);
#endif
break;
} else if (m2h > TOFE_MESSAGE_COMMAND_ECHO) {
break;
}
usleep_range(800, 1200);
} while (timeout--
&& !(m2h & TOFE_MESSAGE_FW_READY));
bcmtch_data_ptr->bcmtch_state_resp_buffer[0] =
m2h & ~TOFE_MESSAGE_FW_READY;
return ret_val;
}
static void bcmtch_dev_process_state_touches(
struct bcmtch_data *bcmtch_data_ptr)
{
int32_t ret_val = 0;
int slots;
/* Check command status */
ret_val = bcmtch_state_check_command_status(
bcmtch_data_ptr,
20);
if (ret_val)
return;
/* Read command response status */
bcmtch_data_ptr->scan_data.status.reg =
bcmtch_data_ptr->bcmtch_state_resp_buffer[0];
slots = bcmtch_data_ptr->scan_data.status.slots;
/* FIXME: Need to take the log slot case into account. */
/* Read variable-size response (long) */
ret_val = bcmtch_dev_read_scan_touches(
bcmtch_data_ptr,
slots);
/* Next touch scan */
bcmtch_state_start_scan(bcmtch_data_ptr);
}
#endif /* BCMTCH_STATE_PROTOCOL */
static void bcmtch_dev_reset_events(
struct bcmtch_data *bcmtch_data_ptr)
{
uint32_t touch = 0;
/* clear active touch structure */
memset(
&bcmtch_data_ptr->touch[0],
0,
sizeof(struct bcmtch_touch) * BCMTCH_MAX_TOUCH);
/* clear system touches */
if (bcmtch_data_ptr->touch_count) {
for (touch = 0; touch < BCMTCH_MAX_TOUCH; touch++) {
input_mt_slot(
bcmtch_data_ptr->p_input_device,
touch);
input_mt_report_slot_state(
bcmtch_data_ptr->p_input_device,
MT_TOOL_FINGER,
false);
}
input_report_key(
bcmtch_data_ptr->p_input_device,
BTN_TOUCH,
false);
input_sync(bcmtch_data_ptr->p_input_device);
}
bcmtch_data_ptr->touch_count = 0;
}
static void bcmtch_dev_post_boot_reset(
struct bcmtch_data *bcmtch_data_ptr)
{
bcmtch_data_ptr->post_boot_section = 0;
bcmtch_data_ptr->post_boot_sections = 0;
bcmtch_data_ptr->post_boot_patches = 0;
bcmtch_data_ptr->post_boot_pending = 0;
bcmtch_data_ptr->postboot_cfg_addr = 0;
bcmtch_data_ptr->postboot_cfg_length = 0;
/* free communication channels */
bcmtch_dev_free_channels(bcmtch_data_ptr);
bcmtch_data_ptr->post_boot_buffer = NULL;
}
static int32_t bcmtch_dev_suspend(
struct bcmtch_data *bcmtch_data_ptr)
{
int32_t ret_val = 0;
/* disable interrupts */
bcmtch_interrupt_disable(bcmtch_data_ptr);
/* free watchdog timer */
bcmtch_dev_watchdog_stop(bcmtch_data_ptr);
/* clear worker */
bcmtch_clear_deferred_worker(bcmtch_data_ptr);
/* lock */
mutex_lock(&bcmtch_data_ptr->mutex_work);
if (bcmtch_boot_flag & BCMTCH_BF_SUSPEND_COLD_BOOT) {
/* post boot reset */
bcmtch_dev_post_boot_reset(bcmtch_data_ptr);
#if BCMTCH_STATE_PROTOCOL
if (bcmtch_data_ptr->work_process_index >= BCMTCH_WP_STATE)
ret_val = bcmtch_state_sleep(bcmtch_data_ptr);
else
#endif /* BCMTCH_STATE_PROTOCOL */
ret_val = bcmtch_dev_set_power_state(
bcmtch_data_ptr,
BCMTCH_POWER_STATE_SLEEP);
bcmtch_dev_power_enable(bcmtch_data_ptr, false);
} else {
#if BCMTCH_STATE_PROTOCOL
if (bcmtch_data_ptr->work_process_index >= BCMTCH_WP_STATE)
ret_val = bcmtch_state_suspend(bcmtch_data_ptr);
else
#endif /* BCMTCH_STATE_PROTOCOL */
/* suspend */
ret_val = bcmtch_dev_request_power_mode(
bcmtch_data_ptr,
BCMTCH_POWER_MODE_NOWAKE,
TOFE_COMMAND_POWER_MODE_SUSPEND);
}
/* clear events */
bcmtch_dev_reset_events(bcmtch_data_ptr);
/* unlock */
mutex_unlock(&bcmtch_data_ptr->mutex_work);
/* update ABI status */
mutex_lock(&bcmtch_data_ptr->mutex_abi);
bcmtch_data_ptr->abi_suspend = true;
mutex_unlock(&bcmtch_data_ptr->mutex_abi);
BCMTCH_DBG(BCMTCH_DF_PM, "PM:%s() - 0x%x\n",
__func__,
ret_val);
return ret_val;
}
static int32_t bcmtch_dev_resume(
struct bcmtch_data *bcmtch_data_ptr)
{
int32_t ret_val = 0;
/* lock */
mutex_lock(&bcmtch_data_ptr->mutex_work);
if (bcmtch_boot_flag & BCMTCH_BF_SUSPEND_COLD_BOOT) {
ret_val = bcmtch_dev_power_enable(
bcmtch_data_ptr,
true);
if (!ret_val)
ret_val = bcmtch_dev_init(bcmtch_data_ptr);
} else {
#if BCMTCH_STATE_PROTOCOL
if (bcmtch_data_ptr->work_process_index >= BCMTCH_WP_STATE)
ret_val = bcmtch_state_resume(
bcmtch_data_ptr);
else {
#endif
ret_val = bcmtch_dev_request_power_mode(
bcmtch_data_ptr,
BCMTCH_POWER_MODE_WAKE,
TOFE_COMMAND_NO_COMMAND);
if (!ret_val)
ret_val =
bcmtch_dev_check_power_state(
bcmtch_data_ptr,
BCMTCH_POWER_STATE_ACTIVE,
25);
if (!ret_val)
ret_val =
bcmtch_dev_wait_for_firmware_ready(
bcmtch_data_ptr,
BCMTCH_FW_READY_WAIT);
#if BCMTCH_STATE_PROTOCOL
}
#endif
}
if (!ret_val)
bcmtch_dev_watchdog_start(bcmtch_data_ptr);
if (!ret_val)
ret_val = bcmtch_interrupt_enable(bcmtch_data_ptr);
#if BCMTCH_STATE_PROTOCOL
if (!ret_val &&
(bcmtch_data_ptr->work_process_index >= BCMTCH_WP_STATE)) {
bcmtch_state_start_scan(bcmtch_data_ptr);
}
#endif /* BCMTCH_STATE_PROTOCOL */
if (ret_val)
BCMTCH_ERR("BCMTOUCH: %s() error rv=%d bf=0x%x\n",
__func__,
ret_val,
bcmtch_boot_flag);
/* unlock */
mutex_unlock(&bcmtch_data_ptr->mutex_work);
/* update ABI status */
mutex_lock(&bcmtch_data_ptr->mutex_abi);
bcmtch_data_ptr->abi_suspend = false;
mutex_unlock(&bcmtch_data_ptr->mutex_abi);
BCMTCH_DBG(BCMTCH_DF_PM, "PM: %s() - 0x%x\n",
__func__,
ret_val);
return ret_val;
}
void bcmtch_dev_watchdog_work(unsigned long int data)
{
struct bcmtch_data *bcmtch_data_ptr =
(struct bcmtch_data *)data;
BCMTCH_DBG(BCMTCH_DF_WD, "WD:\n");
/* queue the interrupt handler */
queue_work(
bcmtch_data_ptr->p_workqueue,
(struct work_struct *)&bcmtch_data_ptr->work);
bcmtch_dev_watchdog_reset(bcmtch_data_ptr);
}
static void bcmtch_dev_watchdog_start(
struct bcmtch_data *bcmtch_data_ptr)
{
if (timer_pending(&bcmtch_data_ptr->watchdog))
del_timer_sync(&bcmtch_data_ptr->watchdog);
init_timer(&bcmtch_data_ptr->watchdog);
bcmtch_data_ptr->watchdog_expires =
(bcmtch_data_ptr->post_boot_sections) ?
msecs_to_jiffies(bcmtch_watchdog_post_boot) :
msecs_to_jiffies(bcmtch_watchdog_normal);
bcmtch_data_ptr->watchdog.function = bcmtch_dev_watchdog_work;
bcmtch_data_ptr->watchdog.data = (unsigned long)bcmtch_data_ptr;
bcmtch_data_ptr->watchdog.expires =
jiffies + bcmtch_data_ptr->watchdog_expires;
add_timer(&bcmtch_data_ptr->watchdog);
}
static int32_t bcmtch_dev_watchdog_restart(
struct bcmtch_data *bcmtch_data_ptr,
uint32_t expires)
{
int32_t ret_val = 0;
bcmtch_data_ptr->watchdog_expires = expires;
ret_val = mod_timer(
&bcmtch_data_ptr->watchdog,
(jiffies + bcmtch_data_ptr->watchdog_expires));
return ret_val;
}
static int32_t bcmtch_dev_watchdog_reset(
struct bcmtch_data *bcmtch_data_ptr)
{
int32_t ret_val = 0;
ret_val = mod_timer(
&bcmtch_data_ptr->watchdog,
(jiffies + bcmtch_data_ptr->watchdog_expires));
return ret_val;
}
static int32_t bcmtch_dev_watchdog_stop(
struct bcmtch_data *bcmtch_data_ptr)
{
int32_t ret_val = 0;
if (bcmtch_data_ptr) {
ret_val = del_timer_sync(&bcmtch_data_ptr->watchdog);
bcmtch_data_ptr->watchdog_expires = 0;
}
return ret_val;
}
static int32_t bcmtch_dev_reset_fw(
struct bcmtch_data *bcmtch_data_ptr)
{
int32_t ret_val = 0;
/* disable interrupts */
bcmtch_interrupt_disable(bcmtch_data_ptr);
/* free watchdog timer */
bcmtch_dev_watchdog_stop(bcmtch_data_ptr);
/* post boot reset */
bcmtch_dev_post_boot_reset(bcmtch_data_ptr);
/* cycle power - off */
bcmtch_dev_power_enable(
bcmtch_data_ptr,
false);
/* pause */
msleep(20);
/* cycle power - on */
ret_val = bcmtch_dev_power_enable(
bcmtch_data_ptr,
true);
if (ret_val) {
BCMTCH_ERR("WG: %s power enable error!\n",
__func__);
goto wdg_reset_error;
}
/* reset the chip on driver load ? */
if (bcmtch_boot_flag &
BCMTCH_BF_HARD_RESET_ON_LOAD) {
bcmtch_dev_reset(
bcmtch_data_ptr,
BCMTCH_RESET_MODE_HARD);
} else if (bcmtch_boot_flag &
BCMTCH_BF_SOFT_RESET_ON_LOAD) {
bcmtch_dev_reset(
bcmtch_data_ptr,
BCMTCH_RESET_MODE_SOFT_CHIP |
BCMTCH_RESET_MODE_SOFT_ARM);
}
/* clear events */
bcmtch_dev_reset_events(bcmtch_data_ptr);
/* init touch controller */
ret_val = bcmtch_dev_init(bcmtch_data_ptr);
if (ret_val) {
BCMTCH_ERR("WG: %s dev_init error!\n",
__func__);
goto wdg_reset_error;
}
/* restart watchdog */
bcmtch_dev_watchdog_start(bcmtch_data_ptr);
/* re-enable interrupts */
ret_val =
bcmtch_interrupt_enable(bcmtch_data_ptr);
wdg_reset_error:
return ret_val;
}
static int32_t bcmtch_dev_watchdog_check(
struct bcmtch_data *bcmtch_data_ptr)
{
int32_t ret_val = 0;
bool bcmtch_error = false;
BCMTCH_DBG(BCMTCH_DF_WD, "WD: Watch DOG\n");
#if BCMTCH_STATE_PROTOCOL
/* Check status */
ret_val =
bcmtch_state_check_command_status(bcmtch_data_ptr, 1);
if (ret_val)
bcmtch_error = true;
else if (bcmtch_data_ptr->work_process_index >= BCMTCH_WP_STATE) {
/* Test stop command */
bcmtch_state_stop_scan(bcmtch_data_ptr);
ret_val =
bcmtch_state_check_command_status(bcmtch_data_ptr, 25);
if (ret_val)
bcmtch_error = true;
else {
/* Test start command */
bcmtch_state_start_scan(bcmtch_data_ptr);
ret_val =
bcmtch_state_check_command_status(
bcmtch_data_ptr, 10);
if (ret_val ||
(bcmtch_data_ptr->bcmtch_state_resp_buffer[0]
< TOFE_MESSAGE_SUCCESS)) {
bcmtch_error = true;
}
}
}
#endif
/* Recover FW */
if ((bcmtch_error) &&
(bcmtch_boot_flag & BCMTCH_BF_FW_RESET_ON_WD)) {
BCMTCH_ERR("WG: watch dog reset [%d]\n", ret_val);
ret_val = bcmtch_dev_reset_fw(bcmtch_data_ptr);
if (ret_val)
return ret_val;
}
return ret_val;
}
static int32_t bcmtch_dev_power_init(
struct bcmtch_data *p_bcmtch_data)
{
int32_t ret_val = 0;
#ifdef CONFIG_REGULATOR
p_bcmtch_data->regulator_avdd33 =
regulator_get(
p_bcmtch_data->p_device,
"avdd33");
if (IS_ERR(p_bcmtch_data->regulator_avdd33))
p_bcmtch_data->regulator_avdd33 = NULL;
p_bcmtch_data->regulator_vddo =
regulator_get(
p_bcmtch_data->p_device,
"vddo");
if (IS_ERR(p_bcmtch_data->regulator_vddo))
p_bcmtch_data->regulator_vddo = NULL;
p_bcmtch_data->regulator_avdd_adldo =
regulator_get(
p_bcmtch_data->p_device,
"avdd_adldo");
if (IS_ERR(p_bcmtch_data->regulator_avdd_adldo))
p_bcmtch_data->regulator_avdd_adldo = NULL;
BCMTCH_DBG(BCMTCH_DF_PM, "PM:%s() %x %x %x\n",
__func__,
(uint32_t)p_bcmtch_data->regulator_avdd33,
(uint32_t)p_bcmtch_data->regulator_vddo,
(uint32_t)p_bcmtch_data->regulator_avdd_adldo);
#endif
return ret_val;
}
static int32_t bcmtch_dev_power_enable(
struct bcmtch_data *p_bcmtch_data,
bool enable)
{
int32_t ret_val = 0;
#ifdef CONFIG_REGULATOR
if (enable) {
if (p_bcmtch_data->regulator_avdd33)
ret_val |= regulator_enable(p_bcmtch_data
->regulator_avdd33);
if (p_bcmtch_data->regulator_vddo)
ret_val |= regulator_enable(p_bcmtch_data
->regulator_vddo);
if (p_bcmtch_data->regulator_avdd_adldo)
ret_val |= regulator_enable(p_bcmtch_data
->regulator_avdd_adldo);
if (p_bcmtch_data->power_on_delay_us)
usleep_range(
p_bcmtch_data->power_on_delay_us - 500,
p_bcmtch_data->power_on_delay_us + 500);
} else {
if (p_bcmtch_data->regulator_avdd33 &&
regulator_is_enabled(
p_bcmtch_data->regulator_avdd33))
regulator_disable(
p_bcmtch_data->regulator_avdd33);
if (p_bcmtch_data->regulator_vddo &&
regulator_is_enabled(
p_bcmtch_data->regulator_vddo))
regulator_disable(
p_bcmtch_data->regulator_vddo);
if (p_bcmtch_data->regulator_avdd_adldo &&
regulator_is_enabled(
p_bcmtch_data->regulator_avdd_adldo))
regulator_disable(
p_bcmtch_data->regulator_avdd_adldo);
}
#endif
if (ret_val)
BCMTCH_ERR("BCMTOUCH: %s() error rv=%d\n",
__func__,
ret_val);
return ret_val;
}
static int32_t bcmtch_dev_power_free(
struct bcmtch_data *p_bcmtch_data)
{
int32_t ret_val = 0;
#ifdef CONFIG_REGULATOR
if (p_bcmtch_data->regulator_avdd33)
regulator_put(p_bcmtch_data->regulator_avdd33);
if (p_bcmtch_data->regulator_vddo)
regulator_put(p_bcmtch_data->regulator_vddo);
if (p_bcmtch_data->regulator_avdd_adldo)
regulator_put(p_bcmtch_data->regulator_avdd_adldo);
p_bcmtch_data->regulator_avdd33 = NULL;
p_bcmtch_data->regulator_vddo = NULL;
p_bcmtch_data->regulator_avdd_adldo = NULL;
#endif
return ret_val;
}
/* -------------------------------------------------- */
/* - BCM Touch Controller Com(munication) Functions - */
/* -------------------------------------------------- */
static int32_t bcmtch_com_init(
struct bcmtch_data *bcmtch_data_ptr)
{
int32_t ret_val = 0;
if (BCMTCH_DEFAULT_I2C_ADDR_SYS !=
bcmtch_data_ptr->platform_data.i2c_addr_sys)
ret_val |= bcmtch_com_write_spm(
bcmtch_data_ptr,
BCMTCH_SPM_REG_I2CS_CHIPID,
bcmtch_data_ptr->platform_data.i2c_addr_sys);
return ret_val;
}
static int32_t bcmtch_com_read_spm(
struct bcmtch_data *bcmtch_data_ptr,
uint8_t reg, uint8_t *data)
{
int32_t ret_val = 0;
if (bcmtch_data_ptr) {
ret_val = bcmtch_i2c_read_spm(
bcmtch_data_ptr->p_i2c_client_spm,
reg,
data);
} else {
BCMTCH_ERR("%s() error, bcmtch_data_ptr == NULL\n", __func__);
ret_val = -ENODATA;
}
return ret_val;
}
static int32_t bcmtch_com_write_spm(
struct bcmtch_data *bcmtch_data_ptr,
uint8_t reg, uint8_t data)
{
int32_t ret_val = 0;
if (bcmtch_data_ptr) {
ret_val = bcmtch_i2c_write_spm(
bcmtch_data_ptr->p_i2c_client_spm,
reg,
data);
} else {
BCMTCH_ERR("%s() error, bcmtch_data_ptr == NULL\n", __func__);
ret_val = -ENODATA;
}
return ret_val;
}
static inline int32_t bcmtch_com_fast_write_spm(
struct bcmtch_data *bcmtch_data_ptr,
uint8_t count, uint8_t *regs, uint8_t *data)
{
int32_t ret_val = 0;
ret_val = bcmtch_i2c_fast_write_spm(
bcmtch_data_ptr->p_i2c_client_spm,
count,
regs,
data);
return ret_val;
}
static int32_t bcmtch_com_read_sys(
struct bcmtch_data *bcmtch_data_ptr,
uint32_t sys_addr,
uint16_t read_len,
uint8_t *read_data)
{
int32_t ret_val = 0;
if (bcmtch_data_ptr) {
ret_val = bcmtch_i2c_read_sys(
bcmtch_data_ptr->p_i2c_client_sys,
sys_addr,
read_len,
read_data);
} else {
BCMTCH_ERR("%s() error, bcmtch_data_ptr == NULL\n", __func__);
ret_val = -ENODATA;
}
return ret_val;
}
static inline int32_t bcmtch_com_write_sys32(
struct bcmtch_data *bcmtch_data_ptr,
uint32_t sys_addr,
uint32_t write_data)
{
return bcmtch_com_write_sys(bcmtch_data_ptr,
sys_addr, 4, (uint8_t *)&write_data);
}
static int32_t bcmtch_com_write_sys(
struct bcmtch_data *bcmtch_data_ptr,
uint32_t sys_addr,
uint16_t write_len,
uint8_t *write_data)
{
int32_t ret_val = 0;
if (bcmtch_data_ptr) {
ret_val = bcmtch_i2c_write_sys(
bcmtch_data_ptr->p_i2c_client_sys,
sys_addr,
write_len,
write_data);
} else {
BCMTCH_ERR("%s() error, bcmtch_data_ptr == NULL\n", __func__);
ret_val = -ENODATA;
}
return ret_val;
}
static int32_t bcmtch_com_read_dma(
struct bcmtch_data *bcmtch_data_ptr,
uint16_t read_len,
uint8_t *read_data)
{
int32_t ret_val = 0;
if (bcmtch_data_ptr) {
ret_val = bcmtch_i2c_read_dma(
bcmtch_data_ptr->p_i2c_client_sys,
read_len,
read_data);
} else {
BCMTCH_ERR("%s() error, bcmtch_data_ptr == NULL\n",
__func__);
ret_val = -ENODATA;
}
return ret_val;
}
/* ------------------------------------- */
/* - BCM Touch Controller OS Functions - */
/* ------------------------------------- */
static irqreturn_t bcmtch_interrupt_handler(int32_t irq, void *dev_id)
{
struct bcmtch_data *bcmtch_data_ptr =
(struct bcmtch_data *)dev_id;
/* track interrupts */
bcmtch_data_ptr->irq_pending = true;
BCMTCH_DBG(BCMTCH_DF_IH, "IH:p=%d\n",
bcmtch_data_ptr->irq_pending);
/* queue the interrupt handler */
queue_work(
bcmtch_data_ptr->p_workqueue,
(struct work_struct *)&bcmtch_data_ptr->work);
/* reset watchdog */
bcmtch_dev_watchdog_reset(bcmtch_data_ptr);
return IRQ_HANDLED;
}
static int32_t bcmtch_interrupt_enable(
struct bcmtch_data *bcmtch_data_ptr)
{
int32_t ret_val = 0;
struct bcmtch_platform_data *p_data;
if (bcmtch_data_ptr->irq_enabled)
return ret_val;
p_data = &bcmtch_data_ptr->platform_data;
ret_val = request_irq(
p_data->touch_irq,
bcmtch_interrupt_handler,
p_data->gpio_interrupt_trigger,
BCMTCH15XXX_NAME,
bcmtch_data_ptr);
if (ret_val) {
BCMTCH_ERR("ERROR: %s() - Unable to request interrupt irq %d\n",
__func__,
p_data->touch_irq);
/* note :
* - polling is not enabled in this release
* - it is an error if an irq is requested
* and not granted
*/
} else
bcmtch_data_ptr->irq_enabled = true;
return ret_val;
}
static void bcmtch_interrupt_disable(
struct bcmtch_data *bcmtch_data_ptr)
{
int32_t irq;
if (bcmtch_data_ptr && bcmtch_data_ptr->irq_enabled) {
irq = bcmtch_data_ptr->platform_data.touch_irq;
if (irq) {
free_irq(irq, bcmtch_data_ptr);
bcmtch_data_ptr->irq_enabled = false;
}
}
}
static int32_t bcmtch_init_input_device(
struct bcmtch_data *bcmtch_data_ptr)
{
int32_t ret_val = 0;
int32_t button_init = 0;
if (bcmtch_data_ptr) {
bcmtch_data_ptr->p_input_device = input_allocate_device();
if (bcmtch_data_ptr->p_input_device) {
bcmtch_data_ptr->p_input_device->name =
"BCMTCH15xxx Touch Screen";
bcmtch_data_ptr->p_input_device->phys =
"I2C";
bcmtch_data_ptr->p_input_device->id.bustype =
BUS_I2C;
bcmtch_data_ptr->p_input_device->id.vendor =
BCMTCH_VENDOR_ID;
bcmtch_data_ptr->p_input_device->id.product =
((bcmtch_data_ptr->chip_id
& BCMTCH_CHIPID_PID_MASK)
>> BCMTCH_CHIPID_PID_SHIFT);
bcmtch_data_ptr->p_input_device->id.version =
bcmtch_data_ptr->rev_id;
set_bit(EV_SYN, bcmtch_data_ptr->p_input_device->evbit);
set_bit(EV_ABS, bcmtch_data_ptr->p_input_device->evbit);
__set_bit(
INPUT_PROP_DIRECT,
bcmtch_data_ptr->p_input_device->propbit);
set_bit(EV_KEY,
bcmtch_data_ptr->p_input_device->evbit);
set_bit(
BTN_TOUCH,
bcmtch_data_ptr->p_input_device->keybit);
while (button_init < bcmtch_data_ptr->
platform_data.ext_button_count) {
set_bit(
bcmtch_data_ptr->platform_data.
ext_button_map[button_init],
bcmtch_data_ptr->
p_input_device->keybit);
button_init++;
}
input_set_abs_params(
bcmtch_data_ptr->p_input_device,
ABS_MT_POSITION_X,
bcmtch_data_ptr->axis_x_min,
bcmtch_data_ptr->axis_x_max,
0,
0);
input_set_abs_params(
bcmtch_data_ptr->p_input_device,
ABS_MT_POSITION_Y,
bcmtch_data_ptr->axis_y_min,
bcmtch_data_ptr->axis_y_max,
0,
0);
/* input_set_abs_params(
bcmtch_data_ptr->p_input_device,
ABS_MT_TOOL_TYPE,
0,
MT_TOOL_MAX,
0,
0);
*/
if (bcmtch_event_flag &
BCMTCH_EVENT_FLAG_TOUCH_SIZE) {
input_set_abs_params(
bcmtch_data_ptr->p_input_device,
ABS_MT_TOUCH_MAJOR,
bcmtch_data_ptr->axis_h_min,
bcmtch_data_ptr->axis_h_max,
0,
0);
input_set_abs_params(
bcmtch_data_ptr->p_input_device,
ABS_MT_TOUCH_MINOR,
bcmtch_data_ptr->axis_h_min,
bcmtch_data_ptr->axis_h_max,
0,
0);
}
if (bcmtch_event_flag &
BCMTCH_EVENT_FLAG_TOOL_SIZE) {
input_set_abs_params(
bcmtch_data_ptr->p_input_device,
ABS_MT_WIDTH_MAJOR,
bcmtch_data_ptr->axis_h_min,
bcmtch_data_ptr->axis_h_max,
0,
0);
input_set_abs_params(
bcmtch_data_ptr->p_input_device,
ABS_MT_WIDTH_MINOR,
bcmtch_data_ptr->axis_h_min,
bcmtch_data_ptr->axis_h_max,
0,
0);
}
if (bcmtch_event_flag &
BCMTCH_EVENT_FLAG_PRESSURE) {
input_set_abs_params(
bcmtch_data_ptr->p_input_device,
ABS_MT_PRESSURE,
0,
BCMTCH_MAX_PRESSURE,
0,
0);
}
if (bcmtch_event_flag &
BCMTCH_EVENT_FLAG_ORIENTATION) {
input_set_abs_params(
bcmtch_data_ptr->p_input_device,
ABS_MT_ORIENTATION,
BCMTCH_MIN_ORIENTATION,
BCMTCH_MAX_ORIENTATION,
0,
0);
}
set_bit(
BTN_TOOL_FINGER,
bcmtch_data_ptr->p_input_device->keybit);
#if LINUX_VERSION_CODE < KERNEL_VERSION(3, 7, 0)
input_mt_init_slots(
bcmtch_data_ptr->p_input_device,
BCMTCH_MAX_TOUCH);
#else
input_mt_init_slots(
bcmtch_data_ptr->p_input_device,
BCMTCH_MAX_TOUCH,
0);
#endif
/* request new os input queue size for this device */
input_set_events_per_packet(
bcmtch_data_ptr->p_input_device,
6 * BCMTCH_MAX_TOUCH);
/* register device */
ret_val =
input_register_device(
bcmtch_data_ptr->p_input_device);
if (ret_val) {
BCMTCH_INFO(
"%s() Unable to register input device\n",
__func__);
input_free_device(
bcmtch_data_ptr->p_input_device);
bcmtch_data_ptr->p_input_device = NULL;
}
} else {
BCMTCH_ERR("%s() Unable to create device\n",
__func__);
ret_val = -ENODEV;
}
} else {
BCMTCH_ERR("%s() error, driver data structure == NULL\n",
__func__);
ret_val = -ENODATA;
}
return ret_val;
}
static inline void bcmtch_free_input_device(
struct bcmtch_data *bcmtch_data_ptr)
{
if (bcmtch_data_ptr && bcmtch_data_ptr->p_input_device) {
input_unregister_device(bcmtch_data_ptr->p_input_device);
bcmtch_data_ptr->p_input_device = NULL;
}
}
static bool bcmtch_dev_process_post_boot(
struct bcmtch_data *bcmtch_data_ptr,
bool irq_serviced)
{
int32_t still_downloading;
int32_t ret_val;
if (irq_serviced) {
/* download shorter packet */
still_downloading =
bcmtch_dev_post_boot_download(
bcmtch_data_ptr,
bcmtch_post_boot_rate_low);
} else {
/* download larger packet */
still_downloading =
bcmtch_dev_post_boot_download(
bcmtch_data_ptr,
bcmtch_post_boot_rate_high);
}
if (!still_downloading) {
BCMTCH_DBG(BCMTCH_DF_PB, "PB:DOWNLOAD COMPLETE\n");
if (bcmtch_data_ptr->postboot_cfg_length) {
/* don't want any stray interrupts */
bcmtch_interrupt_disable(bcmtch_data_ptr);
/* Send post boot init command */
ret_val = bcmtch_dev_send_command(
bcmtch_data_ptr,
TOFE_COMMAND_INIT_POST_BOOT_PATCHES,
bcmtch_data_ptr->postboot_cfg_addr,
bcmtch_data_ptr->postboot_cfg_length,
0);
if (ret_val != 0) {
BCMTCH_ERR(
" send_command error [%d] cmd=%x\n",
ret_val,
TOFE_COMMAND_INIT_POST_BOOT_PATCHES);
}
/* Set to check post boot init request from FW */
bcmtch_data_ptr->post_boot_pending = 1;
/* Set the worker process function to the transient
* one which handles the ISR workqueue during
* the switch from ROM FW to post boot patched FW.
*/
bcmtch_data_ptr->work_process_index =
BCMTCH_WP_PATCH_INIT;
bcmtch_dev_watchdog_restart(
bcmtch_data_ptr,
msecs_to_jiffies(bcmtch_watchdog_normal));
bcmtch_interrupt_enable(bcmtch_data_ptr);
}
return true;
}
return false;
}
static void bcmtch_deferred_worker(struct work_struct *work)
{
struct bcmtch_data *bcmtch_data_ptr =
container_of(work, struct bcmtch_data, work);
bool work_done = false;
mutex_lock(&bcmtch_data_ptr->mutex_work);
if (bcmtch_data_ptr->irq_pending) {
bcmtch_data_ptr->irq_pending = false;
/* Process channels */
bcmtch_data_ptr->bcmtch_dev_process_table
[bcmtch_data_ptr->work_process_index]
(bcmtch_data_ptr);
work_done = true;
}
/* Amortized post boot download */
if (bcmtch_data_ptr->post_boot_sections) {
bcmtch_dev_process_post_boot(
bcmtch_data_ptr,
work_done);
work_done = true;
}
if (!work_done)
bcmtch_dev_watchdog_check(bcmtch_data_ptr);
mutex_unlock(&bcmtch_data_ptr->mutex_work);
}
static int32_t bcmtch_dev_post_boot_get_section(
struct bcmtch_data *bcmtch_data_ptr)
{
struct combi_entry *pb_entry = NULL;
if (bcmtch_data_ptr->post_boot_sections &&
bcmtch_data_ptr->post_boot_buffer) {
pb_entry = (struct combi_entry *)
bcmtch_data_ptr->post_boot_buffer;
while (pb_entry[bcmtch_data_ptr->post_boot_section].length) {
if (pb_entry[bcmtch_data_ptr->post_boot_section].flags &
BCMTCH_FIRMWARE_FLAGS_POST_BOOT) {
bcmtch_data_ptr->post_boot_data =
bcmtch_data_ptr->post_boot_buffer
+ pb_entry[bcmtch_data_ptr->
post_boot_section].offset;
bcmtch_data_ptr->post_boot_addr =
pb_entry[bcmtch_data_ptr->
post_boot_section].addr;
bcmtch_data_ptr->post_boot_left =
pb_entry[bcmtch_data_ptr->
post_boot_section].length;
break;
} else {
bcmtch_data_ptr->post_boot_section++;
}
}
}
return pb_entry[bcmtch_data_ptr->post_boot_section].length;
}
static int32_t bcmtch_dev_post_boot_download(
struct bcmtch_data *bcmtch_data_ptr,
int16_t data_rate)
{
int32_t ret_val;
int16_t write_length;
struct combi_entry *pb_entry = NULL;
if (bcmtch_data_ptr->post_boot_left) {
write_length = data_rate;
if (bcmtch_data_ptr->post_boot_left < write_length)
write_length = bcmtch_data_ptr->post_boot_left;
ret_val = bcmtch_com_write_sys(
bcmtch_data_ptr,
bcmtch_data_ptr->post_boot_addr,
write_length,
bcmtch_data_ptr->post_boot_data);
if (ret_val) {
BCMTCH_ERR("%s() Error - did not download\n",
__func__);
} else {
bcmtch_data_ptr->post_boot_addr += write_length;
bcmtch_data_ptr->post_boot_left -= write_length;
bcmtch_data_ptr->post_boot_data += write_length;
}
} else {
BCMTCH_ERR("%s() Error - no bytes to download\n",
__func__);
}
if (!bcmtch_data_ptr->post_boot_left) {
pb_entry = (struct combi_entry *)
bcmtch_data_ptr->post_boot_buffer;
BCMTCH_DBG(
BCMTCH_DF_PB,
"PB:Section %d Addr 0x%08x Len %d\n",
bcmtch_data_ptr->post_boot_section,
pb_entry[bcmtch_data_ptr->
post_boot_section].addr,
pb_entry[bcmtch_data_ptr->
post_boot_section].length);
if (pb_entry[bcmtch_data_ptr->post_boot_section].flags &
BCMTCH_FIRMWARE_FLAGS_POST_BOOT_PATCH) {
if (--bcmtch_data_ptr->post_boot_patches == 0) {
/* send patch init */
ret_val = bcmtch_dev_send_command(
bcmtch_data_ptr,
TOFE_COMMAND_INIT_POST_BOOT_PATCHES,
0,
0,
0);
if (ret_val != 0) {
BCMTCH_ERR(
" send_command error [%d] cmd=%x\n",
ret_val,
TOFE_COMMAND_INIT_POST_BOOT_PATCHES);
}
}
}
if (--bcmtch_data_ptr->post_boot_sections) {
bcmtch_data_ptr->post_boot_section++;
bcmtch_dev_post_boot_get_section(bcmtch_data_ptr);
}
}
BCMTCH_DBG(BCMTCH_DF_PB, "PB:pb_sec=%d post_boot_left=%d.\n",
bcmtch_data_ptr->post_boot_sections,
bcmtch_data_ptr->post_boot_left);
return bcmtch_data_ptr->post_boot_sections;
}
static int32_t bcmtch_init_deferred_worker(
struct bcmtch_data *bcmtch_data_ptr)
{
int32_t ret_val = 0;
if (bcmtch_data_ptr) {
bcmtch_data_ptr->p_workqueue =
create_workqueue("bcmtch_wq");
if (bcmtch_data_ptr->p_workqueue) {
INIT_WORK(
&bcmtch_data_ptr->work,
bcmtch_deferred_worker);
} else {
BCMTCH_ERR("%s() Unable to create workqueue\n",
__func__);
ret_val = -ENOMEM;
}
} else {
BCMTCH_ERR("%s() error, driver data structure == NULL\n",
__func__);
ret_val = -ENODATA;
}
return ret_val;
}
static void bcmtch_clear_deferred_worker(
struct bcmtch_data *bcmtch_data_ptr)
{
if (bcmtch_data_ptr && bcmtch_data_ptr->p_workqueue)
flush_workqueue(bcmtch_data_ptr->p_workqueue);
}
static void bcmtch_free_deferred_worker(
struct bcmtch_data *bcmtch_data_ptr)
{
if (bcmtch_data_ptr && bcmtch_data_ptr->p_workqueue) {
cancel_work_sync(&bcmtch_data_ptr->work);
destroy_workqueue(bcmtch_data_ptr->p_workqueue);
bcmtch_data_ptr->p_workqueue = NULL;
}
}
static void bcmtch_reset(
struct bcmtch_data *bcmtch_data_ptr)
{
if (bcmtch_data_ptr &&
gpio_is_valid(bcmtch_data_ptr->
platform_data.gpio_reset_pin)) {
msleep(bcmtch_data_ptr->platform_data.gpio_reset_time_ms);
gpio_set_value(
bcmtch_data_ptr->platform_data.gpio_reset_pin,
bcmtch_data_ptr->platform_data.gpio_reset_polarity);
msleep(bcmtch_data_ptr->platform_data.gpio_reset_time_ms);
gpio_set_value(
bcmtch_data_ptr->platform_data.gpio_reset_pin,
!bcmtch_data_ptr->platform_data.gpio_reset_polarity);
msleep(bcmtch_data_ptr->platform_data.gpio_reset_time_ms);
}
}
static int32_t bcmtch_init_gpio(
struct bcmtch_data *bcmtch_data_ptr)
{
struct bcmtch_platform_data *p_platform_data;
int32_t ret_val = 0;
if (!bcmtch_data_ptr) {
BCMTCH_ERR("%s() error, driver data structure == NULL\n",
__func__);
ret_val = -ENODATA;
return ret_val;
}
p_platform_data =
(struct bcmtch_platform_data *)&bcmtch_data_ptr->platform_data;
/*
* setup a gpio pin for BCM Touch Controller reset function
*/
if (gpio_is_valid(p_platform_data->gpio_reset_pin)) {
ret_val = gpio_request(
p_platform_data->gpio_reset_pin,
"BCMTCH reset");
if (ret_val < 0) {
BCMTCH_ERR(
"ERROR: %s() - Unable to request reset pin %d\n",
__func__,
p_platform_data->gpio_reset_pin);
/* note :
* it is an error if a reset pin is requested
* and not granted --> return
*/
return ret_val;
}
/*
* setup reset pin as output
* - invert reset polarity --> don't want to hold in reset
*/
ret_val = gpio_direction_output(
p_platform_data->gpio_reset_pin,
!p_platform_data->gpio_reset_polarity);
if (ret_val < 0) {
BCMTCH_ERR("ERROR: %s() - Unable to set reset pin %d\n",
__func__,
p_platform_data->gpio_reset_pin);
/* note :
* it is an error if a reset pin is requested
* and not set --> return
*/
return ret_val;
}
} else {
BCMTCH_INFO("%s() : no reset pin configured\n",
__func__);
}
/*
* setup a gpio pin for BCM Touch Controller interrupt function
*/
if (gpio_is_valid(p_platform_data->gpio_interrupt_pin)) {
ret_val = gpio_request(
p_platform_data->gpio_interrupt_pin,
"BCMTCH Interrupt");
if (ret_val < 0) {
BCMTCH_ERR(
"ERROR: %s() - Unable to request interrupt pin %d\n",
__func__,
p_platform_data->gpio_interrupt_pin);
/* note :
* it is an error if an interrupt pin is requested
* and not granted --> return
*/
return ret_val;
}
/* setup interrupt pin as input */
ret_val = gpio_direction_input(
p_platform_data->gpio_interrupt_pin);
if (ret_val < 0) {
BCMTCH_ERR(
"ERROR: %s() - Unable to set interrupt pin %d\n",
__func__,
p_platform_data->gpio_interrupt_pin);
/* note :
* it is an error if a interrupt pin is requested
* and not set --> return
*/
return ret_val;
}
} else if (!p_platform_data->touch_irq) {
BCMTCH_INFO("%s() : no interrupt pin configured\n",
__func__);
}
return ret_val;
}
static void bcmtch_free_gpio(
struct bcmtch_data *bcmtch_data_ptr)
{
struct bcmtch_platform_data *p_platform_data;
if (bcmtch_data_ptr) {
p_platform_data =
(struct bcmtch_platform_data *)
&bcmtch_data_ptr->platform_data;
if (gpio_is_valid(p_platform_data->gpio_reset_pin))
gpio_free(p_platform_data->gpio_reset_pin);
if (gpio_is_valid(p_platform_data->gpio_interrupt_pin))
gpio_free(p_platform_data->gpio_interrupt_pin);
}
}
static int32_t bcmtch_os_init_cli(struct device *p_device)
{
int32_t ret_val = 0;
ret_val = device_create_file(p_device, &bcmtch_cli_attr);
if (ret_val)
BCMTCH_ERR(
"ERROR: %s() - device_create_file() failed!\n",
__func__);
return ret_val;
}
static inline void bcmtch_os_free_cli(struct device *p_device)
{
device_remove_file(p_device, &bcmtch_cli_attr);
}
/* ----------------------------------------- */
/* --- BCM Touch Controller PM Functions --- */
/* ----------------------------------------- */
#ifdef CONFIG_PM
#ifndef CONFIG_HAS_EARLYSUSPEND
static int bcmtch_suspend(struct i2c_client *p_client, pm_message_t mesg)
{
if (mesg.event == PM_EVENT_SUSPEND)
bcmtch_dev_suspend(i2c_get_clientdata(p_client));
return 0;
}
static int bcmtch_resume(struct i2c_client *p_client)
{
int rc = 0;
bcmtch_dev_resume(i2c_get_clientdata(p_client));
return rc;
}
#endif
#endif
#ifdef CONFIG_HAS_EARLYSUSPEND
static void bcmtch_early_suspend(struct early_suspend *h)
{
struct bcmtch_data *local_bcmtch_data_p =
container_of(
h,
struct bcmtch_data,
bcmtch_early_suspend_desc);
bcmtch_dev_suspend(local_bcmtch_data_p);
}
static void bcmtch_late_resume(struct early_suspend *h)
{
struct bcmtch_data *bcmtch_data_ptr =
container_of(h, struct bcmtch_data,
bcmtch_early_suspend_desc);
bcmtch_dev_resume(bcmtch_data_ptr);
}
static void bcmtch_register_early_suspend(
struct bcmtch_data *bcmtch_data_ptr)
{
/* Init early suspend parameters */
bcmtch_data_ptr->bcmtch_early_suspend_desc.level =
EARLY_SUSPEND_LEVEL_STOP_DRAWING;
bcmtch_data_ptr->bcmtch_early_suspend_desc.suspend =
bcmtch_early_suspend;
bcmtch_data_ptr->bcmtch_early_suspend_desc.resume =
bcmtch_late_resume;
/* Register early suspend parameters */
register_early_suspend(&bcmtch_data_ptr->
bcmtch_early_suspend_desc);
}
static inline void bcmtch_unregister_early_suspend(
struct bcmtch_data *bcmtch_data_ptr)
{
/* Unregister early suspend parameters */
unregister_early_suspend(&bcmtch_data_ptr->
bcmtch_early_suspend_desc);
}
#endif
/* ----------------------------------------- */
/* -- BCM Touch Controller I2C Functions --- */
/* ----------------------------------------- */
static int32_t bcmtch_i2c_read_spm(
struct i2c_client *p_i2c,
uint8_t reg,
uint8_t *data)
{
int32_t ret_val = 0;
/* setup I2C messages for single byte read transaction */
struct i2c_msg msg[2] = {
/* first write register to spm */
{.addr = p_i2c->addr, .flags = 0, .len = 1, .buf = &reg},
/* Second read data from spm reg */
{.addr = p_i2c->addr, .flags = I2C_M_RD, .len = 1, .buf = data}
};
if (i2c_transfer(p_i2c->adapter, msg, 2) != 2)
ret_val = -EIO;
return ret_val;
}
static int32_t bcmtch_i2c_write_spm(
struct i2c_client *p_i2c,
uint8_t reg,
uint8_t data)
{
int32_t ret_val = 0;
/* setup buffer with reg address and data */
uint8_t buffer[2] = { reg, data };
/* setup I2C message for single byte write transaction */
struct i2c_msg msg[1] = {
/* first write message to spm */
{.addr = p_i2c->addr, .flags = 0, .len = 2, .buf = buffer}
};
if (i2c_transfer(p_i2c->adapter, msg, 1) != 1)
ret_val = -EIO;
return ret_val;
}
static int32_t bcmtch_i2c_fast_write_spm(
struct i2c_client *p_i2c,
uint8_t count,
uint8_t *regs,
uint8_t *data)
{
int32_t ret_val = 0;
/*
* support hard-coded for a max of 5 spm write messages
*
* - 1 i2c message uses 2 uint8_t buffers
*
*/
uint8_t buffer[10]; /* buffers for reg address and data */
struct i2c_msg msg[5];
uint32_t n_msg = 0;
uint8_t *buf_ptr = buffer;
/* setup I2C message for single byte write transaction */
while (n_msg < count) {
msg[n_msg].addr = p_i2c->addr;
msg[n_msg].flags = 0;
msg[n_msg].len = 2;
msg[n_msg].buf = buf_ptr;
*buf_ptr++ = regs[n_msg];
*buf_ptr++ = data[n_msg];
n_msg++;
}
if (i2c_transfer(p_i2c->adapter, msg, n_msg) != n_msg)
ret_val = -EIO;
return ret_val;
}
#if BCMTCH_STATE_PROTOCOL
static int32_t bcmtch_state_i2c_send_command(
struct bcmtch_data *bcmtch_data_ptr,
uint8_t cmd,
uint8_t *params,
int param_num)
{
int ret_val = 0;
struct i2c_client *i2c_spm_ptr =
bcmtch_data_ptr->p_i2c_client_spm;
struct i2c_client *i2c_sys_ptr =
bcmtch_data_ptr->p_i2c_client_sys;
uint8_t *i2c_buffer =
bcmtch_data_ptr->bcmtch_state_cmd_buffer;
uint8_t *cmd_buffer = &i2c_buffer[1];
struct i2c_msg msg;
int i, dma_len;
/* set target register */
i2c_buffer[0] = BCMTCH_SPM_REG_MSG_FROM_HOST;
/* distinguish short/long command */
if (param_num < TOFE_HOST_CMD_SHORT_SIZE) {
/* set command */
cmd_buffer[0] = cmd;
/* set parameters */
for (i = 0; i < param_num; i++)
cmd_buffer[i+1] = params[i];
/* padding */
for (i = param_num; i < TOFE_HOST_CMD_SHORT_SIZE; i++)
cmd_buffer[i+1] = 0;
if (cmd == BCMTCH_CMD_RESUME)
cmd_buffer[TOFE_HOST_CMD_SHORT_SIZE] =
BCMTCH_POWER_MODE_WAKE;
/* i2c write transaction */
msg.addr = i2c_spm_ptr->addr;
msg.flags = 0;
msg.len = TOFE_HOST_CMD_SHORT_SIZE+2;
msg.buf = i2c_buffer;
if (i2c_transfer(i2c_spm_ptr->adapter, &msg, 1) != 1)
return -EIO;
/* 500 us delay for FW to process the command */
usleep_range(500, 1000);
} else {
BCMTCH_DBG(
BCMTCH_DF_ST,
"ST: %s long cmd=0x%0x param_num=%d\n",
__func__,
cmd,
param_num);
/* Before sending a long command, we need to make sure the chip
* is in Active mode (which enables the I2C DMA). The Retention
* mode is used only in two modes: StartScan command (for power
* saving) and Suspend. Here we terminate the StartScan command
* in case it's pending.
*/
if (cmd_buffer[0] == BCMTCH_CMD_START_SCAN ||
cmd_buffer[0] == BCMTCH_CMD_SINGLE_SCAN) {
cmd_buffer[0] = 0;
ret_val = bcmtch_state_stop_scan(bcmtch_data_ptr);
if (ret_val)
return ret_val;
}
cmd_buffer[0] = BCMTCH_CMD_LONG;
for (i = 0; i < TOFE_HOST_CMD_SHORT_SIZE; i++)
cmd_buffer[i+1] = 0;
/* i2c write transaction */
msg.addr = i2c_spm_ptr->addr;
msg.flags = 0;
msg.len = TOFE_HOST_CMD_SHORT_SIZE+2;
msg.buf = i2c_buffer;
if (i2c_transfer(i2c_spm_ptr->adapter, &msg, 1) != 1)
return -EIO;
/* 500 us delay for FW to process the command */
usleep_range(500, 1000);
/* setup i2c messages for DMA write request transaction */
i2c_buffer[0] = BCMTCH_SPM_REG_DMA_WFIFO;
cmd_buffer[0] = cmd;
memcpy(&cmd_buffer[1], params, param_num);
dma_len = (((param_num+1) + 3) & ~0x3) + 1;
/* padding */
for (i = param_num + 2; i < dma_len; i++)
i2c_buffer[i] = 0;
/* debug */
BCMTCH_DBG(
BCMTCH_DF_ST,
"ST: send long cmd params: dma_len=%d param_num=%d",
dma_len,
param_num);
for (i = 0; i < dma_len; i++)
BCMTCH_DBG(
BCMTCH_DF_I2C,
"I2C: 0x%02x",
i2c_buffer[i]);
BCMTCH_DBG(BCMTCH_DF_ST, "ST: END.");
/* i2c write transaction */
msg.addr = i2c_sys_ptr->addr;
msg.flags = 0;
msg.len = dma_len;
msg.buf = i2c_buffer;
if (i2c_transfer(i2c_spm_ptr->adapter, &msg, 1) != 1)
ret_val = -EIO;
}
return ret_val;
}
#endif /* BCMTCH_STATE_PROTOCOL */
static int32_t bcmtch_i2c_read_dma(
struct i2c_client *p_i2c,
uint16_t read_len,
uint8_t *read_data)
{
int32_t ret_val = 0;
uint8_t dma_reg = BCMTCH_SPM_REG_DMA_RFIFO;
/* setup I2C messages for DMA read transaction */
struct i2c_msg dma_read[2] = {
/* next write messages to read the DMA request status */
{.addr = p_i2c->addr, .flags = 0, .len = 1, .buf = &dma_reg},
{.addr = p_i2c->addr, .flags = I2C_M_RD,
.len = read_len, .buf = read_data}
};
/* read status */
if (i2c_transfer(p_i2c->adapter, dma_read, 2) != 2)
ret_val = -EIO;
return ret_val;
}
static int32_t bcmtch_i2c_read_sys(
struct i2c_client *p_i2c,
uint32_t sys_addr,
uint16_t read_len,
uint8_t *read_data)
{
int32_t ret_val = 0;
uint8_t dma_reg = BCMTCH_SPM_REG_DMA_RFIFO;
/* setup the DMA header for this read transaction */
uint8_t dma_header[8] = {
/* set dma controller addr */
BCMTCH_SPM_REG_DMA_ADDR,
/* setup dma address */
(sys_addr & 0xFF),
((sys_addr & 0xFF00) >> 8),
((sys_addr & 0xFF0000) >> 16),
((sys_addr & 0xFF000000) >> 24),
/* setup dma length */
(read_len & 0xFF),
((read_len & 0xFF00) >> 8),
/* setup dma mode */
BCMTCH_DMA_MODE_READ
};
/* setup I2C messages for DMA read request transaction */
struct i2c_msg dma_request[3] = {
/* write DMA request header */
{.addr = p_i2c->addr, .flags = 0, .len = 8, .buf = dma_header},
/* next write messages to read the DMA request */
{.addr = p_i2c->addr, .flags = 0, .len = 1, .buf = &dma_reg},
{.addr = p_i2c->addr, .flags = I2C_M_RD,
.len = read_len, .buf = read_data}
};
/* send complete DMA request */
if (i2c_transfer(p_i2c->adapter, dma_request, 3) != 3)
ret_val = -EIO;
return ret_val;
}
static int32_t bcmtch_i2c_write_sys(
struct i2c_client *p_i2c,
uint32_t sys_addr,
uint16_t write_len,
uint8_t *write_data)
{
int total_dma_len, len, dma_len, ret_val = 0;
uint8_t *dma_data;
struct i2c_msg request;
uint8_t dma_header[8] = {
/* dma controller addr */
BCMTCH_SPM_REG_DMA_ADDR,
/* dma address */
(sys_addr & 0xFF),
((sys_addr & 0xFF00) >> 8),
((sys_addr & 0xFF0000) >> 16),
((sys_addr & 0xFF000000) >> 24),
/* dma length */
(write_len & 0xFF),
((write_len & 0xFF00) >> 8),
/* dma mode */
BCMTCH_DMA_MODE_WRITE
};
total_dma_len = write_len + 1;
dma_data = kzalloc(SZ_4K, GFP_KERNEL);
if (!dma_data)
return -ENOMEM;
request.addr = p_i2c->addr;
request.flags = 0;
request.len = 8;
request.buf = dma_header;
if (i2c_transfer(p_i2c->adapter, &request, 1) != 1) {
ret_val = -EIO;
goto error;
}
for (len = total_dma_len; len > 0; len -= (SZ_4K - 1)) {
if (len < (SZ_4K - 1))
dma_len = len;
else
dma_len = SZ_4K;
request.addr = p_i2c->addr;
request.flags = 0;
request.len = dma_len;
request.buf = dma_data;
dma_data[0] = BCMTCH_SPM_REG_DMA_WFIFO;
memcpy(&dma_data[1],
(write_data + (total_dma_len - len)), dma_len - 1);
if (i2c_transfer(p_i2c->adapter, &request, 1) != 1) {
ret_val = -EIO;
break;
}
}
error:
kfree(dma_data);
return ret_val;
}
static int32_t bcmtch_i2c_init_clients(struct i2c_client *p_i2c_client_spm)
{
int32_t ret_val = 0;
struct i2c_client *p_i2c_client_sys;
struct bcmtch_data *bcmtch_data_ptr =
i2c_get_clientdata(p_i2c_client_spm);
if (p_i2c_client_spm->adapter) {
/* Configure the second I2C slave address. */
p_i2c_client_sys =
i2c_new_dummy(
p_i2c_client_spm->adapter,
bcmtch_data_ptr->platform_data.i2c_addr_sys);
if (p_i2c_client_sys) {
/* assign */
bcmtch_data_ptr->p_i2c_client_spm = p_i2c_client_spm;
bcmtch_data_ptr->p_i2c_client_sys = p_i2c_client_sys;
} else {
BCMTCH_ERR(
"%s() i2c_new_dummy == NULL, slave address: 0x%x\n",
__func__,
bcmtch_data_ptr->platform_data.i2c_addr_sys);
ret_val = -ENODEV;
}
} else {
BCMTCH_ERR("%s() p_i2c_adapter == NULL\n",
__func__);
ret_val = -ENODEV;
}
return ret_val;
}
static inline void bcmtch_i2c_free_clients(
struct bcmtch_data *bcmtch_data_ptr)
{
if (bcmtch_data_ptr && (bcmtch_data_ptr->p_i2c_client_sys)) {
i2c_unregister_device(bcmtch_data_ptr->p_i2c_client_sys);
bcmtch_data_ptr->p_i2c_client_sys = NULL;
}
}
/* ------------------------------------------------- */
/* -- BCM Touch Controller I2C Driver Structures --- */
/* ------------------------------------------------- */
static const struct i2c_device_id bcmtch_i2c_id[] = {
{BCMTCH15XXX_NAME, 0},
{}
};
MODULE_DEVICE_TABLE(i2c, bcmtch_i2c_id);
static struct i2c_driver bcmtch_i2c_driver = {
.driver = {
.name = BCMTCH15XXX_NAME,
.owner = THIS_MODULE,
},
.probe = bcmtch_i2c_probe,
.remove = bcmtch_i2c_remove,
.id_table = bcmtch_i2c_id,
#ifdef CONFIG_PM
#ifndef CONFIG_HAS_EARLYSUSPEND
.suspend = bcmtch_suspend,
.resume = bcmtch_resume,
#endif
#endif
};
/* ------------------------------------------------ */
/* -- BCM Touch Controller I2C Driver Functions --- */
/* ------------------------------------------------ */
static int32_t bcmtch_i2c_probe(
struct i2c_client *p_i2c_client,
const struct i2c_device_id *id)
{
struct bcmtch_data *bcmtch_data_ptr;
int32_t ret_val = 0;
BCMTCH_DBG(BCMTCH_DF_INFO, "INFO: Driver: %s : %s : %s\n",
BCMTCH_DRIVER_VERSION,
BCMTCH_DRIVER_BUILD_DATE,
BCMTCH_DRIVER_BUILD_TIME);
/* print driver probe header */
if (p_i2c_client)
BCMTCH_DBG(
BCMTCH_DF_INFO,
"INFO: dev=%s addr=0x%x irq=%d\n",
p_i2c_client->name,
p_i2c_client->addr,
p_i2c_client->irq);
if (id)
BCMTCH_DBG(BCMTCH_DF_INFO, "INFO: match id=%s\n",
id->name);
/* allocate global BCM Touch Controller driver structure */
ret_val = bcmtch_dev_alloc(p_i2c_client);
if (ret_val)
goto probe_error;
/* setup local platform data from client device structure */
ret_val = bcmtch_dev_init_platform(&p_i2c_client->dev);
if (ret_val)
goto init_platform_error;
bcmtch_data_ptr = i2c_get_clientdata(p_i2c_client);
mutex_lock(&bcmtch_data_ptr->mutex_work);
/* initialize deferred worker (workqueue/tasklet/etc */
ret_val = bcmtch_init_deferred_worker(bcmtch_data_ptr);
if (ret_val)
goto worker_error;
/* initialize power supplies */
ret_val = bcmtch_dev_power_init(bcmtch_data_ptr);
if (ret_val)
goto power_init_error;
/* enable power supplies */
ret_val = bcmtch_dev_power_enable(bcmtch_data_ptr, true);
if (ret_val)
goto power_enable_error;
/* setup the gpio pins
* - 1 gpio used for reset control signal to BCM Touch Controller
* - 1 gpio used as interrupt signal from BCM Touch Controller
*/
ret_val = bcmtch_init_gpio(bcmtch_data_ptr);
if (ret_val)
goto gpio_error;
/*
* setup the i2c clients and bind (store pointers in global structure)
* 1. SPM I2C client
* 2. SYS I2C client
*/
ret_val = bcmtch_i2c_init_clients(p_i2c_client);
if (ret_val)
goto i2c_client_error;
/* reset the chip on driver load ? */
if (bcmtch_boot_flag &
BCMTCH_BF_HARD_RESET_ON_LOAD) {
bcmtch_dev_reset(
bcmtch_data_ptr,
BCMTCH_RESET_MODE_HARD);
} else if (bcmtch_boot_flag &
BCMTCH_BF_SOFT_RESET_ON_LOAD) {
bcmtch_dev_reset(
bcmtch_data_ptr,
BCMTCH_RESET_MODE_SOFT_CHIP |
BCMTCH_RESET_MODE_SOFT_ARM);
}
/* init the table of the worker process functions */
bcmtch_dev_init_worker_process(bcmtch_data_ptr);
/* perform BCM Touch Controller initialization */
ret_val = bcmtch_dev_init(bcmtch_data_ptr);
if (ret_val)
goto init_dev_error;
/* setup the os cli */
ret_val = bcmtch_os_init_cli(&p_i2c_client->dev);
if (ret_val)
goto cli_error;
/* setup the sysfs api */
ret_val = bcmtch_os_init_abi(&p_i2c_client->dev);
if (ret_val)
goto sysfs_api_error;
/* setup the os input device*/
ret_val = bcmtch_init_input_device(bcmtch_data_ptr);
if (ret_val)
goto input_dev_error;
bcmtch_dev_watchdog_start(bcmtch_data_ptr);
ret_val = bcmtch_interrupt_enable(bcmtch_data_ptr);
if (ret_val)
goto interrupt_error;
mutex_unlock(&bcmtch_data_ptr->mutex_work);
#ifdef CONFIG_HAS_EARLYSUSPEND
bcmtch_register_early_suspend(bcmtch_data_ptr);
#endif /* CONFIG_HAS_EARLYSUSPEND */
BCMTCH_INFO("PROBE: success\n");
return 0;
interrupt_error:
input_dev_error:
/* Undo input device init */
bcmtch_free_input_device(bcmtch_data_ptr);
sysfs_api_error:
/* Undo sysfs api init */
bcmtch_os_free_abi(&p_i2c_client->dev);
cli_error:
/* Undo os cli init */
bcmtch_os_free_cli(&p_i2c_client->dev);
init_dev_error:
/* Undo touch controller initialization */
i2c_client_error:
/* Undo i2c clients init */
bcmtch_i2c_free_clients(bcmtch_data_ptr);
gpio_error:
/* Undo gpio init */
bcmtch_free_gpio(bcmtch_data_ptr);
power_enable_error:
/* undo power enable */
bcmtch_dev_power_enable(bcmtch_data_ptr, false);
power_init_error:
/* undo power init */
bcmtch_dev_power_free(bcmtch_data_ptr);
/* Undo worker init */
bcmtch_free_deferred_worker(bcmtch_data_ptr);
worker_error:
mutex_unlock(&bcmtch_data_ptr->mutex_work);
init_platform_error:
/* Undo platform init */
bcmtch_dev_free(p_i2c_client);
probe_error:
BCMTCH_ERR("PROBE: failure\n");
return ret_val;
}
static int32_t bcmtch_i2c_remove(struct i2c_client *p_i2c_client)
{
struct bcmtch_data *bcmtch_data_ptr =
i2c_get_clientdata(p_i2c_client);
/* disable interrupts */
bcmtch_interrupt_disable(bcmtch_data_ptr);
#if BCMTCH_STATE_PROTOCOL
/* state protocol stop scan */
if (bcmtch_data_ptr->work_process_index >= BCMTCH_WP_STATE)
bcmtch_state_stop_scan(bcmtch_data_ptr);
#endif /* BCMTCH_STATE_PROTOCOL */
/* free watchdog timer */
bcmtch_dev_watchdog_stop(bcmtch_data_ptr);
/* free deferred worker (queue) */
bcmtch_free_deferred_worker(bcmtch_data_ptr);
mutex_lock(&bcmtch_data_ptr->mutex_work);
#ifdef CONFIG_HAS_EARLYSUSPEND
bcmtch_unregister_early_suspend(bcmtch_data_ptr);
#endif /* CONFIG_HAS_EARLYSUSPEND */
/* force chip to sleep before exiting */
if (BCMTCH_POWER_STATE_SLEEP !=
bcmtch_dev_get_power_state(bcmtch_data_ptr)) {
bcmtch_dev_set_power_state(bcmtch_data_ptr,
BCMTCH_POWER_STATE_SLEEP);
}
/* disable power */
bcmtch_dev_power_enable(bcmtch_data_ptr, false);
/* release power */
bcmtch_dev_power_free(bcmtch_data_ptr);
/* reset + free communication channels */
bcmtch_dev_post_boot_reset(bcmtch_data_ptr);
/* free i2c device clients */
bcmtch_i2c_free_clients(bcmtch_data_ptr);
/* Undo sysfs api init */
bcmtch_os_free_abi(&p_i2c_client->dev);
/* remove the os cli */
bcmtch_os_free_cli(&p_i2c_client->dev);
/* free input device */
bcmtch_free_input_device(bcmtch_data_ptr);
/* free used gpio pins */
bcmtch_free_gpio(bcmtch_data_ptr);
/* free this mem last */
bcmtch_dev_free(p_i2c_client);
return 0;
}
static int32_t __init bcmtch_i2c_init(void)
{
return i2c_add_driver(&bcmtch_i2c_driver);
}
late_initcall(bcmtch_i2c_init);
static void __exit bcmtch_i2c_exit(void)
{
i2c_del_driver(&bcmtch_i2c_driver);
}
module_exit(bcmtch_i2c_exit);
MODULE_DESCRIPTION("I2C support for BCMTCH15XXX Touchscreen");
MODULE_LICENSE("GPL");
MODULE_VERSION(BCMTCH_DRIVER_VERSION);