1 // SPDX-License-Identifier: GPL-2.0-only
2 /*
3  * Elan I2C/SMBus Touchpad driver - SMBus interface
4  *
5  * Copyright (c) 2013 ELAN Microelectronics Corp.
6  *
7  * Author: 林政維 (Duson Lin) <dusonlin@emc.com.tw>
8  *
9  * Based on cyapa driver:
10  * copyright (c) 2011-2012 Cypress Semiconductor, Inc.
11  * copyright (c) 2011-2012 Google, Inc.
12  *
13  * Trademarks are the property of their respective owners.
14  */
15 
16 #include <linux/delay.h>
17 #include <linux/i2c.h>
18 #include <linux/init.h>
19 #include <linux/kernel.h>
20 
21 #include "elan_i2c.h"
22 
23 /* Elan SMbus commands */
24 #define ETP_SMBUS_IAP_CMD		0x00
25 #define ETP_SMBUS_ENABLE_TP		0x20
26 #define ETP_SMBUS_SLEEP_CMD		0x21
27 #define ETP_SMBUS_IAP_PASSWORD_WRITE	0x29
28 #define ETP_SMBUS_IAP_PASSWORD_READ	0x80
29 #define ETP_SMBUS_WRITE_FW_BLOCK	0x2A
30 #define ETP_SMBUS_IAP_RESET_CMD		0x2B
31 #define ETP_SMBUS_RANGE_CMD		0xA0
32 #define ETP_SMBUS_FW_VERSION_CMD	0xA1
33 #define ETP_SMBUS_XY_TRACENUM_CMD	0xA2
34 #define ETP_SMBUS_SM_VERSION_CMD	0xA3
35 #define ETP_SMBUS_UNIQUEID_CMD		0xA3
36 #define ETP_SMBUS_RESOLUTION_CMD	0xA4
37 #define ETP_SMBUS_HELLOPACKET_CMD	0xA7
38 #define ETP_SMBUS_PACKET_QUERY		0xA8
39 #define ETP_SMBUS_IAP_VERSION_CMD	0xAC
40 #define ETP_SMBUS_IAP_CTRL_CMD		0xAD
41 #define ETP_SMBUS_IAP_CHECKSUM_CMD	0xAE
42 #define ETP_SMBUS_FW_CHECKSUM_CMD	0xAF
43 #define ETP_SMBUS_MAX_BASELINE_CMD	0xC3
44 #define ETP_SMBUS_MIN_BASELINE_CMD	0xC4
45 #define ETP_SMBUS_CALIBRATE_QUERY	0xC5
46 
47 #define ETP_SMBUS_REPORT_LEN		32
48 #define ETP_SMBUS_REPORT_LEN2		7
49 #define ETP_SMBUS_REPORT_OFFSET		2
50 #define ETP_SMBUS_HELLOPACKET_LEN	5
51 #define ETP_SMBUS_IAP_PASSWORD		0x1234
52 #define ETP_SMBUS_IAP_MODE_ON		(1 << 6)
53 
54 static int elan_smbus_initialize(struct i2c_client *client)
55 {
56 	u8 check[ETP_SMBUS_HELLOPACKET_LEN] = { 0x55, 0x55, 0x55, 0x55, 0x55 };
57 	u8 values[I2C_SMBUS_BLOCK_MAX] = {0};
58 	int len, error;
59 
60 	/* Get hello packet */
61 	len = i2c_smbus_read_block_data(client,
62 					ETP_SMBUS_HELLOPACKET_CMD, values);
63 	if (len != ETP_SMBUS_HELLOPACKET_LEN) {
64 		dev_err(&client->dev, "hello packet length fail: %d\n", len);
65 		error = len < 0 ? len : -EIO;
66 		return error;
67 	}
68 
69 	/* compare hello packet */
70 	if (memcmp(values, check, ETP_SMBUS_HELLOPACKET_LEN)) {
71 		dev_err(&client->dev, "hello packet fail [%*ph]\n",
72 			ETP_SMBUS_HELLOPACKET_LEN, values);
73 		return -ENXIO;
74 	}
75 
76 	/* enable tp */
77 	error = i2c_smbus_write_byte(client, ETP_SMBUS_ENABLE_TP);
78 	if (error) {
79 		dev_err(&client->dev, "failed to enable touchpad: %d\n", error);
80 		return error;
81 	}
82 
83 	return 0;
84 }
85 
86 static int elan_smbus_set_mode(struct i2c_client *client, u8 mode)
87 {
88 	u8 cmd[4] = { 0x00, 0x07, 0x00, mode };
89 
90 	return i2c_smbus_write_block_data(client, ETP_SMBUS_IAP_CMD,
91 					  sizeof(cmd), cmd);
92 }
93 
94 static int elan_smbus_sleep_control(struct i2c_client *client, bool sleep)
95 {
96 	if (sleep)
97 		return i2c_smbus_write_byte(client, ETP_SMBUS_SLEEP_CMD);
98 	else
99 		return 0; /* XXX should we send ETP_SMBUS_ENABLE_TP here? */
100 }
101 
102 static int elan_smbus_power_control(struct i2c_client *client, bool enable)
103 {
104 	return 0; /* A no-op */
105 }
106 
107 static int elan_smbus_calibrate(struct i2c_client *client)
108 {
109 	u8 cmd[4] = { 0x00, 0x08, 0x00, 0x01 };
110 
111 	return i2c_smbus_write_block_data(client, ETP_SMBUS_IAP_CMD,
112 					  sizeof(cmd), cmd);
113 }
114 
115 static int elan_smbus_calibrate_result(struct i2c_client *client, u8 *val)
116 {
117 	int error;
118 	u8 buf[I2C_SMBUS_BLOCK_MAX] = {0};
119 
120 	BUILD_BUG_ON(ETP_CALIBRATE_MAX_LEN > sizeof(buf));
121 
122 	error = i2c_smbus_read_block_data(client,
123 					  ETP_SMBUS_CALIBRATE_QUERY, buf);
124 	if (error < 0)
125 		return error;
126 
127 	memcpy(val, buf, ETP_CALIBRATE_MAX_LEN);
128 	return 0;
129 }
130 
131 static int elan_smbus_get_baseline_data(struct i2c_client *client,
132 					bool max_baseline, u8 *value)
133 {
134 	int error;
135 	u8 val[I2C_SMBUS_BLOCK_MAX] = {0};
136 
137 	error = i2c_smbus_read_block_data(client,
138 					  max_baseline ?
139 						ETP_SMBUS_MAX_BASELINE_CMD :
140 						ETP_SMBUS_MIN_BASELINE_CMD,
141 					  val);
142 	if (error < 0)
143 		return error;
144 
145 	*value = be16_to_cpup((__be16 *)val);
146 
147 	return 0;
148 }
149 
150 static int elan_smbus_get_version(struct i2c_client *client,
151 				  u8 pattern, bool iap, u8 *version)
152 {
153 	int error;
154 	u8 val[I2C_SMBUS_BLOCK_MAX] = {0};
155 
156 	error = i2c_smbus_read_block_data(client,
157 					  iap ? ETP_SMBUS_IAP_VERSION_CMD :
158 						ETP_SMBUS_FW_VERSION_CMD,
159 					  val);
160 	if (error < 0) {
161 		dev_err(&client->dev, "failed to get %s version: %d\n",
162 			iap ? "IAP" : "FW", error);
163 		return error;
164 	}
165 
166 	*version = val[2];
167 	return 0;
168 }
169 
170 static int elan_smbus_get_sm_version(struct i2c_client *client, u8 pattern,
171 				     u16 *ic_type, u8 *version, u8 *clickpad)
172 {
173 	int error;
174 	u8 val[I2C_SMBUS_BLOCK_MAX] = {0};
175 
176 	error = i2c_smbus_read_block_data(client,
177 					  ETP_SMBUS_SM_VERSION_CMD, val);
178 	if (error < 0) {
179 		dev_err(&client->dev, "failed to get SM version: %d\n", error);
180 		return error;
181 	}
182 
183 	*version = val[0];
184 	*ic_type = val[1];
185 	*clickpad = val[0] & 0x10;
186 	return 0;
187 }
188 
189 static int elan_smbus_get_product_id(struct i2c_client *client, u16 *id)
190 {
191 	int error;
192 	u8 val[I2C_SMBUS_BLOCK_MAX] = {0};
193 
194 	error = i2c_smbus_read_block_data(client,
195 					  ETP_SMBUS_UNIQUEID_CMD, val);
196 	if (error < 0) {
197 		dev_err(&client->dev, "failed to get product ID: %d\n", error);
198 		return error;
199 	}
200 
201 	*id = be16_to_cpup((__be16 *)val);
202 	return 0;
203 }
204 
205 static int elan_smbus_get_checksum(struct i2c_client *client,
206 				   bool iap, u16 *csum)
207 {
208 	int error;
209 	u8 val[I2C_SMBUS_BLOCK_MAX] = {0};
210 
211 	error = i2c_smbus_read_block_data(client,
212 					  iap ? ETP_SMBUS_FW_CHECKSUM_CMD :
213 						ETP_SMBUS_IAP_CHECKSUM_CMD,
214 					  val);
215 	if (error < 0) {
216 		dev_err(&client->dev, "failed to get %s checksum: %d\n",
217 			iap ? "IAP" : "FW", error);
218 		return error;
219 	}
220 
221 	*csum = be16_to_cpup((__be16 *)val);
222 	return 0;
223 }
224 
225 static int elan_smbus_get_max(struct i2c_client *client,
226 			      unsigned int *max_x, unsigned int *max_y)
227 {
228 	int ret;
229 	int error;
230 	u8 val[I2C_SMBUS_BLOCK_MAX] = {0};
231 
232 	ret = i2c_smbus_read_block_data(client, ETP_SMBUS_RANGE_CMD, val);
233 	if (ret != 3) {
234 		error = ret < 0 ? ret : -EIO;
235 		dev_err(&client->dev, "failed to get dimensions: %d\n", error);
236 		return error;
237 	}
238 
239 	*max_x = (0x0f & val[0]) << 8 | val[1];
240 	*max_y = (0xf0 & val[0]) << 4 | val[2];
241 
242 	return 0;
243 }
244 
245 static int elan_smbus_get_resolution(struct i2c_client *client,
246 				     u8 *hw_res_x, u8 *hw_res_y)
247 {
248 	int ret;
249 	int error;
250 	u8 val[I2C_SMBUS_BLOCK_MAX] = {0};
251 
252 	ret = i2c_smbus_read_block_data(client, ETP_SMBUS_RESOLUTION_CMD, val);
253 	if (ret != 3) {
254 		error = ret < 0 ? ret : -EIO;
255 		dev_err(&client->dev, "failed to get resolution: %d\n", error);
256 		return error;
257 	}
258 
259 	*hw_res_x = val[1] & 0x0F;
260 	*hw_res_y = (val[1] & 0xF0) >> 4;
261 
262 	return 0;
263 }
264 
265 static int elan_smbus_get_num_traces(struct i2c_client *client,
266 				     unsigned int *x_traces,
267 				     unsigned int *y_traces)
268 {
269 	int ret;
270 	int error;
271 	u8 val[I2C_SMBUS_BLOCK_MAX] = {0};
272 
273 	ret = i2c_smbus_read_block_data(client, ETP_SMBUS_XY_TRACENUM_CMD, val);
274 	if (ret != 3) {
275 		error = ret < 0 ? ret : -EIO;
276 		dev_err(&client->dev, "failed to get trace info: %d\n", error);
277 		return error;
278 	}
279 
280 	*x_traces = val[1];
281 	*y_traces = val[2];
282 
283 	return 0;
284 }
285 
286 static int elan_smbus_get_pressure_adjustment(struct i2c_client *client,
287 					      int *adjustment)
288 {
289 	*adjustment = ETP_PRESSURE_OFFSET;
290 	return 0;
291 }
292 
293 static int elan_smbus_iap_get_mode(struct i2c_client *client,
294 				   enum tp_mode *mode)
295 {
296 	int error;
297 	u16 constant;
298 	u8 val[I2C_SMBUS_BLOCK_MAX] = {0};
299 
300 	error = i2c_smbus_read_block_data(client, ETP_SMBUS_IAP_CTRL_CMD, val);
301 	if (error < 0) {
302 		dev_err(&client->dev, "failed to read iap ctrol register: %d\n",
303 			error);
304 		return error;
305 	}
306 
307 	constant = be16_to_cpup((__be16 *)val);
308 	dev_dbg(&client->dev, "iap control reg: 0x%04x.\n", constant);
309 
310 	*mode = (constant & ETP_SMBUS_IAP_MODE_ON) ? IAP_MODE : MAIN_MODE;
311 
312 	return 0;
313 }
314 
315 static int elan_smbus_iap_reset(struct i2c_client *client)
316 {
317 	int error;
318 
319 	error = i2c_smbus_write_byte(client, ETP_SMBUS_IAP_RESET_CMD);
320 	if (error) {
321 		dev_err(&client->dev, "cannot reset IC: %d\n", error);
322 		return error;
323 	}
324 
325 	return 0;
326 }
327 
328 static int elan_smbus_set_flash_key(struct i2c_client *client)
329 {
330 	int error;
331 	u8 cmd[4] = { 0x00, 0x0B, 0x00, 0x5A };
332 
333 	error = i2c_smbus_write_block_data(client, ETP_SMBUS_IAP_CMD,
334 					   sizeof(cmd), cmd);
335 	if (error) {
336 		dev_err(&client->dev, "cannot set flash key: %d\n", error);
337 		return error;
338 	}
339 
340 	return 0;
341 }
342 
343 static int elan_smbus_prepare_fw_update(struct i2c_client *client, u16 ic_type,
344 					u8 iap_version, u16 fw_page_size)
345 {
346 	struct device *dev = &client->dev;
347 	int len;
348 	int error;
349 	enum tp_mode mode;
350 	u8 val[I2C_SMBUS_BLOCK_MAX] = {0};
351 	u8 cmd[4] = {0x0F, 0x78, 0x00, 0x06};
352 	u16 password;
353 
354 	/* Get FW in which mode	(IAP_MODE/MAIN_MODE)  */
355 	error = elan_smbus_iap_get_mode(client, &mode);
356 	if (error)
357 		return error;
358 
359 	if (mode == MAIN_MODE) {
360 
361 		/* set flash key */
362 		error = elan_smbus_set_flash_key(client);
363 		if (error)
364 			return error;
365 
366 		/* write iap password */
367 		if (i2c_smbus_write_byte(client,
368 					 ETP_SMBUS_IAP_PASSWORD_WRITE) < 0) {
369 			dev_err(dev, "cannot write iap password\n");
370 			return -EIO;
371 		}
372 
373 		error = i2c_smbus_write_block_data(client, ETP_SMBUS_IAP_CMD,
374 						   sizeof(cmd), cmd);
375 		if (error) {
376 			dev_err(dev, "failed to write iap password: %d\n",
377 				error);
378 			return error;
379 		}
380 
381 		/*
382 		 * Read back password to make sure we enabled flash
383 		 * successfully.
384 		 */
385 		len = i2c_smbus_read_block_data(client,
386 						ETP_SMBUS_IAP_PASSWORD_READ,
387 						val);
388 		if (len < (int)sizeof(u16)) {
389 			error = len < 0 ? len : -EIO;
390 			dev_err(dev, "failed to read iap password: %d\n",
391 				error);
392 			return error;
393 		}
394 
395 		password = be16_to_cpup((__be16 *)val);
396 		if (password != ETP_SMBUS_IAP_PASSWORD) {
397 			dev_err(dev, "wrong iap password = 0x%X\n", password);
398 			return -EIO;
399 		}
400 
401 		/* Wait 30ms for MAIN_MODE change to IAP_MODE */
402 		msleep(30);
403 	}
404 
405 	error = elan_smbus_set_flash_key(client);
406 	if (error)
407 		return error;
408 
409 	/* Reset IC */
410 	error = elan_smbus_iap_reset(client);
411 	if (error)
412 		return error;
413 
414 	return 0;
415 }
416 
417 
418 static int elan_smbus_write_fw_block(struct i2c_client *client, u16 fw_page_size,
419 				     const u8 *page, u16 checksum, int idx)
420 {
421 	struct device *dev = &client->dev;
422 	int error;
423 	u16 result;
424 	u8 val[I2C_SMBUS_BLOCK_MAX] = {0};
425 
426 	/*
427 	 * Due to the limitation of smbus protocol limiting
428 	 * transfer to 32 bytes at a time, we must split block
429 	 * in 2 transfers.
430 	 */
431 	error = i2c_smbus_write_block_data(client,
432 					   ETP_SMBUS_WRITE_FW_BLOCK,
433 					   fw_page_size / 2,
434 					   page);
435 	if (error) {
436 		dev_err(dev, "Failed to write page %d (part %d): %d\n",
437 			idx, 1, error);
438 		return error;
439 	}
440 
441 	error = i2c_smbus_write_block_data(client,
442 					   ETP_SMBUS_WRITE_FW_BLOCK,
443 					   fw_page_size / 2,
444 					   page + fw_page_size / 2);
445 	if (error) {
446 		dev_err(dev, "Failed to write page %d (part %d): %d\n",
447 			idx, 2, error);
448 		return error;
449 	}
450 
451 
452 	/* Wait for F/W to update one page ROM data. */
453 	usleep_range(8000, 10000);
454 
455 	error = i2c_smbus_read_block_data(client,
456 					  ETP_SMBUS_IAP_CTRL_CMD, val);
457 	if (error < 0) {
458 		dev_err(dev, "Failed to read IAP write result: %d\n",
459 			error);
460 		return error;
461 	}
462 
463 	result = be16_to_cpup((__be16 *)val);
464 	if (result & (ETP_FW_IAP_PAGE_ERR | ETP_FW_IAP_INTF_ERR)) {
465 		dev_err(dev, "IAP reports failed write: %04hx\n",
466 			result);
467 		return -EIO;
468 	}
469 
470 	return 0;
471 }
472 
473 static int elan_smbus_get_report_features(struct i2c_client *client, u8 pattern,
474 					  unsigned int *features,
475 					  unsigned int *report_len)
476 {
477 	/*
478 	 * SMBus controllers with pattern 2 lack area info, as newer
479 	 * high-precision packets use that space for coordinates.
480 	 */
481 	*features = pattern <= 0x01 ? ETP_FEATURE_REPORT_MK : 0;
482 	*report_len = ETP_SMBUS_REPORT_LEN;
483 	return 0;
484 }
485 
486 static int elan_smbus_get_report(struct i2c_client *client,
487 				 u8 *report, unsigned int report_len)
488 {
489 	int len;
490 
491 	BUILD_BUG_ON(I2C_SMBUS_BLOCK_MAX > ETP_SMBUS_REPORT_LEN);
492 
493 	len = i2c_smbus_read_block_data(client,
494 					ETP_SMBUS_PACKET_QUERY,
495 					&report[ETP_SMBUS_REPORT_OFFSET]);
496 	if (len < 0) {
497 		dev_err(&client->dev, "failed to read report data: %d\n", len);
498 		return len;
499 	}
500 
501 	if (report[ETP_REPORT_ID_OFFSET] == ETP_TP_REPORT_ID2)
502 		report_len = ETP_SMBUS_REPORT_LEN2;
503 
504 	if (len != report_len) {
505 		dev_err(&client->dev,
506 			"wrong report length (%d vs %d expected)\n",
507 			len, report_len);
508 		return -EIO;
509 	}
510 
511 	return 0;
512 }
513 
514 static int elan_smbus_finish_fw_update(struct i2c_client *client,
515 				       struct completion *fw_completion)
516 {
517 	/* No special handling unlike I2C transport */
518 	return 0;
519 }
520 
521 static int elan_smbus_get_pattern(struct i2c_client *client, u8 *pattern)
522 {
523 	*pattern = 0;
524 	return 0;
525 }
526 
527 const struct elan_transport_ops elan_smbus_ops = {
528 	.initialize		= elan_smbus_initialize,
529 	.sleep_control		= elan_smbus_sleep_control,
530 	.power_control		= elan_smbus_power_control,
531 	.set_mode		= elan_smbus_set_mode,
532 
533 	.calibrate		= elan_smbus_calibrate,
534 	.calibrate_result	= elan_smbus_calibrate_result,
535 
536 	.get_baseline_data	= elan_smbus_get_baseline_data,
537 
538 	.get_version		= elan_smbus_get_version,
539 	.get_sm_version		= elan_smbus_get_sm_version,
540 	.get_product_id		= elan_smbus_get_product_id,
541 	.get_checksum		= elan_smbus_get_checksum,
542 	.get_pressure_adjustment = elan_smbus_get_pressure_adjustment,
543 
544 	.get_max		= elan_smbus_get_max,
545 	.get_resolution		= elan_smbus_get_resolution,
546 	.get_num_traces		= elan_smbus_get_num_traces,
547 
548 	.iap_get_mode		= elan_smbus_iap_get_mode,
549 	.iap_reset		= elan_smbus_iap_reset,
550 
551 	.prepare_fw_update	= elan_smbus_prepare_fw_update,
552 	.write_fw_block		= elan_smbus_write_fw_block,
553 	.finish_fw_update	= elan_smbus_finish_fw_update,
554 
555 	.get_report_features	= elan_smbus_get_report_features,
556 	.get_report		= elan_smbus_get_report,
557 	.get_pattern		= elan_smbus_get_pattern,
558 };
559