Lines Matching full:data
153 u8 data[MXT_DIAGNOSTIC_SIZE];
284 /* Each client has this additional data */
414 static void mxt_dump_message(struct mxt_data *data, u8 *message)
416 dev_dbg(&data->client->dev, "message: %*ph\n",
417 data->T5_msg_size, message);
420 static int mxt_wait_for_completion(struct mxt_data *data,
424 struct device *dev = &data->client->dev;
438 static int mxt_bootloader_read(struct mxt_data *data,
444 msg.addr = data->bootloader_addr;
445 msg.flags = data->client->flags & I2C_M_TEN;
450 ret = i2c_transfer(data->client->adapter, &msg, 1);
455 dev_err(&data->client->dev, "%s: i2c recv failed (%d)\n",
462 static int mxt_bootloader_write(struct mxt_data *data,
468 msg.addr = data->bootloader_addr;
469 msg.flags = data->client->flags & I2C_M_TEN;
473 ret = i2c_transfer(data->client->adapter, &msg, 1);
478 dev_err(&data->client->dev, "%s: i2c send failed (%d)\n",
485 static int mxt_lookup_bootloader_address(struct mxt_data *data, bool retry)
487 u8 appmode = data->client->addr;
489 u8 family_id = data->info ? data->info->family_id : 0;
508 dev_err(&data->client->dev,
514 data->bootloader_addr = bootloader;
518 static int mxt_probe_bootloader(struct mxt_data *data, bool alt_address)
520 struct device *dev = &data->client->dev;
525 error = mxt_lookup_bootloader_address(data, alt_address);
529 error = mxt_bootloader_read(data, &val, 1);
542 static u8 mxt_get_bootloader_version(struct mxt_data *data, u8 val)
544 struct device *dev = &data->client->dev;
548 if (mxt_bootloader_read(data, &buf[0], 3) != 0) {
563 static int mxt_check_bootloader(struct mxt_data *data, unsigned int state,
566 struct device *dev = &data->client->dev;
578 ret = mxt_wait_for_completion(data, &data->bl_completion,
592 ret = mxt_bootloader_read(data, &val, 1);
597 val = mxt_get_bootloader_version(data, val);
626 static int mxt_send_bootloader_cmd(struct mxt_data *data, bool unlock)
638 return mxt_bootloader_write(data, buf, sizeof(buf));
644 struct mxt_data *data = i2c_get_clientdata(client);
646 switch (data->wakeup_method) {
656 gpiod_set_value(data->wake_gpio, wake_up);
689 /* Read data */
749 mxt_get_object(struct mxt_data *data, u8 type)
754 for (i = 0; i < data->info->object_num; i++) {
755 object = data->object_table + i;
760 dev_warn(&data->client->dev, "Invalid object type T%u\n", type);
764 static void mxt_proc_t6_messages(struct mxt_data *data, u8 *msg)
766 struct device *dev = &data->client->dev;
770 if (crc != data->config_crc) {
771 data->config_crc = crc;
775 complete(&data->crc_completion);
779 complete(&data->reset_completion);
782 if (status != data->t6_status)
794 data->t6_status = status;
797 static int mxt_write_object(struct mxt_data *data,
803 object = mxt_get_object(data, type);
808 return mxt_write_reg(data->client, reg + offset, val);
811 static void mxt_input_button(struct mxt_data *data, u8 *message)
813 struct input_dev *input = data->input_dev;
816 for (i = 0; i < data->t19_num_keys; i++) {
817 if (data->t19_keymap[i] == KEY_RESERVED)
821 input_report_key(input, data->t19_keymap[i],
826 static void mxt_input_sync(struct mxt_data *data)
828 input_mt_report_pointer_emulation(data->input_dev,
829 data->t19_num_keys);
830 input_sync(data->input_dev);
833 static void mxt_proc_t9_message(struct mxt_data *data, u8 *message)
835 struct device *dev = &data->client->dev;
836 struct input_dev *input_dev = data->input_dev;
844 id = message[0] - data->T9_reportid_min;
850 if (data->max_x < 1024)
852 if (data->max_y < 1024)
881 mxt_input_sync(data);
890 touchscreen_report_pos(input_dev, &data->prop, x, y, true);
898 data->update_input = true;
901 static void mxt_proc_t15_messages(struct mxt_data *data, u8 *message)
903 struct input_dev *input_dev = data->input_dev;
907 for (key = 0; key < data->t15_num_keys; key++)
908 input_report_key(input_dev, data->t15_keymap[key],
911 data->update_input = true;
914 static void mxt_proc_t97_messages(struct mxt_data *data, u8 *message)
916 mxt_proc_t15_messages(data, message);
919 static void mxt_proc_t100_message(struct mxt_data *data, u8 *message)
921 struct device *dev = &data->client->dev;
922 struct input_dev *input_dev = data->input_dev;
934 id = message[0] - data->T100_reportid_min - 2;
952 if (data->t100_aux_vect)
953 orientation = message[data->t100_aux_vect];
962 if (data->t100_aux_area)
963 major = message[data->t100_aux_area];
965 if (data->t100_aux_ampl)
966 pressure = message[data->t100_aux_ampl];
968 if (data->t100_aux_vect)
969 orientation = message[data->t100_aux_vect];
982 if (data->t100_aux_ampl)
983 pressure = message[data->t100_aux_ampl];
1011 touchscreen_report_pos(input_dev, &data->prop, x, y, true);
1023 data->update_input = true;
1026 static int mxt_proc_message(struct mxt_data *data, u8 *message)
1033 if (report_id == data->T6_reportid) {
1034 mxt_proc_t6_messages(data, message);
1035 } else if (!data->input_dev) {
1040 mxt_dump_message(data, message);
1041 } else if (report_id >= data->T9_reportid_min &&
1042 report_id <= data->T9_reportid_max) {
1043 mxt_proc_t9_message(data, message);
1044 } else if (report_id >= data->T15_reportid_min &&
1045 report_id <= data->T15_reportid_max) {
1046 mxt_proc_t15_messages(data, message);
1047 } else if (report_id >= data->T97_reportid_min &&
1048 report_id <= data->T97_reportid_max) {
1049 mxt_proc_t97_messages(data, message);
1050 } else if (report_id >= data->T100_reportid_min &&
1051 report_id <= data->T100_reportid_max) {
1052 mxt_proc_t100_message(data, message);
1053 } else if (report_id == data->T19_reportid) {
1054 mxt_input_button(data, message);
1055 data->update_input = true;
1057 mxt_dump_message(data, message);
1063 static int mxt_read_and_process_messages(struct mxt_data *data, u8 count)
1065 struct device *dev = &data->client->dev;
1071 if (count > data->max_reportid)
1075 ret = __mxt_read_reg(data->client, data->T5_address,
1076 data->T5_msg_size * count, data->msg_buf);
1083 ret = mxt_proc_message(data,
1084 data->msg_buf + data->T5_msg_size * i);
1094 static irqreturn_t mxt_process_messages_t44(struct mxt_data *data)
1096 struct device *dev = &data->client->dev;
1101 ret = __mxt_read_reg(data->client, data->T44_address,
1102 data->T5_msg_size + 1, data->msg_buf);
1108 count = data->msg_buf[0];
1117 if (count > data->max_reportid) {
1119 count = data->max_reportid;
1123 ret = mxt_proc_message(data, data->msg_buf + 1);
1133 ret = mxt_read_and_process_messages(data, num_left);
1141 if (data->update_input) {
1142 mxt_input_sync(data);
1143 data->update_input = false;
1149 static int mxt_process_messages_until_invalid(struct mxt_data *data)
1151 struct device *dev = &data->client->dev;
1155 count = data->max_reportid;
1159 read = mxt_read_and_process_messages(data, count);
1164 if (data->update_input) {
1165 mxt_input_sync(data);
1166 data->update_input = false;
1173 static irqreturn_t mxt_process_messages(struct mxt_data *data)
1176 u8 count = data->last_message_count;
1178 if (count < 1 || count > data->max_reportid)
1182 total_handled = mxt_read_and_process_messages(data, count + 1);
1191 num_handled = mxt_read_and_process_messages(data, 2);
1199 } while (total_handled < data->num_touchids);
1202 data->last_message_count = total_handled;
1204 if (data->update_input) {
1205 mxt_input_sync(data);
1206 data->update_input = false;
1214 struct mxt_data *data = dev_id;
1216 if (data->in_bootloader) {
1218 complete(&data->bl_completion);
1222 if (!data->object_table)
1225 if (data->T44_address) {
1226 return mxt_process_messages_t44(data);
1228 return mxt_process_messages(data);
1232 static int mxt_t6_command(struct mxt_data *data, u16 cmd_offset,
1240 reg = data->T6_address + cmd_offset;
1242 ret = mxt_write_reg(data->client, reg, value);
1251 ret = __mxt_read_reg(data->client, reg, 1, &command_register);
1257 dev_err(&data->client->dev, "Command failed!\n");
1264 static int mxt_acquire_irq(struct mxt_data *data)
1268 enable_irq(data->irq);
1270 if (data->use_retrigen_workaround) {
1271 error = mxt_process_messages_until_invalid(data);
1279 static int mxt_soft_reset(struct mxt_data *data)
1281 struct device *dev = &data->client->dev;
1286 disable_irq(data->irq);
1288 reinit_completion(&data->reset_completion);
1290 ret = mxt_t6_command(data, MXT_COMMAND_RESET, MXT_RESET_VALUE, false);
1297 mxt_acquire_irq(data);
1299 ret = mxt_wait_for_completion(data, &data->reset_completion,
1307 static void mxt_update_crc(struct mxt_data *data, u8 cmd, u8 value)
1313 data->config_crc = 0;
1314 reinit_completion(&data->crc_completion);
1316 mxt_t6_command(data, cmd, value, true);
1322 mxt_wait_for_completion(data, &data->crc_completion, MXT_CRC_TIMEOUT);
1364 static int mxt_check_retrigen(struct mxt_data *data)
1366 struct i2c_client *client = data->client;
1371 data->use_retrigen_workaround = false;
1373 irqd = irq_get_irq_data(data->irq);
1380 if (data->T18_address) {
1382 data->T18_address + MXT_COMMS_CTRL,
1392 data->use_retrigen_workaround = true;
1396 static int mxt_prepare_cfg_mem(struct mxt_data *data, struct mxt_cfg *cfg)
1398 struct device *dev = &data->client->dev;
1421 object = mxt_get_object(data, type);
1495 static int mxt_upload_cfg_mem(struct mxt_data *data, struct mxt_cfg *cfg)
1507 error = __mxt_write_reg(data->client,
1511 dev_err(&data->client->dev,
1522 static int mxt_init_t7_power_cfg(struct mxt_data *data);
1543 static int mxt_update_cfg(struct mxt_data *data, const struct firmware *fw)
1545 struct device *dev = &data->client->dev;
1554 u8 *raw_buf __free(kfree) = cfg.raw = kmemdup_nul(fw->data, fw->size,
1561 mxt_update_crc(data, MXT_COMMAND_REPORTALL, 1);
1581 if (cfg.info.family_id != data->info->family_id) {
1586 if (cfg.info.variant_id != data->info->variant_id) {
1610 if (info_crc == data->info_crc) {
1611 if (config_crc == 0 || data->config_crc == 0) {
1613 } else if (config_crc == data->config_crc) {
1615 data->config_crc);
1619 data->config_crc, config_crc);
1624 data->info_crc, info_crc);
1629 data->info->object_num * sizeof(struct mxt_object) +
1632 if (data->mem_size <= cfg.start_ofs) {
1634 data->mem_size, cfg.start_ofs);
1638 cfg.mem_size = data->mem_size - cfg.start_ofs;
1644 error = mxt_prepare_cfg_mem(data, &cfg);
1649 if (data->T71_address)
1650 crc_start = data->T71_address;
1651 else if (data->T7_address)
1652 crc_start = data->T7_address;
1666 error = mxt_upload_cfg_mem(data, &cfg);
1670 mxt_update_crc(data, MXT_COMMAND_BACKUPNV, MXT_BACKUP_VALUE);
1672 error = mxt_check_retrigen(data);
1676 error = mxt_soft_reset(data);
1683 mxt_init_t7_power_cfg(data);
1688 static void mxt_free_input_device(struct mxt_data *data)
1690 if (data->input_dev) {
1691 input_unregister_device(data->input_dev);
1692 data->input_dev = NULL;
1696 static void mxt_free_object_table(struct mxt_data *data)
1699 video_unregister_device(&data->dbg.vdev);
1700 v4l2_device_unregister(&data->dbg.v4l2);
1702 data->object_table = NULL;
1703 data->info = NULL;
1704 kfree(data->raw_info_block);
1705 data->raw_info_block = NULL;
1706 kfree(data->msg_buf);
1707 data->msg_buf = NULL;
1708 data->T5_address = 0;
1709 data->T5_msg_size = 0;
1710 data->T6_reportid = 0;
1711 data->T7_address = 0;
1712 data->T71_address = 0;
1713 data->T9_reportid_min = 0;
1714 data->T9_reportid_max = 0;
1715 data->T15_reportid_min = 0;
1716 data->T15_reportid_max = 0;
1717 data->T18_address = 0;
1718 data->T19_reportid = 0;
1719 data->T44_address = 0;
1720 data->T97_reportid_min = 0;
1721 data->T97_reportid_max = 0;
1722 data->T100_reportid_min = 0;
1723 data->T100_reportid_max = 0;
1724 data->max_reportid = 0;
1727 static int mxt_parse_object_table(struct mxt_data *data,
1730 struct i2c_client *client = data->client;
1737 data->mem_size = 0;
1738 for (i = 0; i < data->info->object_num; i++) {
1754 dev_dbg(&data->client->dev,
1762 if (data->info->family_id == 0x80 &&
1763 data->info->version < 0x20) {
1769 data->T5_msg_size = mxt_obj_size(object);
1772 data->T5_msg_size = mxt_obj_size(object) - 1;
1774 data->T5_address = object->start_address;
1777 data->T6_reportid = min_id;
1778 data->T6_address = object->start_address;
1781 data->T7_address = object->start_address;
1784 data->T71_address = object->start_address;
1787 data->multitouch = MXT_TOUCH_MULTI_T9;
1789 data->T9_reportid_min = min_id;
1790 data->T9_reportid_max = min_id +
1792 data->num_touchids = object->num_report_ids;
1795 data->T15_reportid_min = min_id;
1796 data->T15_reportid_max = max_id;
1799 data->T18_address = object->start_address;
1802 data->T44_address = object->start_address;
1805 data->T19_reportid = min_id;
1808 data->T97_reportid_min = min_id;
1809 data->T97_reportid_max = max_id;
1812 data->multitouch = MXT_TOUCH_MULTITOUCHSCREEN_T100;
1813 data->T100_reportid_min = min_id;
1814 data->T100_reportid_max = max_id;
1816 data->num_touchids = object->num_report_ids - 2;
1823 if (end_address >= data->mem_size)
1824 data->mem_size = end_address + 1;
1828 data->max_reportid = reportid;
1831 if (data->T44_address && (data->T5_address != data->T44_address + 1)) {
1836 data->msg_buf = kcalloc(data->max_reportid,
1837 data->T5_msg_size, GFP_KERNEL);
1838 if (!data->msg_buf)
1844 static int mxt_read_info_block(struct mxt_data *data)
1846 struct i2c_client *client = data->client;
1854 if (data->raw_info_block)
1855 mxt_free_object_table(data);
1887 data->info_crc = crc_ptr[0] | (crc_ptr[1] << 8) | (crc_ptr[2] << 16);
1893 * CRC mismatch can be caused by data corruption due to I2C comms
1896 if ((data->info_crc == 0) || (data->info_crc != calculated_crc)) {
1899 calculated_crc, data->info_crc);
1903 data->raw_info_block = no_free_ptr(id_buf);
1904 data->info = (struct mxt_info *)data->raw_info_block;
1908 data->info->family_id, data->info->variant_id,
1909 data->info->version >> 4, data->info->version & 0xf,
1910 data->info->build, data->info->object_num);
1913 error = mxt_parse_object_table(data,
1914 data->raw_info_block + MXT_OBJECT_START);
1917 mxt_free_object_table(data);
1921 data->object_table =
1922 (struct mxt_object *)(data->raw_info_block + MXT_OBJECT_START);
1927 static int mxt_read_t9_resolution(struct mxt_data *data)
1929 struct i2c_client *client = data->client;
1935 object = mxt_get_object(data, MXT_TOUCH_MULTI_T9);
1941 sizeof(data->xsize), &data->xsize);
1947 sizeof(data->ysize), &data->ysize);
1957 data->max_x = get_unaligned_le16(&range.x);
1958 data->max_y = get_unaligned_le16(&range.y);
1966 data->xy_switch = orient & MXT_T9_ORIENT_SWITCH;
1967 data->invertx = orient & MXT_T9_ORIENT_INVERTX;
1968 data->inverty = orient & MXT_T9_ORIENT_INVERTY;
1973 static int mxt_read_t100_config(struct mxt_data *data)
1975 struct i2c_client *client = data->client;
1982 object = mxt_get_object(data, MXT_TOUCH_MULTITOUCHSCREEN_T100);
1993 data->max_x = get_unaligned_le16(&range_x);
2001 data->max_y = get_unaligned_le16(&range_y);
2005 sizeof(data->xsize), &data->xsize);
2011 sizeof(data->ysize), &data->ysize);
2022 data->xy_switch = cfg & MXT_T100_CFG_SWITCHXY;
2023 data->invertx = cfg & MXT_T100_CFG_INVERTX;
2024 data->inverty = cfg & MXT_T100_CFG_INVERTY;
2036 data->t100_aux_vect = aux++;
2039 data->t100_aux_ampl = aux++;
2042 data->t100_aux_area = aux++;
2046 data->t100_aux_vect, data->t100_aux_ampl, data->t100_aux_area);
2055 struct mxt_data *data)
2070 for (i = 0; i < data->t19_num_keys; i++)
2071 if (data->t19_keymap[i] != KEY_RESERVED)
2073 data->t19_keymap[i]);
2076 static int mxt_initialize_input_device(struct mxt_data *data)
2078 struct device *dev = &data->client->dev;
2085 switch (data->multitouch) {
2087 num_mt_slots = data->T9_reportid_max - data->T9_reportid_min + 1;
2088 error = mxt_read_t9_resolution(data);
2094 num_mt_slots = data->num_touchids;
2095 error = mxt_read_t100_config(data);
2106 if (data->max_x == 0)
2107 data->max_x = 1023;
2109 if (data->max_y == 0)
2110 data->max_y = 1023;
2112 if (data->xy_switch)
2113 swap(data->max_x, data->max_y);
2115 dev_info(dev, "Touchscreen size X%uY%u\n", data->max_x, data->max_y);
2123 input_dev->phys = data->phys;
2129 input_dev->keycode = data->t15_keymap;
2130 input_dev->keycodemax = data->t15_num_keys;
2131 input_dev->keycodesize = sizeof(data->t15_keymap[0]);
2136 input_set_abs_params(input_dev, ABS_X, 0, data->max_x, 0, 0);
2137 input_set_abs_params(input_dev, ABS_Y, 0, data->max_y, 0, 0);
2139 if (data->multitouch == MXT_TOUCH_MULTI_T9 ||
2140 (data->multitouch == MXT_TOUCH_MULTITOUCHSCREEN_T100 &&
2141 data->t100_aux_ampl)) {
2146 if (data->t19_num_keys) {
2147 mxt_set_up_as_touchpad(input_dev, data);
2160 if (data->multitouch == MXT_TOUCH_MULTITOUCHSCREEN_T100) {
2170 0, data->max_x, 0, 0);
2172 0, data->max_y, 0, 0);
2174 if (data->multitouch == MXT_TOUCH_MULTI_T9 ||
2175 (data->multitouch == MXT_TOUCH_MULTITOUCHSCREEN_T100 &&
2176 data->t100_aux_area)) {
2181 if (data->multitouch == MXT_TOUCH_MULTI_T9 ||
2182 (data->multitouch == MXT_TOUCH_MULTITOUCHSCREEN_T100 &&
2183 data->t100_aux_ampl)) {
2188 if (data->multitouch == MXT_TOUCH_MULTITOUCHSCREEN_T100 &&
2189 data->t100_aux_vect) {
2194 if (data->multitouch == MXT_TOUCH_MULTITOUCHSCREEN_T100 &&
2195 data->t100_aux_vect) {
2200 touchscreen_parse_properties(input_dev, true, &data->prop);
2203 if (data->T15_reportid_min || data->T97_reportid_min) {
2204 for (i = 0; i < data->t15_num_keys; i++)
2206 EV_KEY, data->t15_keymap[i]);
2209 input_set_drvdata(input_dev, data);
2217 data->input_dev = input_dev;
2226 static int mxt_configure_objects(struct mxt_data *data,
2235 static int mxt_initialize(struct mxt_data *data)
2237 struct i2c_client *client = data->client;
2242 error = mxt_read_info_block(data);
2247 error = mxt_probe_bootloader(data, false);
2250 error = mxt_probe_bootloader(data, true);
2264 data->in_bootloader = true;
2269 mxt_send_bootloader_cmd(data, false);
2273 error = mxt_check_retrigen(data);
2277 error = mxt_acquire_irq(data);
2282 &client->dev, GFP_KERNEL, data,
2293 static int mxt_set_t7_power_cfg(struct mxt_data *data, u8 sleep)
2295 struct device *dev = &data->client->dev;
2303 new_config = &data->t7_cfg;
2305 error = __mxt_write_reg(data->client, data->T7_address,
2306 sizeof(data->t7_cfg), new_config);
2316 static int mxt_init_t7_power_cfg(struct mxt_data *data)
2318 struct device *dev = &data->client->dev;
2323 error = __mxt_read_reg(data->client, data->T7_address,
2324 sizeof(data->t7_cfg), &data->t7_cfg);
2328 if (data->t7_cfg.active == 0 || data->t7_cfg.idle == 0) {
2331 mxt_soft_reset(data);
2336 data->t7_cfg.active = 20;
2337 data->t7_cfg.idle = 100;
2338 return mxt_set_t7_power_cfg(data, MXT_POWER_CFG_RUN);
2343 data->t7_cfg.active, data->t7_cfg.idle);
2358 static u16 mxt_get_debug_value(struct mxt_data *data, unsigned int x,
2361 struct mxt_info *info = data->info;
2362 struct mxt_dbg *dbg = &data->dbg;
2382 return get_unaligned_le16(&dbg->t37_buf[page].data[ofs]);
2385 static int mxt_convert_debug_pages(struct mxt_data *data, u16 *outbuf)
2387 struct mxt_dbg *dbg = &data->dbg;
2394 rx = data->xy_switch ? y : x;
2395 ry = data->xy_switch ? x : y;
2396 rx = data->invertx ? (data->xsize - 1 - rx) : rx;
2397 ry = data->inverty ? (data->ysize - 1 - ry) : ry;
2399 outbuf[i] = mxt_get_debug_value(data, rx, ry);
2402 if (++x >= (data->xy_switch ? data->ysize : data->xsize)) {
2411 static int mxt_read_diagnostic_debug(struct mxt_data *data, u8 mode,
2414 struct mxt_dbg *dbg = &data->dbg;
2425 ret = mxt_write_reg(data->client, dbg->diag_cmd_address,
2434 ret = __mxt_read_reg(data->client, dbg->diag_cmd_address,
2449 ret = __mxt_read_reg(data->client, dbg->t37_address,
2455 dev_err(&data->client->dev, "T37 page mismatch\n");
2459 dev_dbg(&data->client->dev, "%s page:%d retries:%d\n",
2466 return mxt_convert_debug_pages(data, outbuf);
2473 struct mxt_data *data = q->drv_priv;
2474 size_t size = data->dbg.t37_nodes * sizeof(u16);
2487 struct mxt_data *data = vb2_get_drv_priv(vb->vb2_queue);
2494 dev_err(&data->client->dev, "Error acquiring frame ptr\n");
2498 switch (data->dbg.input) {
2509 ret = mxt_read_diagnostic_debug(data, mode, ptr);
2513 vb2_set_plane_payload(vb, 0, data->dbg.t37_nodes * sizeof(u16));
2540 struct mxt_data *data = video_drvdata(file);
2545 "I2C:%s", dev_name(&data->client->dev));
2570 static int mxt_set_input(struct mxt_data *data, unsigned int i)
2572 struct v4l2_pix_format *f = &data->dbg.format;
2582 f->width = data->xy_switch ? data->ysize : data->xsize;
2583 f->height = data->xy_switch ? data->xsize : data->ysize;
2589 data->dbg.input = i;
2601 struct mxt_data *data = video_drvdata(file);
2603 *i = data->dbg.input;
2610 struct mxt_data *data = video_drvdata(file);
2613 f->fmt.pix = data->dbg.format;
2685 static void mxt_debug_init(struct mxt_data *data)
2687 struct mxt_info *info = data->info;
2688 struct mxt_dbg *dbg = &data->dbg;
2692 object = mxt_get_object(data, MXT_GEN_COMMAND_T6);
2698 object = mxt_get_object(data, MXT_DEBUG_DIAGNOSTIC_T37);
2703 dev_warn(&data->client->dev, "Bad T37 size");
2709 /* Calculate size of data and allocate buffer */
2710 dbg->t37_nodes = data->xsize * data->ysize;
2715 dbg->t37_pages = DIV_ROUND_UP(data->xsize *
2718 sizeof(dbg->t37_buf->data));
2720 dbg->t37_buf = devm_kmalloc_array(&data->client->dev, dbg->t37_pages,
2726 mxt_set_input(data, 0);
2730 error = v4l2_device_register(&data->client->dev, &dbg->v4l2);
2737 dbg->queue.drv_priv = data;
2739 dbg->queue.dev = &data->client->dev;
2750 video_set_drvdata(&dbg->vdev, data);
2761 dev_warn(&data->client->dev, "Error initializing T37\n");
2764 static void mxt_debug_init(struct mxt_data *data)
2769 static int mxt_configure_objects(struct mxt_data *data,
2772 struct device *dev = &data->client->dev;
2775 error = mxt_init_t7_power_cfg(data);
2782 error = mxt_update_cfg(data, cfg);
2787 if (data->multitouch) {
2788 error = mxt_initialize_input_device(data);
2795 mxt_debug_init(data);
2804 struct mxt_data *data = dev_get_drvdata(dev);
2805 struct mxt_info *info = data->info;
2814 struct mxt_data *data = dev_get_drvdata(dev);
2815 struct mxt_info *info = data->info;
2839 struct mxt_data *data = dev_get_drvdata(dev);
2850 for (i = 0; i < data->info->object_num; i++) {
2851 object = data->object_table + i;
2862 error = __mxt_read_reg(data->client, addr, size, obuf);
2880 c = *(fw->data + pos);
2897 static int mxt_flash_fw(struct mxt_data *data, const struct firmware *fw)
2899 struct device *dev = &data->client->dev;
2906 reinit_completion(&data->bl_completion);
2908 error = mxt_check_bootloader(data, MXT_WAITING_BOOTLOAD_CMD, false);
2911 error = mxt_check_bootloader(data, MXT_WAITING_FRAME_DATA,
2919 error = mxt_send_bootloader_cmd(data, true);
2925 error = mxt_check_bootloader(data, MXT_WAITING_FRAME_DATA,
2930 frame_size = ((*(fw->data + pos) << 8) | *(fw->data + pos + 1));
2936 error = mxt_bootloader_write(data, fw->data + pos, frame_size);
2940 error = mxt_check_bootloader(data, MXT_FRAME_CRC_PASS, true);
2963 error = mxt_wait_for_completion(data, &data->bl_completion,
2975 mxt_wait_for_completion(data, &data->bl_completion, MXT_FW_RESET_TIME);
2976 data->in_bootloader = false;
2983 struct mxt_data *data = dev_get_drvdata(dev);
2999 if (!data->in_bootloader) {
3001 data->in_bootloader = true;
3003 error = mxt_t6_command(data, MXT_COMMAND_RESET,
3011 error = mxt_lookup_bootloader_address(data, 0);
3015 mxt_free_input_device(data);
3016 mxt_free_object_table(data);
3018 enable_irq(data->irq);
3021 retval = mxt_flash_fw(data, fw);
3023 disable_irq(data->irq);
3032 struct mxt_data *data = dev_get_drvdata(dev);
3042 error = mxt_initialize(data);
3065 static void mxt_start(struct mxt_data *data)
3067 mxt_wakeup_toggle(data->client, true, false);
3069 switch (data->suspend_mode) {
3071 mxt_soft_reset(data);
3075 mxt_write_object(data,
3081 mxt_set_t7_power_cfg(data, MXT_POWER_CFG_RUN);
3084 mxt_t6_command(data, MXT_COMMAND_CALIBRATE, 1, false);
3089 static void mxt_stop(struct mxt_data *data)
3091 switch (data->suspend_mode) {
3094 mxt_write_object(data,
3100 mxt_set_t7_power_cfg(data, MXT_POWER_CFG_DEEPSLEEP);
3104 mxt_wakeup_toggle(data->client, false, false);
3109 struct mxt_data *data = input_get_drvdata(dev);
3111 mxt_start(data);
3118 struct mxt_data *data = input_get_drvdata(dev);
3120 mxt_stop(data);
3123 static int mxt_parse_device_properties(struct mxt_data *data)
3127 struct device *dev = &data->client->dev;
3155 data->t19_keymap = keymap;
3156 data->t19_num_keys = n_keys;
3181 data->t15_keymap = buttonmap;
3182 data->t15_num_keys = n_keys;
3205 struct mxt_data *data;
3233 data = devm_kzalloc(&client->dev, sizeof(struct mxt_data), GFP_KERNEL);
3234 if (!data)
3237 snprintf(data->phys, sizeof(data->phys), "i2c-%u-%04x/input0",
3240 data->client = client;
3241 data->irq = client->irq;
3242 i2c_set_clientdata(client, data);
3244 init_completion(&data->bl_completion);
3245 init_completion(&data->reset_completion);
3246 init_completion(&data->crc_completion);
3248 data->suspend_mode = dmi_check_system(chromebook_T9_suspend_dmi) ?
3251 error = mxt_parse_device_properties(data);
3259 data->regulators[0].supply = "vdda";
3260 data->regulators[1].supply = "vdd";
3261 error = devm_regulator_bulk_get(&client->dev, ARRAY_SIZE(data->regulators),
3262 data->regulators);
3271 data->reset_gpio = devm_gpiod_get_optional(&client->dev,
3273 if (IS_ERR(data->reset_gpio)) {
3274 error = PTR_ERR(data->reset_gpio);
3280 data->wake_gpio = devm_gpiod_get_optional(&client->dev,
3282 if (IS_ERR(data->wake_gpio)) {
3283 error = PTR_ERR(data->wake_gpio);
3291 client->name, data);
3297 error = regulator_bulk_enable(ARRAY_SIZE(data->regulators),
3298 data->regulators);
3310 if (data->reset_gpio) {
3313 gpiod_set_value_cansleep(data->reset_gpio, 0);
3334 &data->wakeup_method);
3336 error = mxt_initialize(data);
3343 regulator_bulk_disable(ARRAY_SIZE(data->regulators),
3344 data->regulators);
3350 struct mxt_data *data = i2c_get_clientdata(client);
3352 disable_irq(data->irq);
3353 mxt_free_input_device(data);
3354 mxt_free_object_table(data);
3355 regulator_bulk_disable(ARRAY_SIZE(data->regulators),
3356 data->regulators);
3362 struct mxt_data *data = i2c_get_clientdata(client);
3363 struct input_dev *input_dev = data->input_dev;
3370 mxt_stop(data);
3373 disable_irq(data->irq);
3381 struct mxt_data *data = i2c_get_clientdata(client);
3382 struct input_dev *input_dev = data->input_dev;
3387 enable_irq(data->irq);
3391 mxt_start(data);