1// SPDX-License-Identifier: GPL-2.0-or-later
2/*
3 * Copyright (C) 2014, Samsung Electronics Co. Ltd. All Rights Reserved.
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 * SSP -> AP Instruction
13 * They tell what packet type can be expected. In the future there will
14 * be less of them. BYPASS means common sensor packets with accel, gyro,
15 * hrm etc. data. LIBRARY and META are mock-up's for now.
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
27struct ssp_msg_header {
28 u8 cmd;
29 __le16 length;
30 __le16 options;
31 __le32 data;
32} __attribute__((__packed__));
33
34struct 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
43static 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
75static 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(size: 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(objp: 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 * It is a bit heavy to do it this way but often the function is used to compose
106 * the message from smaller chunks which are placed on the stack. Often the
107 * chunks are small so memcpy should be optimalized.
108 */
109static 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
115static 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
126static void ssp_clean_msg(struct ssp_msg *m)
127{
128 kfree(objp: m->buffer);
129 kfree(objp: m);
130}
131
132static 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 -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 * It was designed that way - additional lines to some kind of handshake,
152 * please do not ask why - only the firmware guy can know it.
153 */
154static int ssp_check_lines(struct ssp_data *data, bool state)
155{
156 int delay_cnt = 0;
157
158 gpiod_set_value_cansleep(desc: data->ap_mcu_gpiod, value: state);
159
160 while (gpiod_get_value_cansleep(desc: data->mcu_ap_gpiod) != state) {
161 usleep_range(min: 3000, max: 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 gpiod_set_value_cansleep(desc: data->ap_mcu_gpiod, value: 1);
169
170 return -ETIMEDOUT;
171 }
172 }
173
174 return 0;
175}
176
177static int ssp_do_transfer(struct ssp_data *data, struct ssp_msg *msg,
178 struct completion *done, int timeout)
179{
180 int status;
181 /*
182 * check if this is a short one way message or the whole transfer has
183 * second part after an interrupt
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, state: false);
195 if (status < 0)
196 goto _error_locked;
197
198 status = spi_write(spi: data->spi, buf: msg->buffer, SSP_HEADER_SIZE);
199 if (status < 0) {
200 gpiod_set_value_cansleep(desc: data->ap_mcu_gpiod, value: 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(new: &msg->list, head: &data->pending_list);
208 mutex_unlock(lock: &data->pending_lock);
209 }
210
211 status = ssp_check_lines(data, state: true);
212 if (status < 0) {
213 if (!use_no_irq) {
214 mutex_lock(&data->pending_lock);
215 list_del(entry: &msg->list);
216 mutex_unlock(lock: &data->pending_lock);
217 }
218 goto _error_locked;
219 }
220
221 mutex_unlock(lock: &data->comm_lock);
222
223 if (!use_no_irq && done)
224 if (wait_for_completion_timeout(x: done,
225 timeout: msecs_to_jiffies(m: timeout)) ==
226 0) {
227 mutex_lock(&data->pending_lock);
228 list_del(entry: &msg->list);
229 mutex_unlock(lock: &data->pending_lock);
230
231 data->timeout_cnt++;
232 return -ETIMEDOUT;
233 }
234
235 return 0;
236
237_error_locked:
238 mutex_unlock(lock: &data->comm_lock);
239 data->timeout_cnt++;
240 return status;
241}
242
243static inline int ssp_spi_sync_command(struct ssp_data *data,
244 struct ssp_msg *msg)
245{
246 return ssp_do_transfer(data, msg, NULL, timeout: 0);
247}
248
249static 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: &done, timeout);
258}
259
260static int ssp_handle_big_data(struct ssp_data *data, char *dataframe, int *idx)
261{
262 /* mock-up, it will be changed with adding another sensor types */
263 *idx += 8;
264 return 0;
265}
266
267static 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 if (idx >= len)
277 return -EPROTO;
278 sd = dataframe[idx++];
279 if (sd < 0 || sd >= SSP_SENSOR_MAX) {
280 dev_err(SSP_DEV,
281 "Mcu data frame1 error %d\n", sd);
282 return -EPROTO;
283 }
284
285 if (indio_devs[sd]) {
286 spd = iio_priv(indio_dev: indio_devs[sd]);
287 if (spd->process_data) {
288 if (idx >= len)
289 return -EPROTO;
290 spd->process_data(indio_devs[sd],
291 &dataframe[idx],
292 data->timestamp);
293 }
294 } else {
295 dev_err(SSP_DEV, "no client for frame\n");
296 }
297
298 idx += ssp_offset_map[sd];
299 break;
300 case SSP_MSG2AP_INST_DEBUG_DATA:
301 if (idx >= len)
302 return -EPROTO;
303 sd = ssp_print_mcu_debug(data_frame: dataframe, data_index: &idx, received_len: len);
304 if (sd) {
305 dev_err(SSP_DEV,
306 "Mcu data frame3 error %d\n", sd);
307 return sd;
308 }
309 break;
310 case SSP_MSG2AP_INST_LIBRARY_DATA:
311 idx += len;
312 break;
313 case SSP_MSG2AP_INST_BIG_DATA:
314 ssp_handle_big_data(data, dataframe, idx: &idx);
315 break;
316 case SSP_MSG2AP_INST_TIME_SYNC:
317 data->time_syncing = true;
318 break;
319 case SSP_MSG2AP_INST_RESET:
320 ssp_queue_ssp_refresh_task(data, delay: 0);
321 break;
322 }
323 }
324
325 if (data->time_syncing)
326 data->timestamp = ktime_get_real_ns();
327
328 return 0;
329}
330
331/* threaded irq */
332int ssp_irq_msg(struct ssp_data *data)
333{
334 char *buffer;
335 u8 msg_type;
336 int ret;
337 u16 length, msg_options;
338 struct ssp_msg *msg = NULL, *iter, *n;
339
340 ret = spi_read(spi: data->spi, buf: data->header_buffer, SSP_HEADER_BUFFER_SIZE);
341 if (ret < 0) {
342 dev_err(SSP_DEV, "header read fail\n");
343 return ret;
344 }
345
346 length = le16_to_cpu(data->header_buffer[1]);
347 msg_options = le16_to_cpu(data->header_buffer[0]);
348
349 if (length == 0) {
350 dev_err(SSP_DEV, "length received from mcu is 0\n");
351 return -EINVAL;
352 }
353
354 msg_type = SSP_GET_MESSAGE_TYPE(msg_options);
355
356 switch (msg_type) {
357 case SSP_AP2HUB_READ:
358 case SSP_AP2HUB_WRITE:
359 /*
360 * this is a small list, a few elements - the packets can be
361 * received with no order
362 */
363 mutex_lock(&data->pending_lock);
364 list_for_each_entry_safe(iter, n, &data->pending_list, list) {
365 if (iter->options == msg_options) {
366 list_del(entry: &iter->list);
367 msg = iter;
368 break;
369 }
370 }
371
372 if (!msg) {
373 /*
374 * here can be implemented dead messages handling
375 * but the slave should not send such ones - it is to
376 * check but let's handle this
377 */
378 buffer = kmalloc(size: length, GFP_KERNEL | GFP_DMA);
379 if (!buffer) {
380 ret = -ENOMEM;
381 goto _unlock;
382 }
383
384 /* got dead packet so it is always an error */
385 ret = spi_read(spi: data->spi, buf: buffer, len: length);
386 if (ret >= 0)
387 ret = -EPROTO;
388
389 kfree(objp: buffer);
390
391 dev_err(SSP_DEV, "No match error %x\n",
392 msg_options);
393
394 goto _unlock;
395 }
396
397 if (msg_type == SSP_AP2HUB_READ)
398 ret = spi_read(spi: data->spi,
399 buf: &msg->buffer[SSP_HEADER_SIZE_ALIGNED],
400 len: msg->length);
401
402 if (msg_type == SSP_AP2HUB_WRITE) {
403 ret = spi_write(spi: data->spi,
404 buf: &msg->buffer[SSP_HEADER_SIZE_ALIGNED],
405 len: msg->length);
406 if (msg_options & SSP_AP2HUB_RETURN) {
407 msg->options =
408 SSP_AP2HUB_READ | SSP_AP2HUB_RETURN;
409 msg->length = 1;
410
411 list_add_tail(new: &msg->list, head: &data->pending_list);
412 goto _unlock;
413 }
414 }
415
416 if (msg->done)
417 if (!completion_done(x: msg->done))
418 complete(msg->done);
419_unlock:
420 mutex_unlock(lock: &data->pending_lock);
421 break;
422 case SSP_HUB2AP_WRITE:
423 buffer = kzalloc(size: length, GFP_KERNEL | GFP_DMA);
424 if (!buffer)
425 return -ENOMEM;
426
427 ret = spi_read(spi: data->spi, buf: buffer, len: length);
428 if (ret < 0) {
429 dev_err(SSP_DEV, "spi read fail\n");
430 kfree(objp: buffer);
431 break;
432 }
433
434 ret = ssp_parse_dataframe(data, dataframe: buffer, len: length);
435
436 kfree(objp: buffer);
437 break;
438
439 default:
440 dev_err(SSP_DEV, "unknown msg type\n");
441 return -EPROTO;
442 }
443
444 return ret;
445}
446
447void ssp_clean_pending_list(struct ssp_data *data)
448{
449 struct ssp_msg *msg, *n;
450
451 mutex_lock(&data->pending_lock);
452 list_for_each_entry_safe(msg, n, &data->pending_list, list) {
453 list_del(entry: &msg->list);
454
455 if (msg->done)
456 if (!completion_done(x: msg->done))
457 complete(msg->done);
458 }
459 mutex_unlock(lock: &data->pending_lock);
460}
461
462int ssp_command(struct ssp_data *data, char command, int arg)
463{
464 int ret;
465 struct ssp_msg *msg;
466
467 msg = ssp_create_msg(cmd: command, len: 0, SSP_AP2HUB_WRITE, data: arg);
468 if (!msg)
469 return -ENOMEM;
470
471 ssp_dbg("%s - command 0x%x %d\n", __func__, command, arg);
472
473 ret = ssp_spi_sync_command(data, msg);
474 ssp_clean_msg(m: msg);
475
476 return ret;
477}
478
479int ssp_send_instruction(struct ssp_data *data, u8 inst, u8 sensor_type,
480 u8 *send_buf, u8 length)
481{
482 int ret;
483 struct ssp_msg *msg;
484
485 if (data->fw_dl_state == SSP_FW_DL_STATE_DOWNLOADING) {
486 dev_err(SSP_DEV, "%s - Skip Inst! DL state = %d\n",
487 __func__, data->fw_dl_state);
488 return -EBUSY;
489 } else if (!(data->available_sensors & BIT(sensor_type)) &&
490 (inst <= SSP_MSG2SSP_INST_CHANGE_DELAY)) {
491 dev_err(SSP_DEV, "%s - Bypass Inst Skip! - %u\n",
492 __func__, sensor_type);
493 return -EIO; /* just fail */
494 }
495
496 msg = ssp_create_msg(cmd: inst, len: length + 2, SSP_AP2HUB_WRITE, data: 0);
497 if (!msg)
498 return -ENOMEM;
499
500 ssp_fill_buffer(m: msg, offset: 0, src: &sensor_type, len: 1);
501 ssp_fill_buffer(m: msg, offset: 1, src: send_buf, len: length);
502
503 ssp_dbg("%s - Inst = 0x%x, Sensor Type = 0x%x, data = %u\n",
504 __func__, inst, sensor_type, send_buf[1]);
505
506 ret = ssp_spi_sync(data, msg, timeout: 1000);
507 ssp_clean_msg(m: msg);
508
509 return ret;
510}
511
512int ssp_get_chipid(struct ssp_data *data)
513{
514 int ret;
515 char buffer;
516 struct ssp_msg *msg;
517
518 msg = ssp_create_msg(SSP_MSG2SSP_AP_WHOAMI, len: 1, SSP_AP2HUB_READ, data: 0);
519 if (!msg)
520 return -ENOMEM;
521
522 ret = ssp_spi_sync(data, msg, timeout: 1000);
523
524 buffer = SSP_GET_BUFFER_AT_INDEX(msg, 0);
525
526 ssp_clean_msg(m: msg);
527
528 return ret < 0 ? ret : buffer;
529}
530
531int ssp_set_magnetic_matrix(struct ssp_data *data)
532{
533 int ret;
534 struct ssp_msg *msg;
535
536 msg = ssp_create_msg(SSP_MSG2SSP_AP_SET_MAGNETIC_STATIC_MATRIX,
537 len: data->sensorhub_info->mag_length, SSP_AP2HUB_WRITE,
538 data: 0);
539 if (!msg)
540 return -ENOMEM;
541
542 ssp_fill_buffer(m: msg, offset: 0, src: data->sensorhub_info->mag_table,
543 len: data->sensorhub_info->mag_length);
544
545 ret = ssp_spi_sync(data, msg, timeout: 1000);
546 ssp_clean_msg(m: msg);
547
548 return ret;
549}
550
551unsigned int ssp_get_sensor_scanning_info(struct ssp_data *data)
552{
553 int ret;
554 __le32 result;
555 u32 cpu_result = 0;
556
557 struct ssp_msg *msg = ssp_create_msg(SSP_MSG2SSP_AP_SENSOR_SCANNING, len: 4,
558 SSP_AP2HUB_READ, data: 0);
559 if (!msg)
560 return 0;
561
562 ret = ssp_spi_sync(data, msg, timeout: 1000);
563 if (ret < 0) {
564 dev_err(SSP_DEV, "%s - spi read fail %d\n", __func__, ret);
565 goto _exit;
566 }
567
568 ssp_get_buffer(m: msg, offset: 0, dest: &result, len: 4);
569 cpu_result = le32_to_cpu(result);
570
571 dev_info(SSP_DEV, "%s state: 0x%08x\n", __func__, cpu_result);
572
573_exit:
574 ssp_clean_msg(m: msg);
575 return cpu_result;
576}
577
578unsigned int ssp_get_firmware_rev(struct ssp_data *data)
579{
580 int ret;
581 __le32 result;
582
583 struct ssp_msg *msg = ssp_create_msg(SSP_MSG2SSP_AP_FIRMWARE_REV, len: 4,
584 SSP_AP2HUB_READ, data: 0);
585 if (!msg)
586 return SSP_INVALID_REVISION;
587
588 ret = ssp_spi_sync(data, msg, timeout: 1000);
589 if (ret < 0) {
590 dev_err(SSP_DEV, "%s - transfer fail %d\n", __func__, ret);
591 ret = SSP_INVALID_REVISION;
592 goto _exit;
593 }
594
595 ssp_get_buffer(m: msg, offset: 0, dest: &result, len: 4);
596 ret = le32_to_cpu(result);
597
598_exit:
599 ssp_clean_msg(m: msg);
600 return ret;
601}
602

source code of linux/drivers/iio/common/ssp_sensors/ssp_spi.c