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