![Karol Wrona](/assets/img/avatar_default.png)
Sensorhub is MCU dedicated to collect data and manage several sensors. Sensorhub is a spi device which provides a layer for IIO devices. It provides some data parsing and common mechanism for sensorhub sensors. Adds common sensorhub library for sensorhub driver and iio drivers which uses sensorhub MCU to communicate with sensors. Signed-off-by: Karol Wrona <k.wrona@samsung.com> Acked-by: Kyungmin Park <kyungmin.park@samsung.com> Signed-off-by: Jonathan Cameron <jic23@kernel.org>
609 lines
14 KiB
C
609 lines
14 KiB
C
/*
|
|
* Copyright (C) 2014, Samsung Electronics Co. Ltd. All Rights Reserved.
|
|
*
|
|
* This program is free software; you can redistribute it and/or modify
|
|
* it under the terms of the GNU General Public License as published by
|
|
* the Free Software Foundation; either version 2 of the License, or
|
|
* (at your option) any later version.
|
|
*
|
|
* This program is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU General Public License for more details.
|
|
*
|
|
*/
|
|
|
|
#include "ssp.h"
|
|
|
|
#define SSP_DEV (&data->spi->dev)
|
|
#define SSP_GET_MESSAGE_TYPE(data) (data & (3 << SSP_RW))
|
|
|
|
/*
|
|
* SSP -> AP Instruction
|
|
* They tell what packet type can be expected. In the future there will
|
|
* be less of them. BYPASS means common sensor packets with accel, gyro,
|
|
* hrm etc. data. LIBRARY and META are mock-up's for now.
|
|
*/
|
|
#define SSP_MSG2AP_INST_BYPASS_DATA 0x37
|
|
#define SSP_MSG2AP_INST_LIBRARY_DATA 0x01
|
|
#define SSP_MSG2AP_INST_DEBUG_DATA 0x03
|
|
#define SSP_MSG2AP_INST_BIG_DATA 0x04
|
|
#define SSP_MSG2AP_INST_META_DATA 0x05
|
|
#define SSP_MSG2AP_INST_TIME_SYNC 0x06
|
|
#define SSP_MSG2AP_INST_RESET 0x07
|
|
|
|
#define SSP_UNIMPLEMENTED -1
|
|
|
|
struct ssp_msg_header {
|
|
u8 cmd;
|
|
__le16 length;
|
|
__le16 options;
|
|
__le32 data;
|
|
} __attribute__((__packed__));
|
|
|
|
struct ssp_msg {
|
|
u16 length;
|
|
u16 options;
|
|
struct list_head list;
|
|
struct completion *done;
|
|
struct ssp_msg_header *h;
|
|
char *buffer;
|
|
};
|
|
|
|
static const int ssp_offset_map[SSP_SENSOR_MAX] = {
|
|
[SSP_ACCELEROMETER_SENSOR] = SSP_ACCELEROMETER_SIZE +
|
|
SSP_TIME_SIZE,
|
|
[SSP_GYROSCOPE_SENSOR] = SSP_GYROSCOPE_SIZE +
|
|
SSP_TIME_SIZE,
|
|
[SSP_GEOMAGNETIC_UNCALIB_SENSOR] = SSP_UNIMPLEMENTED,
|
|
[SSP_GEOMAGNETIC_RAW] = SSP_UNIMPLEMENTED,
|
|
[SSP_GEOMAGNETIC_SENSOR] = SSP_UNIMPLEMENTED,
|
|
[SSP_PRESSURE_SENSOR] = SSP_UNIMPLEMENTED,
|
|
[SSP_GESTURE_SENSOR] = SSP_UNIMPLEMENTED,
|
|
[SSP_PROXIMITY_SENSOR] = SSP_UNIMPLEMENTED,
|
|
[SSP_TEMPERATURE_HUMIDITY_SENSOR] = SSP_UNIMPLEMENTED,
|
|
[SSP_LIGHT_SENSOR] = SSP_UNIMPLEMENTED,
|
|
[SSP_PROXIMITY_RAW] = SSP_UNIMPLEMENTED,
|
|
[SSP_ORIENTATION_SENSOR] = SSP_UNIMPLEMENTED,
|
|
[SSP_STEP_DETECTOR] = SSP_UNIMPLEMENTED,
|
|
[SSP_SIG_MOTION_SENSOR] = SSP_UNIMPLEMENTED,
|
|
[SSP_GYRO_UNCALIB_SENSOR] = SSP_UNIMPLEMENTED,
|
|
[SSP_GAME_ROTATION_VECTOR] = SSP_UNIMPLEMENTED,
|
|
[SSP_ROTATION_VECTOR] = SSP_UNIMPLEMENTED,
|
|
[SSP_STEP_COUNTER] = SSP_UNIMPLEMENTED,
|
|
[SSP_BIO_HRM_RAW] = SSP_BIO_HRM_RAW_SIZE +
|
|
SSP_TIME_SIZE,
|
|
[SSP_BIO_HRM_RAW_FAC] = SSP_BIO_HRM_RAW_FAC_SIZE +
|
|
SSP_TIME_SIZE,
|
|
[SSP_BIO_HRM_LIB] = SSP_BIO_HRM_LIB_SIZE +
|
|
SSP_TIME_SIZE,
|
|
};
|
|
|
|
#define SSP_HEADER_SIZE (sizeof(struct ssp_msg_header))
|
|
#define SSP_HEADER_SIZE_ALIGNED (ALIGN(SSP_HEADER_SIZE, 4))
|
|
|
|
static struct ssp_msg *ssp_create_msg(u8 cmd, u16 len, u16 opt, u32 data)
|
|
{
|
|
struct ssp_msg_header h;
|
|
struct ssp_msg *msg;
|
|
|
|
msg = kzalloc(sizeof(*msg), GFP_KERNEL);
|
|
if (!msg)
|
|
return NULL;
|
|
|
|
h.cmd = cmd;
|
|
h.length = cpu_to_le16(len);
|
|
h.options = cpu_to_le16(opt);
|
|
h.data = cpu_to_le32(data);
|
|
|
|
msg->buffer = kzalloc(SSP_HEADER_SIZE_ALIGNED + len,
|
|
GFP_KERNEL | GFP_DMA);
|
|
if (!msg->buffer) {
|
|
kfree(msg);
|
|
return NULL;
|
|
}
|
|
|
|
msg->length = len;
|
|
msg->options = opt;
|
|
|
|
memcpy(msg->buffer, &h, SSP_HEADER_SIZE);
|
|
|
|
return msg;
|
|
}
|
|
|
|
/*
|
|
* It is a bit heavy to do it this way but often the function is used to compose
|
|
* the message from smaller chunks which are placed on the stack. Often the
|
|
* chunks are small so memcpy should be optimalized.
|
|
*/
|
|
static inline void ssp_fill_buffer(struct ssp_msg *m, unsigned int offset,
|
|
const void *src, unsigned int len)
|
|
{
|
|
memcpy(&m->buffer[SSP_HEADER_SIZE_ALIGNED + offset], src, len);
|
|
}
|
|
|
|
static inline void ssp_get_buffer(struct ssp_msg *m, unsigned int offset,
|
|
void *dest, unsigned int len)
|
|
{
|
|
memcpy(dest, &m->buffer[SSP_HEADER_SIZE_ALIGNED + offset], len);
|
|
}
|
|
|
|
#define SSP_GET_BUFFER_AT_INDEX(m, index) \
|
|
(m->buffer[SSP_HEADER_SIZE_ALIGNED + index])
|
|
#define SSP_SET_BUFFER_AT_INDEX(m, index, val) \
|
|
(m->buffer[SSP_HEADER_SIZE_ALIGNED + index] = val)
|
|
|
|
static void ssp_clean_msg(struct ssp_msg *m)
|
|
{
|
|
kfree(m->buffer);
|
|
kfree(m);
|
|
}
|
|
|
|
static int ssp_print_mcu_debug(char *data_frame, int *data_index,
|
|
int received_len)
|
|
{
|
|
int length = data_frame[(*data_index)++];
|
|
|
|
if (length > received_len - *data_index || length <= 0) {
|
|
ssp_dbg("[SSP]: MSG From MCU-invalid debug length(%d/%d)\n",
|
|
length, received_len);
|
|
return length ? length : -EPROTO;
|
|
}
|
|
|
|
ssp_dbg("[SSP]: MSG From MCU - %s\n", &data_frame[*data_index]);
|
|
|
|
*data_index += length;
|
|
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
* It was designed that way - additional lines to some kind of handshake,
|
|
* please do not ask why - only the firmware guy can know it.
|
|
*/
|
|
static int ssp_check_lines(struct ssp_data *data, bool state)
|
|
{
|
|
int delay_cnt = 0;
|
|
|
|
gpio_set_value_cansleep(data->ap_mcu_gpio, state);
|
|
|
|
while (gpio_get_value_cansleep(data->mcu_ap_gpio) != state) {
|
|
usleep_range(3000, 3500);
|
|
|
|
if (data->shut_down || delay_cnt++ > 500) {
|
|
dev_err(SSP_DEV, "%s:timeout, hw ack wait fail %d\n",
|
|
__func__, state);
|
|
|
|
if (!state)
|
|
gpio_set_value_cansleep(data->ap_mcu_gpio, 1);
|
|
|
|
return -ETIMEDOUT;
|
|
}
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int ssp_do_transfer(struct ssp_data *data, struct ssp_msg *msg,
|
|
struct completion *done, int timeout)
|
|
{
|
|
int status;
|
|
/*
|
|
* check if this is a short one way message or the whole transfer has
|
|
* second part after an interrupt
|
|
*/
|
|
const bool use_no_irq = msg->length == 0;
|
|
|
|
if (data->shut_down)
|
|
return -EPERM;
|
|
|
|
msg->done = done;
|
|
|
|
mutex_lock(&data->comm_lock);
|
|
|
|
status = ssp_check_lines(data, false);
|
|
if (status < 0)
|
|
goto _error_locked;
|
|
|
|
status = spi_write(data->spi, msg->buffer, SSP_HEADER_SIZE);
|
|
if (status < 0) {
|
|
gpio_set_value_cansleep(data->ap_mcu_gpio, 1);
|
|
dev_err(SSP_DEV, "%s spi_write fail\n", __func__);
|
|
goto _error_locked;
|
|
}
|
|
|
|
if (!use_no_irq) {
|
|
mutex_lock(&data->pending_lock);
|
|
list_add_tail(&msg->list, &data->pending_list);
|
|
mutex_unlock(&data->pending_lock);
|
|
}
|
|
|
|
status = ssp_check_lines(data, true);
|
|
if (status < 0) {
|
|
if (!use_no_irq) {
|
|
mutex_lock(&data->pending_lock);
|
|
list_del(&msg->list);
|
|
mutex_unlock(&data->pending_lock);
|
|
}
|
|
goto _error_locked;
|
|
}
|
|
|
|
mutex_unlock(&data->comm_lock);
|
|
|
|
if (!use_no_irq && done)
|
|
if (wait_for_completion_timeout(done,
|
|
msecs_to_jiffies(timeout)) ==
|
|
0) {
|
|
mutex_lock(&data->pending_lock);
|
|
list_del(&msg->list);
|
|
mutex_unlock(&data->pending_lock);
|
|
|
|
data->timeout_cnt++;
|
|
return -ETIMEDOUT;
|
|
}
|
|
|
|
return 0;
|
|
|
|
_error_locked:
|
|
mutex_unlock(&data->comm_lock);
|
|
data->timeout_cnt++;
|
|
return status;
|
|
}
|
|
|
|
static inline int ssp_spi_sync_command(struct ssp_data *data,
|
|
struct ssp_msg *msg)
|
|
{
|
|
return ssp_do_transfer(data, msg, NULL, 0);
|
|
}
|
|
|
|
static int ssp_spi_sync(struct ssp_data *data, struct ssp_msg *msg,
|
|
int timeout)
|
|
{
|
|
DECLARE_COMPLETION_ONSTACK(done);
|
|
|
|
if (WARN_ON(!msg->length))
|
|
return -EPERM;
|
|
|
|
return ssp_do_transfer(data, msg, &done, timeout);
|
|
}
|
|
|
|
static int ssp_handle_big_data(struct ssp_data *data, char *dataframe, int *idx)
|
|
{
|
|
/* mock-up, it will be changed with adding another sensor types */
|
|
*idx += 8;
|
|
return 0;
|
|
}
|
|
|
|
static int ssp_parse_dataframe(struct ssp_data *data, char *dataframe, int len)
|
|
{
|
|
int idx, sd;
|
|
struct timespec ts;
|
|
struct ssp_sensor_data *spd;
|
|
struct iio_dev **indio_devs = data->sensor_devs;
|
|
|
|
getnstimeofday(&ts);
|
|
|
|
for (idx = 0; idx < len;) {
|
|
switch (dataframe[idx++]) {
|
|
case SSP_MSG2AP_INST_BYPASS_DATA:
|
|
sd = dataframe[idx++];
|
|
if (sd < 0 || sd >= SSP_SENSOR_MAX) {
|
|
dev_err(SSP_DEV,
|
|
"Mcu data frame1 error %d\n", sd);
|
|
return -EPROTO;
|
|
}
|
|
|
|
if (indio_devs[sd]) {
|
|
spd = iio_priv(indio_devs[sd]);
|
|
if (spd->process_data)
|
|
spd->process_data(indio_devs[sd],
|
|
&dataframe[idx],
|
|
data->timestamp);
|
|
} else {
|
|
dev_err(SSP_DEV, "no client for frame\n");
|
|
}
|
|
|
|
idx += ssp_offset_map[sd];
|
|
break;
|
|
case SSP_MSG2AP_INST_DEBUG_DATA:
|
|
sd = ssp_print_mcu_debug(dataframe, &idx, len);
|
|
if (sd) {
|
|
dev_err(SSP_DEV,
|
|
"Mcu data frame3 error %d\n", sd);
|
|
return sd;
|
|
}
|
|
break;
|
|
case SSP_MSG2AP_INST_LIBRARY_DATA:
|
|
idx += len;
|
|
break;
|
|
case SSP_MSG2AP_INST_BIG_DATA:
|
|
ssp_handle_big_data(data, dataframe, &idx);
|
|
break;
|
|
case SSP_MSG2AP_INST_TIME_SYNC:
|
|
data->time_syncing = true;
|
|
break;
|
|
case SSP_MSG2AP_INST_RESET:
|
|
ssp_queue_ssp_refresh_task(data, 0);
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (data->time_syncing)
|
|
data->timestamp = ts.tv_sec * 1000000000ULL + ts.tv_nsec;
|
|
|
|
return 0;
|
|
}
|
|
|
|
/* threaded irq */
|
|
int ssp_irq_msg(struct ssp_data *data)
|
|
{
|
|
bool found = false;
|
|
char *buffer;
|
|
u8 msg_type;
|
|
int ret;
|
|
u16 length, msg_options;
|
|
struct ssp_msg *msg, *n;
|
|
|
|
ret = spi_read(data->spi, data->header_buffer, SSP_HEADER_BUFFER_SIZE);
|
|
if (ret < 0) {
|
|
dev_err(SSP_DEV, "header read fail\n");
|
|
return ret;
|
|
}
|
|
|
|
length = le16_to_cpu(data->header_buffer[1]);
|
|
msg_options = le16_to_cpu(data->header_buffer[0]);
|
|
|
|
if (length == 0) {
|
|
dev_err(SSP_DEV, "length received from mcu is 0\n");
|
|
return -EINVAL;
|
|
}
|
|
|
|
msg_type = SSP_GET_MESSAGE_TYPE(msg_options);
|
|
|
|
switch (msg_type) {
|
|
case SSP_AP2HUB_READ:
|
|
case SSP_AP2HUB_WRITE:
|
|
/*
|
|
* this is a small list, a few elements - the packets can be
|
|
* received with no order
|
|
*/
|
|
mutex_lock(&data->pending_lock);
|
|
list_for_each_entry_safe(msg, n, &data->pending_list, list) {
|
|
if (msg->options == msg_options) {
|
|
list_del(&msg->list);
|
|
found = true;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (!found) {
|
|
/*
|
|
* here can be implemented dead messages handling
|
|
* but the slave should not send such ones - it is to
|
|
* check but let's handle this
|
|
*/
|
|
buffer = kmalloc(length, GFP_KERNEL | GFP_DMA);
|
|
if (!buffer) {
|
|
ret = -ENOMEM;
|
|
goto _unlock;
|
|
}
|
|
|
|
/* got dead packet so it is always an error */
|
|
ret = spi_read(data->spi, buffer, length);
|
|
if (ret >= 0)
|
|
ret = -EPROTO;
|
|
|
|
kfree(buffer);
|
|
|
|
dev_err(SSP_DEV, "No match error %x\n",
|
|
msg_options);
|
|
|
|
goto _unlock;
|
|
}
|
|
|
|
if (msg_type == SSP_AP2HUB_READ)
|
|
ret = spi_read(data->spi,
|
|
&msg->buffer[SSP_HEADER_SIZE_ALIGNED],
|
|
msg->length);
|
|
|
|
if (msg_type == SSP_AP2HUB_WRITE) {
|
|
ret = spi_write(data->spi,
|
|
&msg->buffer[SSP_HEADER_SIZE_ALIGNED],
|
|
msg->length);
|
|
if (msg_options & SSP_AP2HUB_RETURN) {
|
|
msg->options =
|
|
SSP_AP2HUB_READ | SSP_AP2HUB_RETURN;
|
|
msg->length = 1;
|
|
|
|
list_add_tail(&msg->list, &data->pending_list);
|
|
goto _unlock;
|
|
}
|
|
}
|
|
|
|
if (msg->done)
|
|
if (!completion_done(msg->done))
|
|
complete(msg->done);
|
|
_unlock:
|
|
mutex_unlock(&data->pending_lock);
|
|
break;
|
|
case SSP_HUB2AP_WRITE:
|
|
buffer = kzalloc(length, GFP_KERNEL | GFP_DMA);
|
|
if (!buffer)
|
|
return -ENOMEM;
|
|
|
|
ret = spi_read(data->spi, buffer, length);
|
|
if (ret < 0) {
|
|
dev_err(SSP_DEV, "spi read fail\n");
|
|
kfree(buffer);
|
|
break;
|
|
}
|
|
|
|
ret = ssp_parse_dataframe(data, buffer, length);
|
|
|
|
kfree(buffer);
|
|
break;
|
|
|
|
default:
|
|
dev_err(SSP_DEV, "unknown msg type\n");
|
|
return -EPROTO;
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
void ssp_clean_pending_list(struct ssp_data *data)
|
|
{
|
|
struct ssp_msg *msg, *n;
|
|
|
|
mutex_lock(&data->pending_lock);
|
|
list_for_each_entry_safe(msg, n, &data->pending_list, list) {
|
|
list_del(&msg->list);
|
|
|
|
if (msg->done)
|
|
if (!completion_done(msg->done))
|
|
complete(msg->done);
|
|
}
|
|
mutex_unlock(&data->pending_lock);
|
|
}
|
|
|
|
int ssp_command(struct ssp_data *data, char command, int arg)
|
|
{
|
|
int ret;
|
|
struct ssp_msg *msg;
|
|
|
|
msg = ssp_create_msg(command, 0, SSP_AP2HUB_WRITE, arg);
|
|
if (!msg)
|
|
return -ENOMEM;
|
|
|
|
ssp_dbg("%s - command 0x%x %d\n", __func__, command, arg);
|
|
|
|
ret = ssp_spi_sync_command(data, msg);
|
|
ssp_clean_msg(msg);
|
|
|
|
return ret;
|
|
}
|
|
|
|
int ssp_send_instruction(struct ssp_data *data, u8 inst, u8 sensor_type,
|
|
u8 *send_buf, u8 length)
|
|
{
|
|
int ret;
|
|
struct ssp_msg *msg;
|
|
|
|
if (data->fw_dl_state == SSP_FW_DL_STATE_DOWNLOADING) {
|
|
dev_err(SSP_DEV, "%s - Skip Inst! DL state = %d\n",
|
|
__func__, data->fw_dl_state);
|
|
return -EBUSY;
|
|
} else if (!(data->available_sensors & BIT(sensor_type)) &&
|
|
(inst <= SSP_MSG2SSP_INST_CHANGE_DELAY)) {
|
|
dev_err(SSP_DEV, "%s - Bypass Inst Skip! - %u\n",
|
|
__func__, sensor_type);
|
|
return -EIO; /* just fail */
|
|
}
|
|
|
|
msg = ssp_create_msg(inst, length + 2, SSP_AP2HUB_WRITE, 0);
|
|
if (!msg)
|
|
return -ENOMEM;
|
|
|
|
ssp_fill_buffer(msg, 0, &sensor_type, 1);
|
|
ssp_fill_buffer(msg, 1, send_buf, length);
|
|
|
|
ssp_dbg("%s - Inst = 0x%x, Sensor Type = 0x%x, data = %u\n",
|
|
__func__, inst, sensor_type, send_buf[1]);
|
|
|
|
ret = ssp_spi_sync(data, msg, 1000);
|
|
ssp_clean_msg(msg);
|
|
|
|
return ret;
|
|
}
|
|
|
|
int ssp_get_chipid(struct ssp_data *data)
|
|
{
|
|
int ret;
|
|
char buffer;
|
|
struct ssp_msg *msg;
|
|
|
|
msg = ssp_create_msg(SSP_MSG2SSP_AP_WHOAMI, 1, SSP_AP2HUB_READ, 0);
|
|
if (!msg)
|
|
return -ENOMEM;
|
|
|
|
ret = ssp_spi_sync(data, msg, 1000);
|
|
|
|
buffer = SSP_GET_BUFFER_AT_INDEX(msg, 0);
|
|
|
|
ssp_clean_msg(msg);
|
|
|
|
return ret < 0 ? ret : buffer;
|
|
}
|
|
|
|
int ssp_set_magnetic_matrix(struct ssp_data *data)
|
|
{
|
|
int ret;
|
|
struct ssp_msg *msg;
|
|
|
|
msg = ssp_create_msg(SSP_MSG2SSP_AP_SET_MAGNETIC_STATIC_MATRIX,
|
|
data->sensorhub_info->mag_length, SSP_AP2HUB_WRITE,
|
|
0);
|
|
if (!msg)
|
|
return -ENOMEM;
|
|
|
|
ssp_fill_buffer(msg, 0, data->sensorhub_info->mag_table,
|
|
data->sensorhub_info->mag_length);
|
|
|
|
ret = ssp_spi_sync(data, msg, 1000);
|
|
ssp_clean_msg(msg);
|
|
|
|
return ret;
|
|
}
|
|
|
|
unsigned int ssp_get_sensor_scanning_info(struct ssp_data *data)
|
|
{
|
|
int ret;
|
|
__le32 result;
|
|
u32 cpu_result = 0;
|
|
|
|
struct ssp_msg *msg = ssp_create_msg(SSP_MSG2SSP_AP_SENSOR_SCANNING, 4,
|
|
SSP_AP2HUB_READ, 0);
|
|
if (!msg)
|
|
return 0;
|
|
|
|
ret = ssp_spi_sync(data, msg, 1000);
|
|
if (ret < 0) {
|
|
dev_err(SSP_DEV, "%s - spi read fail %d\n", __func__, ret);
|
|
goto _exit;
|
|
}
|
|
|
|
ssp_get_buffer(msg, 0, &result, 4);
|
|
cpu_result = le32_to_cpu(result);
|
|
|
|
dev_info(SSP_DEV, "%s state: 0x%08x\n", __func__, cpu_result);
|
|
|
|
_exit:
|
|
ssp_clean_msg(msg);
|
|
return cpu_result;
|
|
}
|
|
|
|
unsigned int ssp_get_firmware_rev(struct ssp_data *data)
|
|
{
|
|
int ret;
|
|
__le32 result;
|
|
|
|
struct ssp_msg *msg = ssp_create_msg(SSP_MSG2SSP_AP_FIRMWARE_REV, 4,
|
|
SSP_AP2HUB_READ, 0);
|
|
if (!msg)
|
|
return SSP_INVALID_REVISION;
|
|
|
|
ret = ssp_spi_sync(data, msg, 1000);
|
|
if (ret < 0) {
|
|
dev_err(SSP_DEV, "%s - transfer fail %d\n", __func__, ret);
|
|
ret = SSP_INVALID_REVISION;
|
|
goto _exit;
|
|
}
|
|
|
|
ssp_get_buffer(msg, 0, &result, 4);
|
|
ret = le32_to_cpu(result);
|
|
|
|
_exit:
|
|
ssp_clean_msg(msg);
|
|
return ret;
|
|
}
|