From: HungNien Chen <[email protected]> To support WDT8752 is main modification of this version and description as below: 1. Add definitions for WDT8752. 2. Modify wdt87xx_get_param to have the right method to communicate with the controller. Also add wdt87xx_get_param_hid for retrieving parameters from the controller. 3. Controller specific function pointers are selected when detected controller and they are used in FW writing. 4. Add functions for WDT8752: wdt8752_send_command, wdt8752_write_data, wdt8752_delay, wdt8752_checksum_check and some minor functions. 5. Modify supend/resume flow to support IDLE and SLEEP.
Signed-off-by: HungNien Chen <[email protected]> --- drivers/input/touchscreen/wdt87xx_i2c.c | 963 +++++++++++++++++++++++++------- 1 file changed, 749 insertions(+), 214 deletions(-) diff --git a/drivers/input/touchscreen/wdt87xx_i2c.c b/drivers/input/touchscreen/wdt87xx_i2c.c index 2519617..27553cd 100644 --- a/drivers/input/touchscreen/wdt87xx_i2c.c +++ b/drivers/input/touchscreen/wdt87xx_i2c.c @@ -22,10 +22,15 @@ #include <linux/acpi.h> #include <asm/unaligned.h> -#define WDT87XX_NAME "wdt87xx_i2c" -#define WDT87XX_DRV_VER "0.9.8" -#define WDT87XX_FW_NAME "wdt87xx_fw.bin" -#define WDT87XX_CFG_NAME "wdt87xx_cfg.bin" +#define WDT87XX_NAME "wdt87xx_i2c" +#define WDT87XX_DRV_VER "0.9.9" +#define WDT87XX_FW_NAME "wdt87xx_fw.bin" +#define WDT87XX_CFG_NAME "wdt87xx_cfg.bin" + +#define PLT_WDT8756 0x00 +#define PLT_WDT8752 0x01 + +#define RPT_ID_TOUCH 0x01 #define MODE_ACTIVE 0x01 #define MODE_READY 0x02 @@ -34,8 +39,7 @@ #define MODE_STOP 0xFF #define WDT_MAX_FINGER 10 -#define WDT_RAW_BUF_COUNT 54 -#define WDT_V1_RAW_BUF_COUNT 74 +#define WDT_RAW_BUF_COUNT 76 #define WDT_FIRMWARE_ID 0xa9e368f5 #define PG_SIZE 0x1000 @@ -43,32 +47,23 @@ #define MAX_UNIT_AXIS 0x7FFF +#define PKT_TX_SIZE 16 #define PKT_READ_SIZE 72 #define PKT_WRITE_SIZE 80 /* the finger definition of the report event */ #define FINGER_EV_OFFSET_ID 0 -#define FINGER_EV_OFFSET_X 1 -#define FINGER_EV_OFFSET_Y 3 -#define FINGER_EV_SIZE 5 - -#define FINGER_EV_V1_OFFSET_ID 0 -#define FINGER_EV_V1_OFFSET_W 1 -#define FINGER_EV_V1_OFFSET_P 2 -#define FINGER_EV_V1_OFFSET_X 3 -#define FINGER_EV_V1_OFFSET_Y 5 -#define FINGER_EV_V1_SIZE 7 +#define FINGER_EV_OFFSET_W 1 +#define FINGER_EV_OFFSET_P 2 +#define FINGER_EV_OFFSET_X 3 +#define FINGER_EV_OFFSET_Y 5 +#define FINGER_EV_SIZE 7 /* The definition of a report packet */ #define TOUCH_PK_OFFSET_REPORT_ID 0 #define TOUCH_PK_OFFSET_EVENT 1 -#define TOUCH_PK_OFFSET_SCAN_TIME 51 -#define TOUCH_PK_OFFSET_FNGR_NUM 53 - -#define TOUCH_PK_V1_OFFSET_REPORT_ID 0 -#define TOUCH_PK_V1_OFFSET_EVENT 1 -#define TOUCH_PK_V1_OFFSET_SCAN_TIME 71 -#define TOUCH_PK_V1_OFFSET_FNGR_NUM 73 +#define TOUCH_PK_OFFSET_SCAN_TIME 71 +#define TOUCH_PK_OFFSET_FNGR_NUM 73 /* The definition of the controller parameters */ #define CTL_PARAM_OFFSET_FW_ID 0 @@ -84,6 +79,7 @@ #define CTL_PARAM_OFFSET_PHY_W 22 #define CTL_PARAM_OFFSET_PHY_H 24 #define CTL_PARAM_OFFSET_FACTOR 32 +#define CTL_PARAM_OFFSET_I2C_CFG 36 /* The definition of the device descriptor */ #define WDT_GD_DEVICE 1 @@ -95,6 +91,8 @@ #define VND_REQ_READ 0x06 #define VND_READ_DATA 0x07 #define VND_REQ_WRITE 0x08 +#define VND_REQ_FW_INFO 0xF2 +#define VND_REQ_CTRLER_INFO 0xF4 #define VND_CMD_START 0x00 #define VND_CMD_STOP 0x01 @@ -104,6 +102,8 @@ #define VND_GET_CHECKSUM 0x66 +#define VND_CMD_DEV_MODE 0x82 + #define VND_SET_DATA 0x83 #define VND_SET_COMMAND_DATA 0x84 #define VND_SET_CHECKSUM_CALC 0x86 @@ -155,12 +155,85 @@ #define FW_CHUNK_PAYLOAD_OFFSET 32 /* Controller requires minimum 300us between commands */ -#define WDT_COMMAND_DELAY_MS 2 -#define WDT_FLASH_WRITE_DELAY_MS 4 -#define WDT_FLASH_ERASE_DELAY_MS 200 -#define WDT_FW_RESET_TIME 2500 +#define WDT_CMD_DELAY_US 300 +#define W8752_ERASE4K_DELAY_MS 500 +#define WDT_FLASH_WRITE_DELAY_MS 2 +#define WDT_FW_RESET_TIME_MS 2500 +#define WDT_POLLING_PERIOD_MS 20 +#define W8756_ERASE4K_DELAY_MS 200 + +/* The definition for WDT8752 */ +#define W8752_READ_OFFSET_MASK 0x10000 +#define W8752_DEV_INFO_READ_OFFSET 0xC +#define W8752_PKT_HEADER_SZ 4 +#define W8752_PKT_SIZE 60 + +#define W8752_STATUS_OK 0x80 +#define W8752_STATUS_BUSY 0xFE + +/* Communication commands of WDT8752 */ +#define W8752_BASIC_COMMAND 0x85 +#define W8752_FW_COMMAND 0x91 + +#define W8755_FW_GET_DEV_INFO 0x73 + +#define W8752_SET_FLASH 0x83 +#define W8752_SET_FLASH_ADDRESS 0x87 +#define W8752_SET_CHECKSUM_CALC 0x88 +#define W8752_GET_CHECKSUM 0x65 + +#define W8752_CMD_SFLOCK 0x00 +#define W8752_CMD_SFUNLOCK 0x01 +#define W8752_CMD_RESET 0x02 +#define W8752_CMD_ERASE4K 0x03 +#define W8752_CMD_DEV_MODE 0x82 + +#define W8752_DM_SENSING 0x1 +#define W8752_DM_DOZE 0x2 +#define W8755_DM_SLEEP 0x3 +#define W8752_DM_COMMAND 0x90 + +#define W8752_SFLOCK_KEY 0x9B +#define W8752_SFUNLOCK_KEY 0xDA + +/* The definition of the command packet of WDT8752 */ +#define CMD_SIZE_OFFSET 0x2 +#define CMD_ID_OFFSET 0x4 +#define CMD_DATA1_OFFSET 0x4 +#define CMD_VALUE_OFFSET 0x5 + +#define W8752_POLLING_PERIOD_US 5000 +#define W8752_FLASH_WRITE_DELAY_US 100 + +#define W8752_PROG_SECTOR_SIZE 0x100 + +#define W8752_HID_DESC_ADDR 0x20 + +/* The definition of controller parameters of WDT8752 */ +#define W8752_PARAM_KEY 0x154f +#define W8752_PARAM_KEY_OFFSET 0x2 +#define W8752_PLAT_ID_OFFSET 0x5 +#define W8752_PARAM_OFFSET 0xA +#define W8752_PARAM_LEN_OFFSET 0xC + +struct i2c_hid_desc { + u16 desc_length; + u16 bcd_version; + u16 rpt_desc_length; + u16 rpt_desc_register; + u16 input_register; + u16 max_input_length; + u16 output_register; + u16 max_output_length; + u16 cmd_register; + u16 data_register; + u16 vendor_id; + u16 product_id; + u16 version_id; + u32 reserved; +} __packed; -struct wdt87xx_sys_param { +struct wdt87xx_param { u16 fw_id; u16 plat_id; u16 xmls_id1; @@ -174,17 +247,31 @@ struct wdt87xx_sys_param { u32 max_y; u16 vendor_id; u16 product_id; -}; + u16 i2c_cfg; +} __packed; struct wdt87xx_data { struct i2c_client *client; struct input_dev *input; /* Mutex for fw update to prevent concurrent access */ struct mutex fw_mutex; - struct wdt87xx_sys_param param; + struct wdt87xx_param param; + struct i2c_hid_desc hid_desc; u8 phys[32]; + u32 plt_id; + bool wake_irq_enabled; + + /* Function ptrs for different controller body */ + int (*send_cmd)(struct i2c_client *client, int cmd, int value); + int (*write_flash)(struct i2c_client *client, const char *data, + u32 addr, size_t len); + int (*chksum_check)(struct i2c_client *client, const char *data, + u32 addr, size_t len); + int (*delay)(struct i2c_client *client, u32 delay); }; +static int wdt8752_set_dev_mode(struct i2c_client *client, u8 mode); + static int wdt87xx_i2c_xfer(struct i2c_client *client, void *txdata, size_t txlen, void *rxdata, size_t rxlen) @@ -214,6 +301,8 @@ static int wdt87xx_i2c_xfer(struct i2c_client *client, return error; } + udelay(WDT_CMD_DELAY_US); + return 0; } @@ -225,8 +314,8 @@ static int wdt87xx_get_desc(struct i2c_client *client, u8 desc_idx, tx_buf[2] |= desc_idx & 0xF; - error = wdt87xx_i2c_xfer(client, tx_buf, sizeof(tx_buf), - buf, len); + error = wdt87xx_i2c_xfer(client, tx_buf, sizeof(tx_buf), buf, len); + if (error) { dev_err(&client->dev, "get desc failed: %d\n", error); return error; @@ -238,8 +327,6 @@ static int wdt87xx_get_desc(struct i2c_client *client, u8 desc_idx, return -EINVAL; } - mdelay(WDT_COMMAND_DELAY_MS); - return 0; } @@ -270,23 +357,23 @@ static int wdt87xx_get_string(struct i2c_client *client, u8 str_idx, rx_len = min_t(size_t, len, rx_buf[0]); memcpy(buf, &rx_buf[2], rx_len); - mdelay(WDT_COMMAND_DELAY_MS); - return 0; } static int wdt87xx_get_feature(struct i2c_client *client, - u8 *buf, size_t buf_size) + u8 *buf, size_t len) { - u8 tx_buf[8]; + u8 tx_buf[PKT_TX_SIZE]; u8 rx_buf[PKT_WRITE_SIZE]; size_t tx_len = 0; - size_t rx_len = buf_size + 2; + size_t rx_len = len + 2; int error; if (rx_len > sizeof(rx_buf)) return -EINVAL; + memset(tx_buf, 0, sizeof(tx_buf)); + /* Get feature command packet */ tx_buf[tx_len++] = 0x22; tx_buf[tx_len++] = 0x00; @@ -307,16 +394,14 @@ static int wdt87xx_get_feature(struct i2c_client *client, return error; } - rx_len = min_t(size_t, buf_size, get_unaligned_le16(rx_buf)); + rx_len = min_t(size_t, len, get_unaligned_le16(rx_buf)); memcpy(buf, &rx_buf[2], rx_len); - mdelay(WDT_COMMAND_DELAY_MS); - return 0; } static int wdt87xx_set_feature(struct i2c_client *client, - const u8 *buf, size_t buf_size) + const u8 *buf, size_t len) { u8 tx_buf[PKT_WRITE_SIZE]; int tx_len = 0; @@ -335,22 +420,21 @@ static int wdt87xx_set_feature(struct i2c_client *client, } tx_buf[tx_len++] = 0x23; tx_buf[tx_len++] = 0x00; - tx_buf[tx_len++] = (buf_size & 0xFF); - tx_buf[tx_len++] = ((buf_size & 0xFF00) >> 8); + tx_buf[tx_len++] = (len & 0xFF); + tx_buf[tx_len++] = ((len & 0xFF00) >> 8); - if (tx_len + buf_size > sizeof(tx_buf)) + if (tx_len + len > sizeof(tx_buf)) return -EINVAL; - memcpy(&tx_buf[tx_len], buf, buf_size); - tx_len += buf_size; + memcpy(&tx_buf[tx_len], buf, len); + tx_len += len; error = i2c_master_send(client, tx_buf, tx_len); if (error < 0) { dev_err(&client->dev, "set feature failed: %d\n", error); return error; } - - mdelay(WDT_COMMAND_DELAY_MS); + udelay(WDT_CMD_DELAY_US); return 0; } @@ -395,20 +479,389 @@ static int wdt87xx_send_command(struct i2c_client *client, int cmd, int value) return wdt87xx_set_feature(client, cmd_buf, sizeof(cmd_buf)); } +static u16 misr(u16 cur_value, u16 new_value) +{ + u32 a, b; + u32 bit0; + u32 y; + + a = cur_value; + b = new_value; + bit0 = a ^ (b & 1); + bit0 ^= a >> 1; + bit0 ^= a >> 2; + bit0 ^= a >> 4; + bit0 ^= a >> 5; + bit0 ^= a >> 7; + bit0 ^= a >> 11; + bit0 ^= a >> 15; + y = (a << 1) ^ b; + y = (y & ~1) | (bit0 & 1); + + return (u16)y; +} + +static u16 wdt87xx_calculate_checksum(const u8 *data, size_t len, int byte_mode) +{ + u16 checksum = 0; + u16 *pdata_u16; + size_t i; + + if (byte_mode) + for (i = 0; i < len; i++) + checksum = misr(checksum, (u16)data[i]); + else { + pdata_u16 = (u16 *)data; + for (i = 0; i < (len >> 1); i++) + checksum = misr(checksum, *pdata_u16++); + } + + return checksum; +} + +static int wdt8752_send_command(struct i2c_client *client, int cmd, int value) +{ + u8 cmd_buf[PKT_BUF_SIZE]; + size_t size = 2; + + /* Set the command packet and the packet size is variable in 8752 */ + cmd_buf[CMD_REPORT_ID_OFFSET] = VND_REQ_WRITE; + cmd_buf[CMD_TYPE_OFFSET] = W8752_BASIC_COMMAND; + + switch (cmd) { + case VND_CMD_STOP: + /* + * Command STOP with STOP value, enter the command loop mode + * for operating the flash in 8752 + */ + if (value == MODE_STOP) + return wdt8752_set_dev_mode(client, W8752_DM_COMMAND); + + /* Remap the value of mode to the right one */ + if (value != MODE_ACTIVE) + value--; + + case VND_CMD_DEV_MODE: + cmd_buf[CMD_TYPE_OFFSET] = W8752_FW_COMMAND; + cmd_buf[CMD_ID_OFFSET] = W8752_CMD_DEV_MODE; + cmd_buf[CMD_VALUE_OFFSET] = value; + break; + + case VND_CMD_START: + return wdt8752_set_dev_mode(client, W8752_DM_SENSING); + + case VND_CMD_RESET: + cmd_buf[CMD_ID_OFFSET] = W8752_CMD_RESET; + size = 1; + break; + + case VND_CMD_SFLCK: + cmd_buf[CMD_ID_OFFSET] = W8752_CMD_SFLOCK; + cmd_buf[CMD_VALUE_OFFSET] = W8752_SFLOCK_KEY; + break; + + case VND_CMD_SFUNL: + cmd_buf[CMD_ID_OFFSET] = W8752_CMD_SFUNLOCK; + cmd_buf[CMD_VALUE_OFFSET] = W8752_SFUNLOCK_KEY; + break; + + case VND_CMD_ERASE: + cmd_buf[CMD_ID_OFFSET] = W8752_CMD_ERASE4K; + put_unaligned_le32(value, &cmd_buf[CMD_VALUE_OFFSET]); + size = 5; + break; + + default: + cmd_buf[CMD_REPORT_ID_OFFSET] = 0; + dev_err(&client->dev, "Invalid command: %d\n", cmd); + return -EINVAL; + } + + put_unaligned_le16(size, &cmd_buf[CMD_SIZE_OFFSET]); + + return wdt87xx_set_feature(client, cmd_buf, W8752_PKT_HEADER_SZ + size); +} + +static int wdt8752_exec_read_pkt(struct i2c_client *client, u8 type, + u8 *data, size_t len, int offset) +{ + u8 pkt_buf[PKT_BUF_SIZE]; + int error; + size_t size; + + /* + * Some vendor commands can read the data structure from controller, + * set the mask to indicate the offset. + */ + if (offset & W8752_READ_OFFSET_MASK) + size = offset & 0xFF; + else + size = len; + + pkt_buf[CMD_REPORT_ID_OFFSET] = VND_REQ_READ; + pkt_buf[CMD_TYPE_OFFSET] = type; + put_unaligned_le16(size, &pkt_buf[CMD_SIZE_OFFSET]); + + error = wdt87xx_set_feature(client, pkt_buf, W8752_PKT_HEADER_SZ); + if (error) + return error; + + pkt_buf[CMD_REPORT_ID_OFFSET] = VND_READ_DATA; + pkt_buf[CMD_TYPE_OFFSET] = type; + error = wdt87xx_get_feature(client, pkt_buf, PKT_BUF_SIZE); + if (error) + return error; + + if (pkt_buf[CMD_REPORT_ID_OFFSET] != VND_READ_DATA) { + dev_err(&client->dev, "wrong id of fw response: 0x%x\n", + pkt_buf[CMD_REPORT_ID_OFFSET]); + return -EINVAL; + } + memcpy(data, &pkt_buf[CMD_DATA1_OFFSET], len); + + return 0; +} + +static int wdt8752_get_device_mode(struct i2c_client *client, u8 *pmode) +{ + u8 cmd_buf[PKT_BUF_SIZE]; + int error; + + error = wdt8752_exec_read_pkt(client, W8755_FW_GET_DEV_INFO, cmd_buf, + W8752_PKT_SIZE, W8752_READ_OFFSET_MASK | + W8752_DEV_INFO_READ_OFFSET); + if (error) + return error; + + *pmode = cmd_buf[0]; + return 0; +} + +static int wdt8752_set_dev_mode(struct i2c_client *client, u8 mode) +{ + int count = 20; + int error; + u8 mode_r; + + do { + error = wdt8752_send_command(client, W8752_CMD_DEV_MODE, mode); + if (error) + return error; + + udelay(W8752_POLLING_PERIOD_US); + error = wdt8752_get_device_mode(client, &mode_r); + if (error) + return error; + } while (mode != mode_r && count-- > 0); + + if (mode != mode_r) { + dev_err(&client->dev, "failed to change mode: 0x%x, 0x%x\n", + mode, mode_r); + return -ETIME; + } + + return 0; +} + +static int wdt8752_exec_write_pkt(struct i2c_client *client, u8 type, u8 *data, + size_t len) +{ + u8 pkt_buf[PKT_BUF_SIZE]; + + pkt_buf[CMD_REPORT_ID_OFFSET] = VND_REQ_WRITE; + pkt_buf[CMD_TYPE_OFFSET] = type; + put_unaligned_le16(len, &pkt_buf[CMD_SIZE_OFFSET]); + + memcpy(&pkt_buf[CMD_DATA1_OFFSET], data, len); + + return wdt87xx_set_feature(client, pkt_buf, W8752_PKT_HEADER_SZ + len); +} + +static int wdt8752_delay(struct i2c_client *client, u32 delay) +{ + u8 rc = W8752_STATUS_BUSY; + u8 raw_buf[PKT_BUF_SIZE]; + int count; + int error; + + count = (delay / WDT_POLLING_PERIOD_MS) + 1; + + do { + msleep(WDT_POLLING_PERIOD_MS); + + error = i2c_master_recv(client, raw_buf, 3); + if (error < 0) { + dev_err(&client->dev, "read raw data failed: (%d)\n", + error); + return error; + } + + rc = raw_buf[2]; + } while (rc != W8752_STATUS_OK && count-- > 0); + + return 0; +} + +static int wdt8752_checksum_check(struct i2c_client *client, const char *data, + u32 addr, size_t len) +{ + u8 pkt_buf[PKT_BUF_SIZE]; + int time_delay; + int error; + u16 dev_chksum, fw_chksum; + + put_unaligned_le32(addr, &pkt_buf[0]); + put_unaligned_le32(len, &pkt_buf[4]); + + error = wdt8752_exec_write_pkt(client, W8752_SET_CHECKSUM_CALC, + pkt_buf, 8); + if (error) { + dev_err(&client->dev, "failed to write chksum_calc\n"); + return error; + } + + /* + * It takes about 2ms for every 1K bytes doing the checksum in FW. + * Wait here for the operation to complete. + */ + time_delay = DIV_ROUND_UP(len, 1024); + error = wdt8752_delay(client, time_delay * 4); + if (error) + return error; + + error = wdt8752_exec_read_pkt(client, W8752_GET_CHECKSUM, pkt_buf, + W8752_PKT_SIZE, 0); + if (error) { + dev_err(&client->dev, "failed to read chksum\n"); + return error; + } + + dev_chksum = get_unaligned_le16(pkt_buf); + + /* Calculate the checksum in u16 */ + fw_chksum = wdt87xx_calculate_checksum(data, len, 0); + if (dev_chksum == fw_chksum) + return 0; + + dev_err(&client->dev, "checksum fail: %d vs %d\n", + dev_chksum, fw_chksum); + return -EAGAIN; +} + +static int wdt8752_flash_write_sector(struct i2c_client *client, u8 *data, + u32 addr, size_t len) +{ + int st_addr; + size_t pkt_size; + u8 *pdata; + int error; + u8 pkt_buf[PKT_BUF_SIZE]; + + /* Address and length should be 4 bytes aligned */ + if ((addr & 0x3) != 0 || (len & 0x3) != 0) { + dev_err(&client->dev, + "addr & len must be 4 bytes aligned %x, %zu\n", + addr, len); + return -EINVAL; + } + + st_addr = addr; + pdata = data; + + put_unaligned_le32(addr, &pkt_buf[0]); + + /* initialize the programming address first */ + error = wdt8752_exec_write_pkt(client, W8752_SET_FLASH_ADDRESS, pkt_buf, + sizeof(u32)); + if (error) { + dev_err(&client->dev, "failed to set flash address: 0x%x\n", + addr); + return error; + } + + while (len) { + pkt_size = min_t(size_t, len, W8752_PKT_SIZE); + + error = wdt8752_exec_write_pkt(client, W8752_SET_FLASH, pdata, + pkt_size); + if (error) { + dev_dbg(&client->dev, "failed to program flash: 0x%x\n", + st_addr); + return error; + } + + len -= pkt_size; + pdata += pkt_size; + st_addr += pkt_size; + + udelay(W8752_FLASH_WRITE_DELAY_US); + } + + return 0; +} + +static int wdt8752_write_data(struct i2c_client *client, const char *data, + u32 addr, size_t len) +{ + int error; + u8 *pdata = (u8 *)data; + u32 write_size; + + if (addr & (W8752_PROG_SECTOR_SIZE - 1)) { + dev_err(&client->dev, "start addr must be sector aligned\n"); + return -EINVAL; + } + + while (len) { + write_size = min_t(size_t, len, W8752_PROG_SECTOR_SIZE); + + error = wdt8752_flash_write_sector(client, pdata, addr, + write_size); + + if (error) + return error; + + pdata += W8752_PROG_SECTOR_SIZE; + addr += W8752_PROG_SECTOR_SIZE; + len -= write_size; + } + + return 0; +} + +static int wdt87xx_delay(struct i2c_client *client, u32 delay) +{ + /* + * According to the spec, 4k erase takes the longest time in operations + * and W8756 have to wait it at most 200 ms + */ + if (delay > W8756_ERASE4K_DELAY_MS) + delay = W8756_ERASE4K_DELAY_MS; + + if (delay > WDT_POLLING_PERIOD_MS) + msleep(delay); + else + udelay(delay * 1000); + + return 0; +} + static int wdt87xx_sw_reset(struct i2c_client *client) { int error; + struct wdt87xx_data *wdt = i2c_get_clientdata(client); dev_dbg(&client->dev, "resetting device now\n"); - error = wdt87xx_send_command(client, VND_CMD_RESET, 0); + error = wdt->send_cmd(client, VND_CMD_RESET, 0); + if (error) { dev_err(&client->dev, "reset failed\n"); return error; } /* Wait the device to be ready */ - msleep(WDT_FW_RESET_TIME); + msleep(WDT_FW_RESET_TIME_MS); return 0; } @@ -426,32 +879,16 @@ static const void *wdt87xx_get_fw_chunk(const struct firmware *fw, u32 id) chunk_size = get_unaligned_le32(fw->data + pos + FW_CHUNK_SIZE_OFFSET); - pos += chunk_size + 2 * sizeof(u32); /* chunk ID + size */ + /* chunk ID + size */ + pos += chunk_size + 2 * sizeof(u32); } return NULL; } -static int wdt87xx_get_sysparam(struct i2c_client *client, - struct wdt87xx_sys_param *param) +static void wdt87xx_parse_param(struct wdt87xx_data *wdt, u8 *buf, size_t len) { - u8 buf[PKT_READ_SIZE]; - int error; - - error = wdt87xx_get_desc(client, WDT_GD_DEVICE, buf, 18); - if (error) { - dev_err(&client->dev, "failed to get device desc\n"); - return error; - } - - param->vendor_id = get_unaligned_le16(buf + DEV_DESC_OFFSET_VID); - param->product_id = get_unaligned_le16(buf + DEV_DESC_OFFSET_PID); - - error = wdt87xx_get_string(client, STRIDX_PARAMETERS, buf, 34); - if (error) { - dev_err(&client->dev, "failed to get parameters\n"); - return error; - } + struct wdt87xx_param *param = &wdt->param; param->xmls_id1 = get_unaligned_le16(buf + CTL_PARAM_OFFSET_XMLS_ID1); param->xmls_id2 = get_unaligned_le16(buf + CTL_PARAM_OFFSET_XMLS_ID2); @@ -460,6 +897,9 @@ static int wdt87xx_get_sysparam(struct i2c_client *client, param->phy_w = get_unaligned_le16(buf + CTL_PARAM_OFFSET_PHY_W) / 10; param->phy_h = get_unaligned_le16(buf + CTL_PARAM_OFFSET_PHY_H) / 10; + /* Get the report mode */ + param->i2c_cfg = get_unaligned_le16(buf + CTL_PARAM_OFFSET_I2C_CFG); + /* Get the scaling factor of pixel to logical coordinate */ param->scaling_factor = get_unaligned_le16(buf + CTL_PARAM_OFFSET_FACTOR); @@ -467,34 +907,61 @@ static int wdt87xx_get_sysparam(struct i2c_client *client, param->max_x = MAX_UNIT_AXIS; param->max_y = DIV_ROUND_CLOSEST(MAX_UNIT_AXIS * param->phy_h, param->phy_w); +} - error = wdt87xx_get_string(client, STRIDX_PLATFORM_ID, buf, 8); - if (error) { - dev_err(&client->dev, "failed to get platform id\n"); +static int wdt87xx_get_param_hid(struct wdt87xx_data *wdt) +{ + u8 buf[PKT_READ_SIZE]; + int error; + struct i2c_client *client = wdt->client; + struct wdt87xx_param *param = &wdt->param; + + put_unaligned_le16(W8752_HID_DESC_ADDR, buf); + + error = wdt87xx_i2c_xfer(client, buf, 2, &wdt->hid_desc, + sizeof(wdt->hid_desc)); + if (error < 0) { + dev_err(&client->dev, "failed to get hid desc\n"); return error; } - param->plat_id = buf[1]; + param->vendor_id = wdt->hid_desc.vendor_id; + param->product_id = wdt->hid_desc.product_id; - buf[0] = 0xf2; - error = wdt87xx_get_feature(client, buf, 16); - if (error) { - dev_err(&client->dev, "failed to get firmware id\n"); + return 0; +} + +static int wdt87xx_get_param_private(struct wdt87xx_data *wdt) +{ + u8 buf[PKT_READ_SIZE]; + int error, str_len; + struct i2c_client *client = wdt->client; + struct wdt87xx_param *param = &wdt->param; + + error = wdt87xx_get_desc(client, WDT_GD_DEVICE, buf, 18); + if (error < 0) { + dev_err(&client->dev, "failed to get device desc\n"); return error; } - if (buf[0] != 0xf2) { - dev_err(&client->dev, "wrong id of fw response: 0x%x\n", - buf[0]); - return -EINVAL; + param->vendor_id = get_unaligned_le16(buf + DEV_DESC_OFFSET_VID); + param->product_id = get_unaligned_le16(buf + DEV_DESC_OFFSET_PID); + + str_len = wdt87xx_get_string(client, STRIDX_PARAMETERS, buf, 38); + if (str_len < 0) { + dev_err(&client->dev, "failed to get parameters\n"); + return str_len; } - param->fw_id = get_unaligned_le16(&buf[1]); + wdt87xx_parse_param(wdt, buf, str_len); - dev_info(&client->dev, - "fw_id: 0x%x, plat_id: 0x%x, xml_id1: %04x, xml_id2: %04x\n", - param->fw_id, param->plat_id, - param->xmls_id1, param->xmls_id2); + error = wdt87xx_get_string(client, STRIDX_PLATFORM_ID, buf, 8); + if (error < 0) { + dev_err(&client->dev, "failed to get platform id\n"); + return error; + } + + param->plat_id = buf[1]; return 0; } @@ -548,8 +1015,15 @@ static int wdt87xx_validate_firmware(struct wdt87xx_data *wdt, return 0; } -static int wdt87xx_validate_fw_chunk(const void *data, int id) +static int wdt87xx_validate_fw_chunk(struct i2c_client *client, + const void *data, int id) { + struct wdt87xx_data *wdt = i2c_get_clientdata(client); + + /* There is no fw_id tag could be checked in 8752 */ + if (wdt->plt_id == PLT_WDT8752) + return 0; + if (id == CHUNK_ID_FRWR) { u32 fw_id; @@ -562,37 +1036,37 @@ static int wdt87xx_validate_fw_chunk(const void *data, int id) } static int wdt87xx_write_data(struct i2c_client *client, const char *data, - u32 address, int length) + u32 addr, size_t len) { - u16 packet_size; + size_t pkt_size; int count = 0; int error; u8 pkt_buf[PKT_BUF_SIZE]; /* Address and length should be 4 bytes aligned */ - if ((address & 0x3) != 0 || (length & 0x3) != 0) { + if ((addr & 0x3) != 0 || (len & 0x3) != 0) { dev_err(&client->dev, - "addr & len must be 4 bytes aligned %x, %x\n", - address, length); + "addr & len must be 4 bytes aligned %x, %zu\n", + addr, len); return -EINVAL; } - while (length) { - packet_size = min(length, PACKET_SIZE); + while (len) { + pkt_size = min_t(size_t, len, PACKET_SIZE); pkt_buf[CMD_REPORT_ID_OFFSET] = VND_REQ_WRITE; pkt_buf[CMD_TYPE_OFFSET] = VND_SET_DATA; - put_unaligned_le16(packet_size, &pkt_buf[CMD_INDEX_OFFSET]); - put_unaligned_le32(address, &pkt_buf[CMD_LENGTH_OFFSET]); - memcpy(&pkt_buf[CMD_DATA_OFFSET], data, packet_size); + put_unaligned_le16(pkt_size, &pkt_buf[CMD_INDEX_OFFSET]); + put_unaligned_le32(addr, &pkt_buf[CMD_LENGTH_OFFSET]); + memcpy(&pkt_buf[CMD_DATA_OFFSET], data, pkt_size); error = wdt87xx_set_feature(client, pkt_buf, sizeof(pkt_buf)); if (error) return error; - length -= packet_size; - data += packet_size; - address += packet_size; + len -= pkt_size; + data += pkt_size; + addr += pkt_size; /* Wait for the controller to finish the write */ mdelay(WDT_FLASH_WRITE_DELAY_MS); @@ -606,61 +1080,30 @@ static int wdt87xx_write_data(struct i2c_client *client, const char *data, return 0; } -static u16 misr(u16 cur_value, u8 new_value) -{ - u32 a, b; - u32 bit0; - u32 y; +static int wdt87xx_checksum_check(struct i2c_client *client, const char *data, + u32 addr, size_t len) - a = cur_value; - b = new_value; - bit0 = a ^ (b & 1); - bit0 ^= a >> 1; - bit0 ^= a >> 2; - bit0 ^= a >> 4; - bit0 ^= a >> 5; - bit0 ^= a >> 7; - bit0 ^= a >> 11; - bit0 ^= a >> 15; - y = (a << 1) ^ b; - y = (y & ~1) | (bit0 & 1); - - return (u16)y; -} - -static u16 wdt87xx_calculate_checksum(const u8 *data, size_t length) -{ - u16 checksum = 0; - size_t i; - - for (i = 0; i < length; i++) - checksum = misr(checksum, data[i]); - - return checksum; -} - -static int wdt87xx_get_checksum(struct i2c_client *client, u16 *checksum, - u32 address, int length) { int error; int time_delay; u8 pkt_buf[PKT_BUF_SIZE]; u8 cmd_buf[CMD_BUF_SIZE]; + u16 dev_chksum, fw_chksum; - error = wdt87xx_send_command(client, VND_SET_CHECKSUM_LENGTH, length); + error = wdt87xx_send_command(client, VND_SET_CHECKSUM_LENGTH, len); if (error) { dev_err(&client->dev, "failed to set checksum length\n"); return error; } - error = wdt87xx_send_command(client, VND_SET_CHECKSUM_CALC, address); + error = wdt87xx_send_command(client, VND_SET_CHECKSUM_CALC, addr); if (error) { dev_err(&client->dev, "failed to set checksum address\n"); return error; } /* Wait the operation to complete */ - time_delay = DIV_ROUND_UP(length, 1024); + time_delay = DIV_ROUND_UP(len, 1024); msleep(time_delay * 30); memset(cmd_buf, 0, sizeof(cmd_buf)); @@ -680,82 +1123,81 @@ static int wdt87xx_get_checksum(struct i2c_client *client, u16 *checksum, return error; } - *checksum = get_unaligned_le16(&pkt_buf[CMD_DATA_OFFSET]); - return 0; + dev_chksum = get_unaligned_le16(&pkt_buf[CMD_DATA_OFFSET]); + + /* Calculate the checksum in bytes */ + fw_chksum = wdt87xx_calculate_checksum(data, len, 1); + if (dev_chksum == fw_chksum) + return 0; + + dev_err(&client->dev, + "checksum fail: %d vs %d\n", dev_chksum, fw_chksum); + return -EAGAIN; } static int wdt87xx_write_firmware(struct i2c_client *client, const void *chunk) { - u32 start_addr = get_unaligned_le32(chunk + FW_CHUNK_TGT_START_OFFSET); - u32 size = get_unaligned_le32(chunk + FW_CHUNK_PAYLOAD_LEN_OFFSET); + u32 st_addr = get_unaligned_le32(chunk + FW_CHUNK_TGT_START_OFFSET); + size_t len = get_unaligned_le32(chunk + FW_CHUNK_PAYLOAD_LEN_OFFSET); const void *data = chunk + FW_CHUNK_PAYLOAD_OFFSET; int error; int err1; - int page_size; + int pg_size; int retry = 0; - u16 device_checksum, firmware_checksum; + struct wdt87xx_data *wdt = i2c_get_clientdata(client); dev_dbg(&client->dev, "start 4k page program\n"); - error = wdt87xx_send_command(client, VND_CMD_STOP, MODE_STOP); + error = wdt->send_cmd(client, VND_CMD_STOP, MODE_STOP); if (error) { - dev_err(&client->dev, "stop report mode failed\n"); + dev_err(&client->dev, "failed to stop report\n"); return error; } - error = wdt87xx_send_command(client, VND_CMD_SFUNL, 0); + error = wdt->send_cmd(client, VND_CMD_SFUNL, 0); if (error) { - dev_err(&client->dev, "unlock failed\n"); + dev_err(&client->dev, "failed to unlock flash\n"); goto out_enable_reporting; } - mdelay(10); + msleep(20); - while (size) { - dev_dbg(&client->dev, "%s: %x, %x\n", __func__, - start_addr, size); + while (len) { + dev_dbg(&client->dev, "%s: %x, %zu\n", __func__, st_addr, len); - page_size = min_t(u32, size, PG_SIZE); - size -= page_size; + pg_size = min_t(size_t, len, PG_SIZE); for (retry = 0; retry < MAX_RETRIES; retry++) { - error = wdt87xx_send_command(client, VND_CMD_ERASE, - start_addr); + error = wdt->send_cmd(client, VND_CMD_ERASE, st_addr); if (error) { dev_err(&client->dev, - "erase failed at %#08x\n", start_addr); + "erase failed at %#08x\n", st_addr); break; } - msleep(WDT_FLASH_ERASE_DELAY_MS); - - error = wdt87xx_write_data(client, data, start_addr, - page_size); + error = wdt->delay(client, W8752_ERASE4K_DELAY_MS); if (error) { dev_err(&client->dev, - "write failed at %#08x (%d bytes)\n", - start_addr, page_size); + "delay failed at %#08x\n", st_addr); break; } - error = wdt87xx_get_checksum(client, &device_checksum, - start_addr, page_size); + error = wdt->write_flash(client, data, st_addr, + pg_size); if (error) { dev_err(&client->dev, - "failed to retrieve checksum for %#08x (len: %d)\n", - start_addr, page_size); + "write failed at %#08x (%d bytes)\n", + st_addr, pg_size); break; } - firmware_checksum = - wdt87xx_calculate_checksum(data, page_size); - - if (device_checksum == firmware_checksum) + error = wdt->chksum_check(client, data, st_addr, + pg_size); + if (error != -EAGAIN) break; - dev_err(&client->dev, - "checksum fail: %d vs %d, retry %d\n", - device_checksum, firmware_checksum, retry); + dev_err(&client->dev, "checksum retry (%d) at 0x%x\n", + retry, st_addr); } if (retry == MAX_RETRIES) { @@ -763,22 +1205,22 @@ static int wdt87xx_write_firmware(struct i2c_client *client, const void *chunk) error = -EIO; goto out_lock_device; } - - start_addr = start_addr + page_size; - data = data + page_size; + len -= pg_size; + st_addr += pg_size; + data += pg_size; } out_lock_device: - err1 = wdt87xx_send_command(client, VND_CMD_SFLCK, 0); + err1 = wdt->send_cmd(client, VND_CMD_SFLCK, 0); if (err1) - dev_err(&client->dev, "lock failed\n"); + dev_err(&client->dev, "failed to lock flash\n"); - mdelay(10); + msleep(20); out_enable_reporting: - err1 = wdt87xx_send_command(client, VND_CMD_START, 0); + err1 = wdt->send_cmd(client, VND_CMD_START, 0); if (err1) - dev_err(&client->dev, "start to report failed\n"); + dev_err(&client->dev, "failed to restart to report\n"); return error ? error : err1; } @@ -796,7 +1238,7 @@ static int wdt87xx_load_chunk(struct i2c_client *client, return -EINVAL; } - error = wdt87xx_validate_fw_chunk(chunk, ck_id); + error = wdt87xx_validate_fw_chunk(client, chunk, ck_id); if (error) { dev_err(&client->dev, "invalid chunk (type %d): %d\n", ck_id, error); @@ -814,6 +1256,70 @@ static int wdt87xx_load_chunk(struct i2c_client *client, return 0; } +static int wdt87xx_get_param(struct wdt87xx_data *wdt) +{ + u8 buf[PKT_READ_SIZE]; + int error; + struct i2c_client *client = wdt->client; + struct wdt87xx_param *param = &wdt->param; + u16 param_key; + + buf[CMD_REPORT_ID_OFFSET] = VND_REQ_CTRLER_INFO; + error = wdt87xx_get_feature(client, buf, PACKET_SIZE); + if (error) + dev_err(&client->dev, "failed to get i2c cfg\n"); + + param_key = get_unaligned_le16(buf + W8752_PARAM_KEY_OFFSET); + if (buf[CMD_REPORT_ID_OFFSET] == VND_REQ_CTRLER_INFO && + param_key == W8752_PARAM_KEY) { + param->plat_id = buf[W8752_PLAT_ID_OFFSET]; + wdt87xx_parse_param(wdt, buf + W8752_PARAM_OFFSET, + get_unaligned_le16(buf + + W8752_PARAM_LEN_OFFSET)); + wdt->plt_id = PLT_WDT8752; + wdt->send_cmd = wdt8752_send_command; + wdt->write_flash = wdt8752_write_data; + wdt->delay = wdt8752_delay; + wdt->chksum_check = wdt8752_checksum_check; + error = wdt87xx_get_param_hid(wdt); + } else { + wdt->send_cmd = wdt87xx_send_command; + wdt->write_flash = wdt87xx_write_data; + wdt->delay = wdt87xx_delay; + wdt->chksum_check = wdt87xx_checksum_check; + error = wdt87xx_get_param_private(wdt); + } + + if (error < 0) + return error; + + dev_info(&client->dev, "pid: %04x, vid: %04x, w: %d, h: %d, i_sz: %d\n", + param->vendor_id, param->product_id, param->phy_w, + param->phy_h, wdt->hid_desc.max_input_length); + + buf[CMD_REPORT_ID_OFFSET] = VND_REQ_FW_INFO; + error = wdt87xx_get_feature(client, buf, 16); + if (error) { + dev_err(&client->dev, "failed to get firmware id\n"); + return error; + } + + if (buf[CMD_REPORT_ID_OFFSET] != VND_REQ_FW_INFO) { + dev_err(&client->dev, "wrong id of fw response: 0x%x\n", + buf[CMD_REPORT_ID_OFFSET]); + return -EINVAL; + } + + param->fw_id = get_unaligned_le16(&buf[1]); + + dev_info(&client->dev, + "fw_id: 0x%x, i2c_cfg: 0x%x, xml_id1: %04x, xml_id2: %04x\n", + param->fw_id, param->i2c_cfg, + param->xmls_id1, param->xmls_id2); + + return 0; +} + static int wdt87xx_do_update_firmware(struct i2c_client *client, const struct firmware *fw, unsigned int chunk_id) @@ -846,10 +1352,10 @@ static int wdt87xx_do_update_firmware(struct i2c_client *client, } /* Refresh the parameters */ - error = wdt87xx_get_sysparam(client, &wdt->param); + error = wdt87xx_get_param(wdt); if (error) dev_err(&client->dev, - "failed to refresh system parameters: %d\n", error); + "failed to refresh parameters: %d\n", error); out: enable_irq(client->irq); mutex_unlock(&wdt->fw_mutex); @@ -857,8 +1363,8 @@ out: return error ? error : 0; } -static int wdt87xx_update_firmware(struct device *dev, - const char *fw_name, unsigned int chunk_id) +static int wdt87xx_update_firmware(struct device *dev, const char *fw_name, + unsigned int chunk_id) { struct i2c_client *client = to_i2c_client(dev); const struct firmware *fw; @@ -950,30 +1456,29 @@ static const struct attribute_group wdt87xx_attr_group = { .attrs = wdt87xx_attrs, }; -static void wdt87xx_report_contact(struct input_dev *input, - struct wdt87xx_sys_param *param, - u8 *buf) +static void wdt87xx_report_contact(struct wdt87xx_data *wdt, + struct wdt87xx_param *param, u8 *buf) { + struct input_dev *input = wdt->input; int finger_id; u32 x, y, w; u8 p; - finger_id = (buf[FINGER_EV_V1_OFFSET_ID] >> 3) - 1; + finger_id = (buf[FINGER_EV_OFFSET_ID] >> 3) - 1; if (finger_id < 0) return; - /* Check if this is an active contact */ - if (!(buf[FINGER_EV_V1_OFFSET_ID] & 0x1)) + if (!(buf[FINGER_EV_OFFSET_ID] & 0x1)) return; - w = buf[FINGER_EV_V1_OFFSET_W]; + w = buf[FINGER_EV_OFFSET_W]; w *= param->scaling_factor; - p = buf[FINGER_EV_V1_OFFSET_P]; + p = buf[FINGER_EV_OFFSET_P]; - x = get_unaligned_le16(buf + FINGER_EV_V1_OFFSET_X); + x = get_unaligned_le16(buf + FINGER_EV_OFFSET_X); - y = get_unaligned_le16(buf + FINGER_EV_V1_OFFSET_Y); + y = get_unaligned_le16(buf + FINGER_EV_OFFSET_Y); y = DIV_ROUND_CLOSEST(y * param->phy_h, param->phy_w); /* Refuse incorrect coordinates */ @@ -997,23 +1502,30 @@ static irqreturn_t wdt87xx_ts_interrupt(int irq, void *dev_id) struct i2c_client *client = wdt->client; int i, fingers; int error; - u8 raw_buf[WDT_V1_RAW_BUF_COUNT] = {0}; + int offset = 0; + u8 raw_buf[WDT_RAW_BUF_COUNT] = {0}; + + if (wdt->hid_desc.max_input_length) { + offset = 2; + error = i2c_master_recv(client, raw_buf, + wdt->hid_desc.max_input_length); + } else { + error = i2c_master_recv(client, raw_buf, WDT_RAW_BUF_COUNT); + } - error = i2c_master_recv(client, raw_buf, WDT_V1_RAW_BUF_COUNT); if (error < 0) { - dev_err(&client->dev, "read v1 raw data failed: %d\n", error); + dev_err(&client->dev, "read raw data failed: %d\n", error); goto irq_exit; } - fingers = raw_buf[TOUCH_PK_V1_OFFSET_FNGR_NUM]; + fingers = raw_buf[offset + TOUCH_PK_OFFSET_FNGR_NUM]; if (!fingers) goto irq_exit; for (i = 0; i < WDT_MAX_FINGER; i++) - wdt87xx_report_contact(wdt->input, - &wdt->param, - &raw_buf[TOUCH_PK_V1_OFFSET_EVENT + - i * FINGER_EV_V1_SIZE]); + wdt87xx_report_contact(wdt, &wdt->param, + &raw_buf[offset + TOUCH_PK_OFFSET_EVENT + + i * FINGER_EV_SIZE]); input_mt_sync_frame(wdt->input); input_sync(wdt->input); @@ -1030,6 +1542,7 @@ static int wdt87xx_ts_create_input_device(struct wdt87xx_data *wdt) int error; input = devm_input_allocate_device(dev); + if (!input) { dev_err(dev, "failed to allocate input device\n"); return -ENOMEM; @@ -1089,7 +1602,7 @@ static int wdt87xx_ts_probe(struct i2c_client *client, snprintf(wdt->phys, sizeof(wdt->phys), "i2c-%u-%04x/input0", client->adapter->nr, client->addr); - error = wdt87xx_get_sysparam(client, &wdt->param); + error = wdt87xx_get_param(wdt); if (error) return error; @@ -1106,6 +1619,12 @@ static int wdt87xx_ts_probe(struct i2c_client *client, return error; } + error = device_init_wakeup(&client->dev, true); + if (error) { + dev_err(&client->dev, "inii wakeup failed: %d\n", error); + return error; + } + error = sysfs_create_group(&client->dev.kobj, &wdt87xx_attr_group); if (error) { dev_err(&client->dev, "create sysfs failed: %d\n", error); @@ -1125,16 +1644,22 @@ static int wdt87xx_ts_remove(struct i2c_client *client) static int __maybe_unused wdt87xx_suspend(struct device *dev) { struct i2c_client *client = to_i2c_client(dev); + struct wdt87xx_data *wdt = i2c_get_clientdata(client); int error; + int mode = MODE_IDLE; disable_irq(client->irq); - error = wdt87xx_send_command(client, VND_CMD_STOP, MODE_IDLE); + if (device_may_wakeup(dev)) + wdt->wake_irq_enabled = (enable_irq_wake(client->irq) == 0); + else if (wdt->plt_id == PLT_WDT8752) + mode = MODE_SLEEP; + + error = wdt->send_cmd(client, VND_CMD_STOP, mode); if (error) { enable_irq(client->irq); dev_err(&client->dev, - "failed to stop device when suspending: %d\n", - error); + "failed to stop device when suspending: %d\n", error); return error; } @@ -1144,19 +1669,28 @@ static int __maybe_unused wdt87xx_suspend(struct device *dev) static int __maybe_unused wdt87xx_resume(struct device *dev) { struct i2c_client *client = to_i2c_client(dev); + struct wdt87xx_data *wdt = i2c_get_clientdata(client); + u8 raw_buf[3] = {0}; int error; + if (device_may_wakeup(dev)) { + if (wdt->wake_irq_enabled) + disable_irq_wake(client->irq); + } else { + /* WDT8752 should wakeup device by read operation first */ + if (wdt->plt_id == PLT_WDT8752) + i2c_master_recv(client, raw_buf, 3); + } /* * The chip may have been reset while system is resuming, * give it some time to settle. */ mdelay(100); - error = wdt87xx_send_command(client, VND_CMD_START, 0); + error = wdt->send_cmd(client, VND_CMD_START, 0); if (error) dev_err(&client->dev, - "failed to start device when resuming: %d\n", - error); + "failed to start device when resuming: %d\n", error); enable_irq(client->irq); @@ -1169,6 +1703,7 @@ static const struct i2c_device_id wdt87xx_dev_id[] = { { WDT87XX_NAME, 0 }, { } }; + MODULE_DEVICE_TABLE(i2c, wdt87xx_dev_id); static const struct acpi_device_id wdt87xx_acpi_id[] = { -- 1.9.1
