602 lines · c
1// SPDX-License-Identifier: GPL-2.0-or-later2/*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 Instruction13 * They tell what packet type can be expected. In the future there will14 * 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 0x3718#define SSP_MSG2AP_INST_LIBRARY_DATA 0x0119#define SSP_MSG2AP_INST_DEBUG_DATA 0x0320#define SSP_MSG2AP_INST_BIG_DATA 0x0421#define SSP_MSG2AP_INST_META_DATA 0x0522#define SSP_MSG2AP_INST_TIME_SYNC 0x0623#define SSP_MSG2AP_INST_RESET 0x0724 25#define SSP_UNIMPLEMENTED -126 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(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 * It is a bit heavy to do it this way but often the function is used to compose106 * the message from smaller chunks which are placed on the stack. Often the107 * 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(m->buffer);129 kfree(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(data->ap_mcu_gpiod, state);159 160 while (gpiod_get_value_cansleep(data->mcu_ap_gpiod) != 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 gpiod_set_value_cansleep(data->ap_mcu_gpiod, 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 has183 * second part after an interrupt184 */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 gpiod_set_value_cansleep(data->ap_mcu_gpiod, 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 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, 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, 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_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(dataframe, &idx, 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);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, 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(data->spi, 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 be361 * received with no order362 */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(&iter->list);367 msg = iter;368 break;369 }370 }371 372 if (!msg) {373 /*374 * here can be implemented dead messages handling375 * but the slave should not send such ones - it is to376 * check but let's handle this377 */378 buffer = kmalloc(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(data->spi, buffer, length);386 if (ret >= 0)387 ret = -EPROTO;388 389 kfree(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(data->spi,399 &msg->buffer[SSP_HEADER_SIZE_ALIGNED],400 msg->length);401 402 if (msg_type == SSP_AP2HUB_WRITE) {403 ret = spi_write(data->spi,404 &msg->buffer[SSP_HEADER_SIZE_ALIGNED],405 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(&msg->list, &data->pending_list);412 goto _unlock;413 }414 }415 416 if (msg->done)417 if (!completion_done(msg->done))418 complete(msg->done);419_unlock:420 mutex_unlock(&data->pending_lock);421 break;422 case SSP_HUB2AP_WRITE:423 buffer = kzalloc(length, GFP_KERNEL | GFP_DMA);424 if (!buffer)425 return -ENOMEM;426 427 ret = spi_read(data->spi, buffer, length);428 if (ret < 0) {429 dev_err(SSP_DEV, "spi read fail\n");430 kfree(buffer);431 break;432 }433 434 ret = ssp_parse_dataframe(data, buffer, length);435 436 kfree(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(&msg->list);454 455 if (msg->done)456 if (!completion_done(msg->done))457 complete(msg->done);458 }459 mutex_unlock(&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(command, 0, SSP_AP2HUB_WRITE, 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(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(inst, length + 2, SSP_AP2HUB_WRITE, 0);497 if (!msg)498 return -ENOMEM;499 500 ssp_fill_buffer(msg, 0, &sensor_type, 1);501 ssp_fill_buffer(msg, 1, send_buf, 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, 1000);507 ssp_clean_msg(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, 1, SSP_AP2HUB_READ, 0);519 if (!msg)520 return -ENOMEM;521 522 ret = ssp_spi_sync(data, msg, 1000);523 524 buffer = SSP_GET_BUFFER_AT_INDEX(msg, 0);525 526 ssp_clean_msg(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 data->sensorhub_info->mag_length, SSP_AP2HUB_WRITE,538 0);539 if (!msg)540 return -ENOMEM;541 542 ssp_fill_buffer(msg, 0, data->sensorhub_info->mag_table,543 data->sensorhub_info->mag_length);544 545 ret = ssp_spi_sync(data, msg, 1000);546 ssp_clean_msg(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, 4,558 SSP_AP2HUB_READ, 0);559 if (!msg)560 return 0;561 562 ret = ssp_spi_sync(data, msg, 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(msg, 0, &result, 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(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, 4,584 SSP_AP2HUB_READ, 0);585 if (!msg)586 return SSP_INVALID_REVISION;587 588 ret = ssp_spi_sync(data, msg, 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(msg, 0, &result, 4);596 ret = le32_to_cpu(result);597 598_exit:599 ssp_clean_msg(msg);600 return ret;601}602