rmi_f12.c 14 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551
  1. // SPDX-License-Identifier: GPL-2.0-only
  2. /*
  3. * Copyright (c) 2012-2016 Synaptics Incorporated
  4. */
  5. #include <linux/input.h>
  6. #include <linux/input/mt.h>
  7. #include <linux/rmi.h>
  8. #include "rmi_driver.h"
  9. #include "rmi_2d_sensor.h"
  10. enum rmi_f12_object_type {
  11. RMI_F12_OBJECT_NONE = 0x00,
  12. RMI_F12_OBJECT_FINGER = 0x01,
  13. RMI_F12_OBJECT_STYLUS = 0x02,
  14. RMI_F12_OBJECT_PALM = 0x03,
  15. RMI_F12_OBJECT_UNCLASSIFIED = 0x04,
  16. RMI_F12_OBJECT_GLOVED_FINGER = 0x06,
  17. RMI_F12_OBJECT_NARROW_OBJECT = 0x07,
  18. RMI_F12_OBJECT_HAND_EDGE = 0x08,
  19. RMI_F12_OBJECT_COVER = 0x0A,
  20. RMI_F12_OBJECT_STYLUS_2 = 0x0B,
  21. RMI_F12_OBJECT_ERASER = 0x0C,
  22. RMI_F12_OBJECT_SMALL_OBJECT = 0x0D,
  23. };
  24. #define F12_DATA1_BYTES_PER_OBJ 8
  25. struct f12_data {
  26. struct rmi_2d_sensor sensor;
  27. struct rmi_2d_sensor_platform_data sensor_pdata;
  28. bool has_dribble;
  29. u16 data_addr;
  30. struct rmi_register_descriptor query_reg_desc;
  31. struct rmi_register_descriptor control_reg_desc;
  32. struct rmi_register_descriptor data_reg_desc;
  33. /* F12 Data1 describes sensed objects */
  34. const struct rmi_register_desc_item *data1;
  35. u16 data1_offset;
  36. /* F12 Data5 describes finger ACM */
  37. const struct rmi_register_desc_item *data5;
  38. u16 data5_offset;
  39. /* F12 Data5 describes Pen */
  40. const struct rmi_register_desc_item *data6;
  41. u16 data6_offset;
  42. /* F12 Data9 reports relative data */
  43. const struct rmi_register_desc_item *data9;
  44. u16 data9_offset;
  45. const struct rmi_register_desc_item *data15;
  46. u16 data15_offset;
  47. unsigned long *abs_mask;
  48. unsigned long *rel_mask;
  49. };
  50. static int rmi_f12_read_sensor_tuning(struct f12_data *f12)
  51. {
  52. const struct rmi_register_desc_item *item;
  53. struct rmi_2d_sensor *sensor = &f12->sensor;
  54. struct rmi_function *fn = sensor->fn;
  55. struct rmi_device *rmi_dev = fn->rmi_dev;
  56. int ret;
  57. int offset;
  58. u8 buf[15];
  59. int pitch_x = 0;
  60. int pitch_y = 0;
  61. int rx_receivers = 0;
  62. int tx_receivers = 0;
  63. item = rmi_get_register_desc_item(&f12->control_reg_desc, 8);
  64. if (!item) {
  65. dev_err(&fn->dev,
  66. "F12 does not have the sensor tuning control register\n");
  67. return -ENODEV;
  68. }
  69. offset = rmi_register_desc_calc_reg_offset(&f12->control_reg_desc, 8);
  70. if (item->reg_size > sizeof(buf)) {
  71. dev_err(&fn->dev,
  72. "F12 control8 should be no bigger than %zd bytes, not: %ld\n",
  73. sizeof(buf), item->reg_size);
  74. return -ENODEV;
  75. }
  76. ret = rmi_read_block(rmi_dev, fn->fd.control_base_addr + offset, buf,
  77. item->reg_size);
  78. if (ret)
  79. return ret;
  80. offset = 0;
  81. if (rmi_register_desc_has_subpacket(item, 0)) {
  82. sensor->max_x = (buf[offset + 1] << 8) | buf[offset];
  83. sensor->max_y = (buf[offset + 3] << 8) | buf[offset + 2];
  84. offset += 4;
  85. }
  86. rmi_dbg(RMI_DEBUG_FN, &fn->dev, "%s: max_x: %d max_y: %d\n", __func__,
  87. sensor->max_x, sensor->max_y);
  88. if (rmi_register_desc_has_subpacket(item, 1)) {
  89. pitch_x = (buf[offset + 1] << 8) | buf[offset];
  90. pitch_y = (buf[offset + 3] << 8) | buf[offset + 2];
  91. offset += 4;
  92. }
  93. if (rmi_register_desc_has_subpacket(item, 2)) {
  94. /* Units 1/128 sensor pitch */
  95. rmi_dbg(RMI_DEBUG_FN, &fn->dev,
  96. "%s: Inactive Border xlo:%d xhi:%d ylo:%d yhi:%d\n",
  97. __func__,
  98. buf[offset], buf[offset + 1],
  99. buf[offset + 2], buf[offset + 3]);
  100. offset += 4;
  101. }
  102. if (rmi_register_desc_has_subpacket(item, 3)) {
  103. rx_receivers = buf[offset];
  104. tx_receivers = buf[offset + 1];
  105. offset += 2;
  106. }
  107. /* Skip over sensor flags */
  108. if (rmi_register_desc_has_subpacket(item, 4))
  109. offset += 1;
  110. sensor->x_mm = (pitch_x * rx_receivers) >> 12;
  111. sensor->y_mm = (pitch_y * tx_receivers) >> 12;
  112. rmi_dbg(RMI_DEBUG_FN, &fn->dev, "%s: x_mm: %d y_mm: %d\n", __func__,
  113. sensor->x_mm, sensor->y_mm);
  114. return 0;
  115. }
  116. static void rmi_f12_process_objects(struct f12_data *f12, u8 *data1, int size)
  117. {
  118. int i;
  119. struct rmi_2d_sensor *sensor = &f12->sensor;
  120. int objects = f12->data1->num_subpackets;
  121. if ((f12->data1->num_subpackets * F12_DATA1_BYTES_PER_OBJ) > size)
  122. objects = size / F12_DATA1_BYTES_PER_OBJ;
  123. for (i = 0; i < objects; i++) {
  124. struct rmi_2d_sensor_abs_object *obj = &sensor->objs[i];
  125. obj->type = RMI_2D_OBJECT_NONE;
  126. obj->mt_tool = MT_TOOL_FINGER;
  127. switch (data1[0]) {
  128. case RMI_F12_OBJECT_FINGER:
  129. obj->type = RMI_2D_OBJECT_FINGER;
  130. break;
  131. case RMI_F12_OBJECT_STYLUS:
  132. obj->type = RMI_2D_OBJECT_STYLUS;
  133. obj->mt_tool = MT_TOOL_PEN;
  134. break;
  135. case RMI_F12_OBJECT_PALM:
  136. obj->type = RMI_2D_OBJECT_PALM;
  137. obj->mt_tool = MT_TOOL_PALM;
  138. break;
  139. case RMI_F12_OBJECT_UNCLASSIFIED:
  140. obj->type = RMI_2D_OBJECT_UNCLASSIFIED;
  141. break;
  142. }
  143. obj->x = (data1[2] << 8) | data1[1];
  144. obj->y = (data1[4] << 8) | data1[3];
  145. obj->z = data1[5];
  146. obj->wx = data1[6];
  147. obj->wy = data1[7];
  148. rmi_2d_sensor_abs_process(sensor, obj, i);
  149. data1 += F12_DATA1_BYTES_PER_OBJ;
  150. }
  151. if (sensor->kernel_tracking)
  152. input_mt_assign_slots(sensor->input,
  153. sensor->tracking_slots,
  154. sensor->tracking_pos,
  155. sensor->nbr_fingers,
  156. sensor->dmax);
  157. for (i = 0; i < objects; i++)
  158. rmi_2d_sensor_abs_report(sensor, &sensor->objs[i], i);
  159. }
  160. static irqreturn_t rmi_f12_attention(int irq, void *ctx)
  161. {
  162. int retval;
  163. struct rmi_function *fn = ctx;
  164. struct rmi_device *rmi_dev = fn->rmi_dev;
  165. struct rmi_driver_data *drvdata = dev_get_drvdata(&rmi_dev->dev);
  166. struct f12_data *f12 = dev_get_drvdata(&fn->dev);
  167. struct rmi_2d_sensor *sensor = &f12->sensor;
  168. int valid_bytes = sensor->pkt_size;
  169. if (drvdata->attn_data.data) {
  170. if (sensor->attn_size > drvdata->attn_data.size)
  171. valid_bytes = drvdata->attn_data.size;
  172. else
  173. valid_bytes = sensor->attn_size;
  174. memcpy(sensor->data_pkt, drvdata->attn_data.data,
  175. valid_bytes);
  176. drvdata->attn_data.data += valid_bytes;
  177. drvdata->attn_data.size -= valid_bytes;
  178. } else {
  179. retval = rmi_read_block(rmi_dev, f12->data_addr,
  180. sensor->data_pkt, sensor->pkt_size);
  181. if (retval < 0) {
  182. dev_err(&fn->dev, "Failed to read object data. Code: %d.\n",
  183. retval);
  184. return IRQ_RETVAL(retval);
  185. }
  186. }
  187. if (f12->data1)
  188. rmi_f12_process_objects(f12,
  189. &sensor->data_pkt[f12->data1_offset], valid_bytes);
  190. input_mt_sync_frame(sensor->input);
  191. return IRQ_HANDLED;
  192. }
  193. static int rmi_f12_write_control_regs(struct rmi_function *fn)
  194. {
  195. int ret;
  196. const struct rmi_register_desc_item *item;
  197. struct rmi_device *rmi_dev = fn->rmi_dev;
  198. struct f12_data *f12 = dev_get_drvdata(&fn->dev);
  199. int control_size;
  200. char buf[3];
  201. u16 control_offset = 0;
  202. u8 subpacket_offset = 0;
  203. if (f12->has_dribble
  204. && (f12->sensor.dribble != RMI_REG_STATE_DEFAULT)) {
  205. item = rmi_get_register_desc_item(&f12->control_reg_desc, 20);
  206. if (item) {
  207. control_offset = rmi_register_desc_calc_reg_offset(
  208. &f12->control_reg_desc, 20);
  209. /*
  210. * The byte containing the EnableDribble bit will be
  211. * in either byte 0 or byte 2 of control 20. Depending
  212. * on the existence of subpacket 0. If control 20 is
  213. * larger then 3 bytes, just read the first 3.
  214. */
  215. control_size = min(item->reg_size, 3UL);
  216. ret = rmi_read_block(rmi_dev, fn->fd.control_base_addr
  217. + control_offset, buf, control_size);
  218. if (ret)
  219. return ret;
  220. if (rmi_register_desc_has_subpacket(item, 0))
  221. subpacket_offset += 1;
  222. switch (f12->sensor.dribble) {
  223. case RMI_REG_STATE_OFF:
  224. buf[subpacket_offset] &= ~BIT(2);
  225. break;
  226. case RMI_REG_STATE_ON:
  227. buf[subpacket_offset] |= BIT(2);
  228. break;
  229. case RMI_REG_STATE_DEFAULT:
  230. default:
  231. break;
  232. }
  233. ret = rmi_write_block(rmi_dev,
  234. fn->fd.control_base_addr + control_offset,
  235. buf, control_size);
  236. if (ret)
  237. return ret;
  238. }
  239. }
  240. return 0;
  241. }
  242. static int rmi_f12_config(struct rmi_function *fn)
  243. {
  244. struct rmi_driver *drv = fn->rmi_dev->driver;
  245. struct f12_data *f12 = dev_get_drvdata(&fn->dev);
  246. struct rmi_2d_sensor *sensor;
  247. int ret;
  248. sensor = &f12->sensor;
  249. if (!sensor->report_abs)
  250. drv->clear_irq_bits(fn->rmi_dev, f12->abs_mask);
  251. else
  252. drv->set_irq_bits(fn->rmi_dev, f12->abs_mask);
  253. drv->clear_irq_bits(fn->rmi_dev, f12->rel_mask);
  254. ret = rmi_f12_write_control_regs(fn);
  255. if (ret)
  256. dev_warn(&fn->dev,
  257. "Failed to write F12 control registers: %d\n", ret);
  258. return 0;
  259. }
  260. static int rmi_f12_probe(struct rmi_function *fn)
  261. {
  262. struct f12_data *f12;
  263. int ret;
  264. struct rmi_device *rmi_dev = fn->rmi_dev;
  265. char buf;
  266. u16 query_addr = fn->fd.query_base_addr;
  267. const struct rmi_register_desc_item *item;
  268. struct rmi_2d_sensor *sensor;
  269. struct rmi_device_platform_data *pdata = rmi_get_platform_data(rmi_dev);
  270. struct rmi_driver_data *drvdata = dev_get_drvdata(&rmi_dev->dev);
  271. u16 data_offset = 0;
  272. int mask_size;
  273. rmi_dbg(RMI_DEBUG_FN, &fn->dev, "%s\n", __func__);
  274. mask_size = BITS_TO_LONGS(drvdata->irq_count) * sizeof(unsigned long);
  275. ret = rmi_read(fn->rmi_dev, query_addr, &buf);
  276. if (ret < 0) {
  277. dev_err(&fn->dev, "Failed to read general info register: %d\n",
  278. ret);
  279. return -ENODEV;
  280. }
  281. ++query_addr;
  282. if (!(buf & BIT(0))) {
  283. dev_err(&fn->dev,
  284. "Behavior of F12 without register descriptors is undefined.\n");
  285. return -ENODEV;
  286. }
  287. f12 = devm_kzalloc(&fn->dev, sizeof(struct f12_data) + mask_size * 2,
  288. GFP_KERNEL);
  289. if (!f12)
  290. return -ENOMEM;
  291. f12->abs_mask = (unsigned long *)((char *)f12
  292. + sizeof(struct f12_data));
  293. f12->rel_mask = (unsigned long *)((char *)f12
  294. + sizeof(struct f12_data) + mask_size);
  295. set_bit(fn->irq_pos, f12->abs_mask);
  296. set_bit(fn->irq_pos + 1, f12->rel_mask);
  297. f12->has_dribble = !!(buf & BIT(3));
  298. if (fn->dev.of_node) {
  299. ret = rmi_2d_sensor_of_probe(&fn->dev, &f12->sensor_pdata);
  300. if (ret)
  301. return ret;
  302. } else {
  303. f12->sensor_pdata = pdata->sensor_pdata;
  304. }
  305. ret = rmi_read_register_desc(rmi_dev, query_addr,
  306. &f12->query_reg_desc);
  307. if (ret) {
  308. dev_err(&fn->dev,
  309. "Failed to read the Query Register Descriptor: %d\n",
  310. ret);
  311. return ret;
  312. }
  313. query_addr += 3;
  314. ret = rmi_read_register_desc(rmi_dev, query_addr,
  315. &f12->control_reg_desc);
  316. if (ret) {
  317. dev_err(&fn->dev,
  318. "Failed to read the Control Register Descriptor: %d\n",
  319. ret);
  320. return ret;
  321. }
  322. query_addr += 3;
  323. ret = rmi_read_register_desc(rmi_dev, query_addr,
  324. &f12->data_reg_desc);
  325. if (ret) {
  326. dev_err(&fn->dev,
  327. "Failed to read the Data Register Descriptor: %d\n",
  328. ret);
  329. return ret;
  330. }
  331. query_addr += 3;
  332. sensor = &f12->sensor;
  333. sensor->fn = fn;
  334. f12->data_addr = fn->fd.data_base_addr;
  335. sensor->pkt_size = rmi_register_desc_calc_size(&f12->data_reg_desc);
  336. sensor->axis_align =
  337. f12->sensor_pdata.axis_align;
  338. sensor->x_mm = f12->sensor_pdata.x_mm;
  339. sensor->y_mm = f12->sensor_pdata.y_mm;
  340. sensor->dribble = f12->sensor_pdata.dribble;
  341. if (sensor->sensor_type == rmi_sensor_default)
  342. sensor->sensor_type =
  343. f12->sensor_pdata.sensor_type;
  344. rmi_dbg(RMI_DEBUG_FN, &fn->dev, "%s: data packet size: %d\n", __func__,
  345. sensor->pkt_size);
  346. sensor->data_pkt = devm_kzalloc(&fn->dev, sensor->pkt_size, GFP_KERNEL);
  347. if (!sensor->data_pkt)
  348. return -ENOMEM;
  349. dev_set_drvdata(&fn->dev, f12);
  350. ret = rmi_f12_read_sensor_tuning(f12);
  351. if (ret)
  352. return ret;
  353. /*
  354. * Figure out what data is contained in the data registers. HID devices
  355. * may have registers defined, but their data is not reported in the
  356. * HID attention report. Registers which are not reported in the HID
  357. * attention report check to see if the device is receiving data from
  358. * HID attention reports.
  359. */
  360. item = rmi_get_register_desc_item(&f12->data_reg_desc, 0);
  361. if (item && !drvdata->attn_data.data)
  362. data_offset += item->reg_size;
  363. item = rmi_get_register_desc_item(&f12->data_reg_desc, 1);
  364. if (item) {
  365. f12->data1 = item;
  366. f12->data1_offset = data_offset;
  367. data_offset += item->reg_size;
  368. sensor->nbr_fingers = item->num_subpackets;
  369. sensor->report_abs = 1;
  370. sensor->attn_size += item->reg_size;
  371. }
  372. item = rmi_get_register_desc_item(&f12->data_reg_desc, 2);
  373. if (item && !drvdata->attn_data.data)
  374. data_offset += item->reg_size;
  375. item = rmi_get_register_desc_item(&f12->data_reg_desc, 3);
  376. if (item && !drvdata->attn_data.data)
  377. data_offset += item->reg_size;
  378. item = rmi_get_register_desc_item(&f12->data_reg_desc, 4);
  379. if (item && !drvdata->attn_data.data)
  380. data_offset += item->reg_size;
  381. item = rmi_get_register_desc_item(&f12->data_reg_desc, 5);
  382. if (item) {
  383. f12->data5 = item;
  384. f12->data5_offset = data_offset;
  385. data_offset += item->reg_size;
  386. sensor->attn_size += item->reg_size;
  387. }
  388. item = rmi_get_register_desc_item(&f12->data_reg_desc, 6);
  389. if (item && !drvdata->attn_data.data) {
  390. f12->data6 = item;
  391. f12->data6_offset = data_offset;
  392. data_offset += item->reg_size;
  393. }
  394. item = rmi_get_register_desc_item(&f12->data_reg_desc, 7);
  395. if (item && !drvdata->attn_data.data)
  396. data_offset += item->reg_size;
  397. item = rmi_get_register_desc_item(&f12->data_reg_desc, 8);
  398. if (item && !drvdata->attn_data.data)
  399. data_offset += item->reg_size;
  400. item = rmi_get_register_desc_item(&f12->data_reg_desc, 9);
  401. if (item && !drvdata->attn_data.data) {
  402. f12->data9 = item;
  403. f12->data9_offset = data_offset;
  404. data_offset += item->reg_size;
  405. if (!sensor->report_abs)
  406. sensor->report_rel = 1;
  407. }
  408. item = rmi_get_register_desc_item(&f12->data_reg_desc, 10);
  409. if (item && !drvdata->attn_data.data)
  410. data_offset += item->reg_size;
  411. item = rmi_get_register_desc_item(&f12->data_reg_desc, 11);
  412. if (item && !drvdata->attn_data.data)
  413. data_offset += item->reg_size;
  414. item = rmi_get_register_desc_item(&f12->data_reg_desc, 12);
  415. if (item && !drvdata->attn_data.data)
  416. data_offset += item->reg_size;
  417. item = rmi_get_register_desc_item(&f12->data_reg_desc, 13);
  418. if (item && !drvdata->attn_data.data)
  419. data_offset += item->reg_size;
  420. item = rmi_get_register_desc_item(&f12->data_reg_desc, 14);
  421. if (item && !drvdata->attn_data.data)
  422. data_offset += item->reg_size;
  423. item = rmi_get_register_desc_item(&f12->data_reg_desc, 15);
  424. if (item && !drvdata->attn_data.data) {
  425. f12->data15 = item;
  426. f12->data15_offset = data_offset;
  427. data_offset += item->reg_size;
  428. }
  429. /* allocate the in-kernel tracking buffers */
  430. sensor->tracking_pos = devm_kcalloc(&fn->dev,
  431. sensor->nbr_fingers, sizeof(struct input_mt_pos),
  432. GFP_KERNEL);
  433. sensor->tracking_slots = devm_kcalloc(&fn->dev,
  434. sensor->nbr_fingers, sizeof(int), GFP_KERNEL);
  435. sensor->objs = devm_kcalloc(&fn->dev,
  436. sensor->nbr_fingers,
  437. sizeof(struct rmi_2d_sensor_abs_object),
  438. GFP_KERNEL);
  439. if (!sensor->tracking_pos || !sensor->tracking_slots || !sensor->objs)
  440. return -ENOMEM;
  441. ret = rmi_2d_sensor_configure_input(fn, sensor);
  442. if (ret)
  443. return ret;
  444. return 0;
  445. }
  446. struct rmi_function_handler rmi_f12_handler = {
  447. .driver = {
  448. .name = "rmi4_f12",
  449. },
  450. .func = 0x12,
  451. .probe = rmi_f12_probe,
  452. .config = rmi_f12_config,
  453. .attention = rmi_f12_attention,
  454. };