This source file includes following definitions.
- ssp_create_msg
- ssp_fill_buffer
- ssp_get_buffer
- ssp_clean_msg
- ssp_print_mcu_debug
- ssp_check_lines
- ssp_do_transfer
- ssp_spi_sync_command
- ssp_spi_sync
- ssp_handle_big_data
- ssp_parse_dataframe
- ssp_irq_msg
- ssp_clean_pending_list
- ssp_command
- ssp_send_instruction
- ssp_get_chipid
- ssp_set_magnetic_matrix
- ssp_get_sensor_scanning_info
- ssp_get_firmware_rev
1
2
3
4
5
6 #include "ssp.h"
7
8 #define SSP_DEV (&data->spi->dev)
9 #define SSP_GET_MESSAGE_TYPE(data) (data & (3 << SSP_RW))
10
11
12
13
14
15
16
17 #define SSP_MSG2AP_INST_BYPASS_DATA 0x37
18 #define SSP_MSG2AP_INST_LIBRARY_DATA 0x01
19 #define SSP_MSG2AP_INST_DEBUG_DATA 0x03
20 #define SSP_MSG2AP_INST_BIG_DATA 0x04
21 #define SSP_MSG2AP_INST_META_DATA 0x05
22 #define SSP_MSG2AP_INST_TIME_SYNC 0x06
23 #define SSP_MSG2AP_INST_RESET 0x07
24
25 #define SSP_UNIMPLEMENTED -1
26
27 struct ssp_msg_header {
28 u8 cmd;
29 __le16 length;
30 __le16 options;
31 __le32 data;
32 } __attribute__((__packed__));
33
34 struct ssp_msg {
35 u16 length;
36 u16 options;
37 struct list_head list;
38 struct completion *done;
39 struct ssp_msg_header *h;
40 char *buffer;
41 };
42
43 static const int ssp_offset_map[SSP_SENSOR_MAX] = {
44 [SSP_ACCELEROMETER_SENSOR] = SSP_ACCELEROMETER_SIZE +
45 SSP_TIME_SIZE,
46 [SSP_GYROSCOPE_SENSOR] = SSP_GYROSCOPE_SIZE +
47 SSP_TIME_SIZE,
48 [SSP_GEOMAGNETIC_UNCALIB_SENSOR] = SSP_UNIMPLEMENTED,
49 [SSP_GEOMAGNETIC_RAW] = SSP_UNIMPLEMENTED,
50 [SSP_GEOMAGNETIC_SENSOR] = SSP_UNIMPLEMENTED,
51 [SSP_PRESSURE_SENSOR] = SSP_UNIMPLEMENTED,
52 [SSP_GESTURE_SENSOR] = SSP_UNIMPLEMENTED,
53 [SSP_PROXIMITY_SENSOR] = SSP_UNIMPLEMENTED,
54 [SSP_TEMPERATURE_HUMIDITY_SENSOR] = SSP_UNIMPLEMENTED,
55 [SSP_LIGHT_SENSOR] = SSP_UNIMPLEMENTED,
56 [SSP_PROXIMITY_RAW] = SSP_UNIMPLEMENTED,
57 [SSP_ORIENTATION_SENSOR] = SSP_UNIMPLEMENTED,
58 [SSP_STEP_DETECTOR] = SSP_UNIMPLEMENTED,
59 [SSP_SIG_MOTION_SENSOR] = SSP_UNIMPLEMENTED,
60 [SSP_GYRO_UNCALIB_SENSOR] = SSP_UNIMPLEMENTED,
61 [SSP_GAME_ROTATION_VECTOR] = SSP_UNIMPLEMENTED,
62 [SSP_ROTATION_VECTOR] = SSP_UNIMPLEMENTED,
63 [SSP_STEP_COUNTER] = SSP_UNIMPLEMENTED,
64 [SSP_BIO_HRM_RAW] = SSP_BIO_HRM_RAW_SIZE +
65 SSP_TIME_SIZE,
66 [SSP_BIO_HRM_RAW_FAC] = SSP_BIO_HRM_RAW_FAC_SIZE +
67 SSP_TIME_SIZE,
68 [SSP_BIO_HRM_LIB] = SSP_BIO_HRM_LIB_SIZE +
69 SSP_TIME_SIZE,
70 };
71
72 #define SSP_HEADER_SIZE (sizeof(struct ssp_msg_header))
73 #define SSP_HEADER_SIZE_ALIGNED (ALIGN(SSP_HEADER_SIZE, 4))
74
75 static struct ssp_msg *ssp_create_msg(u8 cmd, u16 len, u16 opt, u32 data)
76 {
77 struct ssp_msg_header h;
78 struct ssp_msg *msg;
79
80 msg = kzalloc(sizeof(*msg), GFP_KERNEL);
81 if (!msg)
82 return NULL;
83
84 h.cmd = cmd;
85 h.length = cpu_to_le16(len);
86 h.options = cpu_to_le16(opt);
87 h.data = cpu_to_le32(data);
88
89 msg->buffer = kzalloc(SSP_HEADER_SIZE_ALIGNED + len,
90 GFP_KERNEL | GFP_DMA);
91 if (!msg->buffer) {
92 kfree(msg);
93 return NULL;
94 }
95
96 msg->length = len;
97 msg->options = opt;
98
99 memcpy(msg->buffer, &h, SSP_HEADER_SIZE);
100
101 return msg;
102 }
103
104
105
106
107
108
109 static inline void ssp_fill_buffer(struct ssp_msg *m, unsigned int offset,
110 const void *src, unsigned int len)
111 {
112 memcpy(&m->buffer[SSP_HEADER_SIZE_ALIGNED + offset], src, len);
113 }
114
115 static inline void ssp_get_buffer(struct ssp_msg *m, unsigned int offset,
116 void *dest, unsigned int len)
117 {
118 memcpy(dest, &m->buffer[SSP_HEADER_SIZE_ALIGNED + offset], len);
119 }
120
121 #define SSP_GET_BUFFER_AT_INDEX(m, index) \
122 (m->buffer[SSP_HEADER_SIZE_ALIGNED + index])
123 #define SSP_SET_BUFFER_AT_INDEX(m, index, val) \
124 (m->buffer[SSP_HEADER_SIZE_ALIGNED + index] = val)
125
126 static void ssp_clean_msg(struct ssp_msg *m)
127 {
128 kfree(m->buffer);
129 kfree(m);
130 }
131
132 static int ssp_print_mcu_debug(char *data_frame, int *data_index,
133 int received_len)
134 {
135 int length = data_frame[(*data_index)++];
136
137 if (length > received_len - *data_index || length <= 0) {
138 ssp_dbg("[SSP]: MSG From MCU-invalid debug length(%d/%d)\n",
139 length, received_len);
140 return length ? length : -EPROTO;
141 }
142
143 ssp_dbg("[SSP]: MSG From MCU - %s\n", &data_frame[*data_index]);
144
145 *data_index += length;
146
147 return 0;
148 }
149
150
151
152
153
154 static int ssp_check_lines(struct ssp_data *data, bool state)
155 {
156 int delay_cnt = 0;
157
158 gpio_set_value_cansleep(data->ap_mcu_gpio, state);
159
160 while (gpio_get_value_cansleep(data->mcu_ap_gpio) != state) {
161 usleep_range(3000, 3500);
162
163 if (data->shut_down || delay_cnt++ > 500) {
164 dev_err(SSP_DEV, "%s:timeout, hw ack wait fail %d\n",
165 __func__, state);
166
167 if (!state)
168 gpio_set_value_cansleep(data->ap_mcu_gpio, 1);
169
170 return -ETIMEDOUT;
171 }
172 }
173
174 return 0;
175 }
176
177 static int ssp_do_transfer(struct ssp_data *data, struct ssp_msg *msg,
178 struct completion *done, int timeout)
179 {
180 int status;
181
182
183
184
185 const bool use_no_irq = msg->length == 0;
186
187 if (data->shut_down)
188 return -EPERM;
189
190 msg->done = done;
191
192 mutex_lock(&data->comm_lock);
193
194 status = ssp_check_lines(data, false);
195 if (status < 0)
196 goto _error_locked;
197
198 status = spi_write(data->spi, msg->buffer, SSP_HEADER_SIZE);
199 if (status < 0) {
200 gpio_set_value_cansleep(data->ap_mcu_gpio, 1);
201 dev_err(SSP_DEV, "%s spi_write fail\n", __func__);
202 goto _error_locked;
203 }
204
205 if (!use_no_irq) {
206 mutex_lock(&data->pending_lock);
207 list_add_tail(&msg->list, &data->pending_list);
208 mutex_unlock(&data->pending_lock);
209 }
210
211 status = ssp_check_lines(data, true);
212 if (status < 0) {
213 if (!use_no_irq) {
214 mutex_lock(&data->pending_lock);
215 list_del(&msg->list);
216 mutex_unlock(&data->pending_lock);
217 }
218 goto _error_locked;
219 }
220
221 mutex_unlock(&data->comm_lock);
222
223 if (!use_no_irq && done)
224 if (wait_for_completion_timeout(done,
225 msecs_to_jiffies(timeout)) ==
226 0) {
227 mutex_lock(&data->pending_lock);
228 list_del(&msg->list);
229 mutex_unlock(&data->pending_lock);
230
231 data->timeout_cnt++;
232 return -ETIMEDOUT;
233 }
234
235 return 0;
236
237 _error_locked:
238 mutex_unlock(&data->comm_lock);
239 data->timeout_cnt++;
240 return status;
241 }
242
243 static inline int ssp_spi_sync_command(struct ssp_data *data,
244 struct ssp_msg *msg)
245 {
246 return ssp_do_transfer(data, msg, NULL, 0);
247 }
248
249 static int ssp_spi_sync(struct ssp_data *data, struct ssp_msg *msg,
250 int timeout)
251 {
252 DECLARE_COMPLETION_ONSTACK(done);
253
254 if (WARN_ON(!msg->length))
255 return -EPERM;
256
257 return ssp_do_transfer(data, msg, &done, timeout);
258 }
259
260 static int ssp_handle_big_data(struct ssp_data *data, char *dataframe, int *idx)
261 {
262
263 *idx += 8;
264 return 0;
265 }
266
267 static int ssp_parse_dataframe(struct ssp_data *data, char *dataframe, int len)
268 {
269 int idx, sd;
270 struct ssp_sensor_data *spd;
271 struct iio_dev **indio_devs = data->sensor_devs;
272
273 for (idx = 0; idx < len;) {
274 switch (dataframe[idx++]) {
275 case SSP_MSG2AP_INST_BYPASS_DATA:
276 sd = dataframe[idx++];
277 if (sd < 0 || sd >= SSP_SENSOR_MAX) {
278 dev_err(SSP_DEV,
279 "Mcu data frame1 error %d\n", sd);
280 return -EPROTO;
281 }
282
283 if (indio_devs[sd]) {
284 spd = iio_priv(indio_devs[sd]);
285 if (spd->process_data)
286 spd->process_data(indio_devs[sd],
287 &dataframe[idx],
288 data->timestamp);
289 } else {
290 dev_err(SSP_DEV, "no client for frame\n");
291 }
292
293 idx += ssp_offset_map[sd];
294 break;
295 case SSP_MSG2AP_INST_DEBUG_DATA:
296 sd = ssp_print_mcu_debug(dataframe, &idx, len);
297 if (sd) {
298 dev_err(SSP_DEV,
299 "Mcu data frame3 error %d\n", sd);
300 return sd;
301 }
302 break;
303 case SSP_MSG2AP_INST_LIBRARY_DATA:
304 idx += len;
305 break;
306 case SSP_MSG2AP_INST_BIG_DATA:
307 ssp_handle_big_data(data, dataframe, &idx);
308 break;
309 case SSP_MSG2AP_INST_TIME_SYNC:
310 data->time_syncing = true;
311 break;
312 case SSP_MSG2AP_INST_RESET:
313 ssp_queue_ssp_refresh_task(data, 0);
314 break;
315 }
316 }
317
318 if (data->time_syncing)
319 data->timestamp = ktime_get_real_ns();
320
321 return 0;
322 }
323
324
325 int ssp_irq_msg(struct ssp_data *data)
326 {
327 bool found = false;
328 char *buffer;
329 u8 msg_type;
330 int ret;
331 u16 length, msg_options;
332 struct ssp_msg *msg, *n;
333
334 ret = spi_read(data->spi, data->header_buffer, SSP_HEADER_BUFFER_SIZE);
335 if (ret < 0) {
336 dev_err(SSP_DEV, "header read fail\n");
337 return ret;
338 }
339
340 length = le16_to_cpu(data->header_buffer[1]);
341 msg_options = le16_to_cpu(data->header_buffer[0]);
342
343 if (length == 0) {
344 dev_err(SSP_DEV, "length received from mcu is 0\n");
345 return -EINVAL;
346 }
347
348 msg_type = SSP_GET_MESSAGE_TYPE(msg_options);
349
350 switch (msg_type) {
351 case SSP_AP2HUB_READ:
352 case SSP_AP2HUB_WRITE:
353
354
355
356
357 mutex_lock(&data->pending_lock);
358 list_for_each_entry_safe(msg, n, &data->pending_list, list) {
359 if (msg->options == msg_options) {
360 list_del(&msg->list);
361 found = true;
362 break;
363 }
364 }
365
366 if (!found) {
367
368
369
370
371
372 buffer = kmalloc(length, GFP_KERNEL | GFP_DMA);
373 if (!buffer) {
374 ret = -ENOMEM;
375 goto _unlock;
376 }
377
378
379 ret = spi_read(data->spi, buffer, length);
380 if (ret >= 0)
381 ret = -EPROTO;
382
383 kfree(buffer);
384
385 dev_err(SSP_DEV, "No match error %x\n",
386 msg_options);
387
388 goto _unlock;
389 }
390
391 if (msg_type == SSP_AP2HUB_READ)
392 ret = spi_read(data->spi,
393 &msg->buffer[SSP_HEADER_SIZE_ALIGNED],
394 msg->length);
395
396 if (msg_type == SSP_AP2HUB_WRITE) {
397 ret = spi_write(data->spi,
398 &msg->buffer[SSP_HEADER_SIZE_ALIGNED],
399 msg->length);
400 if (msg_options & SSP_AP2HUB_RETURN) {
401 msg->options =
402 SSP_AP2HUB_READ | SSP_AP2HUB_RETURN;
403 msg->length = 1;
404
405 list_add_tail(&msg->list, &data->pending_list);
406 goto _unlock;
407 }
408 }
409
410 if (msg->done)
411 if (!completion_done(msg->done))
412 complete(msg->done);
413 _unlock:
414 mutex_unlock(&data->pending_lock);
415 break;
416 case SSP_HUB2AP_WRITE:
417 buffer = kzalloc(length, GFP_KERNEL | GFP_DMA);
418 if (!buffer)
419 return -ENOMEM;
420
421 ret = spi_read(data->spi, buffer, length);
422 if (ret < 0) {
423 dev_err(SSP_DEV, "spi read fail\n");
424 kfree(buffer);
425 break;
426 }
427
428 ret = ssp_parse_dataframe(data, buffer, length);
429
430 kfree(buffer);
431 break;
432
433 default:
434 dev_err(SSP_DEV, "unknown msg type\n");
435 return -EPROTO;
436 }
437
438 return ret;
439 }
440
441 void ssp_clean_pending_list(struct ssp_data *data)
442 {
443 struct ssp_msg *msg, *n;
444
445 mutex_lock(&data->pending_lock);
446 list_for_each_entry_safe(msg, n, &data->pending_list, list) {
447 list_del(&msg->list);
448
449 if (msg->done)
450 if (!completion_done(msg->done))
451 complete(msg->done);
452 }
453 mutex_unlock(&data->pending_lock);
454 }
455
456 int ssp_command(struct ssp_data *data, char command, int arg)
457 {
458 int ret;
459 struct ssp_msg *msg;
460
461 msg = ssp_create_msg(command, 0, SSP_AP2HUB_WRITE, arg);
462 if (!msg)
463 return -ENOMEM;
464
465 ssp_dbg("%s - command 0x%x %d\n", __func__, command, arg);
466
467 ret = ssp_spi_sync_command(data, msg);
468 ssp_clean_msg(msg);
469
470 return ret;
471 }
472
473 int ssp_send_instruction(struct ssp_data *data, u8 inst, u8 sensor_type,
474 u8 *send_buf, u8 length)
475 {
476 int ret;
477 struct ssp_msg *msg;
478
479 if (data->fw_dl_state == SSP_FW_DL_STATE_DOWNLOADING) {
480 dev_err(SSP_DEV, "%s - Skip Inst! DL state = %d\n",
481 __func__, data->fw_dl_state);
482 return -EBUSY;
483 } else if (!(data->available_sensors & BIT(sensor_type)) &&
484 (inst <= SSP_MSG2SSP_INST_CHANGE_DELAY)) {
485 dev_err(SSP_DEV, "%s - Bypass Inst Skip! - %u\n",
486 __func__, sensor_type);
487 return -EIO;
488 }
489
490 msg = ssp_create_msg(inst, length + 2, SSP_AP2HUB_WRITE, 0);
491 if (!msg)
492 return -ENOMEM;
493
494 ssp_fill_buffer(msg, 0, &sensor_type, 1);
495 ssp_fill_buffer(msg, 1, send_buf, length);
496
497 ssp_dbg("%s - Inst = 0x%x, Sensor Type = 0x%x, data = %u\n",
498 __func__, inst, sensor_type, send_buf[1]);
499
500 ret = ssp_spi_sync(data, msg, 1000);
501 ssp_clean_msg(msg);
502
503 return ret;
504 }
505
506 int ssp_get_chipid(struct ssp_data *data)
507 {
508 int ret;
509 char buffer;
510 struct ssp_msg *msg;
511
512 msg = ssp_create_msg(SSP_MSG2SSP_AP_WHOAMI, 1, SSP_AP2HUB_READ, 0);
513 if (!msg)
514 return -ENOMEM;
515
516 ret = ssp_spi_sync(data, msg, 1000);
517
518 buffer = SSP_GET_BUFFER_AT_INDEX(msg, 0);
519
520 ssp_clean_msg(msg);
521
522 return ret < 0 ? ret : buffer;
523 }
524
525 int ssp_set_magnetic_matrix(struct ssp_data *data)
526 {
527 int ret;
528 struct ssp_msg *msg;
529
530 msg = ssp_create_msg(SSP_MSG2SSP_AP_SET_MAGNETIC_STATIC_MATRIX,
531 data->sensorhub_info->mag_length, SSP_AP2HUB_WRITE,
532 0);
533 if (!msg)
534 return -ENOMEM;
535
536 ssp_fill_buffer(msg, 0, data->sensorhub_info->mag_table,
537 data->sensorhub_info->mag_length);
538
539 ret = ssp_spi_sync(data, msg, 1000);
540 ssp_clean_msg(msg);
541
542 return ret;
543 }
544
545 unsigned int ssp_get_sensor_scanning_info(struct ssp_data *data)
546 {
547 int ret;
548 __le32 result;
549 u32 cpu_result = 0;
550
551 struct ssp_msg *msg = ssp_create_msg(SSP_MSG2SSP_AP_SENSOR_SCANNING, 4,
552 SSP_AP2HUB_READ, 0);
553 if (!msg)
554 return 0;
555
556 ret = ssp_spi_sync(data, msg, 1000);
557 if (ret < 0) {
558 dev_err(SSP_DEV, "%s - spi read fail %d\n", __func__, ret);
559 goto _exit;
560 }
561
562 ssp_get_buffer(msg, 0, &result, 4);
563 cpu_result = le32_to_cpu(result);
564
565 dev_info(SSP_DEV, "%s state: 0x%08x\n", __func__, cpu_result);
566
567 _exit:
568 ssp_clean_msg(msg);
569 return cpu_result;
570 }
571
572 unsigned int ssp_get_firmware_rev(struct ssp_data *data)
573 {
574 int ret;
575 __le32 result;
576
577 struct ssp_msg *msg = ssp_create_msg(SSP_MSG2SSP_AP_FIRMWARE_REV, 4,
578 SSP_AP2HUB_READ, 0);
579 if (!msg)
580 return SSP_INVALID_REVISION;
581
582 ret = ssp_spi_sync(data, msg, 1000);
583 if (ret < 0) {
584 dev_err(SSP_DEV, "%s - transfer fail %d\n", __func__, ret);
585 ret = SSP_INVALID_REVISION;
586 goto _exit;
587 }
588
589 ssp_get_buffer(msg, 0, &result, 4);
590 ret = le32_to_cpu(result);
591
592 _exit:
593 ssp_clean_msg(msg);
594 return ret;
595 }