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 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 * 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 */ 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 -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 */ 154 static 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 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 * 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, 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 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 /* mock-up, it will be changed with adding another sensor types */ 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 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 */ 332 int ssp_irq_msg(struct ssp_data *data) 333 { 334 bool found = false; 335 char *buffer; 336 u8 msg_type; 337 int ret; 338 u16 length, msg_options; 339 struct ssp_msg *msg, *n; 340 341 ret = spi_read(data->spi, data->header_buffer, SSP_HEADER_BUFFER_SIZE); 342 if (ret < 0) { 343 dev_err(SSP_DEV, "header read fail\n"); 344 return ret; 345 } 346 347 length = le16_to_cpu(data->header_buffer[1]); 348 msg_options = le16_to_cpu(data->header_buffer[0]); 349 350 if (length == 0) { 351 dev_err(SSP_DEV, "length received from mcu is 0\n"); 352 return -EINVAL; 353 } 354 355 msg_type = SSP_GET_MESSAGE_TYPE(msg_options); 356 357 switch (msg_type) { 358 case SSP_AP2HUB_READ: 359 case SSP_AP2HUB_WRITE: 360 /* 361 * this is a small list, a few elements - the packets can be 362 * received with no order 363 */ 364 mutex_lock(&data->pending_lock); 365 list_for_each_entry_safe(msg, n, &data->pending_list, list) { 366 if (msg->options == msg_options) { 367 list_del(&msg->list); 368 found = true; 369 break; 370 } 371 } 372 373 if (!found) { 374 /* 375 * here can be implemented dead messages handling 376 * but the slave should not send such ones - it is to 377 * check but let's handle this 378 */ 379 buffer = kmalloc(length, GFP_KERNEL | GFP_DMA); 380 if (!buffer) { 381 ret = -ENOMEM; 382 goto _unlock; 383 } 384 385 /* got dead packet so it is always an error */ 386 ret = spi_read(data->spi, buffer, length); 387 if (ret >= 0) 388 ret = -EPROTO; 389 390 kfree(buffer); 391 392 dev_err(SSP_DEV, "No match error %x\n", 393 msg_options); 394 395 goto _unlock; 396 } 397 398 if (msg_type == SSP_AP2HUB_READ) 399 ret = spi_read(data->spi, 400 &msg->buffer[SSP_HEADER_SIZE_ALIGNED], 401 msg->length); 402 403 if (msg_type == SSP_AP2HUB_WRITE) { 404 ret = spi_write(data->spi, 405 &msg->buffer[SSP_HEADER_SIZE_ALIGNED], 406 msg->length); 407 if (msg_options & SSP_AP2HUB_RETURN) { 408 msg->options = 409 SSP_AP2HUB_READ | SSP_AP2HUB_RETURN; 410 msg->length = 1; 411 412 list_add_tail(&msg->list, &data->pending_list); 413 goto _unlock; 414 } 415 } 416 417 if (msg->done) 418 if (!completion_done(msg->done)) 419 complete(msg->done); 420 _unlock: 421 mutex_unlock(&data->pending_lock); 422 break; 423 case SSP_HUB2AP_WRITE: 424 buffer = kzalloc(length, GFP_KERNEL | GFP_DMA); 425 if (!buffer) 426 return -ENOMEM; 427 428 ret = spi_read(data->spi, buffer, length); 429 if (ret < 0) { 430 dev_err(SSP_DEV, "spi read fail\n"); 431 kfree(buffer); 432 break; 433 } 434 435 ret = ssp_parse_dataframe(data, buffer, length); 436 437 kfree(buffer); 438 break; 439 440 default: 441 dev_err(SSP_DEV, "unknown msg type\n"); 442 return -EPROTO; 443 } 444 445 return ret; 446 } 447 448 void ssp_clean_pending_list(struct ssp_data *data) 449 { 450 struct ssp_msg *msg, *n; 451 452 mutex_lock(&data->pending_lock); 453 list_for_each_entry_safe(msg, n, &data->pending_list, list) { 454 list_del(&msg->list); 455 456 if (msg->done) 457 if (!completion_done(msg->done)) 458 complete(msg->done); 459 } 460 mutex_unlock(&data->pending_lock); 461 } 462 463 int ssp_command(struct ssp_data *data, char command, int arg) 464 { 465 int ret; 466 struct ssp_msg *msg; 467 468 msg = ssp_create_msg(command, 0, SSP_AP2HUB_WRITE, arg); 469 if (!msg) 470 return -ENOMEM; 471 472 ssp_dbg("%s - command 0x%x %d\n", __func__, command, arg); 473 474 ret = ssp_spi_sync_command(data, msg); 475 ssp_clean_msg(msg); 476 477 return ret; 478 } 479 480 int ssp_send_instruction(struct ssp_data *data, u8 inst, u8 sensor_type, 481 u8 *send_buf, u8 length) 482 { 483 int ret; 484 struct ssp_msg *msg; 485 486 if (data->fw_dl_state == SSP_FW_DL_STATE_DOWNLOADING) { 487 dev_err(SSP_DEV, "%s - Skip Inst! DL state = %d\n", 488 __func__, data->fw_dl_state); 489 return -EBUSY; 490 } else if (!(data->available_sensors & BIT(sensor_type)) && 491 (inst <= SSP_MSG2SSP_INST_CHANGE_DELAY)) { 492 dev_err(SSP_DEV, "%s - Bypass Inst Skip! - %u\n", 493 __func__, sensor_type); 494 return -EIO; /* just fail */ 495 } 496 497 msg = ssp_create_msg(inst, length + 2, SSP_AP2HUB_WRITE, 0); 498 if (!msg) 499 return -ENOMEM; 500 501 ssp_fill_buffer(msg, 0, &sensor_type, 1); 502 ssp_fill_buffer(msg, 1, send_buf, length); 503 504 ssp_dbg("%s - Inst = 0x%x, Sensor Type = 0x%x, data = %u\n", 505 __func__, inst, sensor_type, send_buf[1]); 506 507 ret = ssp_spi_sync(data, msg, 1000); 508 ssp_clean_msg(msg); 509 510 return ret; 511 } 512 513 int ssp_get_chipid(struct ssp_data *data) 514 { 515 int ret; 516 char buffer; 517 struct ssp_msg *msg; 518 519 msg = ssp_create_msg(SSP_MSG2SSP_AP_WHOAMI, 1, SSP_AP2HUB_READ, 0); 520 if (!msg) 521 return -ENOMEM; 522 523 ret = ssp_spi_sync(data, msg, 1000); 524 525 buffer = SSP_GET_BUFFER_AT_INDEX(msg, 0); 526 527 ssp_clean_msg(msg); 528 529 return ret < 0 ? ret : buffer; 530 } 531 532 int ssp_set_magnetic_matrix(struct ssp_data *data) 533 { 534 int ret; 535 struct ssp_msg *msg; 536 537 msg = ssp_create_msg(SSP_MSG2SSP_AP_SET_MAGNETIC_STATIC_MATRIX, 538 data->sensorhub_info->mag_length, SSP_AP2HUB_WRITE, 539 0); 540 if (!msg) 541 return -ENOMEM; 542 543 ssp_fill_buffer(msg, 0, data->sensorhub_info->mag_table, 544 data->sensorhub_info->mag_length); 545 546 ret = ssp_spi_sync(data, msg, 1000); 547 ssp_clean_msg(msg); 548 549 return ret; 550 } 551 552 unsigned int ssp_get_sensor_scanning_info(struct ssp_data *data) 553 { 554 int ret; 555 __le32 result; 556 u32 cpu_result = 0; 557 558 struct ssp_msg *msg = ssp_create_msg(SSP_MSG2SSP_AP_SENSOR_SCANNING, 4, 559 SSP_AP2HUB_READ, 0); 560 if (!msg) 561 return 0; 562 563 ret = ssp_spi_sync(data, msg, 1000); 564 if (ret < 0) { 565 dev_err(SSP_DEV, "%s - spi read fail %d\n", __func__, ret); 566 goto _exit; 567 } 568 569 ssp_get_buffer(msg, 0, &result, 4); 570 cpu_result = le32_to_cpu(result); 571 572 dev_info(SSP_DEV, "%s state: 0x%08x\n", __func__, cpu_result); 573 574 _exit: 575 ssp_clean_msg(msg); 576 return cpu_result; 577 } 578 579 unsigned int ssp_get_firmware_rev(struct ssp_data *data) 580 { 581 int ret; 582 __le32 result; 583 584 struct ssp_msg *msg = ssp_create_msg(SSP_MSG2SSP_AP_FIRMWARE_REV, 4, 585 SSP_AP2HUB_READ, 0); 586 if (!msg) 587 return SSP_INVALID_REVISION; 588 589 ret = ssp_spi_sync(data, msg, 1000); 590 if (ret < 0) { 591 dev_err(SSP_DEV, "%s - transfer fail %d\n", __func__, ret); 592 ret = SSP_INVALID_REVISION; 593 goto _exit; 594 } 595 596 ssp_get_buffer(msg, 0, &result, 4); 597 ret = le32_to_cpu(result); 598 599 _exit: 600 ssp_clean_msg(msg); 601 return ret; 602 } 603