/* Copyright 2018 The Chromium OS Authors. All rights reserved. * Use of this source code is governed by a BSD-style license that can be * found in the LICENSE file. */ #include "atomic.h" #include "board.h" #include "common.h" #include "console.h" #include "gpio.h" #include "hwtimer.h" #include "hooks.h" #include "i2c.h" #include "registers.h" #include "spi.h" #include "task.h" #include "tablet_mode.h" #include "timer.h" #include "touchpad.h" #include "touchpad_st.h" #include "update_fw.h" #include "usb_api.h" #include "usb_hid_touchpad.h" #include "usb_isochronous.h" #include "util.h" #include "watchdog.h" /* Console output macros */ #define CC_TOUCHPAD CC_USB #define CPUTS(outstr) cputs(CC_TOUCHPAD, outstr) #define CPRINTF(format, args...) cprintf(CC_TOUCHPAD, format, ## args) #define CPRINTS(format, args...) cprints(CC_TOUCHPAD, format, ## args) #define TASK_EVENT_POWER TASK_EVENT_CUSTOM_BIT(0) #define TASK_EVENT_TP_UPDATED TASK_EVENT_CUSTOM_BIT(1) #define SPI (&(spi_devices[SPI_ST_TP_DEVICE_ID])) BUILD_ASSERT(sizeof(struct st_tp_event_t) == 8); BUILD_ASSERT(BYTES_PER_PIXEL == 1); /* Function prototypes */ static int st_tp_panel_init(int full); static int st_tp_read_all_events(int show_error); static int st_tp_read_host_buffer_header(void); static int st_tp_send_ack(void); static int st_tp_start_scan(void); static int st_tp_stop_scan(void); static int st_tp_update_system_state(int new_state, int mask); static void touchpad_power_control(void); /* Global variables */ /* * Current system state, meaning of each bit is defined below. */ static int system_state; #define SYSTEM_STATE_DEBUG_MODE BIT(0) #define SYSTEM_STATE_ENABLE_HEAT_MAP BIT(1) #define SYSTEM_STATE_ENABLE_DOME_SWITCH BIT(2) #define SYSTEM_STATE_ACTIVE_MODE BIT(3) #define SYSTEM_STATE_DOME_SWITCH_LEVEL BIT(4) #define SYSTEM_STATE_READY BIT(5) /* * Pending action for touchpad. */ static int tp_control; #define TP_CONTROL_SHALL_HALT BIT(0) #define TP_CONTROL_SHALL_RESET BIT(1) #define TP_CONTROL_SHALL_INIT BIT(2) #define TP_CONTROL_SHALL_INIT_FULL BIT(3) #define TP_CONTROL_SHALL_DUMP_ERROR BIT(4) #define TP_CONTROL_RESETTING BIT(5) #define TP_CONTROL_INIT BIT(6) #define TP_CONTROL_INIT_FULL BIT(7) /* * Number of times we have reset the touchpad because of errors. */ static int tp_reset_retry_count; #define MAX_TP_RESET_RETRY_COUNT 3 static int dump_memory_on_error; /* * Bitmap to track if a finger exists. */ static int touch_slot; /* * Timestamp of last interrupt (32 bits are enough as we divide the value by 100 * and then put it in a 16-bit field). */ static uint32_t irq_ts; /* * Cached system info. */ static struct st_tp_system_info_t system_info; static struct { #if ST_TP_DUMMY_BYTE == 1 uint8_t dummy; #endif union { uint8_t bytes[512]; struct st_tp_host_buffer_header_t buffer_header; struct st_tp_host_buffer_heat_map_t heat_map; struct st_tp_host_data_header_t data_header; struct st_tp_event_t events[32]; uint32_t dump_info[32]; } /* anonymous */; } __packed rx_buf; #ifdef CONFIG_USB_ISOCHRONOUS #define USB_ISO_PACKET_SIZE 256 /* * Header of each USB pacaket. */ struct packet_header_t { uint8_t index; #define HEADER_FLAGS_NEW_FRAME BIT(0) uint8_t flags; } __packed; BUILD_ASSERT(sizeof(struct packet_header_t) < USB_ISO_PACKET_SIZE); static struct packet_header_t packet_header; /* What will be sent to USB interface. */ struct st_tp_usb_packet_t { #define USB_FRAME_FLAGS_BUTTON BIT(0) /* * This will be true if user clicked on touchpad. * TODO(b/70482333): add corresponding code for button signal. */ uint8_t flags; /* * This will be `st_tp_host_buffer_heat_map_t.frame` but each pixel * will be scaled to 8 bits value. */ uint8_t frame[ST_TOUCH_ROWS * ST_TOUCH_COLS]; } __packed; /* Next buffer index SPI will write to. */ static volatile uint32_t spi_buffer_index; /* Next buffer index USB will read from. */ static volatile uint32_t usb_buffer_index; static struct st_tp_usb_packet_t usb_packet[2]; /* double buffering */ /* How many bytes we have transmitted. */ static size_t transmit_report_offset; /* Function prototypes */ static int get_heat_map_addr(void); static void print_frame(void); static void st_tp_disable_heat_map(void); static void st_tp_enable_heat_map(void); static int st_tp_read_frame(void); static void st_tp_interrupt_send(void); DECLARE_DEFERRED(st_tp_interrupt_send); #endif /* Function implementations */ static void set_bits(int *lvalue, int rvalue, int mask) { *lvalue &= ~mask; *lvalue |= rvalue & mask; } /* * Parse a finger report from ST event and save it to (report)->finger. * * @param report: pointer to a USB HID touchpad report. * @param event: a pointer event from ST. * @param i: array index for next finger. * * @return array index of next finger (i.e. (i + 1) if a finger is added). */ static int st_tp_parse_finger(struct usb_hid_touchpad_report *report, struct st_tp_event_t *event, int i) { const int id = event->finger.touch_id; /* This is not a finger */ if (event->finger.touch_type == ST_TP_TOUCH_TYPE_INVALID) return i; if (event->evt_id == ST_TP_EVENT_ID_ENTER_POINTER) touch_slot |= 1 << id; else if (event->evt_id == ST_TP_EVENT_ID_LEAVE_POINTER) touch_slot &= ~BIT(id); /* We cannot report more fingers */ if (i >= ARRAY_SIZE(report->finger)) { CPRINTS("WARN: ST reports more than %d fingers", i); return i; } switch (event->evt_id) { case ST_TP_EVENT_ID_ENTER_POINTER: case ST_TP_EVENT_ID_MOTION_POINTER: /* Pressure == 255 is a palm. */ report->finger[i].confidence = (event->finger.z < 255); report->finger[i].tip = 1; report->finger[i].inrange = 1; report->finger[i].id = id; report->finger[i].pressure = event->finger.z; report->finger[i].width = (event->finger.minor | (event->minor_high << 4)) << 5; report->finger[i].height = (event->finger.major | (event->major_high << 4)) << 5; report->finger[i].x = (CONFIG_USB_HID_TOUCHPAD_LOGICAL_MAX_X - event->finger.x); report->finger[i].y = (CONFIG_USB_HID_TOUCHPAD_LOGICAL_MAX_Y - event->finger.y); break; case ST_TP_EVENT_ID_LEAVE_POINTER: report->finger[i].id = id; /* When a finger is leaving, it's not a palm */ report->finger[i].confidence = 1; break; } return i + 1; } /* * Read domeswitch level from touchpad, and save in `system_state`. * * After calling this function, use * `system_state & SYSTEM_STATE_DOME_SWITCH_LEVEL` * to get current value. * * @return error code on failure. */ static int st_tp_check_domeswitch_state(void) { int ret = st_tp_read_host_buffer_header(); if (ret) return ret; ret = rx_buf.buffer_header.flags & ST_TP_BUFFER_HEADER_DOMESWITCH_LVL; /* * Domeswitch level from device is inverted. * That is, 0 => pressed, 1 => released. */ set_bits(&system_state, ret ? 0 : SYSTEM_STATE_DOME_SWITCH_LEVEL, SYSTEM_STATE_DOME_SWITCH_LEVEL); return 0; } static int st_tp_write_hid_report(void) { int ret, i, num_finger, num_events; const int old_system_state = system_state; int domeswitch_changed; struct usb_hid_touchpad_report report; ret = st_tp_check_domeswitch_state(); if (ret) return ret; domeswitch_changed = ((old_system_state ^ system_state) & SYSTEM_STATE_DOME_SWITCH_LEVEL); num_events = st_tp_read_all_events(1); if (tp_control) return 1; memset(&report, 0, sizeof(report)); report.id = REPORT_ID_TOUCHPAD; num_finger = 0; for (i = 0; i < num_events; i++) { struct st_tp_event_t *e = &rx_buf.events[i]; switch (e->evt_id) { case ST_TP_EVENT_ID_ENTER_POINTER: case ST_TP_EVENT_ID_MOTION_POINTER: case ST_TP_EVENT_ID_LEAVE_POINTER: num_finger = st_tp_parse_finger(&report, e, num_finger); break; default: break; } } if (!num_finger && !domeswitch_changed) /* nothing changed */ return 0; /* Don't report 0 finger click. */ if (num_finger && (system_state & SYSTEM_STATE_DOME_SWITCH_LEVEL)) report.button = 1; report.count = num_finger; report.timestamp = irq_ts / USB_HID_TOUCHPAD_TIMESTAMP_UNIT; set_touchpad_report(&report); return 0; } static int st_tp_read_report(void) { if (system_state & SYSTEM_STATE_ENABLE_HEAT_MAP) { #ifdef CONFIG_USB_ISOCHRONOUS /* * Because we are using double buffering, so, if * usb_buffer_index = N * * 1. spi_buffer_index == N => ok, both slots are empty * 2. spi_buffer_index == N + 1 => ok, second slot is empty * 3. spi_buffer_index == N + 2 => not ok, need to wait for USB */ if (spi_buffer_index - usb_buffer_index <= 1) { if (st_tp_read_frame() == EC_SUCCESS) { spi_buffer_index++; if (system_state & SYSTEM_STATE_DEBUG_MODE) { print_frame(); usb_buffer_index++; } } } if (spi_buffer_index > usb_buffer_index) hook_call_deferred(&st_tp_interrupt_send_data, 0); #endif } else { st_tp_write_hid_report(); } return st_tp_send_ack(); } static int st_tp_read_host_buffer_header(void) { const uint8_t tx_buf[] = { ST_TP_CMD_READ_SPI_HOST_BUFFER, 0x00, 0x00 }; int rx_len = ST_TP_DUMMY_BYTE + sizeof(rx_buf.buffer_header); return spi_transaction(SPI, tx_buf, sizeof(tx_buf), (uint8_t *)&rx_buf, rx_len); } static int st_tp_send_ack(void) { uint8_t tx_buf[] = { ST_TP_CMD_SPI_HOST_BUFFER_ACK }; return spi_transaction(SPI, tx_buf, sizeof(tx_buf), NULL, 0); } static int st_tp_update_system_state(int new_state, int mask) { int ret = EC_SUCCESS; int need_locked_scan_mode = 0; /* copy reserved bits */ set_bits(&new_state, system_state, ~mask); mask = SYSTEM_STATE_DEBUG_MODE; if ((new_state & mask) != (system_state & mask)) set_bits(&system_state, new_state, mask); mask = SYSTEM_STATE_ENABLE_HEAT_MAP | SYSTEM_STATE_ENABLE_DOME_SWITCH; if ((new_state & mask) != (system_state & mask)) { uint8_t tx_buf[] = { ST_TP_CMD_WRITE_FEATURE_SELECT, 0x05, 0 }; if (new_state & SYSTEM_STATE_ENABLE_HEAT_MAP) { CPRINTS("Heatmap enabled"); tx_buf[2] |= BIT(0); need_locked_scan_mode = 1; } else { CPRINTS("Heatmap disabled"); } if (new_state & SYSTEM_STATE_ENABLE_DOME_SWITCH) tx_buf[2] |= BIT(1); ret = spi_transaction(SPI, tx_buf, sizeof(tx_buf), NULL, 0); if (ret) return ret; set_bits(&system_state, new_state, mask); } mask = SYSTEM_STATE_ACTIVE_MODE; if ((new_state & mask) != (system_state & mask)) { uint8_t tx_buf[] = { ST_TP_CMD_WRITE_SCAN_MODE_SELECT, ST_TP_SCAN_MODE_ACTIVE, !!(new_state & SYSTEM_STATE_ACTIVE_MODE), }; CPRINTS("Enable Multi-Touch: %d", tx_buf[2]); ret = spi_transaction(SPI, tx_buf, sizeof(tx_buf), NULL, 0); if (ret) return ret; set_bits(&system_state, new_state, mask); } /* * We need to lock scan mode to prevent scan rate drop when heat map * mode is enabled. */ if (need_locked_scan_mode) { uint8_t tx_buf[] = { ST_TP_CMD_WRITE_SCAN_MODE_SELECT, ST_TP_SCAN_MODE_LOCKED, 0x0, }; ret = spi_transaction(SPI, tx_buf, sizeof(tx_buf), NULL, 0); if (ret) return ret; } return ret; } static void st_tp_enable_interrupt(int enable) { uint8_t tx_buf[] = { ST_TP_CMD_WRITE_SYSTEM_COMMAND, 0x01, enable ? 1 : 0}; if (enable) gpio_enable_interrupt(GPIO_TOUCHPAD_INT); spi_transaction(SPI, tx_buf, sizeof(tx_buf), NULL, 0); if (!enable) gpio_disable_interrupt(GPIO_TOUCHPAD_INT); } static int st_tp_start_scan(void) { int new_state = (SYSTEM_STATE_ACTIVE_MODE | SYSTEM_STATE_ENABLE_DOME_SWITCH); int mask = new_state; int ret; CPRINTS("ST: Start scanning"); ret = st_tp_update_system_state(new_state, mask); if (ret) return ret; st_tp_send_ack(); st_tp_enable_interrupt(1); return ret; } static int st_tp_read_host_data_memory(uint16_t addr, void *rx_buf, int len) { uint8_t tx_buf[] = { ST_TP_CMD_READ_HOST_DATA_MEMORY, addr >> 8, addr & 0xFF }; return spi_transaction(SPI, tx_buf, sizeof(tx_buf), rx_buf, len); } static int st_tp_stop_scan(void) { int new_state = 0; int mask = SYSTEM_STATE_ACTIVE_MODE; int ret; CPRINTS("ST: Stop scanning"); ret = st_tp_update_system_state(new_state, mask); st_tp_enable_interrupt(0); return ret; } static int st_tp_load_host_data(uint8_t mem_id) { uint8_t tx_buf[] = { ST_TP_CMD_WRITE_SYSTEM_COMMAND, 0x06, mem_id }; int retry, ret; uint16_t count; struct st_tp_host_data_header_t *header = &rx_buf.data_header; int rx_len = sizeof(*header) + ST_TP_DUMMY_BYTE; st_tp_read_host_data_memory(0x0000, &rx_buf, rx_len); if (header->host_data_mem_id == mem_id) return EC_SUCCESS; /* already loaded no need to reload */ count = header->count; ret = spi_transaction(SPI, tx_buf, sizeof(tx_buf), NULL, 0); if (ret) return ret; ret = EC_ERROR_TIMEOUT; retry = 5; while (retry--) { st_tp_read_host_data_memory(0x0000, &rx_buf, rx_len); if (header->magic == ST_TP_HEADER_MAGIC && header->host_data_mem_id == mem_id && header->count != count) { ret = EC_SUCCESS; break; } msleep(10); } return ret; } /* * Read System Info from Host Data Memory. * * @param reload: true to force reloading system info into host data memory * before reading. */ static int st_tp_read_system_info(int reload) { int ret = EC_SUCCESS; int rx_len = ST_TP_DUMMY_BYTE + ST_TP_SYSTEM_INFO_LEN; uint8_t *ptr = rx_buf.bytes; if (reload) ret = st_tp_load_host_data(ST_TP_MEM_ID_SYSTEM_INFO); if (ret) return ret; ret = st_tp_read_host_data_memory(0x0000, &rx_buf, rx_len); if (ret) return ret; /* Parse the content */ memcpy(&system_info, ptr, ST_TP_SYSTEM_INFO_PART_1_SIZE); /* Check header */ if (system_info.header.magic != ST_TP_HEADER_MAGIC || system_info.header.host_data_mem_id != ST_TP_MEM_ID_SYSTEM_INFO) return EC_ERROR_UNKNOWN; ptr += ST_TP_SYSTEM_INFO_PART_1_SIZE; ptr += ST_TP_SYSTEM_INFO_PART_1_RESERVED; memcpy(&system_info.scr_res_x, ptr, ST_TP_SYSTEM_INFO_PART_2_SIZE); #define ST_TP_SHOW(attr) CPRINTS(#attr ": %04x", system_info.attr) ST_TP_SHOW(chip0_id[0]); ST_TP_SHOW(chip0_id[1]); ST_TP_SHOW(chip0_ver); ST_TP_SHOW(scr_tx_len); ST_TP_SHOW(scr_rx_len); ST_TP_SHOW(release_info); #undef ST_TP_SHOW return ret; } /* * Enable / disable deep sleep on memory and bus. * * Before calling dump_error() and dump_error(), deep sleep should be disabled, * otherwise response data might be garbage. */ static void enable_deep_sleep(int enable) { uint8_t cmd[] = {0xFA, 0x20, 0x00, 0x00, 0x68, enable ? 0x0B : 0x08}; spi_transaction(SPI, cmd, sizeof(cmd), NULL, 0); } static void dump_error(void) { uint8_t tx_buf[] = {0xFB, 0x20, 0x01, 0xEF, 0x80}; int rx_len = sizeof(rx_buf.dump_info) + ST_TP_DUMMY_BYTE; int i; spi_transaction(SPI, tx_buf, sizeof(tx_buf), (uint8_t *)&rx_buf, rx_len); for (i = 0; i < ARRAY_SIZE(rx_buf.dump_info); i += 4) CPRINTS("%08x %08x %08x %08x", rx_buf.dump_info[i + 0], rx_buf.dump_info[i + 1], rx_buf.dump_info[i + 2], rx_buf.dump_info[i + 3]); msleep(8); } /* * Dump entire 64K memory on touchpad. * * This is very time consuming. For now, let's disable this in production * build. */ static void dump_memory(void) { uint32_t size = 0x10000, rx_len = 512 + ST_TP_DUMMY_BYTE; uint32_t offset, i; uint8_t cmd[] = {0xFB, 0x00, 0x10, 0x00, 0x00}; if (!dump_memory_on_error) return; for (offset = 0; offset < size; offset += 512) { cmd[3] = (offset >> 8) & 0xFF; cmd[4] = (offset >> 0) & 0xFF; spi_transaction(SPI, cmd, sizeof(cmd), (uint8_t *)&rx_buf, rx_len); for (i = 0; i < rx_len - ST_TP_DUMMY_BYTE; i += 32) { CPRINTF("%.4h %.4h %.4h %.4h %.4h %.4h %.4h %.4h\n", rx_buf.bytes + i + 4 * 0, rx_buf.bytes + i + 4 * 1, rx_buf.bytes + i + 4 * 2, rx_buf.bytes + i + 4 * 3, rx_buf.bytes + i + 4 * 4, rx_buf.bytes + i + 4 * 5, rx_buf.bytes + i + 4 * 6, rx_buf.bytes + i + 4 * 7); msleep(8); } } CPRINTF("===============================\n"); msleep(8); } /* * Set `tp_control` if there are any actions should be taken. */ static void st_tp_handle_error(uint8_t error_type) { tp_control |= TP_CONTROL_SHALL_DUMP_ERROR; /* * Suggest action: memory dump and power cycle. */ if (error_type <= 0x06 || error_type == 0xF1 || error_type == 0xF2 || error_type == 0xF3 || (error_type >= 0x47 && error_type <= 0x4E)) { tp_control |= TP_CONTROL_SHALL_RESET; return; } /* * Suggest action: FW shall halt, consult ST. */ if ((error_type >= 0x20 && error_type <= 0x23) || error_type == 0x25 || (error_type >= 0x2E && error_type <= 0x46)) { CPRINTS("tp shall halt"); tp_control |= TP_CONTROL_SHALL_HALT; return; } /* * Corrupted panel configuration, a panel init should fix it. */ if (error_type >= 0x28 && error_type <= 0x29) { tp_control |= TP_CONTROL_SHALL_INIT; return; } /* * Corrupted CX section, a full panel init should fix it. */ if (error_type >= 0xA0 && error_type <= 0xA6) { tp_control |= TP_CONTROL_SHALL_INIT_FULL; return; } /* * When 0xFF is received, it's very likely ST touchpad is down. * Try if touchpad can be recovered by reset. */ if (error_type == 0xFF) { if (tp_reset_retry_count < MAX_TP_RESET_RETRY_COUNT) { tp_control |= TP_CONTROL_SHALL_RESET; tp_reset_retry_count++; } else { tp_control |= TP_CONTROL_SHALL_HALT; } return; } } /* * Handles error reports. */ static void st_tp_handle_error_report(struct st_tp_event_t *e) { uint8_t error_type = e->report.report_type; CPRINTS("Touchpad error: %x %x", error_type, ((e->report.info[0] << 0) | (e->report.info[1] << 8) | (e->report.info[2] << 16) | (e->report.info[3] << 24))); st_tp_handle_error(error_type); } static void st_tp_handle_status_report(struct st_tp_event_t *e) { static uint32_t prev_idle_count; uint32_t info = ((e->report.info[0] << 0) | (e->report.info[1] << 8) | (e->report.info[2] << 16) | (e->report.info[3] << 24)); if (e->report.report_type == ST_TP_STATUS_FCAL || e->report.report_type == ST_TP_STATUS_FRAME_DROP) CPRINTS("TP STATUS REPORT: %02x %08x", e->report.report_type, info); /* * Idle count might not change if ST FW is busy (for example, when the * user puts a big palm on touchpad). Therefore if idle count doesn't * change, we need to double check with touch count. * * If touch count is 0, and idle count doesn't change, it means that: * * 1) ST doesn't think there are any fingers. * 2) ST is busy on something, can't get into idle mode, and this * might cause (1). * * Resetting touchpad should be the correct action. */ if (e->report.report_type == ST_TP_STATUS_BEACON) { #if 0 const uint8_t touch_count = e->report.reserved; CPRINTS("BEACON: idle count=%08x", info); CPRINTS(" touch count=%d touch slot=%04x", touch_count, touch_slot); #endif if (prev_idle_count == info && touch_slot == 0) { CPRINTS(" idle count=%08x not changed", info); tp_control |= TP_CONTROL_SHALL_RESET; return; } prev_idle_count = info; } } /* * Read all events, and handle errors. * * When there are error events, suggested action will be saved in `tp_control`. * * @param show_error: weather EC should read and dump error or not. * ***If this is true, rx_buf.events[] will be cleared.*** * * @return number of events available */ static int st_tp_read_all_events(int show_error) { uint8_t cmd = ST_TP_CMD_READ_ALL_EVENTS; int rx_len = sizeof(rx_buf.events) + ST_TP_DUMMY_BYTE; int i; if (spi_transaction(SPI, &cmd, 1, (uint8_t *)&rx_buf, rx_len)) return 0; for (i = 0; i < ARRAY_SIZE(rx_buf.events); i++) { struct st_tp_event_t *e = &rx_buf.events[i]; if (e->magic != ST_TP_EVENT_MAGIC) break; switch (e->evt_id) { case ST_TP_EVENT_ID_ERROR_REPORT: st_tp_handle_error_report(e); break; case ST_TP_EVENT_ID_STATUS_REPORT: st_tp_handle_status_report(e); break; } } if (show_error && (tp_control & TP_CONTROL_SHALL_DUMP_ERROR)) { enable_deep_sleep(0); dump_error(); dump_memory(); enable_deep_sleep(1); /* rx_buf.events[] is invalid now */ i = 0; } tp_control &= ~TP_CONTROL_SHALL_DUMP_ERROR; return i; } /* * Reset touchpad. This function will wait for "controller ready" event after * the touchpad is reset. */ static int st_tp_reset(void) { int i, num_events, retry = 100; board_touchpad_reset(); while (retry--) { num_events = st_tp_read_all_events(0); /* * We are not doing full panel initialization, and error code * suggest us to reset or halt. */ if (!(tp_control & (TP_CONTROL_INIT | TP_CONTROL_INIT_FULL)) && (tp_control & (TP_CONTROL_SHALL_HALT | TP_CONTROL_SHALL_RESET))) break; for (i = 0; i < num_events; i++) { struct st_tp_event_t *e = &rx_buf.events[i]; if (e->evt_id == ST_TP_EVENT_ID_CONTROLLER_READY) { CPRINTS("Touchpad ready"); tp_reset_retry_count = 0; return 0; } } msleep(10); } CPRINTS("Timeout waiting for controller ready."); return EC_ERROR_TIMEOUT; } /* Initialize the controller ICs after reset */ static void st_tp_init(void) { tp_control = 0; system_state = 0; if (st_tp_reset()) return; if (tp_control) { CPRINTS("tp_control = %x", tp_control); return; } /* * On boot, ST firmware will load system info to host data memory, * So we don't need to reload it. */ st_tp_read_system_info(0); system_state = SYSTEM_STATE_READY; touch_slot = 0; touchpad_power_control(); } DECLARE_DEFERRED(st_tp_init); #ifdef CONFIG_USB_UPDATE int touchpad_get_info(struct touchpad_info *tp) { if (st_tp_read_system_info(1)) { tp->status = EC_RES_SUCCESS; tp->vendor = ST_VENDOR_ID; /* * failed to get system info, FW corrupted, return some default * values. */ tp->st.id = 0x3936; tp->st.fw_version = 0; tp->st.fw_checksum = 0; return sizeof(*tp); } tp->status = EC_RES_SUCCESS; tp->vendor = ST_VENDOR_ID; tp->st.id = (system_info.chip0_id[0] << 8) | system_info.chip0_id[1]; tp->st.fw_version = system_info.release_info; tp->st.fw_checksum = system_info.fw_crc; return sizeof(*tp); } /* * Helper functions for firmware update * * There is no documentation about ST_TP_CMD_WRITE_HW_REG (0xFA). * All implementations below are based on sample code from ST. */ static int write_hwreg_cmd32(uint32_t address, uint32_t data) { uint8_t tx_buf[] = { ST_TP_CMD_WRITE_HW_REG, (address >> 24) & 0xFF, (address >> 16) & 0xFF, (address >> 8) & 0xFF, (address >> 0) & 0xFF, (data >> 24) & 0xFF, (data >> 16) & 0xFF, (data >> 8) & 0xFF, (data >> 0) & 0xFF, }; return spi_transaction(SPI, tx_buf, sizeof(tx_buf), NULL, 0); } static int write_hwreg_cmd8(uint32_t address, uint8_t data) { uint8_t tx_buf[] = { ST_TP_CMD_WRITE_HW_REG, (address >> 24) & 0xFF, (address >> 16) & 0xFF, (address >> 8) & 0xFF, (address >> 0) & 0xFF, data, }; return spi_transaction(SPI, tx_buf, sizeof(tx_buf), NULL, 0); } static int wait_for_flash_ready(uint8_t type) { uint8_t tx_buf[] = { ST_TP_CMD_READ_HW_REG, 0x20, 0x00, 0x00, type, }; int ret = EC_SUCCESS, retry = 200; while (retry--) { ret = spi_transaction(SPI, tx_buf, sizeof(tx_buf), (uint8_t *)&rx_buf, 1 + ST_TP_DUMMY_BYTE); if (ret == EC_SUCCESS && !(rx_buf.bytes[0] & 0x80)) break; msleep(50); } return retry >= 0 ? ret : EC_ERROR_TIMEOUT; } static int erase_flash(int full_init_required) { int ret; if (full_init_required) ret = write_hwreg_cmd32(0x20000128, 0xFFFFFFFF); else /* Erase everything, except CX */ ret = write_hwreg_cmd32(0x20000128, 0xFFFFFF83); if (ret) return ret; ret = write_hwreg_cmd8(0x2000006B, 0x00); if (ret) return ret; ret = write_hwreg_cmd8(0x2000006A, 0xA0); if (ret) return ret; return wait_for_flash_ready(0x6A); } static int st_tp_prepare_for_update(int full_init_required) { /* hold m3 */ write_hwreg_cmd8(0x20000024, 0x01); /* unlock flash */ write_hwreg_cmd8(0x20000025, 0x20); /* unlock flash erase */ write_hwreg_cmd8(0x200000DE, 0x03); erase_flash(full_init_required); return EC_SUCCESS; } static int st_tp_start_flash_dma(void) { int ret; ret = write_hwreg_cmd8(0x20000071, 0xC0); if (ret) return ret; ret = wait_for_flash_ready(0x71); return ret; } static int st_tp_write_one_chunk(const uint8_t *head, uint32_t addr, uint32_t chunk_size) { uint8_t tx_buf[ST_TP_DMA_CHUNK_SIZE + 5]; uint32_t index = 0; int ret; index = 0; tx_buf[index++] = ST_TP_CMD_WRITE_HW_REG; tx_buf[index++] = (addr >> 24) & 0xFF; tx_buf[index++] = (addr >> 16) & 0xFF; tx_buf[index++] = (addr >> 8) & 0xFF; tx_buf[index++] = (addr >> 0) & 0xFF; memcpy(tx_buf + index, head, chunk_size); ret = spi_transaction(SPI, tx_buf, chunk_size + 5, NULL, 0); return ret; } /* * @param offset: offset in memory to copy the data (in bytes). * @param size: length of data (in bytes). * @param data: pointer to data bytes. */ static int st_tp_write_flash(int offset, int size, const uint8_t *data) { uint8_t tx_buf[12] = {0}; const uint8_t *head = data, *tail = data + size; uint32_t addr, index, chunk_size; uint32_t flash_buffer_size; int ret; offset >>= 2; /* offset should be count in words */ /* * To write to flash, the data has to be separated into several chunks. * Each chunk will be no more than `ST_TP_DMA_CHUNK_SIZE` bytes. * The chunks will first be saved into a buffer, the buffer can only * holds `ST_TP_FLASH_BUFFER_SIZE` bytes. We have to flush the buffer * when the capacity is reached. */ while (head < tail) { addr = 0x00100000; flash_buffer_size = 0; while (flash_buffer_size < ST_TP_FLASH_BUFFER_SIZE) { chunk_size = MIN(ST_TP_DMA_CHUNK_SIZE, tail - head); ret = st_tp_write_one_chunk(head, addr, chunk_size); if (ret) return ret; flash_buffer_size += chunk_size; addr += chunk_size; head += chunk_size; if (head >= tail) break; } /* configuring the DMA */ flash_buffer_size = flash_buffer_size / 4 - 1; index = 0; tx_buf[index++] = ST_TP_CMD_WRITE_HW_REG; tx_buf[index++] = 0x20; tx_buf[index++] = 0x00; tx_buf[index++] = 0x00; tx_buf[index++] = 0x72; /* flash DMA config */ tx_buf[index++] = 0x00; tx_buf[index++] = 0x00; tx_buf[index++] = offset & 0xFF; tx_buf[index++] = (offset >> 8) & 0xFF; tx_buf[index++] = flash_buffer_size & 0xFF; tx_buf[index++] = (flash_buffer_size >> 8) & 0xFF; tx_buf[index++] = 0x00; ret = spi_transaction(SPI, tx_buf, index, NULL, 0); if (ret) return ret; ret = st_tp_start_flash_dma(); if (ret) return ret; offset += ST_TP_FLASH_BUFFER_SIZE / 4; } return EC_SUCCESS; } static int st_tp_check_command_echo(const uint8_t *cmd, const size_t len) { int num_events, i; num_events = st_tp_read_all_events(0); for (i = 0; i < num_events; i++) { struct st_tp_event_t *e = &rx_buf.events[i]; if (e->evt_id == ST_TP_EVENT_ID_STATUS_REPORT && e->report.report_type == ST_TP_STATUS_CMD_ECHO && memcmp(e->report.info, cmd, MIN(4, len)) == 0) return EC_SUCCESS; } return EC_ERROR_BUSY; } static uint8_t get_cx_version(uint8_t tp_version) { /* * CX version is tracked by ST release note: go/whiskers-st-release-note */ if (tp_version >= 32) return 3; if (tp_version >= 20) return 2; if (tp_version >= 18) return 1; return 0; } /* * Perform panel initialization. * * This function will wait until the initialization is done, or 10 second * timeout is reached. * * @param full: 1 => force "full" panel initialization. Otherwise, tp_control * will be checked to decide if full panel initialization is * required. * * @return EC_SUCCESS or error code. */ static int st_tp_panel_init(int full) { uint8_t tx_buf[] = { ST_TP_CMD_WRITE_SYSTEM_COMMAND, 0x00, 0x02 }; int ret, retry; if (tp_control & (TP_CONTROL_INIT | TP_CONTROL_INIT_FULL)) return EC_ERROR_BUSY; st_tp_stop_scan(); ret = st_tp_reset(); /* * TODO(b:118312397): Figure out how to handle st_tp_reset errors (if * needed at all). */ CPRINTS("st_tp_reset ret=%d", ret); full |= tp_control & TP_CONTROL_SHALL_INIT_FULL; if (full) { /* should perform full panel initialization */ tx_buf[2] = 0x3; tp_control = TP_CONTROL_INIT_FULL; } else { tp_control = TP_CONTROL_INIT; } CPRINTS("Start panel initialization (full=%d)", full); spi_transaction(SPI, tx_buf, sizeof(tx_buf), NULL, 0); retry = 100; while (retry--) { watchdog_reload(); msleep(100); ret = st_tp_check_command_echo(tx_buf, sizeof(tx_buf)); if (ret == EC_SUCCESS) { CPRINTS("Panel initialization completed."); tp_control &= ~(TP_CONTROL_INIT | TP_CONTROL_INIT_FULL); st_tp_init(); return EC_SUCCESS; } else if (ret == EC_ERROR_BUSY) { CPRINTS("Panel initialization on going..."); } else if (tp_control & ~(TP_CONTROL_INIT | TP_CONTROL_INIT_FULL)) { /* there are other kind of errors. */ CPRINTS("Panel initialization failed, tp_control: %x", tp_control); return EC_ERROR_UNKNOWN; } } return EC_ERROR_TIMEOUT; } /* * @param offset: should be address between 0 to 1M, aligned with * ST_TP_DMA_CHUNK_SIZE. * @param size: length of `data` array. * @param data: content of new touchpad firmware. */ int touchpad_update_write(int offset, int size, const uint8_t *data) { static int full_init_required; int ret, flash_offset; CPRINTS("%s %08x %d", __func__, offset, size); if (offset == 0) { const struct st_tp_fw_header_t *header; uint8_t old_cx_version; uint8_t new_cx_version; int retry; header = (const struct st_tp_fw_header_t *)data; if (header->signature != 0xAA55AA55) return EC_ERROR_INVAL; for (retry = 50; retry > 0; retry--) { watchdog_reload(); if (system_state & SYSTEM_STATE_READY) break; if (retry % 10 == 0) CPRINTS("TP not ready for update, " "will check again"); msleep(100); } old_cx_version = get_cx_version(system_info.release_info); new_cx_version = get_cx_version(header->release_info); full_init_required = old_cx_version != new_cx_version; /* stop scanning, interrupt, etc... */ st_tp_stop_scan(); ret = st_tp_prepare_for_update(full_init_required); if (ret) return ret; return EC_SUCCESS; } flash_offset = offset - CONFIG_UPDATE_PDU_SIZE; if (flash_offset % ST_TP_DMA_CHUNK_SIZE) return EC_ERROR_INVAL; if (flash_offset >= ST_TP_FLASH_OFFSET_PANEL_CFG && flash_offset < ST_TP_FLASH_OFFSET_CONFIG) /* don't update CX section && panel config section */ return EC_SUCCESS; ret = st_tp_write_flash(flash_offset, size, data); if (ret) return ret; if (offset + size == CONFIG_TOUCHPAD_VIRTUAL_SIZE) { CPRINTS("%s: End update, wait for reset.", __func__); ret = st_tp_panel_init(full_init_required); task_set_event(TASK_ID_TOUCHPAD, TASK_EVENT_TP_UPDATED, 0); return ret; } return EC_SUCCESS; } int touchpad_debug(const uint8_t *param, unsigned int param_size, uint8_t **data, unsigned int *data_size) { static uint8_t buf[8]; int num_events; if (param_size != 1) return EC_RES_INVALID_PARAM; switch (*param) { case ST_TP_DEBUG_CMD_RESET_TOUCHPAD: *data = NULL; *data_size = 0; st_tp_stop_scan(); hook_call_deferred(&st_tp_init_data, 100 * MSEC); return EC_SUCCESS; case ST_TP_DEBUG_CMD_CALIBRATE: /* no return value */ *data = NULL; *data_size = 0; st_tp_panel_init(1); return EC_SUCCESS; case ST_TP_DEBUG_CMD_START_SCAN: *data = NULL; *data_size = 0; st_tp_start_scan(); return EC_SUCCESS; case ST_TP_DEBUG_CMD_STOP_SCAN: *data = NULL; *data_size = 0; st_tp_stop_scan(); return EC_SUCCESS; case ST_TP_DEBUG_CMD_READ_BUF_HEADER: *data = buf; *data_size = 8; st_tp_read_host_buffer_header(); memcpy(buf, rx_buf.bytes, *data_size); CPRINTS("header: %.*h", *data_size, buf); return EC_SUCCESS; case ST_TP_DEBUG_CMD_READ_EVENTS: num_events = st_tp_read_all_events(0); if (num_events) { int i; for (i = 0; i < num_events; i++) { CPRINTS("event[%d]: id=%d, type=%d", i, rx_buf.events[i].evt_id, rx_buf.events[i].report.report_type); } } *data = buf; *data_size = 1; *data[0] = num_events; st_tp_send_ack(); return EC_SUCCESS; } return EC_RES_INVALID_PARAM; } #endif void touchpad_interrupt(enum gpio_signal signal) { irq_ts = __hw_clock_source_read(); task_wake(TASK_ID_TOUCHPAD); } static int touchpad_should_enable(void) { /* touchpad is not ready. */ if (tp_control) return 0; #ifdef CONFIG_USB_SUSPEND if (usb_is_suspended() && !usb_is_remote_wakeup_enabled()) return 0; #endif #ifdef CONFIG_TABLET_MODE if (tablet_get_mode()) return 0; #endif return 1; } /* Make a decision on touchpad power, based on USB and tablet mode status. */ static void touchpad_power_control(void) { const int enabled = !!(system_state & SYSTEM_STATE_ACTIVE_MODE); int enable = touchpad_should_enable(); if (enabled == enable) return; if (enable) st_tp_start_scan(); else st_tp_stop_scan(); } static void touchpad_read_idle_count(void) { static uint32_t prev_count; uint32_t count; int ret; int rx_len = 2 + ST_TP_DUMMY_BYTE; uint8_t cmd_read_counter[] = { 0xFB, 0x00, 0x10, 0xff, 0xff }; /* Find address of idle count. */ ret = st_tp_load_host_data(ST_TP_MEM_ID_SYSTEM_INFO); if (ret) return; st_tp_read_host_data_memory(0x0082, &rx_buf, rx_len); /* Fill in address of idle count, the byte order is reversed. */ cmd_read_counter[3] = rx_buf.bytes[1]; cmd_read_counter[4] = rx_buf.bytes[0]; /* Read idle count */ spi_transaction(SPI, cmd_read_counter, sizeof(cmd_read_counter), (uint8_t *)&rx_buf, 4 + ST_TP_DUMMY_BYTE); count = rx_buf.dump_info[0]; CPRINTS("idle_count = %08x", count); if (count == prev_count) CPRINTS("counter doesn't change..."); else prev_count = count; } /* * Try to collect symptoms of type B error. * * There are three possible symptoms: * 1. error dump section is corrupted / contains error. * 2. memory stack is corrupted (not 0xCC). * 3. idle count is not changing. */ static void touchpad_collect_error(void) { const uint8_t tx_dump_error[] = { 0xFB, 0x20, 0x01, 0xEF, 0x80 }; uint32_t dump_info[2]; const uint8_t tx_dump_memory[] = { 0xFB, 0x00, 0x10, 0x00, 0x00 }; uint32_t dump_memory[16]; int i; enable_deep_sleep(0); spi_transaction(SPI, tx_dump_error, sizeof(tx_dump_error), (uint8_t *)&rx_buf, sizeof(dump_info) + ST_TP_DUMMY_BYTE); memcpy(dump_info, rx_buf.bytes, sizeof(dump_info)); spi_transaction(SPI, tx_dump_memory, sizeof(tx_dump_memory), (uint8_t *)&rx_buf, sizeof(dump_memory) + ST_TP_DUMMY_BYTE); memcpy(dump_memory, rx_buf.bytes, sizeof(dump_memory)); CPRINTS("check error dump: %08x %08x", dump_info[0], dump_info[1]); CPRINTS("check memory dump:"); for (i = 0; i < ARRAY_SIZE(dump_memory); i += 8) { CPRINTF("%08x %08x %08x %08x %08x %08x %08x %08x\n", dump_memory[i + 0], dump_memory[i + 1], dump_memory[i + 2], dump_memory[i + 3], dump_memory[i + 4], dump_memory[i + 5], dump_memory[i + 6], dump_memory[i + 7]); } for (i = 0; i < 3; i++) touchpad_read_idle_count(); enable_deep_sleep(1); tp_control |= TP_CONTROL_SHALL_RESET; } void touchpad_task(void *u) { uint32_t event; while (1) { uint32_t retry; for (retry = 0; retry < 3; retry++) { CPRINTS("st_tp_init: trial %d", retry + 1); st_tp_init(); if (system_state & SYSTEM_STATE_READY) break; /* * React on touchpad errors. */ if (tp_control & TP_CONTROL_SHALL_INIT_FULL) { /* suppress other handlers */ tp_control = TP_CONTROL_SHALL_INIT_FULL; st_tp_panel_init(1); } else if (tp_control & TP_CONTROL_SHALL_INIT) { /* suppress other handlers */ tp_control = TP_CONTROL_SHALL_INIT; st_tp_panel_init(0); } else if (tp_control & TP_CONTROL_SHALL_RESET) { /* suppress other handlers */ tp_control = TP_CONTROL_SHALL_RESET; } else if (tp_control & TP_CONTROL_SHALL_HALT) { CPRINTS("shall halt"); tp_control = 0; break; } } if (system_state & SYSTEM_STATE_READY) break; /* failed to init, mark it as ready to allow upgrade */ system_state = SYSTEM_STATE_READY; /* wait for upgrade complete */ task_wait_event_mask(TASK_EVENT_TP_UPDATED, -1); } touchpad_power_control(); while (1) { /* wait for at most 3 seconds */ event = task_wait_event(3 * 1000 * 1000); if ((event & TASK_EVENT_TIMER) && (system_state & SYSTEM_STATE_ACTIVE_MODE)) /* * Haven't received anything for 3 seconds, and we are * supposed to be in active mode. This is not normal, * check for errors and reset. */ touchpad_collect_error(); if (event & TASK_EVENT_WAKE) while (!tp_control && !gpio_get_level(GPIO_TOUCHPAD_INT)) st_tp_read_report(); /* * React on touchpad errors. */ if (tp_control & TP_CONTROL_SHALL_INIT_FULL) { /* suppress other handlers */ tp_control = TP_CONTROL_SHALL_INIT_FULL; st_tp_panel_init(1); } else if (tp_control & TP_CONTROL_SHALL_INIT) { /* suppress other handlers */ tp_control = TP_CONTROL_SHALL_INIT; st_tp_panel_init(0); } else if (tp_control & TP_CONTROL_SHALL_RESET) { /* suppress other handlers */ tp_control = TP_CONTROL_SHALL_RESET; st_tp_init(); } else if (tp_control & TP_CONTROL_SHALL_HALT) { tp_control = 0; st_tp_stop_scan(); } if (event & TASK_EVENT_POWER) touchpad_power_control(); } } /* * When USB PM status changes, or tablet mode changes, call in the main task to * decide whether to turn touchpad on or off. */ #if defined(CONFIG_USB_SUSPEND) || defined(CONFIG_TABLET_MODE) static void touchpad_power_change(void) { task_set_event(TASK_ID_TOUCHPAD, TASK_EVENT_POWER, 0); } #endif #ifdef CONFIG_USB_SUSPEND DECLARE_HOOK(HOOK_USB_PM_CHANGE, touchpad_power_change, HOOK_PRIO_DEFAULT); #endif #ifdef CONFIG_TABLET_MODE DECLARE_HOOK(HOOK_TABLET_MODE_CHANGE, touchpad_power_change, HOOK_PRIO_DEFAULT); #endif #ifdef CONFIG_USB_ISOCHRONOUS static void st_tp_enable_heat_map(void) { int new_state = (SYSTEM_STATE_ENABLE_HEAT_MAP | SYSTEM_STATE_ENABLE_DOME_SWITCH | SYSTEM_STATE_ACTIVE_MODE); int mask = new_state; st_tp_update_system_state(new_state, mask); } DECLARE_DEFERRED(st_tp_enable_heat_map); static void st_tp_disable_heat_map(void) { int new_state = 0; int mask = SYSTEM_STATE_ENABLE_HEAT_MAP; st_tp_update_system_state(new_state, mask); } DECLARE_DEFERRED(st_tp_disable_heat_map); static void print_frame(void) { char debug_line[ST_TOUCH_COLS + 5]; int i, j, index; int v; struct st_tp_usb_packet_t *packet = &usb_packet[usb_buffer_index & 1]; if (usb_buffer_index == spi_buffer_index) /* buffer is empty. */ return; /* We will have ~150 FPS, let's print ~4 frames per second */ if (usb_buffer_index % 37 == 0) { /* move cursor back to top left corner */ CPRINTF("\x1b[H"); CPUTS("==============\n"); for (i = 0; i < ST_TOUCH_ROWS; i++) { for (j = 0; j < ST_TOUCH_COLS; j++) { index = i * ST_TOUCH_COLS; index += (ST_TOUCH_COLS - j - 1); // flip X v = packet->frame[index]; if (v > 0) debug_line[j] = '0' + v * 10 / 256; else debug_line[j] = ' '; } debug_line[j++] = '\n'; debug_line[j++] = '\0'; CPRINTF(debug_line); } CPUTS("==============\n"); } } static int st_tp_read_frame(void) { int ret = EC_SUCCESS; int rx_len = ST_TOUCH_FRAME_SIZE + ST_TP_DUMMY_BYTE; int heat_map_addr = get_heat_map_addr(); uint8_t tx_buf[] = { ST_TP_CMD_READ_SPI_HOST_BUFFER, (heat_map_addr >> 8) & 0xFF, (heat_map_addr >> 0) & 0xFF, }; /* * Since usb_packet.frame is already ane uint8_t byte array, we can just * make it the RX buffer for SPI transaction. * * When there is a dummy byte, since we know that flags is a one byte * value, and we will override it later, it's okay for SPI transaction * to write the dummy byte to flags address. */ #if ST_TP_DUMMY_BYTE == 1 BUILD_ASSERT(sizeof(usb_packet[0].flags) == 1); uint8_t *rx_buf = &usb_packet[spi_buffer_index & 1].flags; #else uint8_t *rx_buf = usb_packet[spi_buffer_index & 1].frame; #endif st_tp_read_all_events(1); if (tp_control) { ret = EC_ERROR_UNKNOWN; goto failed; } if (heat_map_addr < 0) goto failed; ret = st_tp_check_domeswitch_state(); if (ret) goto failed; /* * Theoretically, we should read host buffer header to check if data is * valid, but the data should always be ready when interrupt pin is low. * Let's skip this check for now. */ ret = spi_transaction(SPI, tx_buf, sizeof(tx_buf), (uint8_t *)rx_buf, rx_len); if (ret == EC_SUCCESS) { int i; uint8_t *dest = usb_packet[spi_buffer_index & 1].frame; uint8_t max_value = 0; for (i = 0; i < ST_TOUCH_COLS * ST_TOUCH_ROWS; i++) max_value |= dest[i]; if (max_value == 0) // empty frame return -1; usb_packet[spi_buffer_index & 1].flags = 0; if (system_state & SYSTEM_STATE_DOME_SWITCH_LEVEL) usb_packet[spi_buffer_index & 1].flags |= USB_FRAME_FLAGS_BUTTON; } failed: return ret; } /* Define USB interface for heat_map */ /* function prototypes */ static int st_tp_usb_set_interface(usb_uint alternate_setting, usb_uint interface); static int heatmap_send_packet(struct usb_isochronous_config const *config); static void st_tp_usb_tx_callback(struct usb_isochronous_config const *config); /* USB descriptors */ USB_ISOCHRONOUS_CONFIG_FULL(usb_st_tp_heatmap_config, USB_IFACE_ST_TOUCHPAD, USB_CLASS_VENDOR_SPEC, USB_SUBCLASS_GOOGLE_HEATMAP, USB_PROTOCOL_GOOGLE_HEATMAP, USB_STR_HEATMAP_NAME, /* interface name */ USB_EP_ST_TOUCHPAD, USB_ISO_PACKET_SIZE, st_tp_usb_tx_callback, st_tp_usb_set_interface, 1 /* 1 extra EP for interrupts */) /* ***This function will be executed in interrupt context*** */ void st_tp_usb_tx_callback(struct usb_isochronous_config const *config) { task_wake(TASK_ID_HEATMAP); } void heatmap_task(void *unused) { struct usb_isochronous_config const *config; config = &usb_st_tp_heatmap_config; while (1) { /* waiting st_tp_usb_tx_callback() */ task_wait_event(-1); if (system_state & SYSTEM_STATE_DEBUG_MODE) continue; if (usb_buffer_index == spi_buffer_index) /* buffer is empty */ continue; while (heatmap_send_packet(config)) /* We failed to write a packet, try again later. */ task_wait_event(100); } } /* USB interface has completed TX, it's asking for more data */ static int heatmap_send_packet(struct usb_isochronous_config const *config) { size_t num_byte_available; size_t offset = 0; int ret, buffer_id = -1; struct st_tp_usb_packet_t *packet = &usb_packet[usb_buffer_index & 1]; packet_header.flags = 0; num_byte_available = sizeof(*packet) - transmit_report_offset; if (num_byte_available > 0) { if (transmit_report_offset == 0) packet_header.flags |= HEADER_FLAGS_NEW_FRAME; ret = usb_isochronous_write_buffer( config, (uint8_t *)&packet_header, sizeof(packet_header), offset, &buffer_id, 0); /* * Since USB_ISO_PACKET_SIZE > sizeof(packet_header), this must * be true. */ if (ret != sizeof(packet_header)) return -1; offset += ret; packet_header.index++; ret = usb_isochronous_write_buffer( config, (uint8_t *)packet + transmit_report_offset, num_byte_available, offset, &buffer_id, 1); if (ret < 0) { /* * TODO(b/70482333): handle this error, it might be: * 1. timeout (buffer_id changed) * 2. invalid offset * * For now, let's just return an error and try again. */ CPRINTS("%s %d: %d", __func__, __LINE__, -ret); return ret; } /* We should have sent some bytes, update offset */ transmit_report_offset += ret; if (transmit_report_offset == sizeof(*packet)) { transmit_report_offset = 0; usb_buffer_index++; } } return 0; } static int st_tp_usb_set_interface(usb_uint alternate_setting, usb_uint interface) { if (alternate_setting == 1) { if ((system_info.release_info & 0xFF) < ST_TP_MIN_HEATMAP_VERSION) { CPRINTS("release version %04x doesn't support heatmap", system_info.release_info); /* Heatmap mode is not supported in this version. */ return -1; } hook_call_deferred(&st_tp_enable_heat_map_data, 0); return 0; } else if (alternate_setting == 0) { hook_call_deferred(&st_tp_disable_heat_map_data, 0); return 0; } else /* we only have two settings. */ return -1; } static int get_heat_map_addr(void) { /* * TODO(stimim): drop this when we are sure all trackpads are having the * same config (e.g. after EVT). */ if (system_info.release_info >= 0x3) return 0x0120; else if (system_info.release_info == 0x1) return 0x20; else return -1; /* Unknown version */ } struct st_tp_interrupt_t { #define ST_TP_INT_FRAME_AVAILABLE BIT(0) uint8_t flags; } __packed; static usb_uint st_tp_usb_int_buffer[ DIV_ROUND_UP(sizeof(struct st_tp_interrupt_t), 2)] __usb_ram; const struct usb_endpoint_descriptor USB_EP_DESC(USB_IFACE_ST_TOUCHPAD, 81) = { .bLength = USB_DT_ENDPOINT_SIZE, .bDescriptorType = USB_DT_ENDPOINT, .bEndpointAddress = 0x80 | USB_EP_ST_TOUCHPAD_INT, .bmAttributes = 0x03 /* Interrupt endpoint */, .wMaxPacketSize = sizeof(struct st_tp_interrupt_t), .bInterval = 1 /* ms */, }; static void st_tp_interrupt_send(void) { struct st_tp_interrupt_t report; memset(&report, 0, sizeof(report)); if (usb_buffer_index < spi_buffer_index) report.flags |= ST_TP_INT_FRAME_AVAILABLE; memcpy_to_usbram((void *)usb_sram_addr(st_tp_usb_int_buffer), &report, sizeof(report)); /* enable TX */ STM32_TOGGLE_EP(USB_EP_ST_TOUCHPAD_INT, EP_TX_MASK, EP_TX_VALID, 0); usb_wake(); } static void st_tp_interrupt_tx(void) { STM32_USB_EP(USB_EP_ST_TOUCHPAD_INT) &= EP_MASK; if (usb_buffer_index < spi_buffer_index) /* pending frames */ hook_call_deferred(&st_tp_interrupt_send_data, 0); } static void st_tp_interrupt_event(enum usb_ep_event evt) { int ep = USB_EP_ST_TOUCHPAD_INT; if (evt == USB_EVENT_RESET) { btable_ep[ep].tx_addr = usb_sram_addr(st_tp_usb_int_buffer); btable_ep[ep].tx_count = sizeof(struct st_tp_interrupt_t); STM32_USB_EP(ep) = ((ep << 0) | EP_TX_VALID | (3 << 9) /* interrupt EP */ | EP_RX_DISAB); } } USB_DECLARE_EP(USB_EP_ST_TOUCHPAD_INT, st_tp_interrupt_tx, st_tp_interrupt_tx, st_tp_interrupt_event); #endif /* Debugging commands */ static int command_touchpad_st(int argc, char **argv) { if (argc < 2) return EC_ERROR_PARAM_COUNT; if (strcasecmp(argv[1], "version") == 0) { st_tp_read_system_info(1); return EC_SUCCESS; } else if (strcasecmp(argv[1], "calibrate") == 0) { st_tp_panel_init(1); return EC_SUCCESS; } else if (strcasecmp(argv[1], "enable") == 0) { #ifdef CONFIG_USB_ISOCHRONOUS set_bits(&system_state, SYSTEM_STATE_DEBUG_MODE, SYSTEM_STATE_DEBUG_MODE); hook_call_deferred(&st_tp_enable_heat_map_data, 0); return 0; #else return EC_ERROR_NOT_HANDLED; #endif } else if (strcasecmp(argv[1], "disable") == 0) { #ifdef CONFIG_USB_ISOCHRONOUS set_bits(&system_state, 0, SYSTEM_STATE_DEBUG_MODE); hook_call_deferred(&st_tp_disable_heat_map_data, 0); return 0; #else return EC_ERROR_NOT_HANDLED; #endif } else if (strcasecmp(argv[1], "dump") == 0) { enable_deep_sleep(0); dump_error(); dump_memory(); enable_deep_sleep(1); return EC_SUCCESS; } else if (strcasecmp(argv[1], "memory_dump") == 0) { if (argc == 3 && !parse_bool(argv[2], &dump_memory_on_error)) return EC_ERROR_PARAM2; ccprintf("memory_dump: %d\n", dump_memory_on_error); return EC_SUCCESS; } else { return EC_ERROR_PARAM1; } } DECLARE_CONSOLE_COMMAND(touchpad_st, command_touchpad_st, ">", "Read write spi. id is spi_devices array index");