common/ssp_sensors/ssp_spi.c

0001 // SPDX-License-Identifier: GPL-2.0-or-later
0002 /*
0003  *  Copyright (C) 2014, Samsung Electronics Co. Ltd. All Rights Reserved.
0004  */
0005
0006 #include "ssp.h"
0007
0008 #define SSP_DEV (&data->spi->dev)
0009 #define SSP_GET_MESSAGE_TYPE(data) (data & (3 << SSP_RW))
0010
0011 /*
0012  * SSP -> AP Instruction
0013  * They tell what packet type can be expected. In the future there will
0014  * be less of them. BYPASS means common sensor packets with accel, gyro,
0015  * hrm etc. data. LIBRARY and META are mock-up's for now.
0016  */
0017 #define SSP_MSG2AP_INST_BYPASS_DATA     0x37
0018 #define SSP_MSG2AP_INST_LIBRARY_DATA        0x01
0019 #define SSP_MSG2AP_INST_DEBUG_DATA      0x03
0020 #define SSP_MSG2AP_INST_BIG_DATA        0x04
0021 #define SSP_MSG2AP_INST_META_DATA       0x05
0022 #define SSP_MSG2AP_INST_TIME_SYNC       0x06
0023 #define SSP_MSG2AP_INST_RESET           0x07
0024
0025 #define SSP_UNIMPLEMENTED -1
0026
0027 struct ssp_msg_header {
0028     u8 cmd;
0029     __le16 length;
0030     __le16 options;
0031     __le32 data;
0032 } __attribute__((__packed__));
0033
0034 struct ssp_msg {
0035     u16 length;
0036     u16 options;
0037     struct list_head list;
0038     struct completion *done;
0039     struct ssp_msg_header *h;
0040     char *buffer;
0041 };
0042
0043 static const int ssp_offset_map[SSP_SENSOR_MAX] = {
0044     [SSP_ACCELEROMETER_SENSOR] =        SSP_ACCELEROMETER_SIZE +
0045                         SSP_TIME_SIZE,
0046     [SSP_GYROSCOPE_SENSOR] =        SSP_GYROSCOPE_SIZE +
0047                         SSP_TIME_SIZE,
0048     [SSP_GEOMAGNETIC_UNCALIB_SENSOR] =  SSP_UNIMPLEMENTED,
0049     [SSP_GEOMAGNETIC_RAW] =         SSP_UNIMPLEMENTED,
0050     [SSP_GEOMAGNETIC_SENSOR] =      SSP_UNIMPLEMENTED,
0051     [SSP_PRESSURE_SENSOR] =         SSP_UNIMPLEMENTED,
0052     [SSP_GESTURE_SENSOR] =          SSP_UNIMPLEMENTED,
0053     [SSP_PROXIMITY_SENSOR] =        SSP_UNIMPLEMENTED,
0054     [SSP_TEMPERATURE_HUMIDITY_SENSOR] = SSP_UNIMPLEMENTED,
0055     [SSP_LIGHT_SENSOR] =            SSP_UNIMPLEMENTED,
0056     [SSP_PROXIMITY_RAW] =           SSP_UNIMPLEMENTED,
0057     [SSP_ORIENTATION_SENSOR] =      SSP_UNIMPLEMENTED,
0058     [SSP_STEP_DETECTOR] =           SSP_UNIMPLEMENTED,
0059     [SSP_SIG_MOTION_SENSOR] =       SSP_UNIMPLEMENTED,
0060     [SSP_GYRO_UNCALIB_SENSOR] =     SSP_UNIMPLEMENTED,
0061     [SSP_GAME_ROTATION_VECTOR] =        SSP_UNIMPLEMENTED,
0062     [SSP_ROTATION_VECTOR] =         SSP_UNIMPLEMENTED,
0063     [SSP_STEP_COUNTER] =            SSP_UNIMPLEMENTED,
0064     [SSP_BIO_HRM_RAW] =         SSP_BIO_HRM_RAW_SIZE +
0065                         SSP_TIME_SIZE,
0066     [SSP_BIO_HRM_RAW_FAC] =         SSP_BIO_HRM_RAW_FAC_SIZE +
0067                         SSP_TIME_SIZE,
0068     [SSP_BIO_HRM_LIB] =         SSP_BIO_HRM_LIB_SIZE +
0069                         SSP_TIME_SIZE,
0070 };
0071
0072 #define SSP_HEADER_SIZE     (sizeof(struct ssp_msg_header))
0073 #define SSP_HEADER_SIZE_ALIGNED (ALIGN(SSP_HEADER_SIZE, 4))
0074
0075 static struct ssp_msg *ssp_create_msg(u8 cmd, u16 len, u16 opt, u32 data)
0076 {
0077     struct ssp_msg_header h;
0078     struct ssp_msg *msg;
0079
0080     msg = kzalloc(sizeof(*msg), GFP_KERNEL);
0081     if (!msg)
0082         return NULL;
0083
0084     h.cmd = cmd;
0085     h.length = cpu_to_le16(len);
0086     h.options = cpu_to_le16(opt);
0087     h.data = cpu_to_le32(data);
0088
0089     msg->buffer = kzalloc(SSP_HEADER_SIZE_ALIGNED + len,
0090                   GFP_KERNEL | GFP_DMA);
0091     if (!msg->buffer) {
0092         kfree(msg);
0093         return NULL;
0094     }
0095
0096     msg->length = len;
0097     msg->options = opt;
0098
0099     memcpy(msg->buffer, &h, SSP_HEADER_SIZE);
0100
0101     return msg;
0102 }
0103
0104 /*
0105  * It is a bit heavy to do it this way but often the function is used to compose
0106  * the message from smaller chunks which are placed on the stack.  Often the
0107  * chunks are small so memcpy should be optimalized.
0108  */
0109 static inline void ssp_fill_buffer(struct ssp_msg *m, unsigned int offset,
0110                    const void *src, unsigned int len)
0111 {
0112     memcpy(&m->buffer[SSP_HEADER_SIZE_ALIGNED + offset], src, len);
0113 }
0114
0115 static inline void ssp_get_buffer(struct ssp_msg *m, unsigned int offset,
0116                   void *dest, unsigned int len)
0117 {
0118     memcpy(dest, &m->buffer[SSP_HEADER_SIZE_ALIGNED + offset],  len);
0119 }
0120
0121 #define SSP_GET_BUFFER_AT_INDEX(m, index) \
0122     (m->buffer[SSP_HEADER_SIZE_ALIGNED + index])
0123 #define SSP_SET_BUFFER_AT_INDEX(m, index, val) \
0124     (m->buffer[SSP_HEADER_SIZE_ALIGNED + index] = val)
0125
0126 static void ssp_clean_msg(struct ssp_msg *m)
0127 {
0128     kfree(m->buffer);
0129     kfree(m);
0130 }
0131
0132 static int ssp_print_mcu_debug(char *data_frame, int *data_index,
0133                    int received_len)
0134 {
0135     int length = data_frame[(*data_index)++];
0136
0137     if (length > received_len - *data_index || length <= 0) {
0138         ssp_dbg("[SSP]: MSG From MCU-invalid debug length(%d/%d)\n",
0139             length, received_len);
0140         return -EPROTO;
0141     }
0142
0143     ssp_dbg("[SSP]: MSG From MCU - %s\n", &data_frame[*data_index]);
0144
0145     *data_index += length;
0146
0147     return 0;
0148 }
0149
0150 /*
0151  * It was designed that way - additional lines to some kind of handshake,
0152  * please do not ask why - only the firmware guy can know it.
0153  */
0154 static int ssp_check_lines(struct ssp_data *data, bool state)
0155 {
0156     int delay_cnt = 0;
0157
0158     gpiod_set_value_cansleep(data->ap_mcu_gpiod, state);
0159
0160     while (gpiod_get_value_cansleep(data->mcu_ap_gpiod) != state) {
0161         usleep_range(3000, 3500);
0162
0163         if (data->shut_down || delay_cnt++ > 500) {
0164             dev_err(SSP_DEV, "%s:timeout, hw ack wait fail %d\n",
0165                 __func__, state);
0166
0167             if (!state)
0168                 gpiod_set_value_cansleep(data->ap_mcu_gpiod, 1);
0169
0170             return -ETIMEDOUT;
0171         }
0172     }
0173
0174     return 0;
0175 }
0176
0177 static int ssp_do_transfer(struct ssp_data *data, struct ssp_msg *msg,
0178                struct completion *done, int timeout)
0179 {
0180     int status;
0181     /*
0182      * check if this is a short one way message or the whole transfer has
0183      * second part after an interrupt
0184      */
0185     const bool use_no_irq = msg->length == 0;
0186
0187     if (data->shut_down)
0188         return -EPERM;
0189
0190     msg->done = done;
0191
0192     mutex_lock(&data->comm_lock);
0193
0194     status = ssp_check_lines(data, false);
0195     if (status < 0)
0196         goto _error_locked;
0197
0198     status = spi_write(data->spi, msg->buffer, SSP_HEADER_SIZE);
0199     if (status < 0) {
0200         gpiod_set_value_cansleep(data->ap_mcu_gpiod, 1);
0201         dev_err(SSP_DEV, "%s spi_write fail\n", __func__);
0202         goto _error_locked;
0203     }
0204
0205     if (!use_no_irq) {
0206         mutex_lock(&data->pending_lock);
0207         list_add_tail(&msg->list, &data->pending_list);
0208         mutex_unlock(&data->pending_lock);
0209     }
0210
0211     status = ssp_check_lines(data, true);
0212     if (status < 0) {
0213         if (!use_no_irq) {
0214             mutex_lock(&data->pending_lock);
0215             list_del(&msg->list);
0216             mutex_unlock(&data->pending_lock);
0217         }
0218         goto _error_locked;
0219     }
0220
0221     mutex_unlock(&data->comm_lock);
0222
0223     if (!use_no_irq && done)
0224         if (wait_for_completion_timeout(done,
0225                         msecs_to_jiffies(timeout)) ==
0226             0) {
0227             mutex_lock(&data->pending_lock);
0228             list_del(&msg->list);
0229             mutex_unlock(&data->pending_lock);
0230
0231             data->timeout_cnt++;
0232             return -ETIMEDOUT;
0233         }
0234
0235     return 0;
0236
0237 _error_locked:
0238     mutex_unlock(&data->comm_lock);
0239     data->timeout_cnt++;
0240     return status;
0241 }
0242
0243 static inline int ssp_spi_sync_command(struct ssp_data *data,
0244                        struct ssp_msg *msg)
0245 {
0246     return ssp_do_transfer(data, msg, NULL, 0);
0247 }
0248
0249 static int ssp_spi_sync(struct ssp_data *data, struct ssp_msg *msg,
0250             int timeout)
0251 {
0252     DECLARE_COMPLETION_ONSTACK(done);
0253
0254     if (WARN_ON(!msg->length))
0255         return -EPERM;
0256
0257     return ssp_do_transfer(data, msg, &done, timeout);
0258 }
0259
0260 static int ssp_handle_big_data(struct ssp_data *data, char *dataframe, int *idx)
0261 {
0262     /* mock-up, it will be changed with adding another sensor types */
0263     *idx += 8;
0264     return 0;
0265 }
0266
0267 static int ssp_parse_dataframe(struct ssp_data *data, char *dataframe, int len)
0268 {
0269     int idx, sd;
0270     struct ssp_sensor_data *spd;
0271     struct iio_dev **indio_devs = data->sensor_devs;
0272
0273     for (idx = 0; idx < len;) {
0274         switch (dataframe[idx++]) {
0275         case SSP_MSG2AP_INST_BYPASS_DATA:
0276             if (idx >= len)
0277                 return -EPROTO;
0278             sd = dataframe[idx++];
0279             if (sd < 0 || sd >= SSP_SENSOR_MAX) {
0280                 dev_err(SSP_DEV,
0281                     "Mcu data frame1 error %d\n", sd);
0282                 return -EPROTO;
0283             }
0284
0285             if (indio_devs[sd]) {
0286                 spd = iio_priv(indio_devs[sd]);
0287                 if (spd->process_data) {
0288                     if (idx >= len)
0289                         return -EPROTO;
0290                     spd->process_data(indio_devs[sd],
0291                               &dataframe[idx],
0292                               data->timestamp);
0293                 }
0294             } else {
0295                 dev_err(SSP_DEV, "no client for frame\n");
0296             }
0297
0298             idx += ssp_offset_map[sd];
0299             break;
0300         case SSP_MSG2AP_INST_DEBUG_DATA:
0301             if (idx >= len)
0302                 return -EPROTO;
0303             sd = ssp_print_mcu_debug(dataframe, &idx, len);
0304             if (sd) {
0305                 dev_err(SSP_DEV,
0306                     "Mcu data frame3 error %d\n", sd);
0307                 return sd;
0308             }
0309             break;
0310         case SSP_MSG2AP_INST_LIBRARY_DATA:
0311             idx += len;
0312             break;
0313         case SSP_MSG2AP_INST_BIG_DATA:
0314             ssp_handle_big_data(data, dataframe, &idx);
0315             break;
0316         case SSP_MSG2AP_INST_TIME_SYNC:
0317             data->time_syncing = true;
0318             break;
0319         case SSP_MSG2AP_INST_RESET:
0320             ssp_queue_ssp_refresh_task(data, 0);
0321             break;
0322         }
0323     }
0324
0325     if (data->time_syncing)
0326         data->timestamp = ktime_get_real_ns();
0327
0328     return 0;
0329 }
0330
0331 /* threaded irq */
0332 int ssp_irq_msg(struct ssp_data *data)
0333 {
0334     char *buffer;
0335     u8 msg_type;
0336     int ret;
0337     u16 length, msg_options;
0338     struct ssp_msg *msg = NULL, *iter, *n;
0339
0340     ret = spi_read(data->spi, data->header_buffer, SSP_HEADER_BUFFER_SIZE);
0341     if (ret < 0) {
0342         dev_err(SSP_DEV, "header read fail\n");
0343         return ret;
0344     }
0345
0346     length = le16_to_cpu(data->header_buffer[1]);
0347     msg_options = le16_to_cpu(data->header_buffer[0]);
0348
0349     if (length == 0) {
0350         dev_err(SSP_DEV, "length received from mcu is 0\n");
0351         return -EINVAL;
0352     }
0353
0354     msg_type = SSP_GET_MESSAGE_TYPE(msg_options);
0355
0356     switch (msg_type) {
0357     case SSP_AP2HUB_READ:
0358     case SSP_AP2HUB_WRITE:
0359         /*
0360          * this is a small list, a few elements - the packets can be
0361          * received with no order
0362          */
0363         mutex_lock(&data->pending_lock);
0364         list_for_each_entry_safe(iter, n, &data->pending_list, list) {
0365             if (iter->options == msg_options) {
0366                 list_del(&iter->list);
0367                 msg = iter;
0368                 break;
0369             }
0370         }
0371
0372         if (!msg) {
0373             /*
0374              * here can be implemented dead messages handling
0375              * but the slave should not send such ones - it is to
0376              * check but let's handle this
0377              */
0378             buffer = kmalloc(length, GFP_KERNEL | GFP_DMA);
0379             if (!buffer) {
0380                 ret = -ENOMEM;
0381                 goto _unlock;
0382             }
0383
0384             /* got dead packet so it is always an error */
0385             ret = spi_read(data->spi, buffer, length);
0386             if (ret >= 0)
0387                 ret = -EPROTO;
0388
0389             kfree(buffer);
0390
0391             dev_err(SSP_DEV, "No match error %x\n",
0392                 msg_options);
0393
0394             goto _unlock;
0395         }
0396
0397         if (msg_type == SSP_AP2HUB_READ)
0398             ret = spi_read(data->spi,
0399                        &msg->buffer[SSP_HEADER_SIZE_ALIGNED],
0400                        msg->length);
0401
0402         if (msg_type == SSP_AP2HUB_WRITE) {
0403             ret = spi_write(data->spi,
0404                     &msg->buffer[SSP_HEADER_SIZE_ALIGNED],
0405                     msg->length);
0406             if (msg_options & SSP_AP2HUB_RETURN) {
0407                 msg->options =
0408                     SSP_AP2HUB_READ | SSP_AP2HUB_RETURN;
0409                 msg->length = 1;
0410
0411                 list_add_tail(&msg->list, &data->pending_list);
0412                 goto _unlock;
0413             }
0414         }
0415
0416         if (msg->done)
0417             if (!completion_done(msg->done))
0418                 complete(msg->done);
0419 _unlock:
0420         mutex_unlock(&data->pending_lock);
0421         break;
0422     case SSP_HUB2AP_WRITE:
0423         buffer = kzalloc(length, GFP_KERNEL | GFP_DMA);
0424         if (!buffer)
0425             return -ENOMEM;
0426
0427         ret = spi_read(data->spi, buffer, length);
0428         if (ret < 0) {
0429             dev_err(SSP_DEV, "spi read fail\n");
0430             kfree(buffer);
0431             break;
0432         }
0433
0434         ret = ssp_parse_dataframe(data, buffer, length);
0435
0436         kfree(buffer);
0437         break;
0438
0439     default:
0440         dev_err(SSP_DEV, "unknown msg type\n");
0441         return -EPROTO;
0442     }
0443
0444     return ret;
0445 }
0446
0447 void ssp_clean_pending_list(struct ssp_data *data)
0448 {
0449     struct ssp_msg *msg, *n;
0450
0451     mutex_lock(&data->pending_lock);
0452     list_for_each_entry_safe(msg, n, &data->pending_list, list) {
0453         list_del(&msg->list);
0454
0455         if (msg->done)
0456             if (!completion_done(msg->done))
0457                 complete(msg->done);
0458     }
0459     mutex_unlock(&data->pending_lock);
0460 }
0461
0462 int ssp_command(struct ssp_data *data, char command, int arg)
0463 {
0464     int ret;
0465     struct ssp_msg *msg;
0466
0467     msg = ssp_create_msg(command, 0, SSP_AP2HUB_WRITE, arg);
0468     if (!msg)
0469         return -ENOMEM;
0470
0471     ssp_dbg("%s - command 0x%x %d\n", __func__, command, arg);
0472
0473     ret = ssp_spi_sync_command(data, msg);
0474     ssp_clean_msg(msg);
0475
0476     return ret;
0477 }
0478
0479 int ssp_send_instruction(struct ssp_data *data, u8 inst, u8 sensor_type,
0480              u8 *send_buf, u8 length)
0481 {
0482     int ret;
0483     struct ssp_msg *msg;
0484
0485     if (data->fw_dl_state == SSP_FW_DL_STATE_DOWNLOADING) {
0486         dev_err(SSP_DEV, "%s - Skip Inst! DL state = %d\n",
0487             __func__, data->fw_dl_state);
0488         return -EBUSY;
0489     } else if (!(data->available_sensors & BIT(sensor_type)) &&
0490            (inst <= SSP_MSG2SSP_INST_CHANGE_DELAY)) {
0491         dev_err(SSP_DEV, "%s - Bypass Inst Skip! - %u\n",
0492             __func__, sensor_type);
0493         return -EIO; /* just fail */
0494     }
0495
0496     msg = ssp_create_msg(inst, length + 2, SSP_AP2HUB_WRITE, 0);
0497     if (!msg)
0498         return -ENOMEM;
0499
0500     ssp_fill_buffer(msg, 0, &sensor_type, 1);
0501     ssp_fill_buffer(msg, 1, send_buf, length);
0502
0503     ssp_dbg("%s - Inst = 0x%x, Sensor Type = 0x%x, data = %u\n",
0504         __func__, inst, sensor_type, send_buf[1]);
0505
0506     ret = ssp_spi_sync(data, msg, 1000);
0507     ssp_clean_msg(msg);
0508
0509     return ret;
0510 }
0511
0512 int ssp_get_chipid(struct ssp_data *data)
0513 {
0514     int ret;
0515     char buffer;
0516     struct ssp_msg *msg;
0517
0518     msg = ssp_create_msg(SSP_MSG2SSP_AP_WHOAMI, 1, SSP_AP2HUB_READ, 0);
0519     if (!msg)
0520         return -ENOMEM;
0521
0522     ret = ssp_spi_sync(data, msg, 1000);
0523
0524     buffer = SSP_GET_BUFFER_AT_INDEX(msg, 0);
0525
0526     ssp_clean_msg(msg);
0527
0528     return ret < 0 ? ret : buffer;
0529 }
0530
0531 int ssp_set_magnetic_matrix(struct ssp_data *data)
0532 {
0533     int ret;
0534     struct ssp_msg *msg;
0535
0536     msg = ssp_create_msg(SSP_MSG2SSP_AP_SET_MAGNETIC_STATIC_MATRIX,
0537                  data->sensorhub_info->mag_length, SSP_AP2HUB_WRITE,
0538                  0);
0539     if (!msg)
0540         return -ENOMEM;
0541
0542     ssp_fill_buffer(msg, 0, data->sensorhub_info->mag_table,
0543             data->sensorhub_info->mag_length);
0544
0545     ret = ssp_spi_sync(data, msg, 1000);
0546     ssp_clean_msg(msg);
0547
0548     return ret;
0549 }
0550
0551 unsigned int ssp_get_sensor_scanning_info(struct ssp_data *data)
0552 {
0553     int ret;
0554     __le32 result;
0555     u32 cpu_result = 0;
0556
0557     struct ssp_msg *msg = ssp_create_msg(SSP_MSG2SSP_AP_SENSOR_SCANNING, 4,
0558                          SSP_AP2HUB_READ, 0);
0559     if (!msg)
0560         return 0;
0561
0562     ret = ssp_spi_sync(data, msg, 1000);
0563     if (ret < 0) {
0564         dev_err(SSP_DEV, "%s - spi read fail %d\n", __func__, ret);
0565         goto _exit;
0566     }
0567
0568     ssp_get_buffer(msg, 0, &result, 4);
0569     cpu_result = le32_to_cpu(result);
0570
0571     dev_info(SSP_DEV, "%s state: 0x%08x\n", __func__, cpu_result);
0572
0573 _exit:
0574     ssp_clean_msg(msg);
0575     return cpu_result;
0576 }
0577
0578 unsigned int ssp_get_firmware_rev(struct ssp_data *data)
0579 {
0580     int ret;
0581     __le32 result;
0582
0583     struct ssp_msg *msg = ssp_create_msg(SSP_MSG2SSP_AP_FIRMWARE_REV, 4,
0584                          SSP_AP2HUB_READ, 0);
0585     if (!msg)
0586         return SSP_INVALID_REVISION;
0587
0588     ret = ssp_spi_sync(data, msg, 1000);
0589     if (ret < 0) {
0590         dev_err(SSP_DEV, "%s - transfer fail %d\n", __func__, ret);
0591         ret = SSP_INVALID_REVISION;
0592         goto _exit;
0593     }
0594
0595     ssp_get_buffer(msg, 0, &result, 4);
0596     ret = le32_to_cpu(result);
0597
0598 _exit:
0599     ssp_clean_msg(msg);
0600     return ret;
0601 }