drivers/iio/common/ssp_sensors/ssp_spi.c

   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
  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  */
 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
 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
 136 static void ssp_clean_msg(struct ssp_msg *m)
 137 {
 138         kfree(m->buffer);
 139         kfree(m);
 140 }
 141
 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  */
 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
 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
 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
 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
 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
 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 */
 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
 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
 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
 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
 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
 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
 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
 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 }