2 * Copyright (C) 2012-2017 Hideep, Inc.
4 * This program is free software; you can redistribute it and/or modify it
5 * under the terms of the GNU General Public License version 2
6 * as published by the Free Software Foudation.
9 #include <linux/module.h>
11 #include <linux/firmware.h>
12 #include <linux/delay.h>
13 #include <linux/gpio.h>
14 #include <linux/gpio/machine.h>
15 #include <linux/i2c.h>
16 #include <linux/acpi.h>
17 #include <linux/interrupt.h>
18 #include <linux/regmap.h>
19 #include <linux/sysfs.h>
20 #include <linux/input.h>
21 #include <linux/input/mt.h>
22 #include <linux/input/touchscreen.h>
23 #include <linux/regulator/consumer.h>
24 #include <asm/unaligned.h>
26 #define HIDEEP_TS_NAME "HiDeep Touchscreen"
27 #define HIDEEP_I2C_NAME "hideep_ts"
29 #define HIDEEP_MT_MAX 10
30 #define HIDEEP_KEY_MAX 3
32 /* count(2) + touch data(100) + key data(6) */
33 #define HIDEEP_MAX_EVENT 108UL
35 #define HIDEEP_TOUCH_EVENT_INDEX 2
36 #define HIDEEP_KEY_EVENT_INDEX 102
38 /* Touch & key event */
39 #define HIDEEP_EVENT_ADDR 0x240
42 #define HIDEEP_RESET_CMD 0x9800
45 #define HIDEEP_MT_RELEASED BIT(4)
46 #define HIDEEP_KEY_PRESSED BIT(7)
47 #define HIDEEP_KEY_FIRST_PRESSED BIT(8)
48 #define HIDEEP_KEY_PRESSED_MASK (HIDEEP_KEY_PRESSED | \
49 HIDEEP_KEY_FIRST_PRESSED)
51 #define HIDEEP_KEY_IDX_MASK 0x0f
54 #define HIDEEP_YRAM_BASE 0x40000000
55 #define HIDEEP_PERIPHERAL_BASE 0x50000000
56 #define HIDEEP_ESI_BASE (HIDEEP_PERIPHERAL_BASE + 0x00000000)
57 #define HIDEEP_FLASH_BASE (HIDEEP_PERIPHERAL_BASE + 0x01000000)
58 #define HIDEEP_SYSCON_BASE (HIDEEP_PERIPHERAL_BASE + 0x02000000)
60 #define HIDEEP_SYSCON_MOD_CON (HIDEEP_SYSCON_BASE + 0x0000)
61 #define HIDEEP_SYSCON_SPC_CON (HIDEEP_SYSCON_BASE + 0x0004)
62 #define HIDEEP_SYSCON_CLK_CON (HIDEEP_SYSCON_BASE + 0x0008)
63 #define HIDEEP_SYSCON_CLK_ENA (HIDEEP_SYSCON_BASE + 0x000C)
64 #define HIDEEP_SYSCON_RST_CON (HIDEEP_SYSCON_BASE + 0x0010)
65 #define HIDEEP_SYSCON_WDT_CON (HIDEEP_SYSCON_BASE + 0x0014)
66 #define HIDEEP_SYSCON_WDT_CNT (HIDEEP_SYSCON_BASE + 0x0018)
67 #define HIDEEP_SYSCON_PWR_CON (HIDEEP_SYSCON_BASE + 0x0020)
68 #define HIDEEP_SYSCON_PGM_ID (HIDEEP_SYSCON_BASE + 0x00F4)
70 #define HIDEEP_FLASH_CON (HIDEEP_FLASH_BASE + 0x0000)
71 #define HIDEEP_FLASH_STA (HIDEEP_FLASH_BASE + 0x0004)
72 #define HIDEEP_FLASH_CFG (HIDEEP_FLASH_BASE + 0x0008)
73 #define HIDEEP_FLASH_TIM (HIDEEP_FLASH_BASE + 0x000C)
74 #define HIDEEP_FLASH_CACHE_CFG (HIDEEP_FLASH_BASE + 0x0010)
75 #define HIDEEP_FLASH_PIO_SIG (HIDEEP_FLASH_BASE + 0x400000)
77 #define HIDEEP_ESI_TX_INVALID (HIDEEP_ESI_BASE + 0x0008)
79 #define HIDEEP_PERASE 0x00040000
80 #define HIDEEP_WRONLY 0x00100000
82 #define HIDEEP_NVM_MASK_OFS 0x0000000C
83 #define HIDEEP_NVM_DEFAULT_PAGE 0
84 #define HIDEEP_NVM_SFR_WPAGE 1
85 #define HIDEEP_NVM_SFR_RPAGE 2
87 #define HIDEEP_PIO_SIG 0x00400000
88 #define HIDEEP_PROT_MODE 0x03400000
90 #define HIDEEP_NVM_PAGE_SIZE 128
92 #define HIDEEP_DWZ_INFO 0x000002C0
143 __be32 payload
[HIDEEP_NVM_PAGE_SIZE
/ sizeof(__be32
)];
146 #define HIDEEP_XFER_BUF_SIZE sizeof(struct pgm_packet)
149 struct i2c_client
*client
;
150 struct input_dev
*input_dev
;
153 struct touchscreen_properties prop
;
155 struct gpio_desc
*reset_gpio
;
157 struct regulator
*vcc_vdd
;
158 struct regulator
*vcc_vid
;
160 struct mutex dev_mutex
;
166 * Data buffer to read packet from the device (contacts and key
167 * states). We align it on double-word boundary to keep word-sized
168 * fields in contact data and double-word-sized fields in program
171 u8 xfer_buf
[HIDEEP_XFER_BUF_SIZE
] __aligned(4);
174 u32 key_codes
[HIDEEP_KEY_MAX
];
176 struct dwz_info dwz_info
;
178 unsigned int fw_size
;
182 static int hideep_pgm_w_mem(struct hideep_ts
*ts
, u32 addr
,
183 const __be32
*data
, size_t count
)
185 struct pgm_packet
*packet
= (void *)ts
->xfer_buf
;
186 size_t len
= count
* sizeof(*data
);
187 struct i2c_msg msg
= {
188 .addr
= ts
->client
->addr
,
189 .len
= len
+ sizeof(packet
->header
.len
) +
190 sizeof(packet
->header
.addr
),
191 .buf
= &packet
->header
.len
,
195 if (len
> HIDEEP_NVM_PAGE_SIZE
)
198 packet
->header
.len
= 0x80 | (count
- 1);
199 packet
->header
.addr
= cpu_to_be32(addr
);
200 memcpy(packet
->payload
, data
, len
);
202 ret
= i2c_transfer(ts
->client
->adapter
, &msg
, 1);
204 return ret
< 0 ? ret
: -EIO
;
209 static int hideep_pgm_r_mem(struct hideep_ts
*ts
, u32 addr
,
210 __be32
*data
, size_t count
)
212 struct pgm_packet
*packet
= (void *)ts
->xfer_buf
;
213 size_t len
= count
* sizeof(*data
);
214 struct i2c_msg msg
[] = {
216 .addr
= ts
->client
->addr
,
217 .len
= sizeof(packet
->header
.len
) +
218 sizeof(packet
->header
.addr
),
219 .buf
= &packet
->header
.len
,
222 .addr
= ts
->client
->addr
,
230 if (len
> HIDEEP_NVM_PAGE_SIZE
)
233 packet
->header
.len
= count
- 1;
234 packet
->header
.addr
= cpu_to_be32(addr
);
236 ret
= i2c_transfer(ts
->client
->adapter
, msg
, ARRAY_SIZE(msg
));
237 if (ret
!= ARRAY_SIZE(msg
))
238 return ret
< 0 ? ret
: -EIO
;
243 static int hideep_pgm_r_reg(struct hideep_ts
*ts
, u32 addr
, u32
*val
)
248 error
= hideep_pgm_r_mem(ts
, addr
, &data
, 1);
250 dev_err(&ts
->client
->dev
,
251 "read of register %#08x failed: %d\n",
256 *val
= be32_to_cpu(data
);
260 static int hideep_pgm_w_reg(struct hideep_ts
*ts
, u32 addr
, u32 val
)
262 __be32 data
= cpu_to_be32(val
);
265 error
= hideep_pgm_w_mem(ts
, addr
, &data
, 1);
267 dev_err(&ts
->client
->dev
,
268 "write to register %#08x (%#08x) failed: %d\n",
276 #define SW_RESET_IN_PGM(clk) \
278 hideep_pgm_w_reg(ts, HIDEEP_SYSCON_WDT_CNT, (clk)); \
279 hideep_pgm_w_reg(ts, HIDEEP_SYSCON_WDT_CON, 0x03); \
280 hideep_pgm_w_reg(ts, HIDEEP_SYSCON_WDT_CON, 0x01); \
283 #define SET_FLASH_PIO(ce) \
284 hideep_pgm_w_reg(ts, HIDEEP_FLASH_CON, \
287 #define SET_PIO_SIG(x, y) \
288 hideep_pgm_w_reg(ts, HIDEEP_FLASH_PIO_SIG + (x), (y))
290 #define SET_FLASH_HWCONTROL() \
291 hideep_pgm_w_reg(ts, HIDEEP_FLASH_CON, 0x00)
293 #define NVM_W_SFR(x, y) \
300 static void hideep_pgm_set(struct hideep_ts
*ts
)
302 hideep_pgm_w_reg(ts
, HIDEEP_SYSCON_WDT_CON
, 0x00);
303 hideep_pgm_w_reg(ts
, HIDEEP_SYSCON_SPC_CON
, 0x00);
304 hideep_pgm_w_reg(ts
, HIDEEP_SYSCON_CLK_ENA
, 0xFF);
305 hideep_pgm_w_reg(ts
, HIDEEP_SYSCON_CLK_CON
, 0x01);
306 hideep_pgm_w_reg(ts
, HIDEEP_SYSCON_PWR_CON
, 0x01);
307 hideep_pgm_w_reg(ts
, HIDEEP_FLASH_TIM
, 0x03);
308 hideep_pgm_w_reg(ts
, HIDEEP_FLASH_CACHE_CFG
, 0x00);
311 static int hideep_pgm_get_pattern(struct hideep_ts
*ts
, u32
*pattern
)
317 error
= regmap_bulk_write(ts
->reg
, p1
, &p2
, 1);
319 dev_err(&ts
->client
->dev
,
320 "%s: regmap_bulk_write() failed with %d\n",
325 usleep_range(1000, 1100);
327 /* flush invalid Tx load register */
328 error
= hideep_pgm_w_reg(ts
, HIDEEP_ESI_TX_INVALID
, 0x01);
332 error
= hideep_pgm_r_reg(ts
, HIDEEP_SYSCON_PGM_ID
, pattern
);
339 static int hideep_enter_pgm(struct hideep_ts
*ts
)
341 int retry_count
= 10;
345 while (retry_count
--) {
346 error
= hideep_pgm_get_pattern(ts
, &pattern
);
348 dev_err(&ts
->client
->dev
,
349 "hideep_pgm_get_pattern failed: %d\n", error
);
350 } else if (pattern
!= 0x39AF9DDF) {
351 dev_err(&ts
->client
->dev
, "%s: bad pattern: %#08x\n",
354 dev_dbg(&ts
->client
->dev
, "found magic code");
357 usleep_range(1000, 1100);
363 dev_err(&ts
->client
->dev
, "failed to enter pgm mode\n");
364 SW_RESET_IN_PGM(1000);
368 static void hideep_nvm_unlock(struct hideep_ts
*ts
)
372 hideep_pgm_w_reg(ts
, HIDEEP_FLASH_CFG
, HIDEEP_NVM_SFR_RPAGE
);
373 hideep_pgm_r_reg(ts
, 0x0000000C, &unmask_code
);
374 hideep_pgm_w_reg(ts
, HIDEEP_FLASH_CFG
, HIDEEP_NVM_DEFAULT_PAGE
);
376 /* make it unprotected code */
377 unmask_code
&= ~HIDEEP_PROT_MODE
;
379 /* compare unmask code */
380 if (unmask_code
!= ts
->nvm_mask
)
381 dev_warn(&ts
->client
->dev
,
382 "read mask code different %#08x vs %#08x",
383 unmask_code
, ts
->nvm_mask
);
385 hideep_pgm_w_reg(ts
, HIDEEP_FLASH_CFG
, HIDEEP_NVM_SFR_WPAGE
);
388 NVM_W_SFR(HIDEEP_NVM_MASK_OFS
, ts
->nvm_mask
);
389 SET_FLASH_HWCONTROL();
390 hideep_pgm_w_reg(ts
, HIDEEP_FLASH_CFG
, HIDEEP_NVM_DEFAULT_PAGE
);
393 static int hideep_check_status(struct hideep_ts
*ts
)
400 error
= hideep_pgm_r_reg(ts
, HIDEEP_FLASH_STA
, &status
);
401 if (!error
&& status
)
404 usleep_range(1000, 1100);
410 static int hideep_program_page(struct hideep_ts
*ts
, u32 addr
,
411 const __be32
*ucode
, size_t xfer_count
)
416 error
= hideep_check_status(ts
);
420 addr
&= ~(HIDEEP_NVM_PAGE_SIZE
- 1);
426 SET_PIO_SIG(HIDEEP_PERASE
| addr
, 0xFFFFFFFF);
430 error
= hideep_check_status(ts
);
437 val
= be32_to_cpu(ucode
[0]);
438 SET_PIO_SIG(HIDEEP_WRONLY
| addr
, val
);
440 hideep_pgm_w_mem(ts
, HIDEEP_FLASH_PIO_SIG
| HIDEEP_WRONLY
,
443 val
= be32_to_cpu(ucode
[xfer_count
- 1]);
444 SET_PIO_SIG(124, val
);
448 usleep_range(1000, 1100);
450 error
= hideep_check_status(ts
);
454 SET_FLASH_HWCONTROL();
459 static int hideep_program_nvm(struct hideep_ts
*ts
,
460 const __be32
*ucode
, size_t ucode_len
)
462 struct pgm_packet
*packet_r
= (void *)ts
->xfer_buf
;
463 __be32
*current_ucode
= packet_r
->payload
;
469 hideep_nvm_unlock(ts
);
471 while (ucode_len
> 0) {
472 xfer_len
= min_t(size_t, ucode_len
, HIDEEP_NVM_PAGE_SIZE
);
473 xfer_count
= xfer_len
/ sizeof(*ucode
);
475 error
= hideep_pgm_r_mem(ts
, 0x00000000 + addr
,
476 current_ucode
, xfer_count
);
478 dev_err(&ts
->client
->dev
,
479 "%s: failed to read page at offset %#08x: %d\n",
480 __func__
, addr
, error
);
484 /* See if the page needs updating */
485 if (memcmp(ucode
, current_ucode
, xfer_len
)) {
486 error
= hideep_program_page(ts
, addr
,
489 dev_err(&ts
->client
->dev
,
490 "%s: iwrite failure @%#08x: %d\n",
491 __func__
, addr
, error
);
495 usleep_range(1000, 1100);
500 ucode_len
-= xfer_len
;
506 static int hideep_verify_nvm(struct hideep_ts
*ts
,
507 const __be32
*ucode
, size_t ucode_len
)
509 struct pgm_packet
*packet_r
= (void *)ts
->xfer_buf
;
510 __be32
*current_ucode
= packet_r
->payload
;
517 while (ucode_len
> 0) {
518 xfer_len
= min_t(size_t, ucode_len
, HIDEEP_NVM_PAGE_SIZE
);
519 xfer_count
= xfer_len
/ sizeof(*ucode
);
521 error
= hideep_pgm_r_mem(ts
, 0x00000000 + addr
,
522 current_ucode
, xfer_count
);
524 dev_err(&ts
->client
->dev
,
525 "%s: failed to read page at offset %#08x: %d\n",
526 __func__
, addr
, error
);
530 if (memcmp(ucode
, current_ucode
, xfer_len
)) {
531 const u8
*ucode_bytes
= (const u8
*)ucode
;
532 const u8
*current_bytes
= (const u8
*)current_ucode
;
534 for (i
= 0; i
< xfer_len
; i
++)
535 if (ucode_bytes
[i
] != current_bytes
[i
])
536 dev_err(&ts
->client
->dev
,
537 "%s: mismatch @%#08x: (%#02x vs %#02x)\n",
547 ucode_len
-= xfer_len
;
553 static int hideep_load_dwz(struct hideep_ts
*ts
)
558 error
= hideep_enter_pgm(ts
);
564 error
= hideep_pgm_r_mem(ts
, HIDEEP_DWZ_INFO
,
565 (void *)&ts
->dwz_info
,
566 sizeof(ts
->dwz_info
) / sizeof(__be32
));
572 dev_err(&ts
->client
->dev
,
573 "failed to fetch DWZ data: %d\n", error
);
577 product_code
= be16_to_cpu(ts
->dwz_info
.product_code
);
579 switch (product_code
& 0xF0) {
581 dev_dbg(&ts
->client
->dev
, "used crimson IC");
582 ts
->fw_size
= 1024 * 48;
583 ts
->nvm_mask
= 0x00310000;
586 dev_dbg(&ts
->client
->dev
, "used lime IC");
587 ts
->fw_size
= 1024 * 64;
588 ts
->nvm_mask
= 0x0030027B;
591 dev_err(&ts
->client
->dev
, "product code is wrong: %#04x",
596 dev_dbg(&ts
->client
->dev
, "firmware release version: %#04x",
597 be16_to_cpu(ts
->dwz_info
.release_ver
));
602 static int hideep_flash_firmware(struct hideep_ts
*ts
,
603 const __be32
*ucode
, size_t ucode_len
)
608 while (retry_cnt
--) {
609 error
= hideep_program_nvm(ts
, ucode
, ucode_len
);
611 error
= hideep_verify_nvm(ts
, ucode
, ucode_len
);
620 static int hideep_update_firmware(struct hideep_ts
*ts
,
621 const __be32
*ucode
, size_t ucode_len
)
625 dev_dbg(&ts
->client
->dev
, "starting firmware update");
627 /* enter program mode */
628 error
= hideep_enter_pgm(ts
);
632 error
= hideep_flash_firmware(ts
, ucode
, ucode_len
);
634 dev_err(&ts
->client
->dev
,
635 "firmware update failed: %d\n", error
);
637 dev_dbg(&ts
->client
->dev
, "firmware updated successfully\n");
639 SW_RESET_IN_PGM(1000);
641 error2
= hideep_load_dwz(ts
);
643 dev_err(&ts
->client
->dev
,
644 "failed to load dwz after firmware update: %d\n",
647 return error
?: error2
;
650 static int hideep_power_on(struct hideep_ts
*ts
)
654 error
= regulator_enable(ts
->vcc_vdd
);
656 dev_err(&ts
->client
->dev
,
657 "failed to enable 'vdd' regulator: %d", error
);
659 usleep_range(999, 1000);
661 error
= regulator_enable(ts
->vcc_vid
);
663 dev_err(&ts
->client
->dev
,
664 "failed to enable 'vcc_vid' regulator: %d",
669 if (ts
->reset_gpio
) {
670 gpiod_set_value_cansleep(ts
->reset_gpio
, 0);
672 error
= regmap_write(ts
->reg
, HIDEEP_RESET_CMD
, 0x01);
674 dev_err(&ts
->client
->dev
,
675 "failed to send 'reset' command: %d\n", error
);
683 static void hideep_power_off(void *data
)
685 struct hideep_ts
*ts
= data
;
688 gpiod_set_value(ts
->reset_gpio
, 1);
690 regulator_disable(ts
->vcc_vid
);
691 regulator_disable(ts
->vcc_vdd
);
694 #define __GET_MT_TOOL_TYPE(type) ((type) == 0x01 ? MT_TOOL_FINGER : MT_TOOL_PEN)
696 static void hideep_report_slot(struct input_dev
*input
,
697 const struct hideep_event
*event
)
699 input_mt_slot(input
, event
->index
& 0x0f);
700 input_mt_report_slot_state(input
,
701 __GET_MT_TOOL_TYPE(event
->type
),
702 !(event
->flag
& HIDEEP_MT_RELEASED
));
703 if (!(event
->flag
& HIDEEP_MT_RELEASED
)) {
704 input_report_abs(input
, ABS_MT_POSITION_X
,
705 le16_to_cpup(&event
->x
));
706 input_report_abs(input
, ABS_MT_POSITION_Y
,
707 le16_to_cpup(&event
->y
));
708 input_report_abs(input
, ABS_MT_PRESSURE
,
709 le16_to_cpup(&event
->z
));
710 input_report_abs(input
, ABS_MT_TOUCH_MAJOR
, event
->w
);
714 static void hideep_parse_and_report(struct hideep_ts
*ts
)
716 const struct hideep_event
*events
=
717 (void *)&ts
->xfer_buf
[HIDEEP_TOUCH_EVENT_INDEX
];
718 const u8
*keys
= &ts
->xfer_buf
[HIDEEP_KEY_EVENT_INDEX
];
719 int touch_count
= ts
->xfer_buf
[0];
720 int key_count
= ts
->xfer_buf
[1] & 0x0f;
721 int lpm_count
= ts
->xfer_buf
[1] & 0xf0;
724 /* get touch event count */
725 dev_dbg(&ts
->client
->dev
, "mt = %d, key = %d, lpm = %02x",
726 touch_count
, key_count
, lpm_count
);
728 touch_count
= min(touch_count
, HIDEEP_MT_MAX
);
729 for (i
= 0; i
< touch_count
; i
++)
730 hideep_report_slot(ts
->input_dev
, events
+ i
);
732 key_count
= min(key_count
, HIDEEP_KEY_MAX
);
733 for (i
= 0; i
< key_count
; i
++) {
734 u8 key_data
= keys
[i
* 2];
736 input_report_key(ts
->input_dev
,
737 ts
->key_codes
[key_data
& HIDEEP_KEY_IDX_MASK
],
738 key_data
& HIDEEP_KEY_PRESSED_MASK
);
741 input_mt_sync_frame(ts
->input_dev
);
742 input_sync(ts
->input_dev
);
745 static irqreturn_t
hideep_irq(int irq
, void *handle
)
747 struct hideep_ts
*ts
= handle
;
750 BUILD_BUG_ON(HIDEEP_MAX_EVENT
> HIDEEP_XFER_BUF_SIZE
);
752 error
= regmap_bulk_read(ts
->reg
, HIDEEP_EVENT_ADDR
,
753 ts
->xfer_buf
, HIDEEP_MAX_EVENT
/ 2);
755 dev_err(&ts
->client
->dev
, "failed to read events: %d\n", error
);
759 hideep_parse_and_report(ts
);
765 static int hideep_get_axis_info(struct hideep_ts
*ts
)
770 error
= regmap_bulk_read(ts
->reg
, 0x28, val
, ARRAY_SIZE(val
));
774 ts
->prop
.max_x
= le16_to_cpup(val
);
775 ts
->prop
.max_y
= le16_to_cpup(val
+ 1);
777 dev_dbg(&ts
->client
->dev
, "X: %d, Y: %d",
778 ts
->prop
.max_x
, ts
->prop
.max_y
);
783 static int hideep_init_input(struct hideep_ts
*ts
)
785 struct device
*dev
= &ts
->client
->dev
;
789 ts
->input_dev
= devm_input_allocate_device(dev
);
790 if (!ts
->input_dev
) {
791 dev_err(dev
, "failed to allocate input device\n");
795 ts
->input_dev
->name
= HIDEEP_TS_NAME
;
796 ts
->input_dev
->id
.bustype
= BUS_I2C
;
797 input_set_drvdata(ts
->input_dev
, ts
);
799 input_set_capability(ts
->input_dev
, EV_ABS
, ABS_MT_POSITION_X
);
800 input_set_capability(ts
->input_dev
, EV_ABS
, ABS_MT_POSITION_Y
);
801 input_set_abs_params(ts
->input_dev
, ABS_MT_PRESSURE
, 0, 65535, 0, 0);
802 input_set_abs_params(ts
->input_dev
, ABS_MT_TOUCH_MAJOR
, 0, 255, 0, 0);
803 input_set_abs_params(ts
->input_dev
, ABS_MT_TOOL_TYPE
,
804 0, MT_TOOL_MAX
, 0, 0);
805 touchscreen_parse_properties(ts
->input_dev
, true, &ts
->prop
);
807 if (ts
->prop
.max_x
== 0 || ts
->prop
.max_y
== 0) {
808 error
= hideep_get_axis_info(ts
);
813 error
= input_mt_init_slots(ts
->input_dev
, HIDEEP_MT_MAX
,
818 ts
->key_num
= device_property_read_u32_array(dev
, "linux,keycodes",
820 if (ts
->key_num
> HIDEEP_KEY_MAX
) {
821 dev_err(dev
, "too many keys defined: %d\n",
826 if (ts
->key_num
<= 0) {
828 "missing or malformed 'linux,keycodes' property\n");
830 error
= device_property_read_u32_array(dev
, "linux,keycodes",
834 dev_dbg(dev
, "failed to read keymap: %d", error
);
839 ts
->input_dev
->keycode
= ts
->key_codes
;
840 ts
->input_dev
->keycodesize
= sizeof(ts
->key_codes
[0]);
841 ts
->input_dev
->keycodemax
= ts
->key_num
;
843 for (i
= 0; i
< ts
->key_num
; i
++)
844 input_set_capability(ts
->input_dev
, EV_KEY
,
849 error
= input_register_device(ts
->input_dev
);
851 dev_err(dev
, "failed to register input device: %d", error
);
858 static ssize_t
hideep_update_fw(struct device
*dev
,
859 struct device_attribute
*attr
,
860 const char *buf
, size_t count
)
862 struct i2c_client
*client
= to_i2c_client(dev
);
863 struct hideep_ts
*ts
= i2c_get_clientdata(client
);
864 const struct firmware
*fw_entry
;
869 error
= kstrtoint(buf
, 0, &mode
);
873 fw_name
= kasprintf(GFP_KERNEL
, "hideep_ts_%04x.bin",
874 be16_to_cpu(ts
->dwz_info
.product_id
));
878 error
= request_firmware(&fw_entry
, fw_name
, dev
);
880 dev_err(dev
, "failed to request firmware %s: %d",
882 goto out_free_fw_name
;
885 if (fw_entry
->size
% sizeof(__be32
)) {
886 dev_err(dev
, "invalid firmware size %zu\n", fw_entry
->size
);
891 if (fw_entry
->size
> ts
->fw_size
) {
892 dev_err(dev
, "fw size (%zu) is too big (memory size %d)\n",
893 fw_entry
->size
, ts
->fw_size
);
898 mutex_lock(&ts
->dev_mutex
);
899 disable_irq(client
->irq
);
901 error
= hideep_update_firmware(ts
, (const __be32
*)fw_entry
->data
,
904 enable_irq(client
->irq
);
905 mutex_unlock(&ts
->dev_mutex
);
908 release_firmware(fw_entry
);
912 return error
?: count
;
915 static ssize_t
hideep_fw_version_show(struct device
*dev
,
916 struct device_attribute
*attr
, char *buf
)
918 struct i2c_client
*client
= to_i2c_client(dev
);
919 struct hideep_ts
*ts
= i2c_get_clientdata(client
);
922 mutex_lock(&ts
->dev_mutex
);
923 len
= scnprintf(buf
, PAGE_SIZE
, "%04x\n",
924 be16_to_cpu(ts
->dwz_info
.release_ver
));
925 mutex_unlock(&ts
->dev_mutex
);
930 static ssize_t
hideep_product_id_show(struct device
*dev
,
931 struct device_attribute
*attr
, char *buf
)
933 struct i2c_client
*client
= to_i2c_client(dev
);
934 struct hideep_ts
*ts
= i2c_get_clientdata(client
);
937 mutex_lock(&ts
->dev_mutex
);
938 len
= scnprintf(buf
, PAGE_SIZE
, "%04x\n",
939 be16_to_cpu(ts
->dwz_info
.product_id
));
940 mutex_unlock(&ts
->dev_mutex
);
945 static DEVICE_ATTR(version
, 0664, hideep_fw_version_show
, NULL
);
946 static DEVICE_ATTR(product_id
, 0664, hideep_product_id_show
, NULL
);
947 static DEVICE_ATTR(update_fw
, 0664, NULL
, hideep_update_fw
);
949 static struct attribute
*hideep_ts_sysfs_entries
[] = {
950 &dev_attr_version
.attr
,
951 &dev_attr_product_id
.attr
,
952 &dev_attr_update_fw
.attr
,
956 static const struct attribute_group hideep_ts_attr_group
= {
957 .attrs
= hideep_ts_sysfs_entries
,
960 static int __maybe_unused
hideep_suspend(struct device
*dev
)
962 struct i2c_client
*client
= to_i2c_client(dev
);
963 struct hideep_ts
*ts
= i2c_get_clientdata(client
);
965 disable_irq(client
->irq
);
966 hideep_power_off(ts
);
971 static int __maybe_unused
hideep_resume(struct device
*dev
)
973 struct i2c_client
*client
= to_i2c_client(dev
);
974 struct hideep_ts
*ts
= i2c_get_clientdata(client
);
977 error
= hideep_power_on(ts
);
979 dev_err(&client
->dev
, "power on failed");
983 enable_irq(client
->irq
);
988 static SIMPLE_DEV_PM_OPS(hideep_pm_ops
, hideep_suspend
, hideep_resume
);
990 static const struct regmap_config hideep_regmap_config
= {
992 .reg_format_endian
= REGMAP_ENDIAN_LITTLE
,
994 .val_format_endian
= REGMAP_ENDIAN_LITTLE
,
995 .max_register
= 0xffff,
998 static int hideep_probe(struct i2c_client
*client
,
999 const struct i2c_device_id
*id
)
1001 struct hideep_ts
*ts
;
1005 if (!i2c_check_functionality(client
->adapter
, I2C_FUNC_I2C
)) {
1006 dev_err(&client
->dev
, "check i2c device error");
1010 if (client
->irq
<= 0) {
1011 dev_err(&client
->dev
, "missing irq: %d\n", client
->irq
);
1015 ts
= devm_kzalloc(&client
->dev
, sizeof(*ts
), GFP_KERNEL
);
1019 ts
->client
= client
;
1020 i2c_set_clientdata(client
, ts
);
1021 mutex_init(&ts
->dev_mutex
);
1023 ts
->reg
= devm_regmap_init_i2c(client
, &hideep_regmap_config
);
1024 if (IS_ERR(ts
->reg
)) {
1025 error
= PTR_ERR(ts
->reg
);
1026 dev_err(&client
->dev
,
1027 "failed to initialize regmap: %d\n", error
);
1031 ts
->vcc_vdd
= devm_regulator_get(&client
->dev
, "vdd");
1032 if (IS_ERR(ts
->vcc_vdd
))
1033 return PTR_ERR(ts
->vcc_vdd
);
1035 ts
->vcc_vid
= devm_regulator_get(&client
->dev
, "vid");
1036 if (IS_ERR(ts
->vcc_vid
))
1037 return PTR_ERR(ts
->vcc_vid
);
1039 ts
->reset_gpio
= devm_gpiod_get_optional(&client
->dev
,
1040 "reset", GPIOD_OUT_HIGH
);
1041 if (IS_ERR(ts
->reset_gpio
))
1042 return PTR_ERR(ts
->reset_gpio
);
1044 error
= hideep_power_on(ts
);
1046 dev_err(&client
->dev
, "power on failed: %d\n", error
);
1050 error
= devm_add_action_or_reset(&client
->dev
, hideep_power_off
, ts
);
1054 error
= hideep_load_dwz(ts
);
1056 dev_err(&client
->dev
, "failed to load dwz: %d", error
);
1060 error
= hideep_init_input(ts
);
1064 error
= devm_request_threaded_irq(&client
->dev
, client
->irq
,
1065 NULL
, hideep_irq
, IRQF_ONESHOT
,
1068 dev_err(&client
->dev
, "failed to request irq %d: %d\n",
1069 client
->irq
, error
);
1073 error
= devm_device_add_group(&client
->dev
, &hideep_ts_attr_group
);
1075 dev_err(&client
->dev
,
1076 "failed to add sysfs attributes: %d\n", error
);
1083 static const struct i2c_device_id hideep_i2c_id
[] = {
1084 { HIDEEP_I2C_NAME
, 0 },
1087 MODULE_DEVICE_TABLE(i2c
, hideep_i2c_id
);
1090 static const struct acpi_device_id hideep_acpi_id
[] = {
1094 MODULE_DEVICE_TABLE(acpi
, hideep_acpi_id
);
1098 static const struct of_device_id hideep_match_table
[] = {
1099 { .compatible
= "hideep,hideep-ts" },
1102 MODULE_DEVICE_TABLE(of
, hideep_match_table
);
1105 static struct i2c_driver hideep_driver
= {
1107 .name
= HIDEEP_I2C_NAME
,
1108 .of_match_table
= of_match_ptr(hideep_match_table
),
1109 .acpi_match_table
= ACPI_PTR(hideep_acpi_id
),
1110 .pm
= &hideep_pm_ops
,
1112 .id_table
= hideep_i2c_id
,
1113 .probe
= hideep_probe
,
1116 module_i2c_driver(hideep_driver
);
1118 MODULE_DESCRIPTION("Driver for HiDeep Touchscreen Controller");
1119 MODULE_AUTHOR("anthony.kim@hideep.com");
1120 MODULE_LICENSE("GPL v2");