Lines Matching refs:data
152 u8 data[MXT_DIAGNOSTIC_SIZE];
283 /* Each client has this additional data */
411 static void mxt_dump_message(struct mxt_data *data, u8 *message)
413 dev_dbg(&data->client->dev, "message: %*ph\n",
414 data->T5_msg_size, message);
417 static int mxt_wait_for_completion(struct mxt_data *data,
421 struct device *dev = &data->client->dev;
435 static int mxt_bootloader_read(struct mxt_data *data,
441 msg.addr = data->bootloader_addr;
442 msg.flags = data->client->flags & I2C_M_TEN;
447 ret = i2c_transfer(data->client->adapter, &msg, 1);
452 dev_err(&data->client->dev, "%s: i2c recv failed (%d)\n",
459 static int mxt_bootloader_write(struct mxt_data *data,
465 msg.addr = data->bootloader_addr;
466 msg.flags = data->client->flags & I2C_M_TEN;
470 ret = i2c_transfer(data->client->adapter, &msg, 1);
475 dev_err(&data->client->dev, "%s: i2c send failed (%d)\n",
482 static int mxt_lookup_bootloader_address(struct mxt_data *data, bool retry)
484 u8 appmode = data->client->addr;
486 u8 family_id = data->info ? data->info->family_id : 0;
505 dev_err(&data->client->dev,
511 data->bootloader_addr = bootloader;
515 static int mxt_probe_bootloader(struct mxt_data *data, bool alt_address)
517 struct device *dev = &data->client->dev;
522 error = mxt_lookup_bootloader_address(data, alt_address);
526 error = mxt_bootloader_read(data, &val, 1);
539 static u8 mxt_get_bootloader_version(struct mxt_data *data, u8 val)
541 struct device *dev = &data->client->dev;
545 if (mxt_bootloader_read(data, &buf[0], 3) != 0) {
560 static int mxt_check_bootloader(struct mxt_data *data, unsigned int state,
563 struct device *dev = &data->client->dev;
575 ret = mxt_wait_for_completion(data, &data->bl_completion,
589 ret = mxt_bootloader_read(data, &val, 1);
594 val = mxt_get_bootloader_version(data, val);
623 static int mxt_send_bootloader_cmd(struct mxt_data *data, bool unlock)
635 return mxt_bootloader_write(data, buf, sizeof(buf));
641 struct mxt_data *data = i2c_get_clientdata(client);
643 switch (data->wakeup_method) {
653 gpiod_set_value(data->wake_gpio, wake_up);
686 /* Read data */
750 mxt_get_object(struct mxt_data *data, u8 type)
755 for (i = 0; i < data->info->object_num; i++) {
756 object = data->object_table + i;
761 dev_warn(&data->client->dev, "Invalid object type T%u\n", type);
765 static void mxt_proc_t6_messages(struct mxt_data *data, u8 *msg)
767 struct device *dev = &data->client->dev;
771 if (crc != data->config_crc) {
772 data->config_crc = crc;
776 complete(&data->crc_completion);
780 complete(&data->reset_completion);
783 if (status != data->t6_status)
795 data->t6_status = status;
798 static int mxt_write_object(struct mxt_data *data,
804 object = mxt_get_object(data, type);
809 return mxt_write_reg(data->client, reg + offset, val);
812 static void mxt_input_button(struct mxt_data *data, u8 *message)
814 struct input_dev *input = data->input_dev;
817 for (i = 0; i < data->t19_num_keys; i++) {
818 if (data->t19_keymap[i] == KEY_RESERVED)
822 input_report_key(input, data->t19_keymap[i],
827 static void mxt_input_sync(struct mxt_data *data)
829 input_mt_report_pointer_emulation(data->input_dev,
830 data->t19_num_keys);
831 input_sync(data->input_dev);
834 static void mxt_proc_t9_message(struct mxt_data *data, u8 *message)
836 struct device *dev = &data->client->dev;
837 struct input_dev *input_dev = data->input_dev;
845 id = message[0] - data->T9_reportid_min;
851 if (data->max_x < 1024)
853 if (data->max_y < 1024)
882 mxt_input_sync(data);
900 data->update_input = true;
903 static void mxt_proc_t15_messages(struct mxt_data *data, u8 *message)
905 struct input_dev *input_dev = data->input_dev;
909 for (key = 0; key < data->t15_num_keys; key++)
910 input_report_key(input_dev, data->t15_keymap[key],
913 data->update_input = true;
916 static void mxt_proc_t97_messages(struct mxt_data *data, u8 *message)
918 mxt_proc_t15_messages(data, message);
921 static void mxt_proc_t100_message(struct mxt_data *data, u8 *message)
923 struct device *dev = &data->client->dev;
924 struct input_dev *input_dev = data->input_dev;
936 id = message[0] - data->T100_reportid_min - 2;
954 if (data->t100_aux_vect)
955 orientation = message[data->t100_aux_vect];
964 if (data->t100_aux_area)
965 major = message[data->t100_aux_area];
967 if (data->t100_aux_ampl)
968 pressure = message[data->t100_aux_ampl];
970 if (data->t100_aux_vect)
971 orientation = message[data->t100_aux_vect];
984 if (data->t100_aux_ampl)
985 pressure = message[data->t100_aux_ampl];
1026 data->update_input = true;
1029 static int mxt_proc_message(struct mxt_data *data, u8 *message)
1036 if (report_id == data->T6_reportid) {
1037 mxt_proc_t6_messages(data, message);
1038 } else if (!data->input_dev) {
1043 mxt_dump_message(data, message);
1044 } else if (report_id >= data->T9_reportid_min &&
1045 report_id <= data->T9_reportid_max) {
1046 mxt_proc_t9_message(data, message);
1047 } else if (report_id >= data->T15_reportid_min &&
1048 report_id <= data->T15_reportid_max) {
1049 mxt_proc_t15_messages(data, message);
1050 } else if (report_id >= data->T97_reportid_min &&
1051 report_id <= data->T97_reportid_max) {
1052 mxt_proc_t97_messages(data, message);
1053 } else if (report_id >= data->T100_reportid_min &&
1054 report_id <= data->T100_reportid_max) {
1055 mxt_proc_t100_message(data, message);
1056 } else if (report_id == data->T19_reportid) {
1057 mxt_input_button(data, message);
1058 data->update_input = true;
1060 mxt_dump_message(data, message);
1066 static int mxt_read_and_process_messages(struct mxt_data *data, u8 count)
1068 struct device *dev = &data->client->dev;
1074 if (count > data->max_reportid)
1078 ret = __mxt_read_reg(data->client, data->T5_address,
1079 data->T5_msg_size * count, data->msg_buf);
1086 ret = mxt_proc_message(data,
1087 data->msg_buf + data->T5_msg_size * i);
1097 static irqreturn_t mxt_process_messages_t44(struct mxt_data *data)
1099 struct device *dev = &data->client->dev;
1104 ret = __mxt_read_reg(data->client, data->T44_address,
1105 data->T5_msg_size + 1, data->msg_buf);
1111 count = data->msg_buf[0];
1120 if (count > data->max_reportid) {
1122 count = data->max_reportid;
1126 ret = mxt_proc_message(data, data->msg_buf + 1);
1136 ret = mxt_read_and_process_messages(data, num_left);
1144 if (data->update_input) {
1145 mxt_input_sync(data);
1146 data->update_input = false;
1152 static int mxt_process_messages_until_invalid(struct mxt_data *data)
1154 struct device *dev = &data->client->dev;
1158 count = data->max_reportid;
1162 read = mxt_read_and_process_messages(data, count);
1167 if (data->update_input) {
1168 mxt_input_sync(data);
1169 data->update_input = false;
1176 static irqreturn_t mxt_process_messages(struct mxt_data *data)
1179 u8 count = data->last_message_count;
1181 if (count < 1 || count > data->max_reportid)
1185 total_handled = mxt_read_and_process_messages(data, count + 1);
1194 num_handled = mxt_read_and_process_messages(data, 2);
1202 } while (total_handled < data->num_touchids);
1205 data->last_message_count = total_handled;
1207 if (data->update_input) {
1208 mxt_input_sync(data);
1209 data->update_input = false;
1217 struct mxt_data *data = dev_id;
1219 if (data->in_bootloader) {
1221 complete(&data->bl_completion);
1225 if (!data->object_table)
1228 if (data->T44_address) {
1229 return mxt_process_messages_t44(data);
1231 return mxt_process_messages(data);
1235 static int mxt_t6_command(struct mxt_data *data, u16 cmd_offset,
1243 reg = data->T6_address + cmd_offset;
1245 ret = mxt_write_reg(data->client, reg, value);
1254 ret = __mxt_read_reg(data->client, reg, 1, &command_register);
1260 dev_err(&data->client->dev, "Command failed!\n");
1267 static int mxt_acquire_irq(struct mxt_data *data)
1271 enable_irq(data->irq);
1273 if (data->use_retrigen_workaround) {
1274 error = mxt_process_messages_until_invalid(data);
1282 static int mxt_soft_reset(struct mxt_data *data)
1284 struct device *dev = &data->client->dev;
1289 disable_irq(data->irq);
1291 reinit_completion(&data->reset_completion);
1293 ret = mxt_t6_command(data, MXT_COMMAND_RESET, MXT_RESET_VALUE, false);
1300 mxt_acquire_irq(data);
1302 ret = mxt_wait_for_completion(data, &data->reset_completion,
1310 static void mxt_update_crc(struct mxt_data *data, u8 cmd, u8 value)
1316 data->config_crc = 0;
1317 reinit_completion(&data->crc_completion);
1319 mxt_t6_command(data, cmd, value, true);
1325 mxt_wait_for_completion(data, &data->crc_completion, MXT_CRC_TIMEOUT);
1367 static int mxt_check_retrigen(struct mxt_data *data)
1369 struct i2c_client *client = data->client;
1374 data->use_retrigen_workaround = false;
1376 irqd = irq_get_irq_data(data->irq);
1383 if (data->T18_address) {
1385 data->T18_address + MXT_COMMS_CTRL,
1395 data->use_retrigen_workaround = true;
1399 static int mxt_prepare_cfg_mem(struct mxt_data *data, struct mxt_cfg *cfg)
1401 struct device *dev = &data->client->dev;
1423 object = mxt_get_object(data, type);
1497 static int mxt_upload_cfg_mem(struct mxt_data *data, struct mxt_cfg *cfg)
1509 error = __mxt_write_reg(data->client,
1513 dev_err(&data->client->dev,
1524 static int mxt_init_t7_power_cfg(struct mxt_data *data);
1545 static int mxt_update_cfg(struct mxt_data *data, const struct firmware *fw)
1547 struct device *dev = &data->client->dev;
1556 cfg.raw = kmemdup_nul(fw->data, fw->size, GFP_KERNEL);
1562 mxt_update_crc(data, MXT_COMMAND_REPORTALL, 1);
1586 if (cfg.info.family_id != data->info->family_id) {
1592 if (cfg.info.variant_id != data->info->variant_id) {
1621 if (info_crc == data->info_crc) {
1622 if (config_crc == 0 || data->config_crc == 0) {
1624 } else if (config_crc == data->config_crc) {
1626 data->config_crc);
1631 data->config_crc, config_crc);
1636 data->info_crc, info_crc);
1641 data->info->object_num * sizeof(struct mxt_object) +
1643 cfg.mem_size = data->mem_size - cfg.start_ofs;
1650 ret = mxt_prepare_cfg_mem(data, &cfg);
1655 if (data->T71_address)
1656 crc_start = data->T71_address;
1657 else if (data->T7_address)
1658 crc_start = data->T7_address;
1672 ret = mxt_upload_cfg_mem(data, &cfg);
1676 mxt_update_crc(data, MXT_COMMAND_BACKUPNV, MXT_BACKUP_VALUE);
1678 ret = mxt_check_retrigen(data);
1682 ret = mxt_soft_reset(data);
1689 mxt_init_t7_power_cfg(data);
1698 static void mxt_free_input_device(struct mxt_data *data)
1700 if (data->input_dev) {
1701 input_unregister_device(data->input_dev);
1702 data->input_dev = NULL;
1706 static void mxt_free_object_table(struct mxt_data *data)
1709 video_unregister_device(&data->dbg.vdev);
1710 v4l2_device_unregister(&data->dbg.v4l2);
1712 data->object_table = NULL;
1713 data->info = NULL;
1714 kfree(data->raw_info_block);
1715 data->raw_info_block = NULL;
1716 kfree(data->msg_buf);
1717 data->msg_buf = NULL;
1718 data->T5_address = 0;
1719 data->T5_msg_size = 0;
1720 data->T6_reportid = 0;
1721 data->T7_address = 0;
1722 data->T71_address = 0;
1723 data->T9_reportid_min = 0;
1724 data->T9_reportid_max = 0;
1725 data->T15_reportid_min = 0;
1726 data->T15_reportid_max = 0;
1727 data->T18_address = 0;
1728 data->T19_reportid = 0;
1729 data->T44_address = 0;
1730 data->T97_reportid_min = 0;
1731 data->T97_reportid_max = 0;
1732 data->T100_reportid_min = 0;
1733 data->T100_reportid_max = 0;
1734 data->max_reportid = 0;
1737 static int mxt_parse_object_table(struct mxt_data *data,
1740 struct i2c_client *client = data->client;
1747 data->mem_size = 0;
1748 for (i = 0; i < data->info->object_num; i++) {
1764 dev_dbg(&data->client->dev,
1772 if (data->info->family_id == 0x80 &&
1773 data->info->version < 0x20) {
1779 data->T5_msg_size = mxt_obj_size(object);
1782 data->T5_msg_size = mxt_obj_size(object) - 1;
1784 data->T5_address = object->start_address;
1787 data->T6_reportid = min_id;
1788 data->T6_address = object->start_address;
1791 data->T7_address = object->start_address;
1794 data->T71_address = object->start_address;
1797 data->multitouch = MXT_TOUCH_MULTI_T9;
1799 data->T9_reportid_min = min_id;
1800 data->T9_reportid_max = min_id +
1802 data->num_touchids = object->num_report_ids;
1805 data->T15_reportid_min = min_id;
1806 data->T15_reportid_max = max_id;
1809 data->T18_address = object->start_address;
1812 data->T44_address = object->start_address;
1815 data->T19_reportid = min_id;
1818 data->T97_reportid_min = min_id;
1819 data->T97_reportid_max = max_id;
1822 data->multitouch = MXT_TOUCH_MULTITOUCHSCREEN_T100;
1823 data->T100_reportid_min = min_id;
1824 data->T100_reportid_max = max_id;
1826 data->num_touchids = object->num_report_ids - 2;
1833 if (end_address >= data->mem_size)
1834 data->mem_size = end_address + 1;
1838 data->max_reportid = reportid;
1841 if (data->T44_address && (data->T5_address != data->T44_address + 1)) {
1846 data->msg_buf = kcalloc(data->max_reportid,
1847 data->T5_msg_size, GFP_KERNEL);
1848 if (!data->msg_buf)
1854 static int mxt_read_info_block(struct mxt_data *data)
1856 struct i2c_client *client = data->client;
1865 if (data->raw_info_block)
1866 mxt_free_object_table(data);
1899 data->info_crc = crc_ptr[0] | (crc_ptr[1] << 8) | (crc_ptr[2] << 16);
1905 * CRC mismatch can be caused by data corruption due to I2C comms
1908 if ((data->info_crc == 0) || (data->info_crc != calculated_crc)) {
1911 calculated_crc, data->info_crc);
1916 data->raw_info_block = id_buf;
1917 data->info = (struct mxt_info *)id_buf;
1921 data->info->family_id, data->info->variant_id,
1922 data->info->version >> 4, data->info->version & 0xf,
1923 data->info->build, data->info->object_num);
1926 error = mxt_parse_object_table(data, id_buf + MXT_OBJECT_START);
1929 mxt_free_object_table(data);
1933 data->object_table = (struct mxt_object *)(id_buf + MXT_OBJECT_START);
1942 static int mxt_read_t9_resolution(struct mxt_data *data)
1944 struct i2c_client *client = data->client;
1950 object = mxt_get_object(data, MXT_TOUCH_MULTI_T9);
1956 sizeof(data->xsize), &data->xsize);
1962 sizeof(data->ysize), &data->ysize);
1972 data->max_x = get_unaligned_le16(&range.x);
1973 data->max_y = get_unaligned_le16(&range.y);
1981 data->xy_switch = orient & MXT_T9_ORIENT_SWITCH;
1982 data->invertx = orient & MXT_T9_ORIENT_INVERTX;
1983 data->inverty = orient & MXT_T9_ORIENT_INVERTY;
1988 static int mxt_read_t100_config(struct mxt_data *data)
1990 struct i2c_client *client = data->client;
1997 object = mxt_get_object(data, MXT_TOUCH_MULTITOUCHSCREEN_T100);
2008 data->max_x = get_unaligned_le16(&range_x);
2016 data->max_y = get_unaligned_le16(&range_y);
2020 sizeof(data->xsize), &data->xsize);
2026 sizeof(data->ysize), &data->ysize);
2037 data->xy_switch = cfg & MXT_T100_CFG_SWITCHXY;
2038 data->invertx = cfg & MXT_T100_CFG_INVERTX;
2039 data->inverty = cfg & MXT_T100_CFG_INVERTY;
2051 data->t100_aux_vect = aux++;
2054 data->t100_aux_ampl = aux++;
2057 data->t100_aux_area = aux++;
2061 data->t100_aux_vect, data->t100_aux_ampl, data->t100_aux_area);
2070 struct mxt_data *data)
2085 for (i = 0; i < data->t19_num_keys; i++)
2086 if (data->t19_keymap[i] != KEY_RESERVED)
2088 data->t19_keymap[i]);
2091 static int mxt_initialize_input_device(struct mxt_data *data)
2093 struct device *dev = &data->client->dev;
2100 switch (data->multitouch) {
2102 num_mt_slots = data->T9_reportid_max - data->T9_reportid_min + 1;
2103 error = mxt_read_t9_resolution(data);
2109 num_mt_slots = data->num_touchids;
2110 error = mxt_read_t100_config(data);
2121 if (data->max_x == 0)
2122 data->max_x = 1023;
2124 if (data->max_y == 0)
2125 data->max_y = 1023;
2127 if (data->xy_switch)
2128 swap(data->max_x, data->max_y);
2130 dev_info(dev, "Touchscreen size X%uY%u\n", data->max_x, data->max_y);
2138 input_dev->phys = data->phys;
2144 input_dev->keycode = data->t15_keymap;
2145 input_dev->keycodemax = data->t15_num_keys;
2146 input_dev->keycodesize = sizeof(data->t15_keymap[0]);
2151 input_set_abs_params(input_dev, ABS_X, 0, data->max_x, 0, 0);
2152 input_set_abs_params(input_dev, ABS_Y, 0, data->max_y, 0, 0);
2154 if (data->multitouch == MXT_TOUCH_MULTI_T9 ||
2155 (data->multitouch == MXT_TOUCH_MULTITOUCHSCREEN_T100 &&
2156 data->t100_aux_ampl)) {
2161 if (data->t19_num_keys) {
2162 mxt_set_up_as_touchpad(input_dev, data);
2175 if (data->multitouch == MXT_TOUCH_MULTITOUCHSCREEN_T100) {
2185 0, data->max_x, 0, 0);
2187 0, data->max_y, 0, 0);
2189 if (data->multitouch == MXT_TOUCH_MULTI_T9 ||
2190 (data->multitouch == MXT_TOUCH_MULTITOUCHSCREEN_T100 &&
2191 data->t100_aux_area)) {
2196 if (data->multitouch == MXT_TOUCH_MULTI_T9 ||
2197 (data->multitouch == MXT_TOUCH_MULTITOUCHSCREEN_T100 &&
2198 data->t100_aux_ampl)) {
2203 if (data->multitouch == MXT_TOUCH_MULTITOUCHSCREEN_T100 &&
2204 data->t100_aux_vect) {
2209 if (data->multitouch == MXT_TOUCH_MULTITOUCHSCREEN_T100 &&
2210 data->t100_aux_vect) {
2216 if (data->T15_reportid_min || data->T97_reportid_min) {
2217 for (i = 0; i < data->t15_num_keys; i++)
2219 EV_KEY, data->t15_keymap[i]);
2222 input_set_drvdata(input_dev, data);
2230 data->input_dev = input_dev;
2239 static int mxt_configure_objects(struct mxt_data *data,
2248 static int mxt_initialize(struct mxt_data *data)
2250 struct i2c_client *client = data->client;
2255 error = mxt_read_info_block(data);
2260 error = mxt_probe_bootloader(data, false);
2263 error = mxt_probe_bootloader(data, true);
2277 data->in_bootloader = true;
2282 mxt_send_bootloader_cmd(data, false);
2286 error = mxt_check_retrigen(data);
2290 error = mxt_acquire_irq(data);
2295 &client->dev, GFP_KERNEL, data,
2306 static int mxt_set_t7_power_cfg(struct mxt_data *data, u8 sleep)
2308 struct device *dev = &data->client->dev;
2316 new_config = &data->t7_cfg;
2318 error = __mxt_write_reg(data->client, data->T7_address,
2319 sizeof(data->t7_cfg), new_config);
2329 static int mxt_init_t7_power_cfg(struct mxt_data *data)
2331 struct device *dev = &data->client->dev;
2336 error = __mxt_read_reg(data->client, data->T7_address,
2337 sizeof(data->t7_cfg), &data->t7_cfg);
2341 if (data->t7_cfg.active == 0 || data->t7_cfg.idle == 0) {
2344 mxt_soft_reset(data);
2349 data->t7_cfg.active = 20;
2350 data->t7_cfg.idle = 100;
2351 return mxt_set_t7_power_cfg(data, MXT_POWER_CFG_RUN);
2356 data->t7_cfg.active, data->t7_cfg.idle);
2371 static u16 mxt_get_debug_value(struct mxt_data *data, unsigned int x,
2374 struct mxt_info *info = data->info;
2375 struct mxt_dbg *dbg = &data->dbg;
2395 return get_unaligned_le16(&dbg->t37_buf[page].data[ofs]);
2398 static int mxt_convert_debug_pages(struct mxt_data *data, u16 *outbuf)
2400 struct mxt_dbg *dbg = &data->dbg;
2407 rx = data->xy_switch ? y : x;
2408 ry = data->xy_switch ? x : y;
2409 rx = data->invertx ? (data->xsize - 1 - rx) : rx;
2410 ry = data->inverty ? (data->ysize - 1 - ry) : ry;
2412 outbuf[i] = mxt_get_debug_value(data, rx, ry);
2415 if (++x >= (data->xy_switch ? data->ysize : data->xsize)) {
2424 static int mxt_read_diagnostic_debug(struct mxt_data *data, u8 mode,
2427 struct mxt_dbg *dbg = &data->dbg;
2438 ret = mxt_write_reg(data->client, dbg->diag_cmd_address,
2447 ret = __mxt_read_reg(data->client, dbg->diag_cmd_address,
2462 ret = __mxt_read_reg(data->client, dbg->t37_address,
2468 dev_err(&data->client->dev, "T37 page mismatch\n");
2472 dev_dbg(&data->client->dev, "%s page:%d retries:%d\n",
2479 return mxt_convert_debug_pages(data, outbuf);
2486 struct mxt_data *data = q->drv_priv;
2487 size_t size = data->dbg.t37_nodes * sizeof(u16);
2500 struct mxt_data *data = vb2_get_drv_priv(vb->vb2_queue);
2507 dev_err(&data->client->dev, "Error acquiring frame ptr\n");
2511 switch (data->dbg.input) {
2522 ret = mxt_read_diagnostic_debug(data, mode, ptr);
2526 vb2_set_plane_payload(vb, 0, data->dbg.t37_nodes * sizeof(u16));
2555 struct mxt_data *data = video_drvdata(file);
2560 "I2C:%s", dev_name(&data->client->dev));
2585 static int mxt_set_input(struct mxt_data *data, unsigned int i)
2587 struct v4l2_pix_format *f = &data->dbg.format;
2597 f->width = data->xy_switch ? data->ysize : data->xsize;
2598 f->height = data->xy_switch ? data->xsize : data->ysize;
2604 data->dbg.input = i;
2616 struct mxt_data *data = video_drvdata(file);
2618 *i = data->dbg.input;
2625 struct mxt_data *data = video_drvdata(file);
2628 f->fmt.pix = data->dbg.format;
2700 static void mxt_debug_init(struct mxt_data *data)
2702 struct mxt_info *info = data->info;
2703 struct mxt_dbg *dbg = &data->dbg;
2707 object = mxt_get_object(data, MXT_GEN_COMMAND_T6);
2713 object = mxt_get_object(data, MXT_DEBUG_DIAGNOSTIC_T37);
2718 dev_warn(&data->client->dev, "Bad T37 size");
2724 /* Calculate size of data and allocate buffer */
2725 dbg->t37_nodes = data->xsize * data->ysize;
2730 dbg->t37_pages = DIV_ROUND_UP(data->xsize *
2733 sizeof(dbg->t37_buf->data));
2735 dbg->t37_buf = devm_kmalloc_array(&data->client->dev, dbg->t37_pages,
2741 mxt_set_input(data, 0);
2745 error = v4l2_device_register(&data->client->dev, &dbg->v4l2);
2752 dbg->queue.drv_priv = data;
2754 dbg->queue.dev = &data->client->dev;
2765 video_set_drvdata(&dbg->vdev, data);
2776 dev_warn(&data->client->dev, "Error initializing T37\n");
2779 static void mxt_debug_init(struct mxt_data *data)
2784 static int mxt_configure_objects(struct mxt_data *data,
2787 struct device *dev = &data->client->dev;
2790 error = mxt_init_t7_power_cfg(data);
2797 error = mxt_update_cfg(data, cfg);
2802 if (data->multitouch) {
2803 error = mxt_initialize_input_device(data);
2810 mxt_debug_init(data);
2819 struct mxt_data *data = dev_get_drvdata(dev);
2820 struct mxt_info *info = data->info;
2829 struct mxt_data *data = dev_get_drvdata(dev);
2830 struct mxt_info *info = data->info;
2856 struct mxt_data *data = dev_get_drvdata(dev);
2869 for (i = 0; i < data->info->object_num; i++) {
2870 object = data->object_table + i;
2882 error = __mxt_read_reg(data->client, addr, size, obuf);
2902 c = *(fw->data + pos);
2921 struct mxt_data *data = dev_get_drvdata(dev);
2940 if (!data->in_bootloader) {
2942 data->in_bootloader = true;
2944 ret = mxt_t6_command(data, MXT_COMMAND_RESET,
2952 ret = mxt_lookup_bootloader_address(data, 0);
2956 mxt_free_input_device(data);
2957 mxt_free_object_table(data);
2959 enable_irq(data->irq);
2962 reinit_completion(&data->bl_completion);
2964 ret = mxt_check_bootloader(data, MXT_WAITING_BOOTLOAD_CMD, false);
2967 ret = mxt_check_bootloader(data, MXT_WAITING_FRAME_DATA, false);
2974 ret = mxt_send_bootloader_cmd(data, true);
2980 ret = mxt_check_bootloader(data, MXT_WAITING_FRAME_DATA, true);
2984 frame_size = ((*(fw->data + pos) << 8) | *(fw->data + pos + 1));
2990 ret = mxt_bootloader_write(data, fw->data + pos, frame_size);
2994 ret = mxt_check_bootloader(data, MXT_FRAME_CRC_PASS, true);
3017 ret = mxt_wait_for_completion(data, &data->bl_completion,
3029 mxt_wait_for_completion(data, &data->bl_completion, MXT_FW_RESET_TIME);
3031 data->in_bootloader = false;
3034 disable_irq(data->irq);
3044 struct mxt_data *data = dev_get_drvdata(dev);
3054 error = mxt_initialize(data);
3079 static void mxt_start(struct mxt_data *data)
3081 mxt_wakeup_toggle(data->client, true, false);
3083 switch (data->suspend_mode) {
3085 mxt_soft_reset(data);
3089 mxt_write_object(data,
3095 mxt_set_t7_power_cfg(data, MXT_POWER_CFG_RUN);
3098 mxt_t6_command(data, MXT_COMMAND_CALIBRATE, 1, false);
3103 static void mxt_stop(struct mxt_data *data)
3105 switch (data->suspend_mode) {
3108 mxt_write_object(data,
3114 mxt_set_t7_power_cfg(data, MXT_POWER_CFG_DEEPSLEEP);
3118 mxt_wakeup_toggle(data->client, false, false);
3123 struct mxt_data *data = input_get_drvdata(dev);
3125 mxt_start(data);
3132 struct mxt_data *data = input_get_drvdata(dev);
3134 mxt_stop(data);
3137 static int mxt_parse_device_properties(struct mxt_data *data)
3141 struct device *dev = &data->client->dev;
3169 data->t19_keymap = keymap;
3170 data->t19_num_keys = n_keys;
3195 data->t15_keymap = buttonmap;
3196 data->t15_num_keys = n_keys;
3219 struct mxt_data *data;
3247 data = devm_kzalloc(&client->dev, sizeof(struct mxt_data), GFP_KERNEL);
3248 if (!data)
3251 snprintf(data->phys, sizeof(data->phys), "i2c-%u-%04x/input0",
3254 data->client = client;
3255 data->irq = client->irq;
3256 i2c_set_clientdata(client, data);
3258 init_completion(&data->bl_completion);
3259 init_completion(&data->reset_completion);
3260 init_completion(&data->crc_completion);
3262 data->suspend_mode = dmi_check_system(chromebook_T9_suspend_dmi) ?
3265 error = mxt_parse_device_properties(data);
3273 data->regulators[0].supply = "vdda";
3274 data->regulators[1].supply = "vdd";
3275 error = devm_regulator_bulk_get(&client->dev, ARRAY_SIZE(data->regulators),
3276 data->regulators);
3285 data->reset_gpio = devm_gpiod_get_optional(&client->dev,
3287 if (IS_ERR(data->reset_gpio)) {
3288 error = PTR_ERR(data->reset_gpio);
3294 data->wake_gpio = devm_gpiod_get_optional(&client->dev,
3296 if (IS_ERR(data->wake_gpio)) {
3297 error = PTR_ERR(data->wake_gpio);
3305 client->name, data);
3311 error = regulator_bulk_enable(ARRAY_SIZE(data->regulators),
3312 data->regulators);
3324 if (data->reset_gpio) {
3327 gpiod_set_value(data->reset_gpio, 0);
3348 &data->wakeup_method);
3350 error = mxt_initialize(data);
3364 mxt_free_input_device(data);
3365 mxt_free_object_table(data);
3367 regulator_bulk_disable(ARRAY_SIZE(data->regulators),
3368 data->regulators);
3374 struct mxt_data *data = i2c_get_clientdata(client);
3376 disable_irq(data->irq);
3378 mxt_free_input_device(data);
3379 mxt_free_object_table(data);
3380 regulator_bulk_disable(ARRAY_SIZE(data->regulators),
3381 data->regulators);
3387 struct mxt_data *data = i2c_get_clientdata(client);
3388 struct input_dev *input_dev = data->input_dev;
3396 mxt_stop(data);
3400 disable_irq(data->irq);
3408 struct mxt_data *data = i2c_get_clientdata(client);
3409 struct input_dev *input_dev = data->input_dev;
3414 enable_irq(data->irq);
3419 mxt_start(data);