Google Git
Sign in
ara-mdk / kernel / panda / b68fdc6b826bdbc6573aa80b114debf659aeec60 / . / drivers / input / touchscreen / syntm12xx.c
blob: 32fd583c82e4ae3a20ee3d3c51971229b63fef58 [file] [log] [blame]
/*
* syntm12xx.c
* Synaptic TM12XX touchscreen driver
*
* Copyright (C) 2009 Nokia Corporation
* Author: Mika Kuoppala <mika.kuoppala@nokia.com>
*
* This program is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License version 2 as published by
* the Free Software Foundation.
*
* This program is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
* more details.
*
* You should have received a copy of the GNU General Public License along with
* this program. If not, see <http://www.gnu.org/licenses/>.
*/
#include <linux/module.h>
#include <linux/input.h>
#include <linux/platform_device.h>
#include <linux/i2c.h>
#include <linux/gpio.h>
#include <linux/delay.h>
#include <linux/interrupt.h>
#include <linux/firmware.h>
#include <linux/slab.h>
#ifdef CONFIG_HAS_EARLYSUSPEND
#include <linux/earlysuspend.h>
#endif
#include <plat/syntm12xx.h>
#define DRIVER_DESC "Synaptic TM12xx Touchscreen Driver"
#define DRIVER_NAME "tm12xx_ts"
/* Do validation of firmware image on device */
#define FIRMWARE_VERIFY
/* Number of touch points and input devices supported */
#define MAX_TOUCH_POINTS 6
#define REG_PDT_PROPERTIES 0xef
#define REG_PAGE_SELECT 0xff
#define FUNC_DEVICE_CONTROL 0x01
#define FUNC_BIST 0x08
#define FUNC_2D 0x11
#define FUNC_BUTTONS 0x19
#define FUNC_TIMER 0x32
#define FUNC_FLASH 0x34
#define FUNC_PROXIMITY 0x40
#define MAX_FUNC_DESCS 7
/* Device Control Functionality */
#define DEVICE_CONTROL_DATA_STATUS 0x00
#define DEVICE_CONTROL_DATA_INTR_STATUS 0x01
#define DEVICE_CONTROL_STATUS_SCODE_MASK 0x0f
#define STATUS_CODE_NO_ERROR 0x00
#define STATUS_CODE_RESET 0x01
#define STATUS_CODE_INVALID_CONF 0x02
#define STATUS_CODE_DEVICE_FAILURE 0x03
#define DEVICE_CONTROL_CTRL 0
#define DEVICE_CONTROL_CONFIGURED (1 << 7)
#define DEVICE_CONTROL_SLEEP_NORMAL 0x00
#define DEVICE_CONTROL_SLEEP_SENSOR 0x01
#define DEVICE_CONTROL_INTR_ENABLE 1
#define INTR_FLASH (1 << 0)
#define INTR_STATUS (1 << 1)
#define INTR_BIST (1 << 2)
#define INTR_2D (1 << 3)
#define INTR_BUTTON (1 << 4)
#define INTR_UADC (1 << 5)
#define INTR_ALL 0x3f
#define DEVICE_CONTROL_STATUS_FLASH_PROG (1 << 6)
#define DEVICE_CONTROL_STATUS_UNCONFIGURED (1 << 7)
#define DEVICE_CONTROL_COMMAND 0x00
#define DEVICE_COMMAND_RESET (1 << 0)
#define DEVICE_COMMAND_SHUTDOWN (1 << 1)
#define DEVICE_CONTROL_QUERY_MANID 0
#define DEVICE_CONTROL_QUERY_PROD_PROPERTIES 1
#define DEVICE_CONTROL_QUERY_PROD_FAMILY 2
#define DEVICE_CONTROL_QUERY_FW_VER 3
#define DEVICE_CONTROL_QUERY_PROD_ID 11
#define DEVICE_CONTROL_QUERY_PROD_ID_LAST 20
#define PRODUCT_ID_LEN (DEVICE_CONTROL_QUERY_PROD_ID_LAST - \
DEVICE_CONTROL_QUERY_PROD_ID + 1)
/* Capasitive Buttons */
#define MAX_BUTTONS 31
#define BUTTON_QUERY_QUERY0 0
#define BUTTON_QUERY_BUTTON_COUNT 1
#define BUTTON_QUERY_BUTTON_MASK 0x1f
#define BUTTON_CONFIGURABLE (1 << 0)
/* 2D Functionality */
#define TOUCH_QUERY_NUM_SENSORS 0 /* Zero based */
#define TOUCH_QUERY_LEN 6
#define TOUCH_CONTROL_REPORT_MODE 0
#define TOUCH_CONTROL_SENSOR_MAX_X 6
#define TOUCH_CONTROL_SENSOR_MAX_Y 8
#define TOUCH_CONTROL_SENSOR_MAPPING 10
/* This is for now fixed for 2 touch points */
#define TOUCH_DATA_LEN (1 + (MAX_TOUCH_POINTS * 5))
#define FINGER_STATE_NOT_PRESENT 0
#define FINGER_STATE_ACCURATE 1
#define FINGER_STATE_INACCURATE 2
#define FINGER_STATE_RESERVED 3
/* Flashing */
#define FLASH_MAX_SIZE (16*1024)
#define FW_MAX_NAME_SIZE 31
#define FLASH_QUERY_BOOTLOADER_ID_0 0
#define FLASH_QUERY_BOOTLOADER_ID_1 1
#define FLASH_QUERY_PROPERTIES 2
#define FLASH_QUERY_BLOCK_SIZE_0 3
#define FLASH_QUERY_BLOCK_SIZE_1 4
#define FLASH_QUERY_FW_BLOCK_COUNT_0 5
#define FLASH_QUERY_FW_BLOCK_COUNT_1 6
#define FLASH_QUERY_CONF_BLOCK_COUNT_0 7
#define FLASH_QUERY_CONF_BLOCK_COUNT_1 8
/* Flash Properties */
#define FLASH_PROPERTY_REGMAP_VERSION (1 << 0)
/* Commands for FLASH_DATA_COMMAND */
#define FLASH_CMD_IDLE 0x00
#define FLASH_CMD_FW_CRC_BLOCK 0x01
#define FLASH_CMD_FW_WRITE_BLOCK 0x02
#define FLASH_CMD_ERASE_ALL 0x03
#define FLASH_CMD_CONF_READ_BLOCK 0x05
#define FLASH_CMD_CONF_WRITE_BLOCK 0x06
#define FLASH_CMD_CONF_ERASE_BLOCK 0x07
#define FLASH_CMD_PROGRAM_ENABLE 0x0f
#define FLASH_ERROR_SUCCESS 0
#define FLASH_ERROR_RESERVED 1
#define FLASH_ERROR_NOT_ENABLED 2
#define FLASH_ERROR_INVALID_BLOCK 3
#define FLASH_ERROR_BLOCK_NOT_ERASED 4
#define FLASH_ERROR_ERASE_KEY 5
#define FLASH_ERROR_UNKNOWN 6
#define FLASH_ERROR_RESET 7
#define FLASH_ERROR_COUNT 8
#define DEVICE_STATUS_NO_ERROR 0
#define DEVICE_STATUS_RESET_OCCURRED 1
#define DEVICE_STATUS_INVALID_CONFIG 2
#define DEVICE_STATUS_DEVICE_FAILURE 3
#define DEVICE_STATUS_CFG_CRC_FAILURE 4
#define DEVICE_STATUS_FW_CRC_FAILURE 5
#define DEVICE_STATUS_CRC_IN_PROGRESS 6
#define DEVICE_STATUS_UNKNOWN 7
#define DEVICE_STATUS_COUNT 8
/* Selftest */
#define BIST_QUERY_LIMIT_REG_COUNT 0
#define BIST_DATA_TEST_NUMBER_CTRL 0
#define BIST_DATA_OVERALL_RESULT 1
#define BIST_DATA_TEST_RESULT 2
#define BIST_CONTROL_COMMAND 0
static const char *const device_status_str[DEVICE_STATUS_COUNT] = {
"no error",
"reset occurred",
"invalid configuration",
"device failure",
"configuration crc failure",
"firmware crc failure",
"crc in progress",
"unknown",
};
static const char *const flash_error_str[FLASH_ERROR_COUNT] = {
"success",
"reserved",
"programming not enabled",
"invalid block number",
"block not erased",
"erase key incorrect",
"unknown",
"device reset",
};
/* Offsets within firmware image */
#define FW_FILE_CHECKSUM 0x0000
#define FW_VERSION 0x0007
#define FW_FW_SIZE 0x0008
#define FW_CONFIG_SIZE 0x000C
#define FW_PRODUCT_ID 0x0010
#define FW_PRODUCT_INFO_0 0x001E
#define FW_PRODUCT_INFO_1 0x001F
#define FW_FW_DATA 0x0100
/* How many times we try to re-initialize chip in row */
#define MAX_FAILED_INITS 4
/* How much data we can put into single write block */
#define MAX_I2C_WRITE_BLOCK_SIZE 32
#define DFLAG_VERBOSE (1 << 0)
#define DFLAG_I2C_DUMP (1 << 1)
struct syn;
struct func_desc {
void (*intr_handler)(struct syn *sd, u8 bits);
u8 num;
u8 version;
u8 query;
u8 command;
u8 control;
u8 data;
u8 exists;
u8 intr_start_bit;
u8 intr_sources;
};
struct touch_sensor_caps {
unsigned is_configurable:1;
unsigned has_gestures:1;
unsigned has_abs_mode:1;
unsigned has_rel_mode:1;
unsigned finger_count:4;
unsigned x_electrodes:5;
unsigned y_electrodes:5;
unsigned max_electrodes:5;
unsigned abs_data_size:2;
/* XXX These are not yet in use
unsigned has_pinch:1;
unsigned has_press:1;
unsigned has_flick:1;
unsigned has_early_tap:1;
unsigned has_double_tap:1;
unsigned had_tap_and_hold:1;
unsigned has_single_tap:1;
unsigned has_anchored_finger:1;
unsigned has_palm_detect:1;
*/
u16 max_x;
u16 max_y;
};
struct button_caps {
u8 button_count;
};
struct flash_caps {
u16 bootloader_id;
u16 block_size;
u16 fw_block_count;
u16 conf_block_count;
u8 properties;
};
struct fw_image {
u32 file_checksum;
u8 version;
u8 product_id[PRODUCT_ID_LEN + 1];
u8 product_info_0;
u8 product_info_1;
const u8 *fw_data;
u32 fw_size;
const u8 *config_data;
u32 config_size;
u32 config_checksum;
};
struct touch_data {
u16 x;
u16 y;
u8 wx;
u8 wy;
u8 z;
u8 finger_state;
};
struct touch_point {
struct input_dev *idev;
struct touch_data cur_td;
struct touch_data prev_td;
int num;
};
struct bist_test_result {
u8 failed; /* == 0, if all passed */
u8 result; /* specific error for failed test */
};
struct syn {
struct mutex lock;
struct i2c_client *client;
struct workqueue_struct *wq;
struct work_struct isr_work;
#ifdef CONFIG_HAS_EARLYSUSPEND
struct early_suspend early_suspend;
#endif
struct func_desc *control;
u8 device_control_ctrl; /* saved state */
struct func_desc *touch;
struct touch_point tp[MAX_TOUCH_POINTS];
struct touch_sensor_caps touch_caps;
struct func_desc *buttons;
struct button_caps button_caps;
u32 button_state;
struct func_desc func_desc[MAX_FUNC_DESCS];
unsigned func_desc_num;
unsigned interrupt_sources;
struct func_desc *flash;
struct flash_caps flash_caps;
struct fw_image fw_image;
const struct firmware *fw_entry;
struct func_desc *bist;
struct func_desc *timer;
struct func_desc *prox;
int gpio_intr;
int func_descs_valid;
int failed_inits;
u32 debug_flag;
unsigned long ts_intr;
unsigned long ts_work;
unsigned long ts_done;
unsigned long t_wakeup_min;
unsigned long t_wakeup_max;
unsigned long t_wakeup_c;
unsigned long t_work_min;
unsigned long t_work_max;
unsigned long t_work_c;
unsigned long t_wakeup;
unsigned long t_work;
unsigned long t_count;
unsigned long f_measure;
int virtualized;
int suspend_mode;
};
#ifdef CONFIG_PM
#ifdef CONFIG_HAS_EARLYSUSPEND
static void syn_ts_early_suspend(struct early_suspend *handler);
static void syn_ts_late_resume(struct early_suspend *handler);
#endif
#endif
static int syn_initialize(struct syn *sd);
static int syn_reset_device(struct syn *sd);
static int syn_read_func_descs(struct syn *sd);
static int syn_write_block(struct syn *sd, int reg, const u8 *data, int len)
{
unsigned char wb[MAX_I2C_WRITE_BLOCK_SIZE + 1];
struct i2c_msg msg;
int r;
int i;
if (len < 1 ||
len > MAX_I2C_WRITE_BLOCK_SIZE) {
dev_info(&sd->client->dev, "too long syn_write_block len %d\n",
len);
return -EIO;
}
wb[0] = reg & 0xff;
for (i = 0; i < len; i++)
wb[i + 1] = data[i];
msg.addr = sd->client->addr;
msg.flags = 0;
msg.len = len + 1;
msg.buf = wb;
r = i2c_transfer(sd->client->adapter, &msg, 1);
if (sd->debug_flag & DFLAG_I2C_DUMP) {
if (r == 1) {
for (i = 0; i < len; i++)
dev_info(&sd->client->dev,
"bw 0x%02x[%d]: 0x%02x\n",
reg + i, i, data[i]);
}
}
if (r == 1)
return 0;
return r;
}
static int syn_read_block(struct syn *sd, int reg, u8 *data, int len)
{
unsigned char wb[1];
struct i2c_msg msg[2];
int r;
wb[0] = reg & 0xff;
msg[0].addr = sd->client->addr;
msg[0].flags = 0;
msg[0].len = 1;
msg[0].buf = wb;
msg[1].addr = msg[0].addr;
msg[1].flags = I2C_M_RD;
msg[1].len = len;
msg[1].buf = data;
r = i2c_transfer(sd->client->adapter, msg, 2);
if (sd->debug_flag & DFLAG_I2C_DUMP) {
if (r == 2) {
int i;
for (i = 0; i < len; i++)
dev_info(&sd->client->dev,
"br 0x%02x[%d]: 0x%02x\n",
reg + i, i, data[i]);
}
}
if (r == 2)
return len;
return r;
}
static int syn_read_u8(struct syn *sd, int reg)
{
unsigned char b[1] = {0};
int r;
r = syn_read_block(sd, reg, b, 1);
if (r == 1)
return (int)b[0];
return r;
}
static int syn_write_u8(struct syn *sd, u8 reg, u8 value)
{
return syn_write_block(sd, reg, &value, 1);
}
static int syn_read_u16(struct syn *sd, int reg)
{
int r;
u8 data[2] = {0};
r = syn_read_block(sd, reg, data, 2);
if (r < 0)
return r;
return (int)data[0] | ((int)(data[1]) << 8);
}
static int syn_write_u16(struct syn *sd, int reg, u16 value)
{
u8 data[2];
data[1] = (value & 0xFF00) >> 8;
data[0] = value & 0x00FF;
return syn_write_block(sd, reg, data, 2);
}
static int syn_control_query_read(struct syn *sd, int reg)
{
return syn_read_u8(sd, sd->control->query + reg);
}
static int syn_control_data_read(struct syn *sd, int reg)
{
return syn_read_u8(sd, sd->control->data + reg);
}
static const char *syn_device_status_str(u8 dev_status)
{
if (dev_status >= DEVICE_STATUS_COUNT)
return device_status_str[DEVICE_STATUS_UNKNOWN];
return device_status_str[dev_status];
}
static int syn_get_nosleep(struct syn *sd)
{
int r;
r = syn_read_u8(sd, sd->control->control + DEVICE_CONTROL_CTRL);
if (r < 0)
return r;
return (r & 0x04) >> 2;
}
static int syn_set_nosleep(struct syn *sd, int val)
{
int r;
r = syn_read_u8(sd, sd->control->control + DEVICE_CONTROL_CTRL);
if (r < 0)
return r;
val = (r & (~0x04)) | ((!!val) << 2);
r = syn_write_u8(sd, sd->control->control + DEVICE_CONTROL_CTRL,
val);
return r;
}
static int syn_get_proximity_state(struct syn *sd)
{
int r;
if (!sd->prox)
return -ENODEV;
r = syn_read_u8(sd, sd->prox->control);
if (r < 0)
return r;
return (r & (1 << 7)) == 0;
}
static int syn_set_proximity_state(struct syn *sd, int val)
{
int r;
if (!sd->prox)
return -ENODEV;
r = syn_read_u8(sd, sd->prox->control);
if (r < 0)
return r;
/* It is called 'inhibit proximity' in register */
val = (r & (~0x80)) | ((!val) << 7);
r = syn_write_u8(sd, sd->prox->control,
val);
if (r < 0)
return r;
return r;
}
static void syn_report_device_status(struct syn *sd, u8 dev_status)
{
struct device *dev = &sd->client->dev;
if (dev_status & (1 << 7))
dev_info(dev, "device is unconfigured\n");
if (dev_status & (1 << 6))
dev_info(dev, "device is in flashing mode\n");
dev_info(dev, "device status: 0x%x, %s\n", dev_status,
syn_device_status_str(dev_status & 0x0f));
}
static void syn_device_change_state(struct syn *sd, u8 dev_status)
{
int r;
/* Unconfigured or reset, we initialize*/
if ((dev_status & (1 << 7)) ||
(dev_status & 0x0f) == DEVICE_STATUS_RESET_OCCURRED) {
r = syn_initialize(sd);
if (r)
dev_err(&sd->client->dev,
"error %d in syn_initialize\n", r);
}
}
static void syn_recalculate_latency_data(struct syn *sd)
{
if (sd->ts_intr <= sd->ts_work && sd->ts_work < sd->ts_done) {
sd->t_wakeup = sd->ts_work - sd->ts_intr;
do_div(sd->t_wakeup, 1000);
sd->t_work = sd->ts_done - sd->ts_work;
do_div(sd->t_work, 1000);
if (sd->t_wakeup > sd->t_wakeup_max)
sd->t_wakeup_max = sd->t_wakeup;
if (sd->t_wakeup < sd->t_wakeup_min)
sd->t_wakeup_min = sd->t_wakeup;
if (sd->t_work > sd->t_work_max)
sd->t_work_max = sd->t_work;
if (sd->t_work < sd->t_work_min)
sd->t_work_min = sd->t_work;
if ((sd->t_work_c + sd->t_work) < sd->t_work_c ||
(sd->t_wakeup_c + sd->t_wakeup) < sd->t_wakeup_c) {
/* Wrap */
sd->t_work_c = sd->t_work;
sd->t_wakeup_c = sd->t_wakeup;
sd->t_count = 0;
} else {
sd->t_work_c += sd->t_work;
sd->t_wakeup_c += sd->t_wakeup;
sd->t_count++;
}
} else {
/* Time wrap or something else, discard */
}
}
static void syn_isr_device_control(struct syn *sd, u8 bits)
{
int dev_status;
dev_status = syn_control_data_read(sd, DEVICE_CONTROL_DATA_STATUS);
if (dev_status < 0) {
dev_err(&sd->client->dev, "error %d reading device status\n",
dev_status);
}
syn_report_device_status(sd, dev_status);
syn_device_change_state(sd, dev_status);
}
static void syn_isr_flash(struct syn *sd, u8 bits)
{
int dev_status;
dev_info(&sd->client->dev, "flash interrupt\n");
if (!sd->flash) {
dev_warn(&sd->client->dev,
"flash interrupt without registered functionality\n");
return;
}
dev_status = syn_control_data_read(sd, DEVICE_CONTROL_DATA_STATUS);
syn_report_device_status(sd, dev_status);
syn_device_change_state(sd, dev_status);
}
static void syn_isr_timer(struct syn *sd, u8 bits)
{
if (!sd->timer) {
dev_warn(&sd->client->dev,
"flash interrupt without registered functionality\n");
return;
}
}
static void syn_isr_bist(struct syn *sd, u8 bits)
{
if (!sd->bist) {
dev_warn(&sd->client->dev,
"bist interrupt without registered functionality\n");
return;
}
}
static void syn_isr_proximity(struct syn *sd, u8 bits)
{
unsigned char data[6] = {0};
struct input_dev *idev;
int r = 0;
idev = sd->tp[0].idev;
if (!sd->prox) {
dev_warn(&sd->client->dev,
"spurious proximity interrupty\n");
return;
}
r = syn_read_block(sd, sd->prox->data, data, 6);
if (r < 0) {
dev_warn(&sd->client->dev,
"error %d reading proximity data\n", r);
return;
}
if (data[0] & 0x01) {
input_report_abs(idev, ABS_RZ, data[1]);
input_report_abs(idev, ABS_HAT0X, data[2]); /* BH */
input_report_abs(idev, ABS_HAT0Y, data[4]); /* LH */
input_report_abs(idev, ABS_HAT1X, data[3]); /* TH */
input_report_abs(idev, ABS_HAT1Y, data[5]); /* RH */
} else
input_report_abs(idev, ABS_RZ, 0);
input_sync(idev);
}
static void syn_touch_parse_one_touch_data(struct syn *sd, struct touch_data *p,
u8 finger_state, const u8 *d)
{
p->finger_state = finger_state;
p->x = (u16)(d[2] & 0x0f) | (u16)(d[0] << 4);
p->y = ((u16)(d[2] & 0xf0) >> 4) | (u16)(d[1] << 4);
p->wx = d[3] & 0x0f;
p->wy = (d[3] & 0xf0) >> 4;
p->z = d[4];
}
static void syn_touch_parse_touch_data(struct syn *sd, const u8 *d)
{
struct tm12xx_ts_platform_data *pdata = sd->client->dev.platform_data;
unsigned i;
u8 fc;
u8 fs;
struct touch_data *p;
fc = sd->touch_caps.finger_count;
if (fc > MAX_TOUCH_POINTS)
dev_err(&sd->client->dev, "error in finger count %d\n", fc);
for (i = 0; i < fc; i++) {
p = &sd->tp[pdata->controller_num].cur_td;
fs = (d[(i >> 2)] >> ((i % 4) << 1)) & 0x03;
/* dev_warn(&sd->client->dev, "fs[%d] = %d\n", i, fs); */
syn_touch_parse_one_touch_data(sd, p, fs,
d + ((fc >> 2) + 1) +
i * 5);
}
}
static int syn_touch_get_data(struct syn *sd)
{
int r;
u8 data[TOUCH_DATA_LEN];
r = syn_read_block(sd, sd->touch->data, data, TOUCH_DATA_LEN);
if (r < 0)
return r;
if (r != TOUCH_DATA_LEN)
return -EIO;
syn_touch_parse_touch_data(sd, data);
return 0;
}
static void syn_touch_report_data(struct syn *sd, int dev_number)
{
struct tm12xx_ts_platform_data *pdata = sd->client->dev.platform_data;
struct input_dev *idev;
struct touch_data *d;
struct touch_data *p;
idev = sd->tp[dev_number].idev;
d = &sd->tp[dev_number].cur_td;
p = &sd->tp[dev_number].prev_td;
if (memcmp(p, d, sizeof(struct touch_data)) == 0)
return;
memcpy(p, d, sizeof(struct touch_data));
switch (d->finger_state) {
case FINGER_STATE_ACCURATE:
input_report_key(idev, BTN_TOUCH, 1);
input_report_key(idev, BTN_MODE, 0);
break;
case FINGER_STATE_INACCURATE:
input_report_key(idev, BTN_TOUCH, 1);
input_report_key(idev, BTN_MODE, 1);
break;
case FINGER_STATE_RESERVED:
/* Intentional fall thru */
case FINGER_STATE_NOT_PRESENT:
input_report_key(idev, BTN_MODE, 0);
input_report_key(idev, BTN_TOUCH, 0);
goto out;
default:
dev_err(&sd->client->dev, "unknown finger state 0x%x\n",
d->finger_state);
goto out;
}
if (sd->virtualized && pdata->swap_xy &&
dev_name(&sd->client->dev)[0] != '2')
d->x = sd->touch_caps.max_x + d->x;
if (pdata->swap_xy) {
input_report_abs(idev, ABS_X, d->y);
input_report_abs(idev, ABS_Y, d->x);
input_report_abs(idev, ABS_TOOL_WIDTH, d->wy);
} else {
input_report_abs(idev, ABS_X, d->x);
input_report_abs(idev, ABS_Y, d->y);
input_report_abs(idev, ABS_TOOL_WIDTH, d->wx);
}
input_report_abs(idev, ABS_Z, d->z);
input_report_abs(idev, ABS_VOLUME, d->wx * d->wy);
out:
input_sync(idev);
}
static void syn_isr_2d(struct syn *sd, u8 bits)
{
struct tm12xx_ts_platform_data *pdata = sd->client->dev.platform_data;
int r;
if (!sd->touch) {
dev_warn(&sd->client->dev,
"2d interrupt without registered functionality\n");
return;
}
r = syn_touch_get_data(sd);
if (r) {
dev_err(&sd->client->dev, "error getting touch data\n");
return;
}
if (sd->debug_flag & DFLAG_VERBOSE) {
dev_info(&sd->client->dev,
"%i: state=0x%x, x=%d, y=%d, z=%d, wx=%d, wy=%d\n",
pdata->controller_num,
sd->tp[pdata->controller_num].cur_td.finger_state,
sd->tp[pdata->controller_num].cur_td.x,
sd->tp[pdata->controller_num].cur_td.y,
sd->tp[pdata->controller_num].cur_td.z,
sd->tp[pdata->controller_num].cur_td.wx,
sd->tp[pdata->controller_num].cur_td.wy);
}
syn_touch_report_data(sd, pdata->controller_num);
}
static int syn_button_report(struct syn *sd, unsigned button_nr, const int val)
{
struct tm12xx_ts_platform_data *pdata = sd->client->dev.platform_data;
unsigned max_buttons;
max_buttons = pdata->num_buttons;
if (button_nr >= max_buttons)
return -EINVAL;
input_report_key(sd->tp[0].idev, pdata->button_map[button_nr], val);
input_sync(sd->tp[0].idev);
return 0;
}
static void syn_isr_buttons(struct syn *sd, u8 bits)
{
int data_reg_count = (sd->button_caps.button_count + 7) / 8;
int i = 0;
int r;
u32 state = 0;
u32 last_state;
if (!sd->buttons) {
dev_warn(&sd->client->dev,
"button interrupt without registered functionality\n");
return;
}
if (data_reg_count > MAX_BUTTONS/8 + 1)
data_reg_count = MAX_BUTTONS/8 + 1;
while (i < data_reg_count) {
r = syn_read_u8(sd, sd->buttons->data + i);
if (r < 0) {
dev_err(&sd->client->dev,
"error reading button state\n");
return;
}
state |= (u32)r << (i * 8);
i++;
}
last_state = sd->button_state;
for (i = 0; i < sd->button_caps.button_count; i++) {
const u32 mask = (1 << i);
if ((state & mask) ^ (last_state & mask)) {
r = syn_button_report(sd, i, state & mask ? 1 : 0);
if (r) {
dev_warn(&sd->client->dev,
"error reporting button "
"(no mapping for %d ?)\n", i);
}
}
}
sd->button_state = state;
}
static u8 syn_get_status_bits(u8 *int_status, int start, int bits)
{
const u16 mask = ((1 << bits) - 1) << start;
u8 val;
val = (*int_status & mask) >> start;
*int_status &= ~mask;
return val;
}
static void syn_isr_call_handlers(struct syn *sd, u8 int_status)
{
int i;
u8 bits;
for (i = 0; i < sd->func_desc_num; i++) {
struct func_desc * const f = &sd->func_desc[i];
if (!int_status)
return;
bits = syn_get_status_bits(&int_status, f->intr_start_bit,
f->intr_sources);
if (likely(bits)) {
if (likely(f->intr_handler))
f->intr_handler(sd, bits);
else {
if (printk_ratelimit())
dev_warn(&sd->client->dev,
"no intr handler for %d\n", i);
}
}
}
if (unlikely(int_status))
dev_warn(&sd->client->dev,
"unhandled attentions: 0x%x\n", int_status);
}
static void syn_clear_device_state(struct syn *sd)
{
int i;
sd->control = NULL;
sd->touch = NULL;
/*
* We don't clear previous exported devices.
* If after firmware upgrade there would be different
* amount of touchpoints rmmod/insmod cycle is needed.
*/
memset(&sd->touch_caps, 0, sizeof(struct touch_sensor_caps));
sd->buttons = NULL;
memset(&sd->button_caps, 0, sizeof(struct button_caps));
sd->button_state = 0;
for (i = 0; i < MAX_FUNC_DESCS; i++)
memset(&sd->func_desc[i], 0, sizeof(struct func_desc));
sd->func_desc_num = 0;
sd->interrupt_sources = 0;
sd->flash = NULL;
memset(&sd->flash_caps, 0, sizeof(struct flash_caps));
memset(&sd->fw_image, 0, sizeof(struct fw_image));
sd->bist = NULL;
}
static void syn_isr_work(struct work_struct *work)
{
int is;
int r;
struct syn *sd = container_of(work, struct syn, isr_work);
mutex_lock(&sd->lock);
if (sd->f_measure) {
sd->ts_work = cpu_clock(get_cpu());
put_cpu();
}
if (sd->func_descs_valid == 0) {
if (sd->failed_inits < MAX_FAILED_INITS) {
r = syn_initialize(sd);
if (r) {
dev_err(&sd->client->dev,
"error initializing\n");
goto out;
}
}
}
is = syn_control_data_read(sd, DEVICE_CONTROL_DATA_INTR_STATUS);
if (unlikely(is < 0)) {
dev_err(&sd->client->dev,
"unable to read intr status\n");
syn_reset_device(sd);
goto out;
}
if (likely(is))
syn_isr_call_handlers(sd, is);
out:
if (sd->f_measure) {
sd->ts_done = cpu_clock(get_cpu());
put_cpu();
syn_recalculate_latency_data(sd);
sd->f_measure = 0;
}
enable_irq(gpio_to_irq(sd->gpio_intr));
mutex_unlock(&sd->lock);
}
static irqreturn_t syn_isr(int irq, void *data)
{
struct syn *sd = data;
if (sd->wq != NULL) {
int r;
r = queue_work(sd->wq, &sd->isr_work);
if (r) {
if (sd->f_measure == 0) {
sd->ts_intr = cpu_clock(get_cpu());
put_cpu();
sd->f_measure = 1;
}
disable_irq_nosync(gpio_to_irq(sd->gpio_intr));
}
}
return IRQ_HANDLED;
}
static int syn_set_input_dev_params(struct syn *sd, int dev_number)
{
struct input_dev *dev;
struct tm12xx_ts_platform_data *pdata;
int i;
if (!sd || dev_number < 0 || dev_number >= MAX_TOUCH_POINTS)
return -EINVAL;
dev = sd->tp[dev_number].idev;
if (!dev)
return -ENODEV;
pdata = sd->client->dev.platform_data;
set_bit(EV_KEY, dev->evbit);
set_bit(EV_ABS, dev->evbit);
set_bit(BTN_TOUCH, dev->keybit);
set_bit(BTN_MODE, dev->keybit);
set_bit(ABS_X, dev->absbit);
set_bit(ABS_Y, dev->absbit);
set_bit(ABS_Z, dev->absbit);
set_bit(ABS_VOLUME, dev->absbit);
set_bit(ABS_TOOL_WIDTH, dev->absbit);
if (dev_number == 0) {
set_bit(ABS_RZ, dev->absbit);
set_bit(ABS_HAT0X, dev->absbit);
set_bit(ABS_HAT0Y, dev->absbit);
set_bit(ABS_HAT1X, dev->absbit);
set_bit(ABS_HAT1Y, dev->absbit);
}
if (pdata->repeat)
set_bit(EV_REP, dev->evbit);
for (i = 0; i < pdata->num_buttons; i++)
set_bit(pdata->button_map[i], dev->keybit);
if (pdata->swap_xy) {
input_set_abs_params(dev, ABS_X, 0, sd->touch_caps.max_y, 0, 0);
input_set_abs_params(dev, ABS_Y, 0, sd->touch_caps.max_x, 0, 0);
} else {
input_set_abs_params(dev, ABS_X, 0, sd->touch_caps.max_x, 0, 0);
input_set_abs_params(dev, ABS_Y, 0, sd->touch_caps.max_y, 0, 0);
}
input_set_abs_params(dev, ABS_Z, 0, 255, 0, 0);
input_set_abs_params(dev, ABS_VOLUME, 0, 225, 0, 0);
input_set_abs_params(dev, ABS_TOOL_WIDTH, 0, 15, 0, 0);
if (dev_number == 0) {
input_set_abs_params(dev, ABS_RZ, 0, 255, 0, 0);
input_set_abs_params(dev, ABS_HAT0X, 0, 255, 0, 0);
input_set_abs_params(dev, ABS_HAT0Y, 0, 255, 0, 0);
input_set_abs_params(dev, ABS_HAT1X, 0, 255, 0, 0);
input_set_abs_params(dev, ABS_HAT1Y, 0, 255, 0, 0);
}
dev->dev.parent = &sd->client->dev;
return 0;
}
static int syn_register_input_devices(struct syn *sd, int num_devices)
{
struct tm12xx_ts_platform_data *pdata;
int r;
if (!sd || num_devices < 0 || num_devices > MAX_TOUCH_POINTS)
return -EINVAL;
pdata = sd->client->dev.platform_data;
/* After firmware upgrade no need to reregister */
if (sd->tp[0].idev != NULL) {
if (sd->debug_flag & DFLAG_VERBOSE)
dev_info(&sd->client->dev,
"input device already existing\n");
return 0;
}
sd->tp[pdata->controller_num].idev = input_allocate_device();
if (!sd->tp[pdata->controller_num].idev) {
dev_err(&sd->client->dev,
"not enough memory for input device %d\n",
pdata->controller_num);
r = -ENOMEM;
goto err_alloc;
}
r = syn_set_input_dev_params(sd, pdata->controller_num);
if (r) {
dev_err(&sd->client->dev,
"%s: Setting input params for controller \
number %i failed.\n",
__func__, pdata->controller_num);
goto err_alloc;
}
if (pdata->idev_name[pdata->controller_num])
sd->tp[pdata->controller_num].idev->name =
pdata->idev_name[pdata->controller_num];
else {
dev_err(&sd->client->dev,
"%s: No input device name for controller \
number %i.\n", __func__, pdata->controller_num);
goto err_alloc;
}
r = input_register_device(sd->tp[pdata->controller_num].idev);
if (r) {
dev_err(&sd->client->dev,
"failed to register input device %d\n",
pdata->controller_num);
goto err_register;
}
return 0;
err_register:
input_unregister_device(sd->tp[pdata->controller_num].idev);
err_alloc:
if (sd->tp[pdata->controller_num].idev) {
input_free_device(sd->tp[pdata->controller_num].idev);
sd->tp[pdata->controller_num].idev = NULL;
}
return r;
}
static struct func_desc *syn_get_func_desc(struct syn *sd, int func)
{
int i;
for (i = 0; i < sd->func_desc_num; i++) {
struct func_desc * const f = &sd->func_desc[i];
if (f->num == func)
return f;
}
return NULL;
}
static int syn_register_intr_handler(struct syn *sd, int func,
void (*h)(struct syn *sd, u8 bits))
{
struct func_desc * const f = syn_get_func_desc(sd, func);
if (!f)
return -EINVAL;
if (f->intr_handler == NULL) {
f->intr_handler = h;
return 0;
}
return -EINVAL;
}
/*
* Flashing support
*/
static int syn_flash_query_caps(struct syn *sd)
{
int r;
r = syn_read_u16(sd, sd->flash->query + FLASH_QUERY_BOOTLOADER_ID_0);
if (r < 0)
return r;
sd->flash_caps.bootloader_id = r;
r = syn_read_u8(sd, sd->flash->query + FLASH_QUERY_PROPERTIES);
if (r < 0)
return r;
sd->flash_caps.properties = r;
r = syn_read_u16(sd, sd->flash->query + FLASH_QUERY_BLOCK_SIZE_0);
if (r < 0)
return r;
sd->flash_caps.block_size = r;
r = syn_read_u16(sd, sd->flash->query + FLASH_QUERY_FW_BLOCK_COUNT_0);
if (r < 0)
return r;
sd->flash_caps.fw_block_count = r;
r = syn_read_u16(sd, sd->flash->query + FLASH_QUERY_CONF_BLOCK_COUNT_0);
if (r < 0)
return r;
sd->flash_caps.conf_block_count = r;
return 0;
}
static u32 syn_crc_fletcher32(const u16 *data, unsigned int len)
{
u32 sum1 = 0xffff;
u32 sum2 = 0xffff;
while (len--) {
sum1 += *data++;
sum2 += sum1;
sum1 = (sum1 & 0xffff) + (sum1 >> 16);
sum2 = (sum2 & 0xffff) + (sum2 >> 16);
}
return sum1 | (sum2 << 16);
}
static int syn_fw_read_bytes(struct syn *sd, u8 *b, int offset, int len)
{
if (offset + len > sd->fw_entry->size) {
dev_err(&sd->client->dev,
"fw_read_bytes overflow on offset %d\n", offset);
return -EINVAL;
}
memcpy(b, sd->fw_entry->data + offset, len);
return len;
}
static int syn_fw_read_u32(struct syn *sd, u32 *d, int offset)
{
const u8 *l;
if (offset + 4 > sd->fw_entry->size) {
dev_err(&sd->client->dev,
"fw_read_u32 overflow on offset %d\n", offset);
return -EINVAL;
}
l = sd->fw_entry->data + offset;
*d = l[0] | (l[1] << 8) | (l[2] << 16) | (l[3] << 24);
return 4;
}
static int syn_request_firmware(struct syn *sd, const char *filename)
{
int r;
r = request_firmware(&sd->fw_entry, filename, &sd->client->dev);
return r;
}
static int syn_check_firmware(struct syn *sd)
{
u32 calc_file_crc;
u32 calc_config_crc;
struct fw_image *d = &sd->fw_image;
int r;
/*
* Restrict sizes.
* Absolute minimum is zero sized fw data and config
* areas.
*/
if (sd->fw_entry->size > FLASH_MAX_SIZE ||
sd->fw_entry->size < FW_FW_DATA + 4) {
dev_err(&sd->client->dev, "illegal firmware size\n");
return -EINVAL;
}
r = syn_fw_read_u32(sd, &d->file_checksum, FW_FILE_CHECKSUM);
if (r < 0)
return r;
r = syn_fw_read_bytes(sd, &d->version, FW_VERSION, 1);
if (r < 0)
return r;
r = syn_fw_read_u32(sd, &d->fw_size, FW_FW_SIZE);
if (r < 0)
return r;
r = syn_fw_read_u32(sd, &d->config_size, FW_CONFIG_SIZE);
if (r < 0)
return r;
if ((d->fw_size + d->config_size + FW_FW_DATA) > sd->fw_entry->size) {
dev_err(&sd->client->dev, "fw size mismatch\n");
return -EINVAL;
}
/* These have to be u32 aligned */
if ((d->fw_size & 0x0f) || (d->config_size & 0x0f)) {
dev_err(&sd->client->dev, "fw areas not aligned to 4 bytes\n");
return -EINVAL;
}
r = syn_fw_read_bytes(sd, d->product_id, FW_PRODUCT_ID,
PRODUCT_ID_LEN);
if (r < 10)
return r;
r = syn_fw_read_bytes(sd, &d->product_info_0,
FW_PRODUCT_INFO_0, 1);
if (r < 0)
return r;
r = syn_fw_read_bytes(sd, &d->product_info_1,
FW_PRODUCT_INFO_1, 1);
if (r < 0)
return r;
r = syn_fw_read_u32(sd, &d->config_checksum,
d->fw_size + FW_FW_DATA + d->config_size - 4);
if (r < 0)
return r;
d->fw_data = sd->fw_entry->data + FW_FW_DATA;
d->config_data = sd->fw_entry->data + FW_FW_DATA + d->fw_size;
calc_file_crc = syn_crc_fletcher32((u16 *)(sd->fw_entry->data + 4),
(sd->fw_entry->size - 4) >> 1);
calc_config_crc = syn_crc_fletcher32((u16 *)(d->config_data),
(d->config_size - 4) >> 1);
if (calc_file_crc != d->file_checksum) {
dev_err(&sd->client->dev, "fw file crc failed\n");
return -EINVAL;
}
if (calc_config_crc != d->config_checksum) {
dev_err(&sd->client->dev, "fw config area crc failed\n");
return -EINVAL;
}
return 0;
}
static const char *syn_flash_error_str(u8 flash_error)
{
if (flash_error >= FLASH_ERROR_COUNT)
return flash_error_str[FLASH_ERROR_UNKNOWN];
return flash_error_str[flash_error];
}
static u8 syn_flash_error(int flash_status)
{
return ((u8)(flash_status) >> 4) & 0x07;
}
/*
* There are two different ways the flash register are organized
*/
static u8 syn_flash_data_command_offset(struct syn *sd)
{
if (sd->flash_caps.properties & FLASH_PROPERTY_REGMAP_VERSION)
return 2 + sd->flash_caps.block_size;
else
return 0;
}
static u8 syn_flash_block_data_offset(struct syn *sd)
{
if (sd->flash_caps.properties & FLASH_PROPERTY_REGMAP_VERSION)
return 2;
else
return 3;
}
static u8 syn_flash_block_num_offset(struct syn *sd)
{
if (sd->flash_caps.properties & FLASH_PROPERTY_REGMAP_VERSION)
return 0;
else
return 1;
}
static int syn_flash_status(struct syn *sd)
{
return syn_read_u8(sd, sd->flash->data +
syn_flash_data_command_offset(sd));
}
static int syn_wait_for_attn(struct syn *sd, unsigned long timeout_usecs,
int state)
{
const unsigned long one_wait = 20;
unsigned long waited = 0;
int r;
do {
r = gpio_get_value(sd->gpio_intr);
if (r == state)
break;
udelay(one_wait);
waited += one_wait;
} while (waited < timeout_usecs);
if (waited > 500000 ||
waited >= timeout_usecs ||
(sd->debug_flag & DFLAG_VERBOSE))
dev_info(&sd->client->dev, "waited %lu usecs for attn\n",
waited);
return r == state ? 0 : -1;
}
static int syn_flash_command(struct syn *sd, u8 flash_command)
{
int r;
int s;
if (flash_command & 0xf0)
return -EINVAL;
r = syn_wait_for_attn(sd, 200 * 1000, 1);
if (r) {
dev_err(&sd->client->dev,
"timeout: attn didn't clear for 200 ms\n");
return r;
}
r = syn_write_u8(sd,
sd->flash->data + syn_flash_data_command_offset(sd),
flash_command);
if (r) {
dev_err(&sd->client->dev, "flash command error %d\n", r);
return r;
}
r = syn_wait_for_attn(sd, 700 * 1000, 0);
if (r) {
dev_err(&sd->client->dev,
"timeout attn didn't assert for 700 ms\n");
}
s = syn_control_data_read(sd, DEVICE_CONTROL_DATA_INTR_STATUS);
if (s < 0)
dev_err(&sd->client->dev, "error reading int status\n");
if (sd->debug_flag & DFLAG_VERBOSE) {
if (s != 0x01)
dev_info(&sd->client->dev,
"wait for attn intr status 0x%x\n", s);
}
return r == 0 ? 0 : -1;
}
static int syn_flash_enable(struct syn *sd)
{
int r;
r = syn_control_data_read(sd, DEVICE_CONTROL_DATA_STATUS);
if (r < 0)
return r;
if (r & (1 << 6)) {
dev_err(&sd->client->dev, "flashing mode already enabled\n");
return 0;
}
r = syn_write_u16(sd, sd->flash->data + syn_flash_block_data_offset(sd),
sd->flash_caps.bootloader_id);
if (r < 0)
return r;
r = syn_flash_command(sd, FLASH_CMD_PROGRAM_ENABLE);
if (r < 0)
return r;
r = syn_read_func_descs(sd);
if (r < 0)
return r;
r = syn_flash_status(sd);
if (r < 0) {
dev_info(&sd->client->dev, "flash error in enable %s\n",
syn_flash_error_str(syn_flash_error(r)));
return r;
}
if (syn_flash_error(r) != FLASH_ERROR_SUCCESS &&
syn_flash_error(r) != FLASH_ERROR_RESET) {
dev_err(&sd->client->dev, "flash error: %s\n",
syn_flash_error_str(syn_flash_error(r)));
return -EINVAL;
}
if (!(r & 0x80)) {
dev_err(&sd->client->dev, "flashing not enabled 0x%02x\n", r);
return -EINVAL;
}
return r;
}
static int syn_flash_write_block_cmd_old(struct syn *sd, const u8 *data,
int blocks, u8 flash_command)
{
int block;
int r;
const u8 block_num_offset = syn_flash_block_num_offset(sd);
const u8 block_data_offset = syn_flash_block_data_offset(sd);
for (block = 0; block < blocks; block++) {
if (!(block % 10))
dev_info(&sd->client->dev, "0x%x writing block %d\n",
flash_command, block);
r = syn_write_u16(sd, sd->flash->data + block_num_offset,
block);
if (r < 0)
return r;
r = syn_write_block(sd, sd->flash->data + block_data_offset,
data + (block * sd->flash_caps.block_size),
sd->flash_caps.block_size);
if (r < 0)
return r;
r = syn_flash_command(sd, flash_command);
if (r < 0)
return r;
r = syn_flash_status(sd);
if (r < 0)
return r;
if (r != 0x80) {
dev_err(&sd->client->dev,
"flash_write error : %s\n",
syn_flash_error_str(syn_flash_error(r)));
return syn_flash_error(r);
}
}
return 0;
}
static int syn_flash_write_block_cmd_fast(struct syn *sd, const u8 *data,
int blocks, u8 flash_command)
{
const u16 block_size = sd->flash_caps.block_size;
u8 *d;
u16 block;
int r = 0;
d = kmalloc(block_size + 3, GFP_KERNEL);
if (d == NULL)
return -ENOMEM;
for (block = 0; block < blocks; block++) {
if (!(block % 10))
dev_info(&sd->client->dev,
"0x%x fast writing block %d\n",
flash_command, block);
d[0] = block & 0xff;
d[1] = (block & 0xff00) >> 8;
memcpy(&d[2], data + (block * block_size), block_size);
d[2 + block_size] = flash_command;
r = syn_wait_for_attn(sd, 200 * 1000, 1);
if (r) {
dev_err(&sd->client->dev,
"timeout: attn didn't clear for 200 ms\n");
goto out;
}
r = syn_write_block(sd, sd->flash->data,
d, block_size + 3);
r = syn_wait_for_attn(sd, 700 * 1000, 0);
if (r) {
dev_err(&sd->client->dev,
"timeout attn didn't assert for 700 ms\n");
goto out;
}
/* We need to do this read to release ATTN */
syn_control_data_read(sd, DEVICE_CONTROL_DATA_INTR_STATUS);
}
out:
kfree(d);
return r;
}
static int syn_flash_write_block_cmd(struct syn *sd, const u8 *data,
int blocks, u8 flash_command)
{
if (sd->flash_caps.properties & FLASH_PROPERTY_REGMAP_VERSION)
return syn_flash_write_block_cmd_fast(sd, data,
blocks, flash_command);
else
return syn_flash_write_block_cmd_old(sd, data,
blocks, flash_command);
}
static int syn_flash_read_config(struct syn *sd, u8 *d)
{
const u8 flash_command = FLASH_CMD_CONF_READ_BLOCK;
const u8 block_num_offset = syn_flash_block_num_offset(sd);
const u8 block_data_offset = syn_flash_block_data_offset(sd);
const int blocks = sd->fw_image.config_size / sd->flash_caps.block_size;
int i;
int r;
for (i = 0; i < blocks; i++) {
if (!(i % 10))
dev_info(&sd->client->dev,
"0x%x reading conf block %d\n",
flash_command, i);
r = syn_write_u16(sd, sd->flash->data + block_num_offset, i);
if (r < 0)
return r;
r = syn_flash_command(sd, flash_command);
if (r < 0)
return r;
r = syn_flash_status(sd);
if (r < 0)
return r;
if (r != 0x80) {
dev_err(&sd->client->dev,
"flash_read error : %s\n",
syn_flash_error_str(syn_flash_error(r)));
return syn_flash_error(r);
}
r = syn_read_block(sd, sd->flash->data + block_data_offset, d,
sd->flash_caps.block_size);
if (r < 0)
return r;
d += sd->flash_caps.block_size;
}
return 0;
}
static int syn_flash_write_config(struct syn *sd)
{
int r;
const int config_size = sd->fw_image.config_size;
const int blocks = config_size / sd->flash_caps.block_size;
r = syn_flash_write_block_cmd(sd, sd->fw_image.config_data, blocks,
FLASH_CMD_CONF_WRITE_BLOCK);
if (r < 0)
return r;
if (r) {
dev_err(&sd->client->dev,
"flash write fw error : %s\n",
syn_flash_error_str(r));
return -EIO;
}
return 0;
}
#ifdef FIRMWARE_VERIFY
static int syn_flash_validate(struct syn *sd)
{
int r;
const int fw_size = sd->fw_image.fw_size;
const int blocks = fw_size / sd->flash_caps.block_size;
if (sd->flash_caps.fw_block_count !=
(fw_size / sd->flash_caps.block_size) ||
(fw_size % sd->flash_caps.block_size)) {
dev_err(&sd->client->dev,
"fw size not aligned to block count\n");
return -EINVAL;
}
r = syn_flash_write_block_cmd(sd, sd->fw_image.fw_data, blocks,
FLASH_CMD_FW_CRC_BLOCK);
if (r < 0)
return r;
if (r) {
dev_err(&sd->client->dev,
"flash validate error : %s\n",
syn_flash_error_str(r));
return -EIO;
}
r = syn_read_u8(sd, sd->flash->data + syn_flash_block_data_offset(sd));
if (r < 0)
return r;
if (r == 0x00) {
dev_info(&sd->client->dev, "flash_validate: image is valid\n");
return 0;
} else if (r == 0xff)
dev_info(&sd->client->dev,
"flash_validate: image is invalid\n");
else
dev_info(&sd->client->dev,
"flash_validate: image status unknown: 0x%02x\n", r);
return -1;
}
static int syn_flash_compare_config(struct syn *sd)
{
u32 cfg_crc_c;
u32 cfg_crc;
u32 cfg_crc_r;
u8 *cfg_data_r;
int r;
cfg_data_r = kmalloc(sd->fw_image.config_size, GFP_KERNEL);
if (cfg_data_r == NULL)
return -ENOMEM;
r = syn_flash_read_config(sd, cfg_data_r);
if (r < 0) {
kfree(cfg_data_r);
return r;
}
dev_info(&sd->client->dev, "Flash read config done\n");
cfg_crc = sd->fw_image.config_checksum;
cfg_crc_c = syn_crc_fletcher32((u16 *)(sd->fw_image.config_data),
(sd->fw_image.config_size - 4) >> 1);
cfg_crc_r = syn_crc_fletcher32((u16 *)(cfg_data_r),
(sd->fw_image.config_size - 4) >> 1);
kfree(cfg_data_r);
cfg_data_r = NULL;
dev_info(&sd->client->dev, "calculated fw image crc 0x%x\n", cfg_crc_c);
dev_info(&sd->client->dev, "read fw image crc 0x%x\n", cfg_crc);
dev_info(&sd->client->dev, "calculated cfg read crc 0x%x\n", cfg_crc_r);
if (cfg_crc != cfg_crc_c) {
dev_err(&sd->client->dev,
"fw crc differs from calculated\n");
return -EINVAL;
}
if (cfg_crc != cfg_crc_r) {
dev_err(&sd->client->dev,
"fw crc differs from read from device\n");
return -EINVAL;
}
if (cfg_crc_c != cfg_crc_r) {
dev_err(&sd->client->dev,
"fw calculated crc differs from read from device\n");
return -EINVAL;
}
return 0;
}
#else /* FIRMWARE_VERIFY */
static int syn_flash_compare_config(struct syn *sd)
{
return 0;
}
static int syn_flash_validate(struct syn *sd)
{
return 0;
}
#endif
static int syn_flash_erase_all(struct syn *sd)
{
int r;
r = syn_write_u16(sd, sd->flash->data + syn_flash_block_data_offset(sd),
sd->flash_caps.bootloader_id);
r = syn_flash_command(sd, FLASH_CMD_ERASE_ALL);
if (r < 0)
return r;
r = syn_flash_status(sd);
if (r < 0)
return r;
if (r != 0x80) {
dev_err(&sd->client->dev,
"flash erase_all error : %d %s\n", syn_flash_error(r),
syn_flash_error_str(syn_flash_error(r)));
return -EIO;
}
return 0;
}
static int syn_flash_write_fw(struct syn *sd)
{
int r;
const int fw_size = sd->fw_image.fw_size;
const int blocks = fw_size / sd->flash_caps.block_size;
r = syn_flash_write_block_cmd(sd, sd->fw_image.fw_data, blocks,
FLASH_CMD_FW_WRITE_BLOCK);
if (r < 0)
return r;
r = syn_flash_status(sd);
if (r < 0)
return r;
if (r != 0x80) {
dev_err(&sd->client->dev,
"flash write fw : %d %s\n", syn_flash_error(r),
syn_flash_error_str(syn_flash_error(r)));
return -EIO;
}
return 0;
}
static int syn_flash_firmware(struct syn *sd)
{
int r;
int flash_status;
/* Restrict interrupts during flashing */
r = syn_write_u8(sd, sd->control->control + DEVICE_CONTROL_INTR_ENABLE,
INTR_FLASH | INTR_STATUS);
r = syn_flash_enable(sd);
if (r < 0)
goto flash_out;
r = syn_flash_validate(sd);
if (r < 0)
goto flash_out;
r = syn_flash_erase_all(sd);
if (r < 0)
goto flash_out;
r = syn_flash_write_fw(sd);
if (r < 0)
goto flash_out;
r = syn_flash_write_config(sd);
if (r < 0)
goto flash_out;
r = syn_flash_compare_config(sd);
if (r < 0)
goto flash_out;
flash_out:
flash_status = syn_flash_status(sd);
dev_info(&sd->client->dev,
"flash status: %x %s\n", flash_status,
syn_flash_error_str(syn_flash_error(flash_status)));
/*
* We reset and interrupt handler should notice that
* everything has changed and reread the page descriptor table.
*/
syn_reset_device(sd);
return syn_flash_error(flash_status) == FLASH_ERROR_SUCCESS ? 0 : -1;
}
static ssize_t syn_show_attr_flash(struct device *dev,
struct device_attribute *attr,
char *buf)
{
struct platform_device *pdev = to_platform_device(dev);
struct syn *sd = platform_get_drvdata(pdev);
const ssize_t size = PAGE_SIZE;
ssize_t l = 0;
int r;
if (!sd->flash) {
l += snprintf(buf + l, size - l, "N/A\n");
return l;
}
mutex_lock(&sd->lock);
r = syn_control_data_read(sd, DEVICE_CONTROL_DATA_STATUS);
mutex_unlock(&sd->lock);
if (r < 0)
dev_err(&sd->client->dev, "read error %d\n", r);
else
l += snprintf(buf + l, size - l, "%d\n",
(r & (1 << 6)) ? 1 : 0);
return l;
}
static ssize_t syn_store_attr_flash(struct device *dev,
struct device_attribute *attr,
const char *buf, size_t count)
{
const struct platform_device *pdev = to_platform_device(dev);
struct syn *sd = platform_get_drvdata(pdev);
int r;
char name[FW_MAX_NAME_SIZE + 1];
if (count > FW_MAX_NAME_SIZE || count == 0) {
dev_err(&sd->client->dev, "firmware name check failure\n");
return 0;
}
memcpy(name, buf, count);
name[count] = 0;
mutex_lock(&sd->lock);
if (name[count - 1] == '\n')
name[count - 1] = 0;
if (sd->fw_entry) {
dev_err(&sd->client->dev, "firmware already in memory\n");
goto firmware_out;
}
r = syn_request_firmware(sd, name);
if (r < 0) {
dev_err(&sd->client->dev, "firmware not found\n");
goto store_out;
}
memset(&sd->fw_image, 0, sizeof(struct fw_image));
r = syn_check_firmware(sd);
if (r != 0) {
dev_err(&sd->client->dev,
"consistency check of firmware failed\n");
goto firmware_out;
}
dev_info(&sd->client->dev, "firmware consistency check ok\n");
r = syn_flash_firmware(sd);
if (r != 0) {
dev_err(&sd->client->dev,
"flashing of firmware failed\n");
goto firmware_out;
}
dev_info(&sd->client->dev, "flashing done with success\n");
firmware_out:
memset(&sd->fw_image, 0, sizeof(struct fw_image));
release_firmware(sd->fw_entry);
sd->fw_entry = NULL;
store_out:
mutex_unlock(&sd->lock);
return count;
}
static ssize_t syn_show_attr_product_id(struct device *dev,
struct device_attribute *attr,
char *buf)
{
struct platform_device *pdev = to_platform_device(dev);
struct syn *sd = platform_get_drvdata(pdev);
const ssize_t size = PAGE_SIZE;
u8 product_id[PRODUCT_ID_LEN + 1];
ssize_t l = 0;
int r;
if (!sd->flash) {
l += snprintf(buf + l, size - l, "N/A\n");
return l;
}
mutex_lock(&sd->lock);
r = syn_read_block(sd, sd->control->query +
DEVICE_CONTROL_QUERY_PROD_ID,
product_id, PRODUCT_ID_LEN);
mutex_unlock(&sd->lock);
product_id[PRODUCT_ID_LEN] = 0;
if (r < 0)
dev_warn(&sd->client->dev,
"error %d reading product id\n", r);
else
l += snprintf(buf + l, size - l, "%s\n",
product_id);
return l;
}
static ssize_t syn_show_attr_product_family(struct device *dev,
struct device_attribute *attr,
char *buf)
{
struct platform_device *pdev = to_platform_device(dev);
struct syn *sd = platform_get_drvdata(pdev);
const ssize_t size = PAGE_SIZE;
ssize_t l = 0;
int r;
if (!sd->flash) {
l += snprintf(buf + l, size - l, "N/A\n");
return l;
}
mutex_lock(&sd->lock);
r = syn_control_query_read(sd,
DEVICE_CONTROL_QUERY_PROD_FAMILY);
mutex_unlock(&sd->lock);
if (r < 0)
dev_warn(&sd->client->dev,
"error %d reading product family\n", r);
else
l += snprintf(buf + l, size - l, "%d\n",
r);
return l;
}
static ssize_t syn_show_attr_firmware_version(struct device *dev,
struct device_attribute *attr,
char *buf)
{
struct platform_device *pdev = to_platform_device(dev);
struct syn *sd = platform_get_drvdata(pdev);
const ssize_t size = PAGE_SIZE;
ssize_t l = 0;
int r;
if (!sd->flash) {
l += snprintf(buf + l, size - l, "N/A\n");
return l;
}
mutex_lock(&sd->lock);
r = syn_control_query_read(sd,
DEVICE_CONTROL_QUERY_FW_VER);
mutex_unlock(&sd->lock);
if (r < 0)
dev_warn(&sd->client->dev,
"error %d reading fw version\n", r);
else
l += snprintf(buf + l, size - l, "%d\n",
r);
return l;
}
/*
* BIST (selftest) support
*/
static int syn_bist_run_test(struct syn *sd, struct bist_test_result *tr,
u8 test)
{
int r;
u8 intr_mask = INTR_ALL;
if (!sd || !tr || !sd->bist)
return -EINVAL;
mutex_lock(&sd->lock);
r = syn_read_u8(sd, sd->control->control +
DEVICE_CONTROL_INTR_ENABLE);
if (r < 0)
goto out;
intr_mask = r & 0xFF;
/* Restrict interrupt sources*/
r = syn_write_u8(sd, sd->control->control + DEVICE_CONTROL_INTR_ENABLE,
INTR_BIST | INTR_STATUS);
r = syn_write_u8(sd, sd->bist->data + BIST_DATA_TEST_NUMBER_CTRL,
test);
if (r < 0)
goto out;
r = syn_write_u8(sd, sd->bist->command + BIST_CONTROL_COMMAND,
0x01);
if (r < 0)
goto out;
r = syn_wait_for_attn(sd, 5 * 1000 * 1000, 0);
if (r < 0) {
dev_err(&sd->client->dev, "timeout running bist test\n");
goto out;
}
r = syn_control_data_read(sd, DEVICE_CONTROL_DATA_INTR_STATUS);
if (r < 0)
dev_err(&sd->client->dev, "error reading int status\n");
r = syn_read_u8(sd, sd->bist->command + BIST_CONTROL_COMMAND);
if (r < 0)
goto out;
if (r & (1 << 0)) {
r = -EBUSY;
goto out;
}
r = syn_read_u8(sd, sd->bist->data + BIST_DATA_OVERALL_RESULT);
if (r < 0)
goto out;
tr->failed = r;
r = syn_read_u8(sd, sd->bist->data + BIST_DATA_TEST_RESULT);
if (r < 0)
goto out;
tr->result = r;
out:
r = syn_write_u8(sd, sd->control->control + DEVICE_CONTROL_INTR_ENABLE,
intr_mask);
mutex_unlock(&sd->lock);
return r;
}
static int syn_test_i2c_wr(struct syn *sd, const u8 value)
{
int r;
r = syn_write_u8(sd, sd->bist->data + BIST_DATA_TEST_NUMBER_CTRL,
value);
if (r < 0)
goto out;
r = syn_read_u8(sd, sd->bist->data + BIST_DATA_TEST_NUMBER_CTRL);
if (r < 0)
goto out;
if (r != value) {
dev_err(&sd->client->dev,
"write verify error: wrote 0x%x got 0x%x\n",
value, r);
r = -EINVAL;
goto out;
}
r = 0;
out:
return r;
}
static int syn_test_i2c(struct syn *sd)
{
int r;
int i;
mutex_lock(&sd->lock);
for (i = 0; i < 8; i++) {
r = syn_test_i2c_wr(sd, 1 << i);
if (r < 0)
goto out;
}
for (i = 0; i < 256; i++) {
r = syn_test_i2c_wr(sd, i);
if (r < 0)
goto out;
}
out:
mutex_unlock(&sd->lock);
return r;
}
static int syn_bist_selftest(struct syn *sd, struct bist_test_result *tr)
{
int r;
r = syn_test_i2c(sd);
if (r != 0)
return r;
r = syn_bist_run_test(sd, tr, 0x00);
return r;
}
static ssize_t syn_show_attr_selftest(struct device *dev,
struct device_attribute *attr,
char *buf)
{
struct platform_device *pdev = to_platform_device(dev);
struct syn *sd = platform_get_drvdata(pdev);
const ssize_t size = PAGE_SIZE;
ssize_t l = 0;
struct bist_test_result tr = { 0, };
int r;
if (!sd->bist) {
l += snprintf(buf + l, size - l, "Not available\n");
return l;
}
r = syn_bist_selftest(sd, &tr);
if (r != 0)
l += snprintf(buf + l, size - l,
"FAIL (io error %d)\n", r);
else {
if (tr.failed == 0)
l += snprintf(buf + l, size - l,
"PASS\n");
else
l += snprintf(buf + l, size - l,
"FAIL (test %d, result %d)\n",
tr.failed, tr.result);
}
return l;
}
static ssize_t syn_store_attr_reset(struct device *dev,
struct device_attribute *attr,
const char *buf, size_t count)
{
struct platform_device *pdev = to_platform_device(dev);
struct syn *sd = platform_get_drvdata(pdev);
mutex_lock(&sd->lock);
syn_reset_device(sd);
mutex_unlock(&sd->lock);
return count;
}
static ssize_t syn_show_attr_doze(struct device *dev,
struct device_attribute *attr,
char *buf)
{
struct platform_device *pdev = to_platform_device(dev);
struct syn *sd = platform_get_drvdata(pdev);
const ssize_t size = PAGE_SIZE;
ssize_t l = 0;
int r;
mutex_lock(&sd->lock);
r = syn_get_nosleep(sd);
mutex_unlock(&sd->lock);
if (r < 0)
goto out;
l += snprintf(buf + l, size - l, "%d\n", !r);
out:
return l;
}
static ssize_t syn_store_attr_doze(struct device *dev,
struct device_attribute *attr,
const char *buf, size_t count)
{
struct platform_device *pdev = to_platform_device(dev);
struct syn *sd = platform_get_drvdata(pdev);
int val;
if (sscanf(buf, "%i", &val) != 1) {
dev_info(&sd->client->dev,
"error parsing debug\n");
return count;
}
if (val & (~0x01))
return count;
mutex_lock(&sd->lock);
syn_set_nosleep(sd, !val);
mutex_unlock(&sd->lock);
return count;
}
static ssize_t syn_show_attr_sleepmode(struct device *dev,
struct device_attribute *attr,
char *buf)
{
struct platform_device *pdev = to_platform_device(dev);
struct syn *sd = platform_get_drvdata(pdev);
const ssize_t size = PAGE_SIZE;
ssize_t l = 0;
int r;
mutex_lock(&sd->lock);
r = syn_read_u8(sd, sd->control->control + DEVICE_CONTROL_CTRL);
if (r < 0)
goto out;
l += snprintf(buf + l, size - l, "%d\n", (r & 0x03));
out:
mutex_unlock(&sd->lock);
return l;
}
static ssize_t syn_store_attr_sleepmode(struct device *dev,
struct device_attribute *attr,
const char *buf, size_t count)
{
struct platform_device *pdev = to_platform_device(dev);
struct syn *sd = platform_get_drvdata(pdev);
int val;
int r;
if (sscanf(buf, "%i", &val) != 1) {
dev_info(&sd->client->dev,
"error parsing debug\n");
return count;
}
if (val & (~0x03))
return count;
mutex_lock(&sd->lock);
r = syn_read_u8(sd, sd->control->control + DEVICE_CONTROL_CTRL);
if (r < 0)
goto out;
val = (r & (~0x03)) | (val & 0x03);
r = syn_write_u8(sd, sd->control->control + DEVICE_CONTROL_CTRL,
val);
out:
mutex_unlock(&sd->lock);
return count;
}
static ssize_t syn_show_attr_proximity(struct device *dev,
struct device_attribute *attr,
char *buf)
{
struct platform_device *pdev = to_platform_device(dev);
struct syn *sd = platform_get_drvdata(pdev);
const ssize_t size = PAGE_SIZE;
ssize_t l = 0;
int r;
mutex_lock(&sd->lock);
r = syn_get_proximity_state(sd);
mutex_unlock(&sd->lock);
if (r < 0)
r = 0;
l += snprintf(buf + l, size - l, "%d\n", r);
return l;
}
static ssize_t syn_store_attr_proximity(struct device *dev,
struct device_attribute *attr,
const char *buf, size_t count)
{
struct platform_device *pdev = to_platform_device(dev);
struct syn *sd = platform_get_drvdata(pdev);
int val;
if (sscanf(buf, "%i", &val) != 1) {
dev_info(&sd->client->dev,
"error parsing debug\n");
return count;
}
if (val & (~0x01))
return count;
mutex_lock(&sd->lock);
syn_set_proximity_state(sd, !!val);
mutex_unlock(&sd->lock);
return count;
}
static ssize_t syn_show_attr_sensitivity(struct device *dev,
struct device_attribute *attr,
char *buf)
{
struct platform_device *pdev = to_platform_device(dev);
struct syn *sd = platform_get_drvdata(pdev);
const ssize_t size = PAGE_SIZE;
ssize_t l = 0;
int i;
u8 addr;
int r;
if (!sd->touch) {
l += snprintf(buf + l, size - l, "Not available\n");
return l;
}
addr = sd->touch->control + TOUCH_CONTROL_SENSOR_MAPPING +
sd->touch_caps.max_electrodes;
if (sd->touch_caps.has_gestures)
addr += 2;
mutex_lock(&sd->lock);
for (i = 0; i < sd->touch_caps.max_electrodes; i++) {
r = syn_read_u8(sd, addr + i);
if (r < 0) {
l += snprintf(buf + l, size - l, "Read error %d\n", r);
goto out;
} else
l += snprintf(buf + l, size - l, "0x%x ", r);
}
l += snprintf(buf + l, size - l, "\n");
out:
mutex_unlock(&sd->lock);
return l;
}
static ssize_t syn_store_attr_sensitivity(struct device *dev,
struct device_attribute *attr,
const char *buf, size_t count)
{
struct platform_device *pdev = to_platform_device(dev);
struct syn *sd = platform_get_drvdata(pdev);
int r;
int addr;
int base;
int value;
if (!sd->touch)
return count;
if (sscanf(buf, "%d %i", &addr, &value) != 2) {
dev_info(&sd->client->dev,
"error parsing sensitivity info <addr> <value>\n");
return count;
}
if (addr >= sd->touch_caps.max_electrodes) {
dev_info(&sd->client->dev,
"electorode number out of bounds %d > %d\n", addr,
sd->touch_caps.max_electrodes);
return count;
}
base = sd->touch->control + TOUCH_CONTROL_SENSOR_MAPPING +
sd->touch_caps.max_electrodes;
if (sd->touch_caps.has_gestures)
base += 2;
mutex_lock(&sd->lock);
r = syn_write_u8(sd, base + addr, value);
if (r < 0) {
dev_err(&sd->client->dev, "write failed with %d\n", r);
goto out;
}
r = syn_read_u8(sd, base + addr);
if (r < 0) {
dev_err(&sd->client->dev, "read failed with %d\n", r);
goto out;
}
if (r != value) {
dev_warn(&sd->client->dev,
"value verify error 0x%x != 0x%x\n", r, value);
}
out:
mutex_unlock(&sd->lock);
return count;
}
static ssize_t syn_show_attr_sensormap(struct device *dev,
struct device_attribute *attr,
char *buf)
{
struct platform_device *pdev = to_platform_device(dev);
struct syn *sd = platform_get_drvdata(pdev);
const ssize_t size = PAGE_SIZE;
ssize_t l = 0;
int i;
u8 addr;
int r;
if (!sd->touch) {
l += snprintf(buf + l, size - l, "Not available\n");
return l;
}
addr = sd->touch->control + TOUCH_CONTROL_SENSOR_MAPPING;
if (sd->touch_caps.has_gestures)
addr += 2;
mutex_lock(&sd->lock);
for (i = 0; i < sd->touch_caps.max_electrodes; i++) {
r = syn_read_u8(sd, addr + i);
if (r < 0) {
l += snprintf(buf + l, size - l, "Read error %d\n", r);
goto out;
} else
l += snprintf(buf + l, size - l, "%s: %d\n",
r & 0x80 ? "Y" : "X", r & 0x1F);
}
l += snprintf(buf + l, size - l, "\n");
out:
mutex_unlock(&sd->lock);
return l;
}
static ssize_t syn_show_attr_reg_dump(struct device *dev,
struct device_attribute *attr,
char *buf)
{
struct platform_device *pdev = to_platform_device(dev);
struct syn *sd = platform_get_drvdata(pdev);
const ssize_t size = PAGE_SIZE;
ssize_t l = 0;
int i;
int r;
if (!sd->touch) {
l += snprintf(buf + l, size - l, "Not available\n");
return l;
}
mutex_lock(&sd->lock);
for (i = 0; i < 0xff; i++) {
r = syn_read_u8(sd, i);
if (r < 0) {
l += snprintf(buf + l, size - l,
"Read error at 0x%x %d\n", i, r);
goto out;
} else
l += snprintf(buf + l, size - l,
"0x%02x: 0x%02x (%d)\n", i, r, r);
}
l += snprintf(buf + l, size - l, "\n");
out:
mutex_unlock(&sd->lock);
return l;
}
static ssize_t syn_store_attr_reg_dump(struct device *dev,
struct device_attribute *attr,
const char *buf, size_t count)
{
struct platform_device *pdev = to_platform_device(dev);
struct syn *sd = platform_get_drvdata(pdev);
int addr;
int value;
if (!sd->touch)
return count;
if (sscanf(buf, "%i", &addr) != 1) {
dev_info(&sd->client->dev,
"error parsing addr\n");
return count;
}
if (addr < 0 || addr > 0xff) {
dev_info(&sd->client->dev,
"error 0x%x out of bounds\n", addr);
return count;
}
mutex_lock(&sd->lock);
value = syn_read_u8(sd, addr);
if (value < 0) {
dev_info(&sd->client->dev,
"error %d reading from 0x%x\n", value, addr);
goto out;
}
dev_info(&sd->client->dev, "0x%x: 0x%x\n", addr, value);
out:
mutex_unlock(&sd->lock);
return count;
}
static ssize_t syn_show_attr_debug(struct device *dev,
struct device_attribute *attr,
char *buf)
{
struct platform_device *pdev = to_platform_device(dev);
struct syn *sd = platform_get_drvdata(pdev);
const ssize_t size = PAGE_SIZE;
ssize_t l = 0;
mutex_lock(&sd->lock);
l += snprintf(buf + l, size - l, "0x%02x\n", sd->debug_flag);
mutex_unlock(&sd->lock);
return l;
}
static ssize_t syn_store_attr_debug(struct device *dev,
struct device_attribute *attr,
const char *buf, size_t count)
{
struct platform_device *pdev = to_platform_device(dev);
struct syn *sd = platform_get_drvdata(pdev);
int flag = 0;
if (sscanf(buf, "%i", &flag) != 1) {
dev_info(&sd->client->dev,
"error parsing debug\n");
return count;
}
mutex_lock(&sd->lock);
sd->debug_flag = flag;
mutex_unlock(&sd->lock);
return count;
}
static ssize_t syn_store_attr_latency(struct device *dev,
struct device_attribute *attr,
const char *buf, size_t count)
{
struct platform_device *pdev = to_platform_device(dev);
struct syn *sd = platform_get_drvdata(pdev);
mutex_lock(&sd->lock);
sd->t_work_min = ULONG_MAX;
sd->t_work_max = 0;
sd->t_work = 0;
sd->t_work_c = 0;
sd->t_wakeup_min = ULONG_MAX;
sd->t_wakeup_max = 0;
sd->t_wakeup = 0;
sd->t_wakeup_c = 0;
sd->t_count = 0;
mutex_unlock(&sd->lock);
return count;
}
static ssize_t syn_show_attr_latency(struct device *dev,
struct device_attribute *attr,
char *buf)
{
struct platform_device *pdev = to_platform_device(dev);
struct syn *sd = platform_get_drvdata(pdev);
const ssize_t size = PAGE_SIZE;
ssize_t l = 0;
mutex_lock(&sd->lock);
l += snprintf(buf + l, size - l,
"count %lu: wakeup %lu (%lu, %lu, %lu), "
"work %lu (%lu, %lu, %lu)\n",
sd->t_count,
sd->t_wakeup, sd->t_wakeup_min, sd->t_wakeup_max,
sd->t_count ? (sd->t_wakeup_c / sd->t_count) : 0,
sd->t_work, sd->t_work_min, sd->t_work_max,
sd->t_count ? (sd->t_work_c / sd->t_count) : 0);
mutex_unlock(&sd->lock);
return l;
}
static ssize_t syn_show_attr_virtualized(struct device *dev,
struct device_attribute *attr,
char *buf)
{
struct platform_device *pdev = to_platform_device(dev);
struct syn *sd = platform_get_drvdata(pdev);
const ssize_t size = PAGE_SIZE;
ssize_t l = 0;
mutex_lock(&sd->lock);
l += snprintf(buf + l, size - l, "%d\n", sd->virtualized);
mutex_unlock(&sd->lock);
return l;
}
static ssize_t syn_store_attr_virtualized(struct device *dev,
struct device_attribute *attr,
const char *buf, size_t count)
{
struct platform_device *pdev = to_platform_device(dev);
struct syn *sd = platform_get_drvdata(pdev);
int val;
if (sscanf(buf, "%i", &val) != 1) {
dev_info(&sd->client->dev,
"error parsing virtualized\n");
return count;
}
if (val & (~0x01))
return count;
mutex_lock(&sd->lock);
sd->virtualized = val;
mutex_unlock(&sd->lock);
return count;
}
static DEVICE_ATTR(flash, S_IWUSR | S_IRUGO,
syn_show_attr_flash, syn_store_attr_flash);
static DEVICE_ATTR(product_id, S_IRUGO,
syn_show_attr_product_id, NULL);
static DEVICE_ATTR(product_family, S_IRUGO,
syn_show_attr_product_family, NULL);
static DEVICE_ATTR(firmware_version, S_IRUGO,
syn_show_attr_firmware_version, NULL);
static DEVICE_ATTR(selftest, S_IRUGO,
syn_show_attr_selftest, NULL);
static DEVICE_ATTR(reset, S_IWUSR, NULL, syn_store_attr_reset);
static DEVICE_ATTR(doze, S_IRUGO | S_IWUSR,
syn_show_attr_doze, syn_store_attr_doze);
static DEVICE_ATTR(sleepmode, S_IRUGO | S_IWUSR,
syn_show_attr_sleepmode, syn_store_attr_sleepmode);
static DEVICE_ATTR(proximity, S_IRUGO | S_IWUSR,
syn_show_attr_proximity, syn_store_attr_proximity);
static DEVICE_ATTR(sensitivity, S_IRUGO | S_IWUSR,
syn_show_attr_sensitivity, syn_store_attr_sensitivity);
static DEVICE_ATTR(sensormap, S_IRUGO,
syn_show_attr_sensormap, NULL);
static DEVICE_ATTR(dump, S_IRUGO | S_IWUSR,
syn_show_attr_reg_dump, syn_store_attr_reg_dump);
static DEVICE_ATTR(debug, S_IRUGO | S_IWUSR,
syn_show_attr_debug, syn_store_attr_debug);
static DEVICE_ATTR(latency, S_IRUGO | S_IWUSR,
syn_show_attr_latency, syn_store_attr_latency);
static DEVICE_ATTR(virtualized, S_IRUGO | S_IWUSR,
syn_show_attr_virtualized, syn_store_attr_virtualized);
static struct attribute *syn_attrs[] = {
&dev_attr_flash.attr,
&dev_attr_product_id.attr,
&dev_attr_product_family.attr,
&dev_attr_firmware_version.attr,
&dev_attr_selftest.attr,
&dev_attr_reset.attr,
&dev_attr_doze.attr,
&dev_attr_sleepmode.attr,
&dev_attr_proximity.attr,
&dev_attr_sensitivity.attr,
&dev_attr_sensormap.attr,
&dev_attr_dump.attr,
&dev_attr_debug.attr,
&dev_attr_latency.attr,
&dev_attr_virtualized.attr,
NULL,
};
static struct attribute_group syn_attr_group = {
.attrs = syn_attrs,
};
static void syn_create_sysfs(struct syn *sd)
{
int r;
r = sysfs_create_group(&sd->client->dev.kobj, &syn_attr_group);
if (r) {
dev_err(&sd->client->dev,
"failed to create flash sysfs files\n");
}
}
static void syn_remove_sysfs(struct syn *sd)
{
sysfs_remove_group(&sd->client->dev.kobj, &syn_attr_group);
}
static int syn_read_func_descs(struct syn *sd)
{
int properties = 0;
int fun = 0;
int r = 0;
int addr = REG_PDT_PROPERTIES;
sd->func_descs_valid = 0;
sd->interrupt_sources = 0;
properties = syn_read_u8(sd, addr--);
if (properties < 0)
return properties;
/* We don't support non standard page select register addr */
if (properties != 0x00) {
dev_err(&sd->client->dev, "unsupported pdt\n");
return -ENODEV;
}
sd->func_desc_num = 0;
while (sd->func_desc_num < MAX_FUNC_DESCS) {
struct func_desc * const f = &sd->func_desc[sd->func_desc_num];
u8 regs[5];
fun = syn_read_u8(sd, addr);
if (fun < 0)
return fun;
if (fun == 0x00)
goto out;
if (sd->debug_flag & DFLAG_VERBOSE)
dev_info(&sd->client->dev,
"found function 0x%x\n", fun);
f->num = fun;
addr -= 5;
r = syn_read_block(sd, addr, regs, 5);
if (r != 5) {
dev_err(&sd->client->dev, "error reading pdt\n");
return -ENODEV;
}
f->query = regs[0];
f->command = regs[1];
f->control = regs[2];
f->data = regs[3];
f->intr_sources = regs[4] & 0x07;
f->version = (regs[4] >> 5) & 0x3;
if (f->intr_sources) {
f->intr_start_bit = sd->interrupt_sources;
sd->interrupt_sources += f->intr_sources;
}
sd->func_desc_num++;
addr--;
}
out:
/* Put shortcuts in place */
sd->control = syn_get_func_desc(sd, FUNC_DEVICE_CONTROL);
sd->flash = syn_get_func_desc(sd, FUNC_FLASH);
sd->touch = syn_get_func_desc(sd, FUNC_2D);
sd->buttons = syn_get_func_desc(sd, FUNC_BUTTONS);
sd->bist = syn_get_func_desc(sd, FUNC_BIST);
sd->prox = syn_get_func_desc(sd, FUNC_PROXIMITY);
if (sd->touch == NULL)
dev_warn(&sd->client->dev,
"no 2d functionality found! (in flash mode ?)\n");
if (sd->flash) {
r = syn_flash_query_caps(sd);
if (r)
return r;
} else
dev_warn(&sd->client->dev, "no flash functionality found!\n");
if (sd->control) {
sd->func_descs_valid = 1;
return 0;
}
return -1;
}
static int syn_register_handlers(struct syn *sd)
{
int r;
r = syn_register_intr_handler(sd, FUNC_DEVICE_CONTROL,
syn_isr_device_control);
if (r < 0) {
dev_err(&sd->client->dev,
"no device control, cant continue\n");
return r;
}
/*
* Don't care about return values here.
* Install interrupt handlers for every function
* (even if they dont exist)
*/
syn_register_intr_handler(sd, FUNC_BIST, syn_isr_bist);
syn_register_intr_handler(sd, FUNC_BUTTONS, syn_isr_buttons);
syn_register_intr_handler(sd, FUNC_TIMER, syn_isr_timer);
syn_register_intr_handler(sd, FUNC_2D, syn_isr_2d);
syn_register_intr_handler(sd, FUNC_FLASH, syn_isr_flash);
syn_register_intr_handler(sd, FUNC_PROXIMITY, syn_isr_proximity);
return 0;
}
static int syn_touch_get_max_pos(struct syn *sd, u8 reg)
{
int data;
data = syn_read_u16(sd, sd->touch->control + reg);
if (data < 0)
return data;
return data & 0x00000fff;
}
static int syn_touch_get_max_x_pos(struct syn *sd)
{
return syn_touch_get_max_pos(sd, TOUCH_CONTROL_SENSOR_MAX_X);
}
static int syn_touch_get_max_y_pos(struct syn *sd)
{
return syn_touch_get_max_pos(sd, TOUCH_CONTROL_SENSOR_MAX_Y);
}
static int syn_button_query_caps(struct syn *sd)
{
int r;
r = syn_read_u8(sd, sd->buttons->query + BUTTON_QUERY_BUTTON_COUNT);
if (r < 0)
return r;
if (r > MAX_BUTTONS)
return -EINVAL;
sd->button_caps.button_count = r & BUTTON_QUERY_BUTTON_MASK;
return 0;
}
static int syn_touch_query_caps(struct syn *sd)
{
int r;
u8 data[TOUCH_QUERY_LEN] = {0};
if (sd->touch == NULL)
return -ENODEV;
r = syn_read_block(sd, sd->touch->query + TOUCH_QUERY_NUM_SENSORS,
data, TOUCH_QUERY_LEN);
if (r < 0)
return r;
if (data[0] != 0) {
dev_err(&sd->client->dev, "no support for multiple sensors\n");
return -ENODEV;
}
sd->touch_caps.is_configurable = (data[1] & (1 << 7)) ? 1 : 0;
sd->touch_caps.has_gestures = (data[1] & (1 << 5)) ? 1 : 0;
sd->touch_caps.has_abs_mode = (data[1] & (1 << 4)) ? 1 : 0;
sd->touch_caps.has_rel_mode = (data[1] & (1 << 3)) ? 1 : 0;
sd->touch_caps.finger_count = (data[1] & 0x07) + 1;
sd->touch_caps.x_electrodes = (data[2] & 0x1f);
sd->touch_caps.y_electrodes = (data[3] & 0x1f);
sd->touch_caps.max_electrodes = (data[4] & 0x1f);
sd->touch_caps.abs_data_size = (data[5] & 0x03);
if (sd->touch_caps.finger_count > MAX_TOUCH_POINTS ||
sd->touch_caps.has_rel_mode ||
/* sd->touch_caps.has_gestures || */
sd->touch_caps.abs_data_size) {
dev_err(&sd->client->dev, "no support for this sensor\n");
return -ENODEV;
}
r = syn_touch_get_max_x_pos(sd);
if (r < 0)
return r;
sd->touch_caps.max_x = r;
r = syn_touch_get_max_y_pos(sd);
if (r < 0)
return r;
sd->touch_caps.max_y = r;
return 0;
}
static int syn_reset_device(struct syn *sd)
{
int r;
/*
* We get called from various contexts, for example after firmware
* change. Resetting with state registermap would be disastrous
* so we reread everything in order to be sure to write
* to correct register.
*/
r = syn_read_func_descs(sd);
if (!sd->control) {
dev_err(&sd->client->dev, "no control. can't reset!\n");
return -1;
}
dev_info(&sd->client->dev, "resetting device (reg 0x%x)\n",
sd->control->command + DEVICE_CONTROL_COMMAND);
r = syn_write_u8(sd, sd->control->control + DEVICE_CONTROL_INTR_ENABLE,
0);
r = syn_control_data_read(sd, DEVICE_CONTROL_DATA_INTR_STATUS);
sd->func_descs_valid = 0;
r = syn_write_u8(sd, sd->control->command +
DEVICE_CONTROL_COMMAND, DEVICE_COMMAND_RESET);
r = syn_wait_for_attn(sd, 100 * 1000, 0);
r = syn_wait_for_attn(sd, 100 * 1000, 1);
r = syn_wait_for_attn(sd, 500 * 1000, 0);
return 0;
}
static int syn_initialize(struct syn *sd)
{
int r;
char prod_id[PRODUCT_ID_LEN + 1];
int prod_family;
int prod_fw_version;
syn_clear_device_state(sd);
r = syn_read_u8(sd, REG_PAGE_SELECT);
if (r < 0) {
dev_err(&sd->client->dev, "error reading page select\n");
goto err_out;
}
if (r != 0x00) {
dev_err(&sd->client->dev, "page select non zero\n");
r = -ENODEV;
goto err_out;
}
r = syn_read_func_descs(sd);
if (r < 0) {
dev_err(&sd->client->dev, "error reading func descs\n");
goto err_out;
}
if (!sd->control) {
dev_err(&sd->client->dev, "no control functions found\n");
r = -ENODEV;
goto err_out;
}
/* Clear the Unconfigured bit */
r = syn_write_u8(sd, sd->control->control + DEVICE_CONTROL_CTRL,
DEVICE_CONTROL_CONFIGURED);
if (!sd->bist)
dev_warn(&sd->client->dev, "no bist capabilities found\n");
if (sd->touch) {
r = syn_touch_query_caps(sd);
if (r < 0) {
dev_err(&sd->client->dev,
"error reading touch capabilities\n");
sd->touch = NULL;
}
} else {
dev_err(&sd->client->dev, "no touch capabilities found\n");
}
if (sd->buttons) {
r = syn_button_query_caps(sd);
if (r < 0) {
dev_err(&sd->client->dev,
"error reading button capabilities\n");
sd->buttons = NULL;
}
} else {
dev_err(&sd->client->dev, "no button capabilities found\n");
}
r = syn_read_block(sd, sd->control->query +
DEVICE_CONTROL_QUERY_PROD_ID,
prod_id, PRODUCT_ID_LEN);
if (r != PRODUCT_ID_LEN) {
dev_err(&sd->client->dev, "unable to read product id\n");
r = -ENODEV;
goto err_out;
}
prod_id[r] = 0;
prod_family = syn_control_query_read(sd,
DEVICE_CONTROL_QUERY_PROD_FAMILY);
if (prod_family < 0) {
dev_err(&sd->client->dev, "unable to read product family\n");
goto err_out;
}
prod_fw_version = syn_control_query_read(sd,
DEVICE_CONTROL_QUERY_FW_VER);
if (prod_fw_version < 0) {
dev_err(&sd->client->dev, "unable to read product family\n");
goto err_out;
}
printk(KERN_INFO DRIVER_NAME ": product ID: %s family:%d fw:%d\n",
prod_id, prod_family, prod_fw_version);
r = syn_register_handlers(sd);
if (r) {
dev_err(&sd->client->dev, "failed to register_handlers\n");
r = -ENODEV;
goto err_out;
}
if (sd->touch) {
r = syn_register_input_devices(sd, sd->touch_caps.finger_count);
if (r) {
dev_err(&sd->client->dev,
"failed to register input devices\n");
r = -ENODEV;
goto err_out;
}
}
if (sd->prox) {
/* By default disable it */
syn_set_proximity_state(sd, 0);
}
r = syn_control_data_read(sd, DEVICE_CONTROL_DATA_STATUS);
if (r < 0) {
dev_err(&sd->client->dev, "error %d reading device status\n",
r);
}
/*
* If we get reset during initialization, unconfigured should be on
*/
if (r & (1 << 7)) {
dev_warn(&sd->client->dev, "lost config during initialize\n");
sd->failed_inits++;
syn_reset_device(sd);
goto err_out;
}
sd->failed_inits = 0;
return 0;
err_out:
return r;
}
static int syn_probe(struct i2c_client *client, const struct i2c_device_id *id)
{
struct syn *sd;
struct tm12xx_ts_platform_data *pdata;
int r;
int man_id;
sd = kzalloc(sizeof(struct syn), GFP_KERNEL);
if (sd == NULL)
return -ENOMEM;
INIT_WORK(&sd->isr_work, syn_isr_work);
i2c_set_clientdata(client, sd);
sd->client = client;
mutex_init(&sd->lock);
sd->t_work_min = ULONG_MAX;
sd->t_wakeup_min = ULONG_MAX;
sd->wq = create_singlethread_workqueue("tm12xx_wq");
if (!sd->wq) {
r = -ENOMEM;
goto err_free_dev;
}
pdata = sd->client->dev.platform_data;
if (!pdata) {
dev_err(&client->dev, "no platform data found\n");
r = -ENODEV;
goto err_free_dev;
}
sd->gpio_intr = pdata->gpio_intr;
if (pdata->suspend_state == SYNTM12XX_SLEEP_ON_SUSPEND)
sd->suspend_mode = DEVICE_CONTROL_SLEEP_SENSOR;
else
sd->suspend_mode = DEVICE_CONTROL_SLEEP_NORMAL;
r = syn_read_func_descs(sd);
if (r < 0) {
dev_err(&client->dev, "error reading func descs\n");
goto err_free_dev;
}
r = syn_write_u8(sd, sd->control->control + DEVICE_CONTROL_INTR_ENABLE,
0);
if (r < 0)
goto err_free_dev;
r = syn_control_data_read(sd, DEVICE_CONTROL_DATA_INTR_STATUS);
if (r < 0)
goto err_free_dev;
man_id = syn_control_query_read(sd, DEVICE_CONTROL_QUERY_MANID);
if (man_id < 0) {
dev_dbg(&client->dev, "unable to get manufacturer id\n");
r = -ENODEV;
goto err_free_dev;
}
printk(KERN_INFO DRIVER_NAME ": " DRIVER_DESC
" found man id %x (%d)\n", man_id, man_id);
r = gpio_request(sd->gpio_intr, "Synaptic TM12XX Interrupt");
if (r < 0) {
dev_dbg(&client->dev, "unable to get INT GPIO\n");
r = -ENODEV;
goto err_free_dev;
}
gpio_direction_input(sd->gpio_intr);
r = syn_register_intr_handler(sd, FUNC_DEVICE_CONTROL,
syn_isr_device_control);
if (r < 0) {
dev_err(&sd->client->dev,
"no device control, can't continue\n");
r = -ENODEV;
goto err_free_int_gpio;
}
mutex_lock(&sd->lock);
r = request_irq(gpio_to_irq(sd->gpio_intr), syn_isr,
IRQF_DISABLED | IRQF_TRIGGER_LOW | IRQF_TRIGGER_FALLING,
DRIVER_NAME, sd);
if (r) {
dev_dbg(&client->dev, "can't get IRQ %d (%d), err %d\n",
gpio_to_irq(sd->gpio_intr), sd->gpio_intr, r);
goto err_release_mutex;
}
syn_create_sysfs(sd);
/* Initialize thru reset */
r = syn_reset_device(sd);
if (r < 0) {
dev_err(&client->dev, "error in reset device\n");
goto err_free_irq;
}
#ifdef CONFIG_HAS_EARLYSUSPEND
sd->early_suspend.level = EARLY_SUSPEND_LEVEL_BLANK_SCREEN + 1;
sd->early_suspend.suspend = syn_ts_early_suspend;
sd->early_suspend.resume = syn_ts_late_resume;
register_early_suspend(&sd->early_suspend);
#endif
mutex_unlock(&sd->lock);
return 0;
err_free_irq:
free_irq(gpio_to_irq(sd->gpio_intr), sd);
err_release_mutex:
mutex_unlock(&sd->lock);
err_free_int_gpio:
gpio_free(sd->gpio_intr);
err_free_dev:
kfree(sd);
sd = NULL;
return r;
}
static int __exit syn_remove(struct i2c_client *client)
{
struct syn *sd = i2c_get_clientdata(client);
int i;
mutex_lock(&sd->lock);
if (sd->control)
syn_write_u8(sd,
sd->control->control + DEVICE_CONTROL_INTR_ENABLE,
0);
free_irq(gpio_to_irq(sd->gpio_intr), sd);
mutex_unlock(&sd->lock);
destroy_workqueue(sd->wq);
sd->wq = NULL;
syn_remove_sysfs(sd);
for (i = 0; i < MAX_TOUCH_POINTS; i++) {
if (sd->tp[i].idev) {
input_unregister_device(sd->tp[i].idev);
input_free_device(sd->tp[i].idev);
sd->tp[i].idev = NULL;
}
}
gpio_free(sd->gpio_intr);
kfree(sd);
i2c_set_clientdata(client, NULL);
return 0;
}
#ifdef CONFIG_PM
static int syn_suspend(struct i2c_client *client, pm_message_t msg)
{
struct syn *sd = i2c_get_clientdata(client);
int r;
mutex_lock(&sd->lock);
r = syn_read_u8(sd, sd->control->control + DEVICE_CONTROL_CTRL);
/* If we fail to get previous finetuned power mode, we don't care */
if (r < 0)
goto out;
sd->device_control_ctrl = r & 0xff;
r = syn_write_u8(sd, sd->control->control + DEVICE_CONTROL_CTRL,
sd->suspend_mode);
out:
mutex_unlock(&sd->lock);
return 0;
}
static int syn_resume(struct i2c_client *client)
{
struct syn *sd = i2c_get_clientdata(client);
int r;
mutex_lock(&sd->lock);
r = syn_write_u8(sd, sd->control->control + DEVICE_CONTROL_CTRL,
sd->device_control_ctrl);
if (r < 0)
dev_err(&sd->client->dev, "error %d restoring device state\n",
r);
mutex_unlock(&sd->lock);
return 0;
}
#ifdef CONFIG_HAS_EARLYSUSPEND
static void syn_ts_early_suspend(struct early_suspend *handler)
{
struct syn *sd;
sd = container_of(handler, struct syn, early_suspend);
syn_suspend(sd->client, PMSG_SUSPEND);
}
static void syn_ts_late_resume(struct early_suspend *handler)
{
struct syn *sd;
sd = container_of(handler, struct syn, early_suspend);
syn_resume(sd->client);
}
#endif
#endif
static const struct i2c_device_id syn_id[] = {
{ "tm12xx_ts_primary", 0 },
{ "tm12xx_ts_secondary", 1},
{ }
};
static struct i2c_driver syn_i2c_driver = {
.driver = {
.name = DRIVER_NAME,
},
.probe = syn_probe,
.remove = __exit_p(syn_remove),
.id_table = syn_id,
#ifdef CONFIG_PM
#ifdef CONFIG_HAS_EARLYSUSPEND
.suspend = NULL,
.resume = NULL,
#else
.suspend = syn_suspend,
.resume = syn_resume,
#endif
#endif
};
static int __init syn_init(void)
{
int r;
r = i2c_add_driver(&syn_i2c_driver);
if (r < 0) {
printk(KERN_WARNING DRIVER_NAME
" driver registration failed\n");
return r;
}
return 0;
}
static void __exit syn_exit(void)
{
i2c_del_driver(&syn_i2c_driver);
}
module_init(syn_init);
module_exit(syn_exit);
MODULE_AUTHOR("Mika Kuoppala <mika.kuoppala@nokia.com>");
MODULE_DESCRIPTION("Synaptic TM12xx Touch controller driver");
MODULE_LICENSE("GPL");