common/siano/smscoreapi.c

0001 // SPDX-License-Identifier: GPL-2.0-only
0002 /*
0003  *  Siano core API module
0004  *
0005  *  This file contains implementation for the interface to sms core component
0006  *
0007  *  author: Uri Shkolnik
0008  *
0009  *  Copyright (c), 2005-2008 Siano Mobile Silicon, Inc.
0010  */
0011
0012 #include "smscoreapi.h"
0013
0014 #include <linux/kernel.h>
0015 #include <linux/init.h>
0016 #include <linux/module.h>
0017 #include <linux/moduleparam.h>
0018 #include <linux/dma-mapping.h>
0019 #include <linux/delay.h>
0020 #include <linux/io.h>
0021 #include <linux/slab.h>
0022
0023 #include <linux/firmware.h>
0024 #include <linux/wait.h>
0025 #include <asm/byteorder.h>
0026
0027 #include "sms-cards.h"
0028 #include "smsir.h"
0029
0030 struct smscore_device_notifyee_t {
0031     struct list_head entry;
0032     hotplug_t hotplug;
0033 };
0034
0035 struct smscore_idlist_t {
0036     struct list_head entry;
0037     int     id;
0038     int     data_type;
0039 };
0040
0041 struct smscore_client_t {
0042     struct list_head entry;
0043     struct smscore_device_t *coredev;
0044     void            *context;
0045     struct list_head    idlist;
0046     onresponse_t        onresponse_handler;
0047     onremove_t      onremove_handler;
0048 };
0049
0050 static char *siano_msgs[] = {
0051     [MSG_TYPE_BASE_VAL                           - MSG_TYPE_BASE_VAL] = "MSG_TYPE_BASE_VAL",
0052     [MSG_SMS_GET_VERSION_REQ                     - MSG_TYPE_BASE_VAL] = "MSG_SMS_GET_VERSION_REQ",
0053     [MSG_SMS_GET_VERSION_RES                     - MSG_TYPE_BASE_VAL] = "MSG_SMS_GET_VERSION_RES",
0054     [MSG_SMS_MULTI_BRIDGE_CFG                    - MSG_TYPE_BASE_VAL] = "MSG_SMS_MULTI_BRIDGE_CFG",
0055     [MSG_SMS_GPIO_CONFIG_REQ                     - MSG_TYPE_BASE_VAL] = "MSG_SMS_GPIO_CONFIG_REQ",
0056     [MSG_SMS_GPIO_CONFIG_RES                     - MSG_TYPE_BASE_VAL] = "MSG_SMS_GPIO_CONFIG_RES",
0057     [MSG_SMS_GPIO_SET_LEVEL_REQ                  - MSG_TYPE_BASE_VAL] = "MSG_SMS_GPIO_SET_LEVEL_REQ",
0058     [MSG_SMS_GPIO_SET_LEVEL_RES                  - MSG_TYPE_BASE_VAL] = "MSG_SMS_GPIO_SET_LEVEL_RES",
0059     [MSG_SMS_GPIO_GET_LEVEL_REQ                  - MSG_TYPE_BASE_VAL] = "MSG_SMS_GPIO_GET_LEVEL_REQ",
0060     [MSG_SMS_GPIO_GET_LEVEL_RES                  - MSG_TYPE_BASE_VAL] = "MSG_SMS_GPIO_GET_LEVEL_RES",
0061     [MSG_SMS_EEPROM_BURN_IND                     - MSG_TYPE_BASE_VAL] = "MSG_SMS_EEPROM_BURN_IND",
0062     [MSG_SMS_LOG_ENABLE_CHANGE_REQ               - MSG_TYPE_BASE_VAL] = "MSG_SMS_LOG_ENABLE_CHANGE_REQ",
0063     [MSG_SMS_LOG_ENABLE_CHANGE_RES               - MSG_TYPE_BASE_VAL] = "MSG_SMS_LOG_ENABLE_CHANGE_RES",
0064     [MSG_SMS_SET_MAX_TX_MSG_LEN_REQ              - MSG_TYPE_BASE_VAL] = "MSG_SMS_SET_MAX_TX_MSG_LEN_REQ",
0065     [MSG_SMS_SET_MAX_TX_MSG_LEN_RES              - MSG_TYPE_BASE_VAL] = "MSG_SMS_SET_MAX_TX_MSG_LEN_RES",
0066     [MSG_SMS_SPI_HALFDUPLEX_TOKEN_HOST_TO_DEVICE - MSG_TYPE_BASE_VAL] = "MSG_SMS_SPI_HALFDUPLEX_TOKEN_HOST_TO_DEVICE",
0067     [MSG_SMS_SPI_HALFDUPLEX_TOKEN_DEVICE_TO_HOST - MSG_TYPE_BASE_VAL] = "MSG_SMS_SPI_HALFDUPLEX_TOKEN_DEVICE_TO_HOST",
0068     [MSG_SMS_BACKGROUND_SCAN_FLAG_CHANGE_REQ     - MSG_TYPE_BASE_VAL] = "MSG_SMS_BACKGROUND_SCAN_FLAG_CHANGE_REQ",
0069     [MSG_SMS_BACKGROUND_SCAN_FLAG_CHANGE_RES     - MSG_TYPE_BASE_VAL] = "MSG_SMS_BACKGROUND_SCAN_FLAG_CHANGE_RES",
0070     [MSG_SMS_BACKGROUND_SCAN_SIGNAL_DETECTED_IND - MSG_TYPE_BASE_VAL] = "MSG_SMS_BACKGROUND_SCAN_SIGNAL_DETECTED_IND",
0071     [MSG_SMS_BACKGROUND_SCAN_NO_SIGNAL_IND       - MSG_TYPE_BASE_VAL] = "MSG_SMS_BACKGROUND_SCAN_NO_SIGNAL_IND",
0072     [MSG_SMS_CONFIGURE_RF_SWITCH_REQ             - MSG_TYPE_BASE_VAL] = "MSG_SMS_CONFIGURE_RF_SWITCH_REQ",
0073     [MSG_SMS_CONFIGURE_RF_SWITCH_RES             - MSG_TYPE_BASE_VAL] = "MSG_SMS_CONFIGURE_RF_SWITCH_RES",
0074     [MSG_SMS_MRC_PATH_DISCONNECT_REQ             - MSG_TYPE_BASE_VAL] = "MSG_SMS_MRC_PATH_DISCONNECT_REQ",
0075     [MSG_SMS_MRC_PATH_DISCONNECT_RES             - MSG_TYPE_BASE_VAL] = "MSG_SMS_MRC_PATH_DISCONNECT_RES",
0076     [MSG_SMS_RECEIVE_1SEG_THROUGH_FULLSEG_REQ    - MSG_TYPE_BASE_VAL] = "MSG_SMS_RECEIVE_1SEG_THROUGH_FULLSEG_REQ",
0077     [MSG_SMS_RECEIVE_1SEG_THROUGH_FULLSEG_RES    - MSG_TYPE_BASE_VAL] = "MSG_SMS_RECEIVE_1SEG_THROUGH_FULLSEG_RES",
0078     [MSG_SMS_RECEIVE_VHF_VIA_VHF_INPUT_REQ       - MSG_TYPE_BASE_VAL] = "MSG_SMS_RECEIVE_VHF_VIA_VHF_INPUT_REQ",
0079     [MSG_SMS_RECEIVE_VHF_VIA_VHF_INPUT_RES       - MSG_TYPE_BASE_VAL] = "MSG_SMS_RECEIVE_VHF_VIA_VHF_INPUT_RES",
0080     [MSG_WR_REG_RFT_REQ                          - MSG_TYPE_BASE_VAL] = "MSG_WR_REG_RFT_REQ",
0081     [MSG_WR_REG_RFT_RES                          - MSG_TYPE_BASE_VAL] = "MSG_WR_REG_RFT_RES",
0082     [MSG_RD_REG_RFT_REQ                          - MSG_TYPE_BASE_VAL] = "MSG_RD_REG_RFT_REQ",
0083     [MSG_RD_REG_RFT_RES                          - MSG_TYPE_BASE_VAL] = "MSG_RD_REG_RFT_RES",
0084     [MSG_RD_REG_ALL_RFT_REQ                      - MSG_TYPE_BASE_VAL] = "MSG_RD_REG_ALL_RFT_REQ",
0085     [MSG_RD_REG_ALL_RFT_RES                      - MSG_TYPE_BASE_VAL] = "MSG_RD_REG_ALL_RFT_RES",
0086     [MSG_HELP_INT                                - MSG_TYPE_BASE_VAL] = "MSG_HELP_INT",
0087     [MSG_RUN_SCRIPT_INT                          - MSG_TYPE_BASE_VAL] = "MSG_RUN_SCRIPT_INT",
0088     [MSG_SMS_EWS_INBAND_REQ                      - MSG_TYPE_BASE_VAL] = "MSG_SMS_EWS_INBAND_REQ",
0089     [MSG_SMS_EWS_INBAND_RES                      - MSG_TYPE_BASE_VAL] = "MSG_SMS_EWS_INBAND_RES",
0090     [MSG_SMS_RFS_SELECT_REQ                      - MSG_TYPE_BASE_VAL] = "MSG_SMS_RFS_SELECT_REQ",
0091     [MSG_SMS_RFS_SELECT_RES                      - MSG_TYPE_BASE_VAL] = "MSG_SMS_RFS_SELECT_RES",
0092     [MSG_SMS_MB_GET_VER_REQ                      - MSG_TYPE_BASE_VAL] = "MSG_SMS_MB_GET_VER_REQ",
0093     [MSG_SMS_MB_GET_VER_RES                      - MSG_TYPE_BASE_VAL] = "MSG_SMS_MB_GET_VER_RES",
0094     [MSG_SMS_MB_WRITE_CFGFILE_REQ                - MSG_TYPE_BASE_VAL] = "MSG_SMS_MB_WRITE_CFGFILE_REQ",
0095     [MSG_SMS_MB_WRITE_CFGFILE_RES                - MSG_TYPE_BASE_VAL] = "MSG_SMS_MB_WRITE_CFGFILE_RES",
0096     [MSG_SMS_MB_READ_CFGFILE_REQ                 - MSG_TYPE_BASE_VAL] = "MSG_SMS_MB_READ_CFGFILE_REQ",
0097     [MSG_SMS_MB_READ_CFGFILE_RES                 - MSG_TYPE_BASE_VAL] = "MSG_SMS_MB_READ_CFGFILE_RES",
0098     [MSG_SMS_RD_MEM_REQ                          - MSG_TYPE_BASE_VAL] = "MSG_SMS_RD_MEM_REQ",
0099     [MSG_SMS_RD_MEM_RES                          - MSG_TYPE_BASE_VAL] = "MSG_SMS_RD_MEM_RES",
0100     [MSG_SMS_WR_MEM_REQ                          - MSG_TYPE_BASE_VAL] = "MSG_SMS_WR_MEM_REQ",
0101     [MSG_SMS_WR_MEM_RES                          - MSG_TYPE_BASE_VAL] = "MSG_SMS_WR_MEM_RES",
0102     [MSG_SMS_UPDATE_MEM_REQ                      - MSG_TYPE_BASE_VAL] = "MSG_SMS_UPDATE_MEM_REQ",
0103     [MSG_SMS_UPDATE_MEM_RES                      - MSG_TYPE_BASE_VAL] = "MSG_SMS_UPDATE_MEM_RES",
0104     [MSG_SMS_ISDBT_ENABLE_FULL_PARAMS_SET_REQ    - MSG_TYPE_BASE_VAL] = "MSG_SMS_ISDBT_ENABLE_FULL_PARAMS_SET_REQ",
0105     [MSG_SMS_ISDBT_ENABLE_FULL_PARAMS_SET_RES    - MSG_TYPE_BASE_VAL] = "MSG_SMS_ISDBT_ENABLE_FULL_PARAMS_SET_RES",
0106     [MSG_SMS_RF_TUNE_REQ                         - MSG_TYPE_BASE_VAL] = "MSG_SMS_RF_TUNE_REQ",
0107     [MSG_SMS_RF_TUNE_RES                         - MSG_TYPE_BASE_VAL] = "MSG_SMS_RF_TUNE_RES",
0108     [MSG_SMS_ISDBT_ENABLE_HIGH_MOBILITY_REQ      - MSG_TYPE_BASE_VAL] = "MSG_SMS_ISDBT_ENABLE_HIGH_MOBILITY_REQ",
0109     [MSG_SMS_ISDBT_ENABLE_HIGH_MOBILITY_RES      - MSG_TYPE_BASE_VAL] = "MSG_SMS_ISDBT_ENABLE_HIGH_MOBILITY_RES",
0110     [MSG_SMS_ISDBT_SB_RECEPTION_REQ              - MSG_TYPE_BASE_VAL] = "MSG_SMS_ISDBT_SB_RECEPTION_REQ",
0111     [MSG_SMS_ISDBT_SB_RECEPTION_RES              - MSG_TYPE_BASE_VAL] = "MSG_SMS_ISDBT_SB_RECEPTION_RES",
0112     [MSG_SMS_GENERIC_EPROM_WRITE_REQ             - MSG_TYPE_BASE_VAL] = "MSG_SMS_GENERIC_EPROM_WRITE_REQ",
0113     [MSG_SMS_GENERIC_EPROM_WRITE_RES             - MSG_TYPE_BASE_VAL] = "MSG_SMS_GENERIC_EPROM_WRITE_RES",
0114     [MSG_SMS_GENERIC_EPROM_READ_REQ              - MSG_TYPE_BASE_VAL] = "MSG_SMS_GENERIC_EPROM_READ_REQ",
0115     [MSG_SMS_GENERIC_EPROM_READ_RES              - MSG_TYPE_BASE_VAL] = "MSG_SMS_GENERIC_EPROM_READ_RES",
0116     [MSG_SMS_EEPROM_WRITE_REQ                    - MSG_TYPE_BASE_VAL] = "MSG_SMS_EEPROM_WRITE_REQ",
0117     [MSG_SMS_EEPROM_WRITE_RES                    - MSG_TYPE_BASE_VAL] = "MSG_SMS_EEPROM_WRITE_RES",
0118     [MSG_SMS_CUSTOM_READ_REQ                     - MSG_TYPE_BASE_VAL] = "MSG_SMS_CUSTOM_READ_REQ",
0119     [MSG_SMS_CUSTOM_READ_RES                     - MSG_TYPE_BASE_VAL] = "MSG_SMS_CUSTOM_READ_RES",
0120     [MSG_SMS_CUSTOM_WRITE_REQ                    - MSG_TYPE_BASE_VAL] = "MSG_SMS_CUSTOM_WRITE_REQ",
0121     [MSG_SMS_CUSTOM_WRITE_RES                    - MSG_TYPE_BASE_VAL] = "MSG_SMS_CUSTOM_WRITE_RES",
0122     [MSG_SMS_INIT_DEVICE_REQ                     - MSG_TYPE_BASE_VAL] = "MSG_SMS_INIT_DEVICE_REQ",
0123     [MSG_SMS_INIT_DEVICE_RES                     - MSG_TYPE_BASE_VAL] = "MSG_SMS_INIT_DEVICE_RES",
0124     [MSG_SMS_ATSC_SET_ALL_IP_REQ                 - MSG_TYPE_BASE_VAL] = "MSG_SMS_ATSC_SET_ALL_IP_REQ",
0125     [MSG_SMS_ATSC_SET_ALL_IP_RES                 - MSG_TYPE_BASE_VAL] = "MSG_SMS_ATSC_SET_ALL_IP_RES",
0126     [MSG_SMS_ATSC_START_ENSEMBLE_REQ             - MSG_TYPE_BASE_VAL] = "MSG_SMS_ATSC_START_ENSEMBLE_REQ",
0127     [MSG_SMS_ATSC_START_ENSEMBLE_RES             - MSG_TYPE_BASE_VAL] = "MSG_SMS_ATSC_START_ENSEMBLE_RES",
0128     [MSG_SMS_SET_OUTPUT_MODE_REQ                 - MSG_TYPE_BASE_VAL] = "MSG_SMS_SET_OUTPUT_MODE_REQ",
0129     [MSG_SMS_SET_OUTPUT_MODE_RES                 - MSG_TYPE_BASE_VAL] = "MSG_SMS_SET_OUTPUT_MODE_RES",
0130     [MSG_SMS_ATSC_IP_FILTER_GET_LIST_REQ         - MSG_TYPE_BASE_VAL] = "MSG_SMS_ATSC_IP_FILTER_GET_LIST_REQ",
0131     [MSG_SMS_ATSC_IP_FILTER_GET_LIST_RES         - MSG_TYPE_BASE_VAL] = "MSG_SMS_ATSC_IP_FILTER_GET_LIST_RES",
0132     [MSG_SMS_SUB_CHANNEL_START_REQ               - MSG_TYPE_BASE_VAL] = "MSG_SMS_SUB_CHANNEL_START_REQ",
0133     [MSG_SMS_SUB_CHANNEL_START_RES               - MSG_TYPE_BASE_VAL] = "MSG_SMS_SUB_CHANNEL_START_RES",
0134     [MSG_SMS_SUB_CHANNEL_STOP_REQ                - MSG_TYPE_BASE_VAL] = "MSG_SMS_SUB_CHANNEL_STOP_REQ",
0135     [MSG_SMS_SUB_CHANNEL_STOP_RES                - MSG_TYPE_BASE_VAL] = "MSG_SMS_SUB_CHANNEL_STOP_RES",
0136     [MSG_SMS_ATSC_IP_FILTER_ADD_REQ              - MSG_TYPE_BASE_VAL] = "MSG_SMS_ATSC_IP_FILTER_ADD_REQ",
0137     [MSG_SMS_ATSC_IP_FILTER_ADD_RES              - MSG_TYPE_BASE_VAL] = "MSG_SMS_ATSC_IP_FILTER_ADD_RES",
0138     [MSG_SMS_ATSC_IP_FILTER_REMOVE_REQ           - MSG_TYPE_BASE_VAL] = "MSG_SMS_ATSC_IP_FILTER_REMOVE_REQ",
0139     [MSG_SMS_ATSC_IP_FILTER_REMOVE_RES           - MSG_TYPE_BASE_VAL] = "MSG_SMS_ATSC_IP_FILTER_REMOVE_RES",
0140     [MSG_SMS_ATSC_IP_FILTER_REMOVE_ALL_REQ       - MSG_TYPE_BASE_VAL] = "MSG_SMS_ATSC_IP_FILTER_REMOVE_ALL_REQ",
0141     [MSG_SMS_ATSC_IP_FILTER_REMOVE_ALL_RES       - MSG_TYPE_BASE_VAL] = "MSG_SMS_ATSC_IP_FILTER_REMOVE_ALL_RES",
0142     [MSG_SMS_WAIT_CMD                            - MSG_TYPE_BASE_VAL] = "MSG_SMS_WAIT_CMD",
0143     [MSG_SMS_ADD_PID_FILTER_REQ                  - MSG_TYPE_BASE_VAL] = "MSG_SMS_ADD_PID_FILTER_REQ",
0144     [MSG_SMS_ADD_PID_FILTER_RES                  - MSG_TYPE_BASE_VAL] = "MSG_SMS_ADD_PID_FILTER_RES",
0145     [MSG_SMS_REMOVE_PID_FILTER_REQ               - MSG_TYPE_BASE_VAL] = "MSG_SMS_REMOVE_PID_FILTER_REQ",
0146     [MSG_SMS_REMOVE_PID_FILTER_RES               - MSG_TYPE_BASE_VAL] = "MSG_SMS_REMOVE_PID_FILTER_RES",
0147     [MSG_SMS_FAST_INFORMATION_CHANNEL_REQ        - MSG_TYPE_BASE_VAL] = "MSG_SMS_FAST_INFORMATION_CHANNEL_REQ",
0148     [MSG_SMS_FAST_INFORMATION_CHANNEL_RES        - MSG_TYPE_BASE_VAL] = "MSG_SMS_FAST_INFORMATION_CHANNEL_RES",
0149     [MSG_SMS_DAB_CHANNEL                         - MSG_TYPE_BASE_VAL] = "MSG_SMS_DAB_CHANNEL",
0150     [MSG_SMS_GET_PID_FILTER_LIST_REQ             - MSG_TYPE_BASE_VAL] = "MSG_SMS_GET_PID_FILTER_LIST_REQ",
0151     [MSG_SMS_GET_PID_FILTER_LIST_RES             - MSG_TYPE_BASE_VAL] = "MSG_SMS_GET_PID_FILTER_LIST_RES",
0152     [MSG_SMS_POWER_DOWN_REQ                      - MSG_TYPE_BASE_VAL] = "MSG_SMS_POWER_DOWN_REQ",
0153     [MSG_SMS_POWER_DOWN_RES                      - MSG_TYPE_BASE_VAL] = "MSG_SMS_POWER_DOWN_RES",
0154     [MSG_SMS_ATSC_SLT_EXIST_IND                  - MSG_TYPE_BASE_VAL] = "MSG_SMS_ATSC_SLT_EXIST_IND",
0155     [MSG_SMS_ATSC_NO_SLT_IND                     - MSG_TYPE_BASE_VAL] = "MSG_SMS_ATSC_NO_SLT_IND",
0156     [MSG_SMS_GET_STATISTICS_REQ                  - MSG_TYPE_BASE_VAL] = "MSG_SMS_GET_STATISTICS_REQ",
0157     [MSG_SMS_GET_STATISTICS_RES                  - MSG_TYPE_BASE_VAL] = "MSG_SMS_GET_STATISTICS_RES",
0158     [MSG_SMS_SEND_DUMP                           - MSG_TYPE_BASE_VAL] = "MSG_SMS_SEND_DUMP",
0159     [MSG_SMS_SCAN_START_REQ                      - MSG_TYPE_BASE_VAL] = "MSG_SMS_SCAN_START_REQ",
0160     [MSG_SMS_SCAN_START_RES                      - MSG_TYPE_BASE_VAL] = "MSG_SMS_SCAN_START_RES",
0161     [MSG_SMS_SCAN_STOP_REQ                       - MSG_TYPE_BASE_VAL] = "MSG_SMS_SCAN_STOP_REQ",
0162     [MSG_SMS_SCAN_STOP_RES                       - MSG_TYPE_BASE_VAL] = "MSG_SMS_SCAN_STOP_RES",
0163     [MSG_SMS_SCAN_PROGRESS_IND                   - MSG_TYPE_BASE_VAL] = "MSG_SMS_SCAN_PROGRESS_IND",
0164     [MSG_SMS_SCAN_COMPLETE_IND                   - MSG_TYPE_BASE_VAL] = "MSG_SMS_SCAN_COMPLETE_IND",
0165     [MSG_SMS_LOG_ITEM                            - MSG_TYPE_BASE_VAL] = "MSG_SMS_LOG_ITEM",
0166     [MSG_SMS_DAB_SUBCHANNEL_RECONFIG_REQ         - MSG_TYPE_BASE_VAL] = "MSG_SMS_DAB_SUBCHANNEL_RECONFIG_REQ",
0167     [MSG_SMS_DAB_SUBCHANNEL_RECONFIG_RES         - MSG_TYPE_BASE_VAL] = "MSG_SMS_DAB_SUBCHANNEL_RECONFIG_RES",
0168     [MSG_SMS_HO_PER_SLICES_IND                   - MSG_TYPE_BASE_VAL] = "MSG_SMS_HO_PER_SLICES_IND",
0169     [MSG_SMS_HO_INBAND_POWER_IND                 - MSG_TYPE_BASE_VAL] = "MSG_SMS_HO_INBAND_POWER_IND",
0170     [MSG_SMS_MANUAL_DEMOD_REQ                    - MSG_TYPE_BASE_VAL] = "MSG_SMS_MANUAL_DEMOD_REQ",
0171     [MSG_SMS_HO_TUNE_ON_REQ                      - MSG_TYPE_BASE_VAL] = "MSG_SMS_HO_TUNE_ON_REQ",
0172     [MSG_SMS_HO_TUNE_ON_RES                      - MSG_TYPE_BASE_VAL] = "MSG_SMS_HO_TUNE_ON_RES",
0173     [MSG_SMS_HO_TUNE_OFF_REQ                     - MSG_TYPE_BASE_VAL] = "MSG_SMS_HO_TUNE_OFF_REQ",
0174     [MSG_SMS_HO_TUNE_OFF_RES                     - MSG_TYPE_BASE_VAL] = "MSG_SMS_HO_TUNE_OFF_RES",
0175     [MSG_SMS_HO_PEEK_FREQ_REQ                    - MSG_TYPE_BASE_VAL] = "MSG_SMS_HO_PEEK_FREQ_REQ",
0176     [MSG_SMS_HO_PEEK_FREQ_RES                    - MSG_TYPE_BASE_VAL] = "MSG_SMS_HO_PEEK_FREQ_RES",
0177     [MSG_SMS_HO_PEEK_FREQ_IND                    - MSG_TYPE_BASE_VAL] = "MSG_SMS_HO_PEEK_FREQ_IND",
0178     [MSG_SMS_MB_ATTEN_SET_REQ                    - MSG_TYPE_BASE_VAL] = "MSG_SMS_MB_ATTEN_SET_REQ",
0179     [MSG_SMS_MB_ATTEN_SET_RES                    - MSG_TYPE_BASE_VAL] = "MSG_SMS_MB_ATTEN_SET_RES",
0180     [MSG_SMS_ENABLE_STAT_IN_I2C_REQ              - MSG_TYPE_BASE_VAL] = "MSG_SMS_ENABLE_STAT_IN_I2C_REQ",
0181     [MSG_SMS_ENABLE_STAT_IN_I2C_RES              - MSG_TYPE_BASE_VAL] = "MSG_SMS_ENABLE_STAT_IN_I2C_RES",
0182     [MSG_SMS_SET_ANTENNA_CONFIG_REQ              - MSG_TYPE_BASE_VAL] = "MSG_SMS_SET_ANTENNA_CONFIG_REQ",
0183     [MSG_SMS_SET_ANTENNA_CONFIG_RES              - MSG_TYPE_BASE_VAL] = "MSG_SMS_SET_ANTENNA_CONFIG_RES",
0184     [MSG_SMS_GET_STATISTICS_EX_REQ               - MSG_TYPE_BASE_VAL] = "MSG_SMS_GET_STATISTICS_EX_REQ",
0185     [MSG_SMS_GET_STATISTICS_EX_RES               - MSG_TYPE_BASE_VAL] = "MSG_SMS_GET_STATISTICS_EX_RES",
0186     [MSG_SMS_SLEEP_RESUME_COMP_IND               - MSG_TYPE_BASE_VAL] = "MSG_SMS_SLEEP_RESUME_COMP_IND",
0187     [MSG_SMS_SWITCH_HOST_INTERFACE_REQ           - MSG_TYPE_BASE_VAL] = "MSG_SMS_SWITCH_HOST_INTERFACE_REQ",
0188     [MSG_SMS_SWITCH_HOST_INTERFACE_RES           - MSG_TYPE_BASE_VAL] = "MSG_SMS_SWITCH_HOST_INTERFACE_RES",
0189     [MSG_SMS_DATA_DOWNLOAD_REQ                   - MSG_TYPE_BASE_VAL] = "MSG_SMS_DATA_DOWNLOAD_REQ",
0190     [MSG_SMS_DATA_DOWNLOAD_RES                   - MSG_TYPE_BASE_VAL] = "MSG_SMS_DATA_DOWNLOAD_RES",
0191     [MSG_SMS_DATA_VALIDITY_REQ                   - MSG_TYPE_BASE_VAL] = "MSG_SMS_DATA_VALIDITY_REQ",
0192     [MSG_SMS_DATA_VALIDITY_RES                   - MSG_TYPE_BASE_VAL] = "MSG_SMS_DATA_VALIDITY_RES",
0193     [MSG_SMS_SWDOWNLOAD_TRIGGER_REQ              - MSG_TYPE_BASE_VAL] = "MSG_SMS_SWDOWNLOAD_TRIGGER_REQ",
0194     [MSG_SMS_SWDOWNLOAD_TRIGGER_RES              - MSG_TYPE_BASE_VAL] = "MSG_SMS_SWDOWNLOAD_TRIGGER_RES",
0195     [MSG_SMS_SWDOWNLOAD_BACKDOOR_REQ             - MSG_TYPE_BASE_VAL] = "MSG_SMS_SWDOWNLOAD_BACKDOOR_REQ",
0196     [MSG_SMS_SWDOWNLOAD_BACKDOOR_RES             - MSG_TYPE_BASE_VAL] = "MSG_SMS_SWDOWNLOAD_BACKDOOR_RES",
0197     [MSG_SMS_GET_VERSION_EX_REQ                  - MSG_TYPE_BASE_VAL] = "MSG_SMS_GET_VERSION_EX_REQ",
0198     [MSG_SMS_GET_VERSION_EX_RES                  - MSG_TYPE_BASE_VAL] = "MSG_SMS_GET_VERSION_EX_RES",
0199     [MSG_SMS_CLOCK_OUTPUT_CONFIG_REQ             - MSG_TYPE_BASE_VAL] = "MSG_SMS_CLOCK_OUTPUT_CONFIG_REQ",
0200     [MSG_SMS_CLOCK_OUTPUT_CONFIG_RES             - MSG_TYPE_BASE_VAL] = "MSG_SMS_CLOCK_OUTPUT_CONFIG_RES",
0201     [MSG_SMS_I2C_SET_FREQ_REQ                    - MSG_TYPE_BASE_VAL] = "MSG_SMS_I2C_SET_FREQ_REQ",
0202     [MSG_SMS_I2C_SET_FREQ_RES                    - MSG_TYPE_BASE_VAL] = "MSG_SMS_I2C_SET_FREQ_RES",
0203     [MSG_SMS_GENERIC_I2C_REQ                     - MSG_TYPE_BASE_VAL] = "MSG_SMS_GENERIC_I2C_REQ",
0204     [MSG_SMS_GENERIC_I2C_RES                     - MSG_TYPE_BASE_VAL] = "MSG_SMS_GENERIC_I2C_RES",
0205     [MSG_SMS_DVBT_BDA_DATA                       - MSG_TYPE_BASE_VAL] = "MSG_SMS_DVBT_BDA_DATA",
0206     [MSG_SW_RELOAD_REQ                           - MSG_TYPE_BASE_VAL] = "MSG_SW_RELOAD_REQ",
0207     [MSG_SMS_DATA_MSG                            - MSG_TYPE_BASE_VAL] = "MSG_SMS_DATA_MSG",
0208     [MSG_TABLE_UPLOAD_REQ                        - MSG_TYPE_BASE_VAL] = "MSG_TABLE_UPLOAD_REQ",
0209     [MSG_TABLE_UPLOAD_RES                        - MSG_TYPE_BASE_VAL] = "MSG_TABLE_UPLOAD_RES",
0210     [MSG_SW_RELOAD_START_REQ                     - MSG_TYPE_BASE_VAL] = "MSG_SW_RELOAD_START_REQ",
0211     [MSG_SW_RELOAD_START_RES                     - MSG_TYPE_BASE_VAL] = "MSG_SW_RELOAD_START_RES",
0212     [MSG_SW_RELOAD_EXEC_REQ                      - MSG_TYPE_BASE_VAL] = "MSG_SW_RELOAD_EXEC_REQ",
0213     [MSG_SW_RELOAD_EXEC_RES                      - MSG_TYPE_BASE_VAL] = "MSG_SW_RELOAD_EXEC_RES",
0214     [MSG_SMS_SPI_INT_LINE_SET_REQ                - MSG_TYPE_BASE_VAL] = "MSG_SMS_SPI_INT_LINE_SET_REQ",
0215     [MSG_SMS_SPI_INT_LINE_SET_RES                - MSG_TYPE_BASE_VAL] = "MSG_SMS_SPI_INT_LINE_SET_RES",
0216     [MSG_SMS_GPIO_CONFIG_EX_REQ                  - MSG_TYPE_BASE_VAL] = "MSG_SMS_GPIO_CONFIG_EX_REQ",
0217     [MSG_SMS_GPIO_CONFIG_EX_RES                  - MSG_TYPE_BASE_VAL] = "MSG_SMS_GPIO_CONFIG_EX_RES",
0218     [MSG_SMS_WATCHDOG_ACT_REQ                    - MSG_TYPE_BASE_VAL] = "MSG_SMS_WATCHDOG_ACT_REQ",
0219     [MSG_SMS_WATCHDOG_ACT_RES                    - MSG_TYPE_BASE_VAL] = "MSG_SMS_WATCHDOG_ACT_RES",
0220     [MSG_SMS_LOOPBACK_REQ                        - MSG_TYPE_BASE_VAL] = "MSG_SMS_LOOPBACK_REQ",
0221     [MSG_SMS_LOOPBACK_RES                        - MSG_TYPE_BASE_VAL] = "MSG_SMS_LOOPBACK_RES",
0222     [MSG_SMS_RAW_CAPTURE_START_REQ               - MSG_TYPE_BASE_VAL] = "MSG_SMS_RAW_CAPTURE_START_REQ",
0223     [MSG_SMS_RAW_CAPTURE_START_RES               - MSG_TYPE_BASE_VAL] = "MSG_SMS_RAW_CAPTURE_START_RES",
0224     [MSG_SMS_RAW_CAPTURE_ABORT_REQ               - MSG_TYPE_BASE_VAL] = "MSG_SMS_RAW_CAPTURE_ABORT_REQ",
0225     [MSG_SMS_RAW_CAPTURE_ABORT_RES               - MSG_TYPE_BASE_VAL] = "MSG_SMS_RAW_CAPTURE_ABORT_RES",
0226     [MSG_SMS_RAW_CAPTURE_COMPLETE_IND            - MSG_TYPE_BASE_VAL] = "MSG_SMS_RAW_CAPTURE_COMPLETE_IND",
0227     [MSG_SMS_DATA_PUMP_IND                       - MSG_TYPE_BASE_VAL] = "MSG_SMS_DATA_PUMP_IND",
0228     [MSG_SMS_DATA_PUMP_REQ                       - MSG_TYPE_BASE_VAL] = "MSG_SMS_DATA_PUMP_REQ",
0229     [MSG_SMS_DATA_PUMP_RES                       - MSG_TYPE_BASE_VAL] = "MSG_SMS_DATA_PUMP_RES",
0230     [MSG_SMS_FLASH_DL_REQ                        - MSG_TYPE_BASE_VAL] = "MSG_SMS_FLASH_DL_REQ",
0231     [MSG_SMS_EXEC_TEST_1_REQ                     - MSG_TYPE_BASE_VAL] = "MSG_SMS_EXEC_TEST_1_REQ",
0232     [MSG_SMS_EXEC_TEST_1_RES                     - MSG_TYPE_BASE_VAL] = "MSG_SMS_EXEC_TEST_1_RES",
0233     [MSG_SMS_ENABLE_TS_INTERFACE_REQ             - MSG_TYPE_BASE_VAL] = "MSG_SMS_ENABLE_TS_INTERFACE_REQ",
0234     [MSG_SMS_ENABLE_TS_INTERFACE_RES             - MSG_TYPE_BASE_VAL] = "MSG_SMS_ENABLE_TS_INTERFACE_RES",
0235     [MSG_SMS_SPI_SET_BUS_WIDTH_REQ               - MSG_TYPE_BASE_VAL] = "MSG_SMS_SPI_SET_BUS_WIDTH_REQ",
0236     [MSG_SMS_SPI_SET_BUS_WIDTH_RES               - MSG_TYPE_BASE_VAL] = "MSG_SMS_SPI_SET_BUS_WIDTH_RES",
0237     [MSG_SMS_SEND_EMM_REQ                        - MSG_TYPE_BASE_VAL] = "MSG_SMS_SEND_EMM_REQ",
0238     [MSG_SMS_SEND_EMM_RES                        - MSG_TYPE_BASE_VAL] = "MSG_SMS_SEND_EMM_RES",
0239     [MSG_SMS_DISABLE_TS_INTERFACE_REQ            - MSG_TYPE_BASE_VAL] = "MSG_SMS_DISABLE_TS_INTERFACE_REQ",
0240     [MSG_SMS_DISABLE_TS_INTERFACE_RES            - MSG_TYPE_BASE_VAL] = "MSG_SMS_DISABLE_TS_INTERFACE_RES",
0241     [MSG_SMS_IS_BUF_FREE_REQ                     - MSG_TYPE_BASE_VAL] = "MSG_SMS_IS_BUF_FREE_REQ",
0242     [MSG_SMS_IS_BUF_FREE_RES                     - MSG_TYPE_BASE_VAL] = "MSG_SMS_IS_BUF_FREE_RES",
0243     [MSG_SMS_EXT_ANTENNA_REQ                     - MSG_TYPE_BASE_VAL] = "MSG_SMS_EXT_ANTENNA_REQ",
0244     [MSG_SMS_EXT_ANTENNA_RES                     - MSG_TYPE_BASE_VAL] = "MSG_SMS_EXT_ANTENNA_RES",
0245     [MSG_SMS_CMMB_GET_NET_OF_FREQ_REQ_OBSOLETE   - MSG_TYPE_BASE_VAL] = "MSG_SMS_CMMB_GET_NET_OF_FREQ_REQ_OBSOLETE",
0246     [MSG_SMS_CMMB_GET_NET_OF_FREQ_RES_OBSOLETE   - MSG_TYPE_BASE_VAL] = "MSG_SMS_CMMB_GET_NET_OF_FREQ_RES_OBSOLETE",
0247     [MSG_SMS_BATTERY_LEVEL_REQ                   - MSG_TYPE_BASE_VAL] = "MSG_SMS_BATTERY_LEVEL_REQ",
0248     [MSG_SMS_BATTERY_LEVEL_RES                   - MSG_TYPE_BASE_VAL] = "MSG_SMS_BATTERY_LEVEL_RES",
0249     [MSG_SMS_CMMB_INJECT_TABLE_REQ_OBSOLETE      - MSG_TYPE_BASE_VAL] = "MSG_SMS_CMMB_INJECT_TABLE_REQ_OBSOLETE",
0250     [MSG_SMS_CMMB_INJECT_TABLE_RES_OBSOLETE      - MSG_TYPE_BASE_VAL] = "MSG_SMS_CMMB_INJECT_TABLE_RES_OBSOLETE",
0251     [MSG_SMS_FM_RADIO_BLOCK_IND                  - MSG_TYPE_BASE_VAL] = "MSG_SMS_FM_RADIO_BLOCK_IND",
0252     [MSG_SMS_HOST_NOTIFICATION_IND               - MSG_TYPE_BASE_VAL] = "MSG_SMS_HOST_NOTIFICATION_IND",
0253     [MSG_SMS_CMMB_GET_CONTROL_TABLE_REQ_OBSOLETE - MSG_TYPE_BASE_VAL] = "MSG_SMS_CMMB_GET_CONTROL_TABLE_REQ_OBSOLETE",
0254     [MSG_SMS_CMMB_GET_CONTROL_TABLE_RES_OBSOLETE - MSG_TYPE_BASE_VAL] = "MSG_SMS_CMMB_GET_CONTROL_TABLE_RES_OBSOLETE",
0255     [MSG_SMS_CMMB_GET_NETWORKS_REQ               - MSG_TYPE_BASE_VAL] = "MSG_SMS_CMMB_GET_NETWORKS_REQ",
0256     [MSG_SMS_CMMB_GET_NETWORKS_RES               - MSG_TYPE_BASE_VAL] = "MSG_SMS_CMMB_GET_NETWORKS_RES",
0257     [MSG_SMS_CMMB_START_SERVICE_REQ              - MSG_TYPE_BASE_VAL] = "MSG_SMS_CMMB_START_SERVICE_REQ",
0258     [MSG_SMS_CMMB_START_SERVICE_RES              - MSG_TYPE_BASE_VAL] = "MSG_SMS_CMMB_START_SERVICE_RES",
0259     [MSG_SMS_CMMB_STOP_SERVICE_REQ               - MSG_TYPE_BASE_VAL] = "MSG_SMS_CMMB_STOP_SERVICE_REQ",
0260     [MSG_SMS_CMMB_STOP_SERVICE_RES               - MSG_TYPE_BASE_VAL] = "MSG_SMS_CMMB_STOP_SERVICE_RES",
0261     [MSG_SMS_CMMB_ADD_CHANNEL_FILTER_REQ         - MSG_TYPE_BASE_VAL] = "MSG_SMS_CMMB_ADD_CHANNEL_FILTER_REQ",
0262     [MSG_SMS_CMMB_ADD_CHANNEL_FILTER_RES         - MSG_TYPE_BASE_VAL] = "MSG_SMS_CMMB_ADD_CHANNEL_FILTER_RES",
0263     [MSG_SMS_CMMB_REMOVE_CHANNEL_FILTER_REQ      - MSG_TYPE_BASE_VAL] = "MSG_SMS_CMMB_REMOVE_CHANNEL_FILTER_REQ",
0264     [MSG_SMS_CMMB_REMOVE_CHANNEL_FILTER_RES      - MSG_TYPE_BASE_VAL] = "MSG_SMS_CMMB_REMOVE_CHANNEL_FILTER_RES",
0265     [MSG_SMS_CMMB_START_CONTROL_INFO_REQ         - MSG_TYPE_BASE_VAL] = "MSG_SMS_CMMB_START_CONTROL_INFO_REQ",
0266     [MSG_SMS_CMMB_START_CONTROL_INFO_RES         - MSG_TYPE_BASE_VAL] = "MSG_SMS_CMMB_START_CONTROL_INFO_RES",
0267     [MSG_SMS_CMMB_STOP_CONTROL_INFO_REQ          - MSG_TYPE_BASE_VAL] = "MSG_SMS_CMMB_STOP_CONTROL_INFO_REQ",
0268     [MSG_SMS_CMMB_STOP_CONTROL_INFO_RES          - MSG_TYPE_BASE_VAL] = "MSG_SMS_CMMB_STOP_CONTROL_INFO_RES",
0269     [MSG_SMS_ISDBT_TUNE_REQ                      - MSG_TYPE_BASE_VAL] = "MSG_SMS_ISDBT_TUNE_REQ",
0270     [MSG_SMS_ISDBT_TUNE_RES                      - MSG_TYPE_BASE_VAL] = "MSG_SMS_ISDBT_TUNE_RES",
0271     [MSG_SMS_TRANSMISSION_IND                    - MSG_TYPE_BASE_VAL] = "MSG_SMS_TRANSMISSION_IND",
0272     [MSG_SMS_PID_STATISTICS_IND                  - MSG_TYPE_BASE_VAL] = "MSG_SMS_PID_STATISTICS_IND",
0273     [MSG_SMS_POWER_DOWN_IND                      - MSG_TYPE_BASE_VAL] = "MSG_SMS_POWER_DOWN_IND",
0274     [MSG_SMS_POWER_DOWN_CONF                     - MSG_TYPE_BASE_VAL] = "MSG_SMS_POWER_DOWN_CONF",
0275     [MSG_SMS_POWER_UP_IND                        - MSG_TYPE_BASE_VAL] = "MSG_SMS_POWER_UP_IND",
0276     [MSG_SMS_POWER_UP_CONF                       - MSG_TYPE_BASE_VAL] = "MSG_SMS_POWER_UP_CONF",
0277     [MSG_SMS_POWER_MODE_SET_REQ                  - MSG_TYPE_BASE_VAL] = "MSG_SMS_POWER_MODE_SET_REQ",
0278     [MSG_SMS_POWER_MODE_SET_RES                  - MSG_TYPE_BASE_VAL] = "MSG_SMS_POWER_MODE_SET_RES",
0279     [MSG_SMS_DEBUG_HOST_EVENT_REQ                - MSG_TYPE_BASE_VAL] = "MSG_SMS_DEBUG_HOST_EVENT_REQ",
0280     [MSG_SMS_DEBUG_HOST_EVENT_RES                - MSG_TYPE_BASE_VAL] = "MSG_SMS_DEBUG_HOST_EVENT_RES",
0281     [MSG_SMS_NEW_CRYSTAL_REQ                     - MSG_TYPE_BASE_VAL] = "MSG_SMS_NEW_CRYSTAL_REQ",
0282     [MSG_SMS_NEW_CRYSTAL_RES                     - MSG_TYPE_BASE_VAL] = "MSG_SMS_NEW_CRYSTAL_RES",
0283     [MSG_SMS_CONFIG_SPI_REQ                      - MSG_TYPE_BASE_VAL] = "MSG_SMS_CONFIG_SPI_REQ",
0284     [MSG_SMS_CONFIG_SPI_RES                      - MSG_TYPE_BASE_VAL] = "MSG_SMS_CONFIG_SPI_RES",
0285     [MSG_SMS_I2C_SHORT_STAT_IND                  - MSG_TYPE_BASE_VAL] = "MSG_SMS_I2C_SHORT_STAT_IND",
0286     [MSG_SMS_START_IR_REQ                        - MSG_TYPE_BASE_VAL] = "MSG_SMS_START_IR_REQ",
0287     [MSG_SMS_START_IR_RES                        - MSG_TYPE_BASE_VAL] = "MSG_SMS_START_IR_RES",
0288     [MSG_SMS_IR_SAMPLES_IND                      - MSG_TYPE_BASE_VAL] = "MSG_SMS_IR_SAMPLES_IND",
0289     [MSG_SMS_CMMB_CA_SERVICE_IND                 - MSG_TYPE_BASE_VAL] = "MSG_SMS_CMMB_CA_SERVICE_IND",
0290     [MSG_SMS_SLAVE_DEVICE_DETECTED               - MSG_TYPE_BASE_VAL] = "MSG_SMS_SLAVE_DEVICE_DETECTED",
0291     [MSG_SMS_INTERFACE_LOCK_IND                  - MSG_TYPE_BASE_VAL] = "MSG_SMS_INTERFACE_LOCK_IND",
0292     [MSG_SMS_INTERFACE_UNLOCK_IND                - MSG_TYPE_BASE_VAL] = "MSG_SMS_INTERFACE_UNLOCK_IND",
0293     [MSG_SMS_SEND_ROSUM_BUFF_REQ                 - MSG_TYPE_BASE_VAL] = "MSG_SMS_SEND_ROSUM_BUFF_REQ",
0294     [MSG_SMS_SEND_ROSUM_BUFF_RES                 - MSG_TYPE_BASE_VAL] = "MSG_SMS_SEND_ROSUM_BUFF_RES",
0295     [MSG_SMS_ROSUM_BUFF                          - MSG_TYPE_BASE_VAL] = "MSG_SMS_ROSUM_BUFF",
0296     [MSG_SMS_SET_AES128_KEY_REQ                  - MSG_TYPE_BASE_VAL] = "MSG_SMS_SET_AES128_KEY_REQ",
0297     [MSG_SMS_SET_AES128_KEY_RES                  - MSG_TYPE_BASE_VAL] = "MSG_SMS_SET_AES128_KEY_RES",
0298     [MSG_SMS_MBBMS_WRITE_REQ                     - MSG_TYPE_BASE_VAL] = "MSG_SMS_MBBMS_WRITE_REQ",
0299     [MSG_SMS_MBBMS_WRITE_RES                     - MSG_TYPE_BASE_VAL] = "MSG_SMS_MBBMS_WRITE_RES",
0300     [MSG_SMS_MBBMS_READ_IND                      - MSG_TYPE_BASE_VAL] = "MSG_SMS_MBBMS_READ_IND",
0301     [MSG_SMS_IQ_STREAM_START_REQ                 - MSG_TYPE_BASE_VAL] = "MSG_SMS_IQ_STREAM_START_REQ",
0302     [MSG_SMS_IQ_STREAM_START_RES                 - MSG_TYPE_BASE_VAL] = "MSG_SMS_IQ_STREAM_START_RES",
0303     [MSG_SMS_IQ_STREAM_STOP_REQ                  - MSG_TYPE_BASE_VAL] = "MSG_SMS_IQ_STREAM_STOP_REQ",
0304     [MSG_SMS_IQ_STREAM_STOP_RES                  - MSG_TYPE_BASE_VAL] = "MSG_SMS_IQ_STREAM_STOP_RES",
0305     [MSG_SMS_IQ_STREAM_DATA_BLOCK                - MSG_TYPE_BASE_VAL] = "MSG_SMS_IQ_STREAM_DATA_BLOCK",
0306     [MSG_SMS_GET_EEPROM_VERSION_REQ              - MSG_TYPE_BASE_VAL] = "MSG_SMS_GET_EEPROM_VERSION_REQ",
0307     [MSG_SMS_GET_EEPROM_VERSION_RES              - MSG_TYPE_BASE_VAL] = "MSG_SMS_GET_EEPROM_VERSION_RES",
0308     [MSG_SMS_SIGNAL_DETECTED_IND                 - MSG_TYPE_BASE_VAL] = "MSG_SMS_SIGNAL_DETECTED_IND",
0309     [MSG_SMS_NO_SIGNAL_IND                       - MSG_TYPE_BASE_VAL] = "MSG_SMS_NO_SIGNAL_IND",
0310     [MSG_SMS_MRC_SHUTDOWN_SLAVE_REQ              - MSG_TYPE_BASE_VAL] = "MSG_SMS_MRC_SHUTDOWN_SLAVE_REQ",
0311     [MSG_SMS_MRC_SHUTDOWN_SLAVE_RES              - MSG_TYPE_BASE_VAL] = "MSG_SMS_MRC_SHUTDOWN_SLAVE_RES",
0312     [MSG_SMS_MRC_BRINGUP_SLAVE_REQ               - MSG_TYPE_BASE_VAL] = "MSG_SMS_MRC_BRINGUP_SLAVE_REQ",
0313     [MSG_SMS_MRC_BRINGUP_SLAVE_RES               - MSG_TYPE_BASE_VAL] = "MSG_SMS_MRC_BRINGUP_SLAVE_RES",
0314     [MSG_SMS_EXTERNAL_LNA_CTRL_REQ               - MSG_TYPE_BASE_VAL] = "MSG_SMS_EXTERNAL_LNA_CTRL_REQ",
0315     [MSG_SMS_EXTERNAL_LNA_CTRL_RES               - MSG_TYPE_BASE_VAL] = "MSG_SMS_EXTERNAL_LNA_CTRL_RES",
0316     [MSG_SMS_SET_PERIODIC_STATISTICS_REQ         - MSG_TYPE_BASE_VAL] = "MSG_SMS_SET_PERIODIC_STATISTICS_REQ",
0317     [MSG_SMS_SET_PERIODIC_STATISTICS_RES         - MSG_TYPE_BASE_VAL] = "MSG_SMS_SET_PERIODIC_STATISTICS_RES",
0318     [MSG_SMS_CMMB_SET_AUTO_OUTPUT_TS0_REQ        - MSG_TYPE_BASE_VAL] = "MSG_SMS_CMMB_SET_AUTO_OUTPUT_TS0_REQ",
0319     [MSG_SMS_CMMB_SET_AUTO_OUTPUT_TS0_RES        - MSG_TYPE_BASE_VAL] = "MSG_SMS_CMMB_SET_AUTO_OUTPUT_TS0_RES",
0320     [LOCAL_TUNE                                  - MSG_TYPE_BASE_VAL] = "LOCAL_TUNE",
0321     [LOCAL_IFFT_H_ICI                            - MSG_TYPE_BASE_VAL] = "LOCAL_IFFT_H_ICI",
0322     [MSG_RESYNC_REQ                              - MSG_TYPE_BASE_VAL] = "MSG_RESYNC_REQ",
0323     [MSG_SMS_CMMB_GET_MRC_STATISTICS_REQ         - MSG_TYPE_BASE_VAL] = "MSG_SMS_CMMB_GET_MRC_STATISTICS_REQ",
0324     [MSG_SMS_CMMB_GET_MRC_STATISTICS_RES         - MSG_TYPE_BASE_VAL] = "MSG_SMS_CMMB_GET_MRC_STATISTICS_RES",
0325     [MSG_SMS_LOG_EX_ITEM                         - MSG_TYPE_BASE_VAL] = "MSG_SMS_LOG_EX_ITEM",
0326     [MSG_SMS_DEVICE_DATA_LOSS_IND                - MSG_TYPE_BASE_VAL] = "MSG_SMS_DEVICE_DATA_LOSS_IND",
0327     [MSG_SMS_MRC_WATCHDOG_TRIGGERED_IND          - MSG_TYPE_BASE_VAL] = "MSG_SMS_MRC_WATCHDOG_TRIGGERED_IND",
0328     [MSG_SMS_USER_MSG_REQ                        - MSG_TYPE_BASE_VAL] = "MSG_SMS_USER_MSG_REQ",
0329     [MSG_SMS_USER_MSG_RES                        - MSG_TYPE_BASE_VAL] = "MSG_SMS_USER_MSG_RES",
0330     [MSG_SMS_SMART_CARD_INIT_REQ                 - MSG_TYPE_BASE_VAL] = "MSG_SMS_SMART_CARD_INIT_REQ",
0331     [MSG_SMS_SMART_CARD_INIT_RES                 - MSG_TYPE_BASE_VAL] = "MSG_SMS_SMART_CARD_INIT_RES",
0332     [MSG_SMS_SMART_CARD_WRITE_REQ                - MSG_TYPE_BASE_VAL] = "MSG_SMS_SMART_CARD_WRITE_REQ",
0333     [MSG_SMS_SMART_CARD_WRITE_RES                - MSG_TYPE_BASE_VAL] = "MSG_SMS_SMART_CARD_WRITE_RES",
0334     [MSG_SMS_SMART_CARD_READ_IND                 - MSG_TYPE_BASE_VAL] = "MSG_SMS_SMART_CARD_READ_IND",
0335     [MSG_SMS_TSE_ENABLE_REQ                      - MSG_TYPE_BASE_VAL] = "MSG_SMS_TSE_ENABLE_REQ",
0336     [MSG_SMS_TSE_ENABLE_RES                      - MSG_TYPE_BASE_VAL] = "MSG_SMS_TSE_ENABLE_RES",
0337     [MSG_SMS_CMMB_GET_SHORT_STATISTICS_REQ       - MSG_TYPE_BASE_VAL] = "MSG_SMS_CMMB_GET_SHORT_STATISTICS_REQ",
0338     [MSG_SMS_CMMB_GET_SHORT_STATISTICS_RES       - MSG_TYPE_BASE_VAL] = "MSG_SMS_CMMB_GET_SHORT_STATISTICS_RES",
0339     [MSG_SMS_LED_CONFIG_REQ                      - MSG_TYPE_BASE_VAL] = "MSG_SMS_LED_CONFIG_REQ",
0340     [MSG_SMS_LED_CONFIG_RES                      - MSG_TYPE_BASE_VAL] = "MSG_SMS_LED_CONFIG_RES",
0341     [MSG_PWM_ANTENNA_REQ                         - MSG_TYPE_BASE_VAL] = "MSG_PWM_ANTENNA_REQ",
0342     [MSG_PWM_ANTENNA_RES                         - MSG_TYPE_BASE_VAL] = "MSG_PWM_ANTENNA_RES",
0343     [MSG_SMS_CMMB_SMD_SN_REQ                     - MSG_TYPE_BASE_VAL] = "MSG_SMS_CMMB_SMD_SN_REQ",
0344     [MSG_SMS_CMMB_SMD_SN_RES                     - MSG_TYPE_BASE_VAL] = "MSG_SMS_CMMB_SMD_SN_RES",
0345     [MSG_SMS_CMMB_SET_CA_CW_REQ                  - MSG_TYPE_BASE_VAL] = "MSG_SMS_CMMB_SET_CA_CW_REQ",
0346     [MSG_SMS_CMMB_SET_CA_CW_RES                  - MSG_TYPE_BASE_VAL] = "MSG_SMS_CMMB_SET_CA_CW_RES",
0347     [MSG_SMS_CMMB_SET_CA_SALT_REQ                - MSG_TYPE_BASE_VAL] = "MSG_SMS_CMMB_SET_CA_SALT_REQ",
0348     [MSG_SMS_CMMB_SET_CA_SALT_RES                - MSG_TYPE_BASE_VAL] = "MSG_SMS_CMMB_SET_CA_SALT_RES",
0349     [MSG_SMS_NSCD_INIT_REQ                       - MSG_TYPE_BASE_VAL] = "MSG_SMS_NSCD_INIT_REQ",
0350     [MSG_SMS_NSCD_INIT_RES                       - MSG_TYPE_BASE_VAL] = "MSG_SMS_NSCD_INIT_RES",
0351     [MSG_SMS_NSCD_PROCESS_SECTION_REQ            - MSG_TYPE_BASE_VAL] = "MSG_SMS_NSCD_PROCESS_SECTION_REQ",
0352     [MSG_SMS_NSCD_PROCESS_SECTION_RES            - MSG_TYPE_BASE_VAL] = "MSG_SMS_NSCD_PROCESS_SECTION_RES",
0353     [MSG_SMS_DBD_CREATE_OBJECT_REQ               - MSG_TYPE_BASE_VAL] = "MSG_SMS_DBD_CREATE_OBJECT_REQ",
0354     [MSG_SMS_DBD_CREATE_OBJECT_RES               - MSG_TYPE_BASE_VAL] = "MSG_SMS_DBD_CREATE_OBJECT_RES",
0355     [MSG_SMS_DBD_CONFIGURE_REQ                   - MSG_TYPE_BASE_VAL] = "MSG_SMS_DBD_CONFIGURE_REQ",
0356     [MSG_SMS_DBD_CONFIGURE_RES                   - MSG_TYPE_BASE_VAL] = "MSG_SMS_DBD_CONFIGURE_RES",
0357     [MSG_SMS_DBD_SET_KEYS_REQ                    - MSG_TYPE_BASE_VAL] = "MSG_SMS_DBD_SET_KEYS_REQ",
0358     [MSG_SMS_DBD_SET_KEYS_RES                    - MSG_TYPE_BASE_VAL] = "MSG_SMS_DBD_SET_KEYS_RES",
0359     [MSG_SMS_DBD_PROCESS_HEADER_REQ              - MSG_TYPE_BASE_VAL] = "MSG_SMS_DBD_PROCESS_HEADER_REQ",
0360     [MSG_SMS_DBD_PROCESS_HEADER_RES              - MSG_TYPE_BASE_VAL] = "MSG_SMS_DBD_PROCESS_HEADER_RES",
0361     [MSG_SMS_DBD_PROCESS_DATA_REQ                - MSG_TYPE_BASE_VAL] = "MSG_SMS_DBD_PROCESS_DATA_REQ",
0362     [MSG_SMS_DBD_PROCESS_DATA_RES                - MSG_TYPE_BASE_VAL] = "MSG_SMS_DBD_PROCESS_DATA_RES",
0363     [MSG_SMS_DBD_PROCESS_GET_DATA_REQ            - MSG_TYPE_BASE_VAL] = "MSG_SMS_DBD_PROCESS_GET_DATA_REQ",
0364     [MSG_SMS_DBD_PROCESS_GET_DATA_RES            - MSG_TYPE_BASE_VAL] = "MSG_SMS_DBD_PROCESS_GET_DATA_RES",
0365     [MSG_SMS_NSCD_OPEN_SESSION_REQ               - MSG_TYPE_BASE_VAL] = "MSG_SMS_NSCD_OPEN_SESSION_REQ",
0366     [MSG_SMS_NSCD_OPEN_SESSION_RES               - MSG_TYPE_BASE_VAL] = "MSG_SMS_NSCD_OPEN_SESSION_RES",
0367     [MSG_SMS_SEND_HOST_DATA_TO_DEMUX_REQ         - MSG_TYPE_BASE_VAL] = "MSG_SMS_SEND_HOST_DATA_TO_DEMUX_REQ",
0368     [MSG_SMS_SEND_HOST_DATA_TO_DEMUX_RES         - MSG_TYPE_BASE_VAL] = "MSG_SMS_SEND_HOST_DATA_TO_DEMUX_RES",
0369     [MSG_LAST_MSG_TYPE                           - MSG_TYPE_BASE_VAL] = "MSG_LAST_MSG_TYPE",
0370 };
0371
0372 char *smscore_translate_msg(enum msg_types msgtype)
0373 {
0374     int i = msgtype - MSG_TYPE_BASE_VAL;
0375     char *msg;
0376
0377     if (i < 0 || i >= ARRAY_SIZE(siano_msgs))
0378         return "Unknown msg type";
0379
0380     msg = siano_msgs[i];
0381
0382     if (!*msg)
0383         return "Unknown msg type";
0384
0385     return msg;
0386 }
0387 EXPORT_SYMBOL_GPL(smscore_translate_msg);
0388
0389 void smscore_set_board_id(struct smscore_device_t *core, int id)
0390 {
0391     core->board_id = id;
0392 }
0393
0394 int smscore_led_state(struct smscore_device_t *core, int led)
0395 {
0396     if (led >= 0)
0397         core->led_state = led;
0398     return core->led_state;
0399 }
0400 EXPORT_SYMBOL_GPL(smscore_set_board_id);
0401
0402 int smscore_get_board_id(struct smscore_device_t *core)
0403 {
0404     return core->board_id;
0405 }
0406 EXPORT_SYMBOL_GPL(smscore_get_board_id);
0407
0408 struct smscore_registry_entry_t {
0409     struct list_head entry;
0410     char devpath[32];
0411     int mode;
0412     enum sms_device_type_st type;
0413 };
0414
0415 static struct list_head g_smscore_notifyees;
0416 static struct list_head g_smscore_devices;
0417 static DEFINE_MUTEX(g_smscore_deviceslock);
0418
0419 static struct list_head g_smscore_registry;
0420 static DEFINE_MUTEX(g_smscore_registrylock);
0421
0422 static int default_mode = DEVICE_MODE_NONE;
0423
0424 module_param(default_mode, int, 0644);
0425 MODULE_PARM_DESC(default_mode, "default firmware id (device mode)");
0426
0427 static struct smscore_registry_entry_t *smscore_find_registry(char *devpath)
0428 {
0429     struct smscore_registry_entry_t *entry;
0430     struct list_head *next;
0431
0432     mutex_lock(&g_smscore_registrylock);
0433     for (next = g_smscore_registry.next;
0434          next != &g_smscore_registry;
0435          next = next->next) {
0436         entry = (struct smscore_registry_entry_t *) next;
0437         if (!strncmp(entry->devpath, devpath, sizeof(entry->devpath))) {
0438             mutex_unlock(&g_smscore_registrylock);
0439             return entry;
0440         }
0441     }
0442     entry = kmalloc(sizeof(*entry), GFP_KERNEL);
0443     if (entry) {
0444         entry->mode = default_mode;
0445         strscpy(entry->devpath, devpath, sizeof(entry->devpath));
0446         list_add(&entry->entry, &g_smscore_registry);
0447     } else
0448         pr_err("failed to create smscore_registry.\n");
0449     mutex_unlock(&g_smscore_registrylock);
0450     return entry;
0451 }
0452
0453 int smscore_registry_getmode(char *devpath)
0454 {
0455     struct smscore_registry_entry_t *entry;
0456
0457     entry = smscore_find_registry(devpath);
0458     if (entry)
0459         return entry->mode;
0460     else
0461         pr_err("No registry found.\n");
0462
0463     return default_mode;
0464 }
0465 EXPORT_SYMBOL_GPL(smscore_registry_getmode);
0466
0467 static enum sms_device_type_st smscore_registry_gettype(char *devpath)
0468 {
0469     struct smscore_registry_entry_t *entry;
0470
0471     entry = smscore_find_registry(devpath);
0472     if (entry)
0473         return entry->type;
0474     else
0475         pr_err("No registry found.\n");
0476
0477     return -EINVAL;
0478 }
0479
0480 static void smscore_registry_setmode(char *devpath, int mode)
0481 {
0482     struct smscore_registry_entry_t *entry;
0483
0484     entry = smscore_find_registry(devpath);
0485     if (entry)
0486         entry->mode = mode;
0487     else
0488         pr_err("No registry found.\n");
0489 }
0490
0491 static void smscore_registry_settype(char *devpath,
0492                      enum sms_device_type_st type)
0493 {
0494     struct smscore_registry_entry_t *entry;
0495
0496     entry = smscore_find_registry(devpath);
0497     if (entry)
0498         entry->type = type;
0499     else
0500         pr_err("No registry found.\n");
0501 }
0502
0503
0504 static void list_add_locked(struct list_head *new, struct list_head *head,
0505                 spinlock_t *lock)
0506 {
0507     unsigned long flags;
0508
0509     spin_lock_irqsave(lock, flags);
0510
0511     list_add(new, head);
0512
0513     spin_unlock_irqrestore(lock, flags);
0514 }
0515
0516 /*
0517  * register a client callback that called when device plugged in/unplugged
0518  * NOTE: if devices exist callback is called immediately for each device
0519  *
0520  * @param hotplug callback
0521  *
0522  * return: 0 on success, <0 on error.
0523  */
0524 int smscore_register_hotplug(hotplug_t hotplug)
0525 {
0526     struct smscore_device_notifyee_t *notifyee;
0527     struct list_head *next, *first;
0528     int rc = 0;
0529
0530     mutex_lock(&g_smscore_deviceslock);
0531     notifyee = kmalloc(sizeof(*notifyee), GFP_KERNEL);
0532     if (notifyee) {
0533         /* now notify callback about existing devices */
0534         first = &g_smscore_devices;
0535         for (next = first->next;
0536              next != first && !rc;
0537              next = next->next) {
0538             struct smscore_device_t *coredev =
0539                 (struct smscore_device_t *) next;
0540             rc = hotplug(coredev, coredev->device, 1);
0541         }
0542
0543         if (rc >= 0) {
0544             notifyee->hotplug = hotplug;
0545             list_add(&notifyee->entry, &g_smscore_notifyees);
0546         } else
0547             kfree(notifyee);
0548     } else
0549         rc = -ENOMEM;
0550
0551     mutex_unlock(&g_smscore_deviceslock);
0552
0553     return rc;
0554 }
0555 EXPORT_SYMBOL_GPL(smscore_register_hotplug);
0556
0557 /*
0558  * unregister a client callback that called when device plugged in/unplugged
0559  *
0560  * @param hotplug callback
0561  *
0562  */
0563 void smscore_unregister_hotplug(hotplug_t hotplug)
0564 {
0565     struct list_head *next, *first;
0566
0567     mutex_lock(&g_smscore_deviceslock);
0568
0569     first = &g_smscore_notifyees;
0570
0571     for (next = first->next; next != first;) {
0572         struct smscore_device_notifyee_t *notifyee =
0573             (struct smscore_device_notifyee_t *) next;
0574         next = next->next;
0575
0576         if (notifyee->hotplug == hotplug) {
0577             list_del(&notifyee->entry);
0578             kfree(notifyee);
0579         }
0580     }
0581
0582     mutex_unlock(&g_smscore_deviceslock);
0583 }
0584 EXPORT_SYMBOL_GPL(smscore_unregister_hotplug);
0585
0586 static void smscore_notify_clients(struct smscore_device_t *coredev)
0587 {
0588     struct smscore_client_t *client;
0589
0590     /* the client must call smscore_unregister_client from remove handler */
0591     while (!list_empty(&coredev->clients)) {
0592         client = (struct smscore_client_t *) coredev->clients.next;
0593         client->onremove_handler(client->context);
0594     }
0595 }
0596
0597 static int smscore_notify_callbacks(struct smscore_device_t *coredev,
0598                     struct device *device, int arrival)
0599 {
0600     struct smscore_device_notifyee_t *elem;
0601     int rc = 0;
0602
0603     /* note: must be called under g_deviceslock */
0604
0605     list_for_each_entry(elem, &g_smscore_notifyees, entry) {
0606         rc = elem->hotplug(coredev, device, arrival);
0607         if (rc < 0)
0608             break;
0609     }
0610
0611     return rc;
0612 }
0613
0614 static struct
0615 smscore_buffer_t *smscore_createbuffer(u8 *buffer, void *common_buffer,
0616                        dma_addr_t common_buffer_phys)
0617 {
0618     struct smscore_buffer_t *cb;
0619
0620     cb = kzalloc(sizeof(*cb), GFP_KERNEL);
0621     if (!cb)
0622         return NULL;
0623
0624     cb->p = buffer;
0625     cb->offset_in_common = buffer - (u8 *) common_buffer;
0626     if (common_buffer_phys)
0627         cb->phys = common_buffer_phys + cb->offset_in_common;
0628
0629     return cb;
0630 }
0631
0632 /*
0633  * creates coredev object for a device, prepares buffers,
0634  * creates buffer mappings, notifies registered hotplugs about new device.
0635  *
0636  * @param params device pointer to struct with device specific parameters
0637  *               and handlers
0638  * @param coredev pointer to a value that receives created coredev object
0639  *
0640  * return: 0 on success, <0 on error.
0641  */
0642 int smscore_register_device(struct smsdevice_params_t *params,
0643                 struct smscore_device_t **coredev,
0644                 gfp_t gfp_buf_flags,
0645                 void *mdev)
0646 {
0647     struct smscore_device_t *dev;
0648     u8 *buffer;
0649
0650     dev = kzalloc(sizeof(*dev), GFP_KERNEL);
0651     if (!dev)
0652         return -ENOMEM;
0653
0654 #ifdef CONFIG_MEDIA_CONTROLLER_DVB
0655     dev->media_dev = mdev;
0656 #endif
0657     dev->gfp_buf_flags = gfp_buf_flags;
0658
0659     /* init list entry so it could be safe in smscore_unregister_device */
0660     INIT_LIST_HEAD(&dev->entry);
0661
0662     /* init queues */
0663     INIT_LIST_HEAD(&dev->clients);
0664     INIT_LIST_HEAD(&dev->buffers);
0665
0666     /* init locks */
0667     spin_lock_init(&dev->clientslock);
0668     spin_lock_init(&dev->bufferslock);
0669
0670     /* init completion events */
0671     init_completion(&dev->version_ex_done);
0672     init_completion(&dev->data_download_done);
0673     init_completion(&dev->data_validity_done);
0674     init_completion(&dev->trigger_done);
0675     init_completion(&dev->init_device_done);
0676     init_completion(&dev->reload_start_done);
0677     init_completion(&dev->resume_done);
0678     init_completion(&dev->gpio_configuration_done);
0679     init_completion(&dev->gpio_set_level_done);
0680     init_completion(&dev->gpio_get_level_done);
0681     init_completion(&dev->ir_init_done);
0682
0683     /* Buffer management */
0684     init_waitqueue_head(&dev->buffer_mng_waitq);
0685
0686     /* alloc common buffer */
0687     dev->common_buffer_size = params->buffer_size * params->num_buffers;
0688     if (params->usb_device)
0689         buffer = kzalloc(dev->common_buffer_size, GFP_KERNEL);
0690     else
0691         buffer = dma_alloc_coherent(params->device,
0692                         dev->common_buffer_size,
0693                         &dev->common_buffer_phys,
0694                         GFP_KERNEL | dev->gfp_buf_flags);
0695     if (!buffer) {
0696         smscore_unregister_device(dev);
0697         return -ENOMEM;
0698     }
0699     dev->common_buffer = buffer;
0700
0701     /* prepare dma buffers */
0702     for (; dev->num_buffers < params->num_buffers;
0703          dev->num_buffers++, buffer += params->buffer_size) {
0704         struct smscore_buffer_t *cb;
0705
0706         cb = smscore_createbuffer(buffer, dev->common_buffer,
0707                       dev->common_buffer_phys);
0708         if (!cb) {
0709             smscore_unregister_device(dev);
0710             return -ENOMEM;
0711         }
0712
0713         smscore_putbuffer(dev, cb);
0714     }
0715
0716     pr_debug("allocated %d buffers\n", dev->num_buffers);
0717
0718     dev->mode = DEVICE_MODE_NONE;
0719     dev->board_id = SMS_BOARD_UNKNOWN;
0720     dev->context = params->context;
0721     dev->device = params->device;
0722     dev->usb_device = params->usb_device;
0723     dev->setmode_handler = params->setmode_handler;
0724     dev->detectmode_handler = params->detectmode_handler;
0725     dev->sendrequest_handler = params->sendrequest_handler;
0726     dev->preload_handler = params->preload_handler;
0727     dev->postload_handler = params->postload_handler;
0728
0729     dev->device_flags = params->flags;
0730     strscpy(dev->devpath, params->devpath, sizeof(dev->devpath));
0731
0732     smscore_registry_settype(dev->devpath, params->device_type);
0733
0734     /* add device to devices list */
0735     mutex_lock(&g_smscore_deviceslock);
0736     list_add(&dev->entry, &g_smscore_devices);
0737     mutex_unlock(&g_smscore_deviceslock);
0738
0739     *coredev = dev;
0740
0741     pr_debug("device %p created\n", dev);
0742
0743     return 0;
0744 }
0745 EXPORT_SYMBOL_GPL(smscore_register_device);
0746
0747
0748 static int smscore_sendrequest_and_wait(struct smscore_device_t *coredev,
0749         void *buffer, size_t size, struct completion *completion) {
0750     int rc;
0751
0752     if (!completion)
0753         return -EINVAL;
0754     init_completion(completion);
0755
0756     rc = coredev->sendrequest_handler(coredev->context, buffer, size);
0757     if (rc < 0) {
0758         pr_info("sendrequest returned error %d\n", rc);
0759         return rc;
0760     }
0761
0762     return wait_for_completion_timeout(completion,
0763             msecs_to_jiffies(SMS_PROTOCOL_MAX_RAOUNDTRIP_MS)) ?
0764             0 : -ETIME;
0765 }
0766
0767 /*
0768  * Starts & enables IR operations
0769  *
0770  * return: 0 on success, < 0 on error.
0771  */
0772 static int smscore_init_ir(struct smscore_device_t *coredev)
0773 {
0774     int ir_io;
0775     int rc;
0776     void *buffer;
0777
0778     coredev->ir.dev = NULL;
0779     ir_io = sms_get_board(smscore_get_board_id(coredev))->board_cfg.ir;
0780     if (ir_io) {/* only if IR port exist we use IR sub-module */
0781         pr_debug("IR loading\n");
0782         rc = sms_ir_init(coredev);
0783
0784         if  (rc != 0)
0785             pr_err("Error initialization DTV IR sub-module\n");
0786         else {
0787             buffer = kmalloc(sizeof(struct sms_msg_data2) +
0788                         SMS_DMA_ALIGNMENT,
0789                         GFP_KERNEL | coredev->gfp_buf_flags);
0790             if (buffer) {
0791                 struct sms_msg_data2 *msg =
0792                 (struct sms_msg_data2 *)
0793                 SMS_ALIGN_ADDRESS(buffer);
0794
0795                 SMS_INIT_MSG(&msg->x_msg_header,
0796                         MSG_SMS_START_IR_REQ,
0797                         sizeof(struct sms_msg_data2));
0798                 msg->msg_data[0] = coredev->ir.controller;
0799                 msg->msg_data[1] = coredev->ir.timeout;
0800
0801                 rc = smscore_sendrequest_and_wait(coredev, msg,
0802                         msg->x_msg_header. msg_length,
0803                         &coredev->ir_init_done);
0804
0805                 kfree(buffer);
0806             } else
0807                 pr_err("Sending IR initialization message failed\n");
0808         }
0809     } else
0810         pr_info("IR port has not been detected\n");
0811
0812     return 0;
0813 }
0814
0815 /*
0816  * configures device features according to board configuration structure.
0817  *
0818  * @param coredev pointer to a coredev object returned by
0819  *                smscore_register_device
0820  *
0821  * return: 0 on success, <0 on error.
0822  */
0823 static int smscore_configure_board(struct smscore_device_t *coredev)
0824 {
0825     struct sms_board *board;
0826
0827     board = sms_get_board(coredev->board_id);
0828     if (!board) {
0829         pr_err("no board configuration exist.\n");
0830         return -EINVAL;
0831     }
0832
0833     if (board->mtu) {
0834         struct sms_msg_data mtu_msg;
0835         pr_debug("set max transmit unit %d\n", board->mtu);
0836
0837         mtu_msg.x_msg_header.msg_src_id = 0;
0838         mtu_msg.x_msg_header.msg_dst_id = HIF_TASK;
0839         mtu_msg.x_msg_header.msg_flags = 0;
0840         mtu_msg.x_msg_header.msg_type = MSG_SMS_SET_MAX_TX_MSG_LEN_REQ;
0841         mtu_msg.x_msg_header.msg_length = sizeof(mtu_msg);
0842         mtu_msg.msg_data[0] = board->mtu;
0843
0844         coredev->sendrequest_handler(coredev->context, &mtu_msg,
0845                          sizeof(mtu_msg));
0846     }
0847
0848     if (board->crystal) {
0849         struct sms_msg_data crys_msg;
0850         pr_debug("set crystal value %d\n", board->crystal);
0851
0852         SMS_INIT_MSG(&crys_msg.x_msg_header,
0853                 MSG_SMS_NEW_CRYSTAL_REQ,
0854                 sizeof(crys_msg));
0855         crys_msg.msg_data[0] = board->crystal;
0856
0857         coredev->sendrequest_handler(coredev->context, &crys_msg,
0858                          sizeof(crys_msg));
0859     }
0860
0861     return 0;
0862 }
0863
0864 /*
0865  * sets initial device mode and notifies client hotplugs that device is ready
0866  *
0867  * @param coredev pointer to a coredev object returned by
0868  *        smscore_register_device
0869  *
0870  * return: 0 on success, <0 on error.
0871  */
0872 int smscore_start_device(struct smscore_device_t *coredev)
0873 {
0874     int rc;
0875     int board_id = smscore_get_board_id(coredev);
0876     int mode = smscore_registry_getmode(coredev->devpath);
0877
0878     /* Device is initialized as DEVICE_MODE_NONE */
0879     if (board_id != SMS_BOARD_UNKNOWN && mode == DEVICE_MODE_NONE)
0880         mode = sms_get_board(board_id)->default_mode;
0881
0882     rc = smscore_set_device_mode(coredev, mode);
0883     if (rc < 0) {
0884         pr_info("set device mode failed , rc %d\n", rc);
0885         return rc;
0886     }
0887     rc = smscore_configure_board(coredev);
0888     if (rc < 0) {
0889         pr_info("configure board failed , rc %d\n", rc);
0890         return rc;
0891     }
0892
0893     mutex_lock(&g_smscore_deviceslock);
0894
0895     rc = smscore_notify_callbacks(coredev, coredev->device, 1);
0896     smscore_init_ir(coredev);
0897
0898     pr_debug("device %p started, rc %d\n", coredev, rc);
0899
0900     mutex_unlock(&g_smscore_deviceslock);
0901
0902     return rc;
0903 }
0904 EXPORT_SYMBOL_GPL(smscore_start_device);
0905
0906
0907 static int smscore_load_firmware_family2(struct smscore_device_t *coredev,
0908                      void *buffer, size_t size)
0909 {
0910     struct sms_firmware *firmware = (struct sms_firmware *) buffer;
0911     struct sms_msg_data5 *msg;
0912     u32 mem_address,  calc_checksum = 0;
0913     u32 i, *ptr;
0914     u8 *payload = firmware->payload;
0915     int rc = 0;
0916     firmware->start_address = le32_to_cpup((__le32 *)&firmware->start_address);
0917     firmware->length = le32_to_cpup((__le32 *)&firmware->length);
0918
0919     mem_address = firmware->start_address;
0920
0921     pr_debug("loading FW to addr 0x%x size %d\n",
0922          mem_address, firmware->length);
0923     if (coredev->preload_handler) {
0924         rc = coredev->preload_handler(coredev->context);
0925         if (rc < 0)
0926             return rc;
0927     }
0928
0929     /* PAGE_SIZE buffer shall be enough and dma aligned */
0930     msg = kmalloc(PAGE_SIZE, GFP_KERNEL | coredev->gfp_buf_flags);
0931     if (!msg)
0932         return -ENOMEM;
0933
0934     if (coredev->mode != DEVICE_MODE_NONE) {
0935         pr_debug("sending reload command.\n");
0936         SMS_INIT_MSG(&msg->x_msg_header, MSG_SW_RELOAD_START_REQ,
0937                  sizeof(struct sms_msg_hdr));
0938         rc = smscore_sendrequest_and_wait(coredev, msg,
0939                           msg->x_msg_header.msg_length,
0940                           &coredev->reload_start_done);
0941         if (rc < 0) {
0942             pr_err("device reload failed, rc %d\n", rc);
0943             goto exit_fw_download;
0944         }
0945         mem_address = *(u32 *) &payload[20];
0946     }
0947
0948     for (i = 0, ptr = (u32 *)firmware->payload; i < firmware->length/4 ;
0949          i++, ptr++)
0950         calc_checksum += *ptr;
0951
0952     while (size && rc >= 0) {
0953         struct sms_data_download *data_msg =
0954             (struct sms_data_download *) msg;
0955         int payload_size = min_t(int, size, SMS_MAX_PAYLOAD_SIZE);
0956
0957         SMS_INIT_MSG(&msg->x_msg_header, MSG_SMS_DATA_DOWNLOAD_REQ,
0958                  (u16)(sizeof(struct sms_msg_hdr) +
0959                       sizeof(u32) + payload_size));
0960
0961         data_msg->mem_addr = mem_address;
0962         memcpy(data_msg->payload, payload, payload_size);
0963
0964         rc = smscore_sendrequest_and_wait(coredev, data_msg,
0965                 data_msg->x_msg_header.msg_length,
0966                 &coredev->data_download_done);
0967
0968         payload += payload_size;
0969         size -= payload_size;
0970         mem_address += payload_size;
0971     }
0972
0973     if (rc < 0)
0974         goto exit_fw_download;
0975
0976     pr_debug("sending MSG_SMS_DATA_VALIDITY_REQ expecting 0x%x\n",
0977         calc_checksum);
0978     SMS_INIT_MSG(&msg->x_msg_header, MSG_SMS_DATA_VALIDITY_REQ,
0979             sizeof(msg->x_msg_header) +
0980             sizeof(u32) * 3);
0981     msg->msg_data[0] = firmware->start_address;
0982         /* Entry point */
0983     msg->msg_data[1] = firmware->length;
0984     msg->msg_data[2] = 0; /* Regular checksum*/
0985     rc = smscore_sendrequest_and_wait(coredev, msg,
0986                       msg->x_msg_header.msg_length,
0987                       &coredev->data_validity_done);
0988     if (rc < 0)
0989         goto exit_fw_download;
0990
0991     if (coredev->mode == DEVICE_MODE_NONE) {
0992         pr_debug("sending MSG_SMS_SWDOWNLOAD_TRIGGER_REQ\n");
0993         SMS_INIT_MSG(&msg->x_msg_header,
0994                 MSG_SMS_SWDOWNLOAD_TRIGGER_REQ,
0995                 sizeof(*msg));
0996
0997         msg->msg_data[0] = firmware->start_address;
0998                     /* Entry point */
0999         msg->msg_data[1] = 6; /* Priority */
1000         msg->msg_data[2] = 0x200; /* Stack size */
1001         msg->msg_data[3] = 0; /* Parameter */
1002         msg->msg_data[4] = 4; /* Task ID */
1003
1004         rc = smscore_sendrequest_and_wait(coredev, msg,
1005                     msg->x_msg_header.msg_length,
1006                     &coredev->trigger_done);
1007     } else {
1008         SMS_INIT_MSG(&msg->x_msg_header, MSG_SW_RELOAD_EXEC_REQ,
1009                 sizeof(struct sms_msg_hdr));
1010         rc = coredev->sendrequest_handler(coredev->context, msg,
1011                 msg->x_msg_header.msg_length);
1012     }
1013
1014     if (rc < 0)
1015         goto exit_fw_download;
1016
1017     /*
1018      * backward compatibility - wait to device_ready_done for
1019      * not more than 400 ms
1020      */
1021     msleep(400);
1022
1023 exit_fw_download:
1024     kfree(msg);
1025
1026     if (coredev->postload_handler) {
1027         pr_debug("rc=%d, postload=0x%p\n",
1028              rc, coredev->postload_handler);
1029         if (rc >= 0)
1030             return coredev->postload_handler(coredev->context);
1031     }
1032
1033     pr_debug("rc=%d\n", rc);
1034     return rc;
1035 }
1036
1037 static char *smscore_fw_lkup[][DEVICE_MODE_MAX] = {
1038     [SMS_NOVA_A0] = {
1039         [DEVICE_MODE_DVBT]      = SMS_FW_DVB_NOVA_12MHZ,
1040         [DEVICE_MODE_DVBH]      = SMS_FW_DVB_NOVA_12MHZ,
1041         [DEVICE_MODE_DAB_TDMB]      = SMS_FW_TDMB_NOVA_12MHZ,
1042         [DEVICE_MODE_DVBT_BDA]      = SMS_FW_DVB_NOVA_12MHZ,
1043         [DEVICE_MODE_ISDBT]     = SMS_FW_ISDBT_NOVA_12MHZ,
1044         [DEVICE_MODE_ISDBT_BDA]     = SMS_FW_ISDBT_NOVA_12MHZ,
1045     },
1046     [SMS_NOVA_B0] = {
1047         [DEVICE_MODE_DVBT]      = SMS_FW_DVB_NOVA_12MHZ_B0,
1048         [DEVICE_MODE_DVBH]      = SMS_FW_DVB_NOVA_12MHZ_B0,
1049         [DEVICE_MODE_DAB_TDMB]      = SMS_FW_TDMB_NOVA_12MHZ_B0,
1050         [DEVICE_MODE_DVBT_BDA]      = SMS_FW_DVB_NOVA_12MHZ_B0,
1051         [DEVICE_MODE_ISDBT]     = SMS_FW_ISDBT_NOVA_12MHZ_B0,
1052         [DEVICE_MODE_ISDBT_BDA]     = SMS_FW_ISDBT_NOVA_12MHZ_B0,
1053         [DEVICE_MODE_FM_RADIO]      = SMS_FW_FM_RADIO,
1054         [DEVICE_MODE_FM_RADIO_BDA]  = SMS_FW_FM_RADIO,
1055     },
1056     [SMS_VEGA] = {
1057         [DEVICE_MODE_CMMB]      = SMS_FW_CMMB_VEGA_12MHZ,
1058     },
1059     [SMS_VENICE] = {
1060         [DEVICE_MODE_CMMB]      = SMS_FW_CMMB_VENICE_12MHZ,
1061     },
1062     [SMS_MING] = {
1063         [DEVICE_MODE_CMMB]      = SMS_FW_CMMB_MING_APP,
1064     },
1065     [SMS_PELE] = {
1066         [DEVICE_MODE_ISDBT]     = SMS_FW_ISDBT_PELE,
1067         [DEVICE_MODE_ISDBT_BDA]     = SMS_FW_ISDBT_PELE,
1068     },
1069     [SMS_RIO] = {
1070         [DEVICE_MODE_DVBT]      = SMS_FW_DVB_RIO,
1071         [DEVICE_MODE_DVBH]      = SMS_FW_DVBH_RIO,
1072         [DEVICE_MODE_DVBT_BDA]      = SMS_FW_DVB_RIO,
1073         [DEVICE_MODE_ISDBT]     = SMS_FW_ISDBT_RIO,
1074         [DEVICE_MODE_ISDBT_BDA]     = SMS_FW_ISDBT_RIO,
1075         [DEVICE_MODE_FM_RADIO]      = SMS_FW_FM_RADIO_RIO,
1076         [DEVICE_MODE_FM_RADIO_BDA]  = SMS_FW_FM_RADIO_RIO,
1077     },
1078     [SMS_DENVER_1530] = {
1079         [DEVICE_MODE_ATSC]      = SMS_FW_ATSC_DENVER,
1080     },
1081     [SMS_DENVER_2160] = {
1082         [DEVICE_MODE_DAB_TDMB]      = SMS_FW_TDMB_DENVER,
1083     },
1084 };
1085
1086 /*
1087  * get firmware file name from one of the two mechanisms : sms_boards or
1088  * smscore_fw_lkup.
1089  * @param coredev pointer to a coredev object returned by
1090  *        smscore_register_device
1091  * @param mode requested mode of operation
1092  * @param lookup if 1, always get the fw filename from smscore_fw_lkup
1093  *   table. if 0, try first to get from sms_boards
1094  *
1095  * return: 0 on success, <0 on error.
1096  */
1097 static char *smscore_get_fw_filename(struct smscore_device_t *coredev,
1098                   int mode)
1099 {
1100     char **fw;
1101     int board_id = smscore_get_board_id(coredev);
1102     enum sms_device_type_st type;
1103
1104     type = smscore_registry_gettype(coredev->devpath);
1105
1106     /* Prevent looking outside the smscore_fw_lkup table */
1107     if (type <= SMS_UNKNOWN_TYPE || type >= SMS_NUM_OF_DEVICE_TYPES)
1108         return NULL;
1109     if (mode <= DEVICE_MODE_NONE || mode >= DEVICE_MODE_MAX)
1110         return NULL;
1111
1112     pr_debug("trying to get fw name from sms_boards board_id %d mode %d\n",
1113           board_id, mode);
1114     fw = sms_get_board(board_id)->fw;
1115     if (!fw || !fw[mode]) {
1116         pr_debug("cannot find fw name in sms_boards, getting from lookup table mode %d type %d\n",
1117               mode, type);
1118         return smscore_fw_lkup[type][mode];
1119     }
1120
1121     return fw[mode];
1122 }
1123
1124 /*
1125  * loads specified firmware into a buffer and calls device loadfirmware_handler
1126  *
1127  * @param coredev pointer to a coredev object returned by
1128  *                smscore_register_device
1129  * @param filename null-terminated string specifies firmware file name
1130  * @param loadfirmware_handler device handler that loads firmware
1131  *
1132  * return: 0 on success, <0 on error.
1133  */
1134 static int smscore_load_firmware_from_file(struct smscore_device_t *coredev,
1135                        int mode,
1136                        loadfirmware_t loadfirmware_handler)
1137 {
1138     int rc = -ENOENT;
1139     u8 *fw_buf;
1140     u32 fw_buf_size;
1141     const struct firmware *fw;
1142
1143     char *fw_filename = smscore_get_fw_filename(coredev, mode);
1144     if (!fw_filename) {
1145         pr_err("mode %d not supported on this device\n", mode);
1146         return -ENOENT;
1147     }
1148     pr_debug("Firmware name: %s\n", fw_filename);
1149
1150     if (!loadfirmware_handler &&
1151         !(coredev->device_flags & SMS_DEVICE_FAMILY2))
1152         return -EINVAL;
1153
1154     rc = request_firmware(&fw, fw_filename, coredev->device);
1155     if (rc < 0) {
1156         pr_err("failed to open firmware file '%s'\n", fw_filename);
1157         return rc;
1158     }
1159     pr_debug("read fw %s, buffer size=0x%zx\n", fw_filename, fw->size);
1160     fw_buf = kmalloc(ALIGN(fw->size + sizeof(struct sms_firmware),
1161              SMS_ALLOC_ALIGNMENT), GFP_KERNEL | coredev->gfp_buf_flags);
1162     if (!fw_buf) {
1163         pr_err("failed to allocate firmware buffer\n");
1164         rc = -ENOMEM;
1165     } else {
1166         memcpy(fw_buf, fw->data, fw->size);
1167         fw_buf_size = fw->size;
1168
1169         rc = (coredev->device_flags & SMS_DEVICE_FAMILY2) ?
1170             smscore_load_firmware_family2(coredev, fw_buf, fw_buf_size)
1171             : loadfirmware_handler(coredev->context, fw_buf,
1172             fw_buf_size);
1173     }
1174
1175     kfree(fw_buf);
1176     release_firmware(fw);
1177
1178     return rc;
1179 }
1180
1181 /*
1182  * notifies all clients registered with the device, notifies hotplugs,
1183  * frees all buffers and coredev object
1184  *
1185  * @param coredev pointer to a coredev object returned by
1186  *                smscore_register_device
1187  *
1188  * return: 0 on success, <0 on error.
1189  */
1190 void smscore_unregister_device(struct smscore_device_t *coredev)
1191 {
1192     struct smscore_buffer_t *cb;
1193     int num_buffers = 0;
1194     int retry = 0;
1195
1196     mutex_lock(&g_smscore_deviceslock);
1197
1198     /* Release input device (IR) resources */
1199     sms_ir_exit(coredev);
1200
1201     smscore_notify_clients(coredev);
1202     smscore_notify_callbacks(coredev, NULL, 0);
1203
1204     /* at this point all buffers should be back
1205      * onresponse must no longer be called */
1206
1207     while (1) {
1208         while (!list_empty(&coredev->buffers)) {
1209             cb = (struct smscore_buffer_t *) coredev->buffers.next;
1210             list_del(&cb->entry);
1211             kfree(cb);
1212             num_buffers++;
1213         }
1214         if (num_buffers == coredev->num_buffers)
1215             break;
1216         if (++retry > 10) {
1217             pr_info("exiting although not all buffers released.\n");
1218             break;
1219         }
1220
1221         pr_debug("waiting for %d buffer(s)\n",
1222              coredev->num_buffers - num_buffers);
1223         mutex_unlock(&g_smscore_deviceslock);
1224         msleep(100);
1225         mutex_lock(&g_smscore_deviceslock);
1226     }
1227
1228     pr_debug("freed %d buffers\n", num_buffers);
1229
1230     if (coredev->common_buffer) {
1231         if (coredev->usb_device)
1232             kfree(coredev->common_buffer);
1233         else
1234             dma_free_coherent(coredev->device,
1235                       coredev->common_buffer_size,
1236                       coredev->common_buffer,
1237                       coredev->common_buffer_phys);
1238     }
1239     kfree(coredev->fw_buf);
1240
1241     list_del(&coredev->entry);
1242     kfree(coredev);
1243
1244     mutex_unlock(&g_smscore_deviceslock);
1245
1246     pr_debug("device %p destroyed\n", coredev);
1247 }
1248 EXPORT_SYMBOL_GPL(smscore_unregister_device);
1249
1250 static int smscore_detect_mode(struct smscore_device_t *coredev)
1251 {
1252     void *buffer = kmalloc(sizeof(struct sms_msg_hdr) + SMS_DMA_ALIGNMENT,
1253                    GFP_KERNEL | coredev->gfp_buf_flags);
1254     struct sms_msg_hdr *msg =
1255         (struct sms_msg_hdr *) SMS_ALIGN_ADDRESS(buffer);
1256     int rc;
1257
1258     if (!buffer)
1259         return -ENOMEM;
1260
1261     SMS_INIT_MSG(msg, MSG_SMS_GET_VERSION_EX_REQ,
1262              sizeof(struct sms_msg_hdr));
1263
1264     rc = smscore_sendrequest_and_wait(coredev, msg, msg->msg_length,
1265                       &coredev->version_ex_done);
1266     if (rc == -ETIME) {
1267         pr_err("MSG_SMS_GET_VERSION_EX_REQ failed first try\n");
1268
1269         if (wait_for_completion_timeout(&coredev->resume_done,
1270                         msecs_to_jiffies(5000))) {
1271             rc = smscore_sendrequest_and_wait(
1272                 coredev, msg, msg->msg_length,
1273                 &coredev->version_ex_done);
1274             if (rc < 0)
1275                 pr_err("MSG_SMS_GET_VERSION_EX_REQ failed second try, rc %d\n",
1276                     rc);
1277         } else
1278             rc = -ETIME;
1279     }
1280
1281     kfree(buffer);
1282
1283     return rc;
1284 }
1285
1286 /*
1287  * send init device request and wait for response
1288  *
1289  * @param coredev pointer to a coredev object returned by
1290  *                smscore_register_device
1291  * @param mode requested mode of operation
1292  *
1293  * return: 0 on success, <0 on error.
1294  */
1295 static int smscore_init_device(struct smscore_device_t *coredev, int mode)
1296 {
1297     void *buffer;
1298     struct sms_msg_data *msg;
1299     int rc = 0;
1300
1301     buffer = kmalloc(sizeof(struct sms_msg_data) +
1302             SMS_DMA_ALIGNMENT, GFP_KERNEL | coredev->gfp_buf_flags);
1303     if (!buffer)
1304         return -ENOMEM;
1305
1306     msg = (struct sms_msg_data *)SMS_ALIGN_ADDRESS(buffer);
1307     SMS_INIT_MSG(&msg->x_msg_header, MSG_SMS_INIT_DEVICE_REQ,
1308             sizeof(struct sms_msg_data));
1309     msg->msg_data[0] = mode;
1310
1311     rc = smscore_sendrequest_and_wait(coredev, msg,
1312             msg->x_msg_header. msg_length,
1313             &coredev->init_device_done);
1314
1315     kfree(buffer);
1316     return rc;
1317 }
1318
1319 /*
1320  * calls device handler to change mode of operation
1321  * NOTE: stellar/usb may disconnect when changing mode
1322  *
1323  * @param coredev pointer to a coredev object returned by
1324  *                smscore_register_device
1325  * @param mode requested mode of operation
1326  *
1327  * return: 0 on success, <0 on error.
1328  */
1329 int smscore_set_device_mode(struct smscore_device_t *coredev, int mode)
1330 {
1331     int rc = 0;
1332
1333     pr_debug("set device mode to %d\n", mode);
1334     if (coredev->device_flags & SMS_DEVICE_FAMILY2) {
1335         if (mode <= DEVICE_MODE_NONE || mode >= DEVICE_MODE_MAX) {
1336             pr_err("invalid mode specified %d\n", mode);
1337             return -EINVAL;
1338         }
1339
1340         smscore_registry_setmode(coredev->devpath, mode);
1341
1342         if (!(coredev->device_flags & SMS_DEVICE_NOT_READY)) {
1343             rc = smscore_detect_mode(coredev);
1344             if (rc < 0) {
1345                 pr_err("mode detect failed %d\n", rc);
1346                 return rc;
1347             }
1348         }
1349
1350         if (coredev->mode == mode) {
1351             pr_debug("device mode %d already set\n", mode);
1352             return 0;
1353         }
1354
1355         if (!(coredev->modes_supported & (1 << mode))) {
1356             rc = smscore_load_firmware_from_file(coredev,
1357                                  mode, NULL);
1358             if (rc >= 0)
1359                 pr_debug("firmware download success\n");
1360         } else {
1361             pr_debug("mode %d is already supported by running firmware\n",
1362                  mode);
1363         }
1364         if (coredev->fw_version >= 0x800) {
1365             rc = smscore_init_device(coredev, mode);
1366             if (rc < 0)
1367                 pr_err("device init failed, rc %d.\n", rc);
1368         }
1369     } else {
1370         if (mode <= DEVICE_MODE_NONE || mode >= DEVICE_MODE_MAX) {
1371             pr_err("invalid mode specified %d\n", mode);
1372             return -EINVAL;
1373         }
1374
1375         smscore_registry_setmode(coredev->devpath, mode);
1376
1377         if (coredev->detectmode_handler)
1378             coredev->detectmode_handler(coredev->context,
1379                             &coredev->mode);
1380
1381         if (coredev->mode != mode && coredev->setmode_handler)
1382             rc = coredev->setmode_handler(coredev->context, mode);
1383     }
1384
1385     if (rc >= 0) {
1386         char *buffer;
1387         coredev->mode = mode;
1388         coredev->device_flags &= ~SMS_DEVICE_NOT_READY;
1389
1390         buffer = kmalloc(sizeof(struct sms_msg_data) +
1391                  SMS_DMA_ALIGNMENT, GFP_KERNEL | coredev->gfp_buf_flags);
1392         if (buffer) {
1393             struct sms_msg_data *msg = (struct sms_msg_data *) SMS_ALIGN_ADDRESS(buffer);
1394
1395             SMS_INIT_MSG(&msg->x_msg_header, MSG_SMS_INIT_DEVICE_REQ,
1396                      sizeof(struct sms_msg_data));
1397             msg->msg_data[0] = mode;
1398
1399             rc = smscore_sendrequest_and_wait(
1400                 coredev, msg, msg->x_msg_header.msg_length,
1401                 &coredev->init_device_done);
1402
1403             kfree(buffer);
1404         }
1405     }
1406
1407     if (rc < 0)
1408         pr_err("return error code %d.\n", rc);
1409     else
1410         pr_debug("Success setting device mode.\n");
1411
1412     return rc;
1413 }
1414
1415 /*
1416  * calls device handler to get current mode of operation
1417  *
1418  * @param coredev pointer to a coredev object returned by
1419  *                smscore_register_device
1420  *
1421  * return: current mode
1422  */
1423 int smscore_get_device_mode(struct smscore_device_t *coredev)
1424 {
1425     return coredev->mode;
1426 }
1427 EXPORT_SYMBOL_GPL(smscore_get_device_mode);
1428
1429 /*
1430  * find client by response id & type within the clients list.
1431  * return client handle or NULL.
1432  *
1433  * @param coredev pointer to a coredev object returned by
1434  *                smscore_register_device
1435  * @param data_type client data type (SMS_DONT_CARE for all types)
1436  * @param id client id (SMS_DONT_CARE for all id)
1437  *
1438  */
1439 static struct
1440 smscore_client_t *smscore_find_client(struct smscore_device_t *coredev,
1441                       int data_type, int id)
1442 {
1443     struct list_head *first;
1444     struct smscore_client_t *client;
1445     unsigned long flags;
1446     struct list_head *firstid;
1447     struct smscore_idlist_t *client_id;
1448
1449     spin_lock_irqsave(&coredev->clientslock, flags);
1450     first = &coredev->clients;
1451     list_for_each_entry(client, first, entry) {
1452         firstid = &client->idlist;
1453         list_for_each_entry(client_id, firstid, entry) {
1454             if ((client_id->id == id) &&
1455                 (client_id->data_type == data_type ||
1456                 (client_id->data_type == 0)))
1457                 goto found;
1458         }
1459     }
1460     client = NULL;
1461 found:
1462     spin_unlock_irqrestore(&coredev->clientslock, flags);
1463     return client;
1464 }
1465
1466 /*
1467  * find client by response id/type, call clients onresponse handler
1468  * return buffer to pool on error
1469  *
1470  * @param coredev pointer to a coredev object returned by
1471  *                smscore_register_device
1472  * @param cb pointer to response buffer descriptor
1473  *
1474  */
1475 void smscore_onresponse(struct smscore_device_t *coredev,
1476         struct smscore_buffer_t *cb) {
1477     struct sms_msg_hdr *phdr = (struct sms_msg_hdr *) ((u8 *) cb->p
1478             + cb->offset);
1479     struct smscore_client_t *client;
1480     int rc = -EBUSY;
1481     static unsigned long last_sample_time; /* = 0; */
1482     static int data_total; /* = 0; */
1483     unsigned long time_now = jiffies_to_msecs(jiffies);
1484
1485     if (!last_sample_time)
1486         last_sample_time = time_now;
1487
1488     if (time_now - last_sample_time > 10000) {
1489         pr_debug("data rate %d bytes/secs\n",
1490               (int)((data_total * 1000) /
1491                 (time_now - last_sample_time)));
1492
1493         last_sample_time = time_now;
1494         data_total = 0;
1495     }
1496
1497     data_total += cb->size;
1498     /* Do we need to re-route? */
1499     if ((phdr->msg_type == MSG_SMS_HO_PER_SLICES_IND) ||
1500             (phdr->msg_type == MSG_SMS_TRANSMISSION_IND)) {
1501         if (coredev->mode == DEVICE_MODE_DVBT_BDA)
1502             phdr->msg_dst_id = DVBT_BDA_CONTROL_MSG_ID;
1503     }
1504
1505
1506     client = smscore_find_client(coredev, phdr->msg_type, phdr->msg_dst_id);
1507
1508     /* If no client registered for type & id,
1509      * check for control client where type is not registered */
1510     if (client)
1511         rc = client->onresponse_handler(client->context, cb);
1512
1513     if (rc < 0) {
1514         switch (phdr->msg_type) {
1515         case MSG_SMS_ISDBT_TUNE_RES:
1516             break;
1517         case MSG_SMS_RF_TUNE_RES:
1518             break;
1519         case MSG_SMS_SIGNAL_DETECTED_IND:
1520             break;
1521         case MSG_SMS_NO_SIGNAL_IND:
1522             break;
1523         case MSG_SMS_SPI_INT_LINE_SET_RES:
1524             break;
1525         case MSG_SMS_INTERFACE_LOCK_IND:
1526             break;
1527         case MSG_SMS_INTERFACE_UNLOCK_IND:
1528             break;
1529         case MSG_SMS_GET_VERSION_EX_RES:
1530         {
1531             struct sms_version_res *ver =
1532                 (struct sms_version_res *) phdr;
1533             pr_debug("Firmware id %d prots 0x%x ver %d.%d\n",
1534                   ver->firmware_id, ver->supported_protocols,
1535                   ver->rom_ver_major, ver->rom_ver_minor);
1536
1537             coredev->mode = ver->firmware_id == 255 ?
1538                 DEVICE_MODE_NONE : ver->firmware_id;
1539             coredev->modes_supported = ver->supported_protocols;
1540             coredev->fw_version = ver->rom_ver_major << 8 |
1541                           ver->rom_ver_minor;
1542
1543             complete(&coredev->version_ex_done);
1544             break;
1545         }
1546         case MSG_SMS_INIT_DEVICE_RES:
1547             complete(&coredev->init_device_done);
1548             break;
1549         case MSG_SW_RELOAD_START_RES:
1550             complete(&coredev->reload_start_done);
1551             break;
1552         case MSG_SMS_DATA_VALIDITY_RES:
1553         {
1554             struct sms_msg_data *validity = (struct sms_msg_data *) phdr;
1555
1556             pr_debug("MSG_SMS_DATA_VALIDITY_RES, checksum = 0x%x\n",
1557                 validity->msg_data[0]);
1558             complete(&coredev->data_validity_done);
1559             break;
1560         }
1561         case MSG_SMS_DATA_DOWNLOAD_RES:
1562             complete(&coredev->data_download_done);
1563             break;
1564         case MSG_SW_RELOAD_EXEC_RES:
1565             break;
1566         case MSG_SMS_SWDOWNLOAD_TRIGGER_RES:
1567             complete(&coredev->trigger_done);
1568             break;
1569         case MSG_SMS_SLEEP_RESUME_COMP_IND:
1570             complete(&coredev->resume_done);
1571             break;
1572         case MSG_SMS_GPIO_CONFIG_EX_RES:
1573             complete(&coredev->gpio_configuration_done);
1574             break;
1575         case MSG_SMS_GPIO_SET_LEVEL_RES:
1576             complete(&coredev->gpio_set_level_done);
1577             break;
1578         case MSG_SMS_GPIO_GET_LEVEL_RES:
1579         {
1580             u32 *msgdata = (u32 *) phdr;
1581             coredev->gpio_get_res = msgdata[1];
1582             pr_debug("gpio level %d\n",
1583                     coredev->gpio_get_res);
1584             complete(&coredev->gpio_get_level_done);
1585             break;
1586         }
1587         case MSG_SMS_START_IR_RES:
1588             complete(&coredev->ir_init_done);
1589             break;
1590         case MSG_SMS_IR_SAMPLES_IND:
1591             sms_ir_event(coredev,
1592                 (const char *)
1593                 ((char *)phdr
1594                 + sizeof(struct sms_msg_hdr)),
1595                 (int)phdr->msg_length
1596                 - sizeof(struct sms_msg_hdr));
1597             break;
1598
1599         case MSG_SMS_DVBT_BDA_DATA:
1600             /*
1601              * It can be received here, if the frontend is
1602              * tuned into a valid channel and the proper firmware
1603              * is loaded. That happens when the module got removed
1604              * and re-inserted, without powering the device off
1605              */
1606             break;
1607
1608         default:
1609             pr_debug("message %s(%d) not handled.\n",
1610                   smscore_translate_msg(phdr->msg_type),
1611                   phdr->msg_type);
1612             break;
1613         }
1614         smscore_putbuffer(coredev, cb);
1615     }
1616 }
1617 EXPORT_SYMBOL_GPL(smscore_onresponse);
1618
1619 /*
1620  * return pointer to next free buffer descriptor from core pool
1621  *
1622  * @param coredev pointer to a coredev object returned by
1623  *                smscore_register_device
1624  *
1625  * return: pointer to descriptor on success, NULL on error.
1626  */
1627
1628 static struct smscore_buffer_t *get_entry(struct smscore_device_t *coredev)
1629 {
1630     struct smscore_buffer_t *cb = NULL;
1631     unsigned long flags;
1632
1633     spin_lock_irqsave(&coredev->bufferslock, flags);
1634     if (!list_empty(&coredev->buffers)) {
1635         cb = (struct smscore_buffer_t *) coredev->buffers.next;
1636         list_del(&cb->entry);
1637     }
1638     spin_unlock_irqrestore(&coredev->bufferslock, flags);
1639     return cb;
1640 }
1641
1642 struct smscore_buffer_t *smscore_getbuffer(struct smscore_device_t *coredev)
1643 {
1644     struct smscore_buffer_t *cb = NULL;
1645
1646     wait_event(coredev->buffer_mng_waitq, (cb = get_entry(coredev)));
1647
1648     return cb;
1649 }
1650 EXPORT_SYMBOL_GPL(smscore_getbuffer);
1651
1652 /*
1653  * return buffer descriptor to a pool
1654  *
1655  * @param coredev pointer to a coredev object returned by
1656  *                smscore_register_device
1657  * @param cb pointer buffer descriptor
1658  *
1659  */
1660 void smscore_putbuffer(struct smscore_device_t *coredev,
1661         struct smscore_buffer_t *cb) {
1662     wake_up_interruptible(&coredev->buffer_mng_waitq);
1663     list_add_locked(&cb->entry, &coredev->buffers, &coredev->bufferslock);
1664 }
1665 EXPORT_SYMBOL_GPL(smscore_putbuffer);
1666
1667 static int smscore_validate_client(struct smscore_device_t *coredev,
1668                    struct smscore_client_t *client,
1669                    int data_type, int id)
1670 {
1671     struct smscore_idlist_t *listentry;
1672     struct smscore_client_t *registered_client;
1673
1674     if (!client) {
1675         pr_err("bad parameter.\n");
1676         return -EINVAL;
1677     }
1678     registered_client = smscore_find_client(coredev, data_type, id);
1679     if (registered_client == client)
1680         return 0;
1681
1682     if (registered_client) {
1683         pr_err("The msg ID already registered to another client.\n");
1684         return -EEXIST;
1685     }
1686     listentry = kzalloc(sizeof(*listentry), GFP_KERNEL);
1687     if (!listentry)
1688         return -ENOMEM;
1689
1690     listentry->id = id;
1691     listentry->data_type = data_type;
1692     list_add_locked(&listentry->entry, &client->idlist,
1693             &coredev->clientslock);
1694     return 0;
1695 }
1696
1697 /*
1698  * creates smsclient object, check that id is taken by another client
1699  *
1700  * @param coredev pointer to a coredev object from clients hotplug
1701  * @param initial_id all messages with this id would be sent to this client
1702  * @param data_type all messages of this type would be sent to this client
1703  * @param onresponse_handler client handler that is called to
1704  *                           process incoming messages
1705  * @param onremove_handler client handler that is called when device is removed
1706  * @param context client-specific context
1707  * @param client pointer to a value that receives created smsclient object
1708  *
1709  * return: 0 on success, <0 on error.
1710  */
1711 int smscore_register_client(struct smscore_device_t *coredev,
1712                 struct smsclient_params_t *params,
1713                 struct smscore_client_t **client)
1714 {
1715     struct smscore_client_t *newclient;
1716     /* check that no other channel with same parameters exists */
1717     if (smscore_find_client(coredev, params->data_type,
1718                 params->initial_id)) {
1719         pr_err("Client already exist.\n");
1720         return -EEXIST;
1721     }
1722
1723     newclient = kzalloc(sizeof(*newclient), GFP_KERNEL);
1724     if (!newclient)
1725         return -ENOMEM;
1726
1727     INIT_LIST_HEAD(&newclient->idlist);
1728     newclient->coredev = coredev;
1729     newclient->onresponse_handler = params->onresponse_handler;
1730     newclient->onremove_handler = params->onremove_handler;
1731     newclient->context = params->context;
1732     list_add_locked(&newclient->entry, &coredev->clients,
1733             &coredev->clientslock);
1734     smscore_validate_client(coredev, newclient, params->data_type,
1735                 params->initial_id);
1736     *client = newclient;
1737     pr_debug("%p %d %d\n", params->context, params->data_type,
1738           params->initial_id);
1739
1740     return 0;
1741 }
1742 EXPORT_SYMBOL_GPL(smscore_register_client);
1743
1744 /*
1745  * frees smsclient object and all subclients associated with it
1746  *
1747  * @param client pointer to smsclient object returned by
1748  *               smscore_register_client
1749  *
1750  */
1751 void smscore_unregister_client(struct smscore_client_t *client)
1752 {
1753     struct smscore_device_t *coredev = client->coredev;
1754     unsigned long flags;
1755
1756     spin_lock_irqsave(&coredev->clientslock, flags);
1757
1758
1759     while (!list_empty(&client->idlist)) {
1760         struct smscore_idlist_t *identry =
1761             (struct smscore_idlist_t *) client->idlist.next;
1762         list_del(&identry->entry);
1763         kfree(identry);
1764     }
1765
1766     pr_debug("%p\n", client->context);
1767
1768     list_del(&client->entry);
1769     kfree(client);
1770
1771     spin_unlock_irqrestore(&coredev->clientslock, flags);
1772 }
1773 EXPORT_SYMBOL_GPL(smscore_unregister_client);
1774
1775 /*
1776  * verifies that source id is not taken by another client,
1777  * calls device handler to send requests to the device
1778  *
1779  * @param client pointer to smsclient object returned by
1780  *               smscore_register_client
1781  * @param buffer pointer to a request buffer
1782  * @param size size (in bytes) of request buffer
1783  *
1784  * return: 0 on success, <0 on error.
1785  */
1786 int smsclient_sendrequest(struct smscore_client_t *client,
1787               void *buffer, size_t size)
1788 {
1789     struct smscore_device_t *coredev;
1790     struct sms_msg_hdr *phdr = (struct sms_msg_hdr *) buffer;
1791     int rc;
1792
1793     if (!client) {
1794         pr_err("Got NULL client\n");
1795         return -EINVAL;
1796     }
1797
1798     coredev = client->coredev;
1799
1800     /* check that no other channel with same id exists */
1801     if (!coredev) {
1802         pr_err("Got NULL coredev\n");
1803         return -EINVAL;
1804     }
1805
1806     rc = smscore_validate_client(client->coredev, client, 0,
1807                      phdr->msg_src_id);
1808     if (rc < 0)
1809         return rc;
1810
1811     return coredev->sendrequest_handler(coredev->context, buffer, size);
1812 }
1813 EXPORT_SYMBOL_GPL(smsclient_sendrequest);
1814
1815
1816 /* old GPIO managements implementation */
1817 int smscore_configure_gpio(struct smscore_device_t *coredev, u32 pin,
1818                struct smscore_config_gpio *pinconfig)
1819 {
1820     struct {
1821         struct sms_msg_hdr hdr;
1822         u32 data[6];
1823     } msg;
1824
1825     if (coredev->device_flags & SMS_DEVICE_FAMILY2) {
1826         msg.hdr.msg_src_id = DVBT_BDA_CONTROL_MSG_ID;
1827         msg.hdr.msg_dst_id = HIF_TASK;
1828         msg.hdr.msg_flags = 0;
1829         msg.hdr.msg_type  = MSG_SMS_GPIO_CONFIG_EX_REQ;
1830         msg.hdr.msg_length = sizeof(msg);
1831
1832         msg.data[0] = pin;
1833         msg.data[1] = pinconfig->pullupdown;
1834
1835         /* Convert slew rate for Nova: Fast(0) = 3 / Slow(1) = 0; */
1836         msg.data[2] = pinconfig->outputslewrate == 0 ? 3 : 0;
1837
1838         switch (pinconfig->outputdriving) {
1839         case SMS_GPIO_OUTPUTDRIVING_S_16mA:
1840             msg.data[3] = 7; /* Nova - 16mA */
1841             break;
1842         case SMS_GPIO_OUTPUTDRIVING_S_12mA:
1843             msg.data[3] = 5; /* Nova - 11mA */
1844             break;
1845         case SMS_GPIO_OUTPUTDRIVING_S_8mA:
1846             msg.data[3] = 3; /* Nova - 7mA */
1847             break;
1848         case SMS_GPIO_OUTPUTDRIVING_S_4mA:
1849         default:
1850             msg.data[3] = 2; /* Nova - 4mA */
1851             break;
1852         }
1853
1854         msg.data[4] = pinconfig->direction;
1855         msg.data[5] = 0;
1856     } else /* TODO: SMS_DEVICE_FAMILY1 */
1857         return -EINVAL;
1858
1859     return coredev->sendrequest_handler(coredev->context,
1860                         &msg, sizeof(msg));
1861 }
1862
1863 int smscore_set_gpio(struct smscore_device_t *coredev, u32 pin, int level)
1864 {
1865     struct {
1866         struct sms_msg_hdr hdr;
1867         u32 data[3];
1868     } msg;
1869
1870     if (pin > MAX_GPIO_PIN_NUMBER)
1871         return -EINVAL;
1872
1873     msg.hdr.msg_src_id = DVBT_BDA_CONTROL_MSG_ID;
1874     msg.hdr.msg_dst_id = HIF_TASK;
1875     msg.hdr.msg_flags = 0;
1876     msg.hdr.msg_type  = MSG_SMS_GPIO_SET_LEVEL_REQ;
1877     msg.hdr.msg_length = sizeof(msg);
1878
1879     msg.data[0] = pin;
1880     msg.data[1] = level ? 1 : 0;
1881     msg.data[2] = 0;
1882
1883     return coredev->sendrequest_handler(coredev->context,
1884                         &msg, sizeof(msg));
1885 }
1886
1887 /* new GPIO management implementation */
1888 static int get_gpio_pin_params(u32 pin_num, u32 *p_translatedpin_num,
1889         u32 *p_group_num, u32 *p_group_cfg) {
1890
1891     *p_group_cfg = 1;
1892
1893     if (pin_num <= 1)   {
1894         *p_translatedpin_num = 0;
1895         *p_group_num = 9;
1896         *p_group_cfg = 2;
1897     } else if (pin_num >= 2 && pin_num <= 6) {
1898         *p_translatedpin_num = 2;
1899         *p_group_num = 0;
1900         *p_group_cfg = 2;
1901     } else if (pin_num >= 7 && pin_num <= 11) {
1902         *p_translatedpin_num = 7;
1903         *p_group_num = 1;
1904     } else if (pin_num >= 12 && pin_num <= 15) {
1905         *p_translatedpin_num = 12;
1906         *p_group_num = 2;
1907         *p_group_cfg = 3;
1908     } else if (pin_num == 16) {
1909         *p_translatedpin_num = 16;
1910         *p_group_num = 23;
1911     } else if (pin_num >= 17 && pin_num <= 24) {
1912         *p_translatedpin_num = 17;
1913         *p_group_num = 3;
1914     } else if (pin_num == 25) {
1915         *p_translatedpin_num = 25;
1916         *p_group_num = 6;
1917     } else if (pin_num >= 26 && pin_num <= 28) {
1918         *p_translatedpin_num = 26;
1919         *p_group_num = 4;
1920     } else if (pin_num == 29) {
1921         *p_translatedpin_num = 29;
1922         *p_group_num = 5;
1923         *p_group_cfg = 2;
1924     } else if (pin_num == 30) {
1925         *p_translatedpin_num = 30;
1926         *p_group_num = 8;
1927     } else if (pin_num == 31) {
1928         *p_translatedpin_num = 31;
1929         *p_group_num = 17;
1930     } else
1931         return -1;
1932
1933     *p_group_cfg <<= 24;
1934
1935     return 0;
1936 }
1937
1938 int smscore_gpio_configure(struct smscore_device_t *coredev, u8 pin_num,
1939         struct smscore_config_gpio *p_gpio_config) {
1940
1941     u32 total_len;
1942     u32 translatedpin_num = 0;
1943     u32 group_num = 0;
1944     u32 electric_char;
1945     u32 group_cfg;
1946     void *buffer;
1947     int rc;
1948
1949     struct set_gpio_msg {
1950         struct sms_msg_hdr x_msg_header;
1951         u32 msg_data[6];
1952     } *p_msg;
1953
1954
1955     if (pin_num > MAX_GPIO_PIN_NUMBER)
1956         return -EINVAL;
1957
1958     if (!p_gpio_config)
1959         return -EINVAL;
1960
1961     total_len = sizeof(struct sms_msg_hdr) + (sizeof(u32) * 6);
1962
1963     buffer = kmalloc(total_len + SMS_DMA_ALIGNMENT,
1964             GFP_KERNEL | coredev->gfp_buf_flags);
1965     if (!buffer)
1966         return -ENOMEM;
1967
1968     p_msg = (struct set_gpio_msg *) SMS_ALIGN_ADDRESS(buffer);
1969
1970     p_msg->x_msg_header.msg_src_id = DVBT_BDA_CONTROL_MSG_ID;
1971     p_msg->x_msg_header.msg_dst_id = HIF_TASK;
1972     p_msg->x_msg_header.msg_flags = 0;
1973     p_msg->x_msg_header.msg_length = (u16) total_len;
1974     p_msg->msg_data[0] = pin_num;
1975
1976     if (!(coredev->device_flags & SMS_DEVICE_FAMILY2)) {
1977         p_msg->x_msg_header.msg_type = MSG_SMS_GPIO_CONFIG_REQ;
1978         if (get_gpio_pin_params(pin_num, &translatedpin_num, &group_num,
1979                 &group_cfg) != 0) {
1980             rc = -EINVAL;
1981             goto free;
1982         }
1983
1984         p_msg->msg_data[1] = translatedpin_num;
1985         p_msg->msg_data[2] = group_num;
1986         electric_char = (p_gpio_config->pullupdown)
1987                 | (p_gpio_config->inputcharacteristics << 2)
1988                 | (p_gpio_config->outputslewrate << 3)
1989                 | (p_gpio_config->outputdriving << 4);
1990         p_msg->msg_data[3] = electric_char;
1991         p_msg->msg_data[4] = p_gpio_config->direction;
1992         p_msg->msg_data[5] = group_cfg;
1993     } else {
1994         p_msg->x_msg_header.msg_type = MSG_SMS_GPIO_CONFIG_EX_REQ;
1995         p_msg->msg_data[1] = p_gpio_config->pullupdown;
1996         p_msg->msg_data[2] = p_gpio_config->outputslewrate;
1997         p_msg->msg_data[3] = p_gpio_config->outputdriving;
1998         p_msg->msg_data[4] = p_gpio_config->direction;
1999         p_msg->msg_data[5] = 0;
2000     }
2001
2002     rc = smscore_sendrequest_and_wait(coredev, p_msg, total_len,
2003             &coredev->gpio_configuration_done);
2004
2005     if (rc != 0) {
2006         if (rc == -ETIME)
2007             pr_err("smscore_gpio_configure timeout\n");
2008         else
2009             pr_err("smscore_gpio_configure error\n");
2010     }
2011 free:
2012     kfree(buffer);
2013
2014     return rc;
2015 }
2016
2017 int smscore_gpio_set_level(struct smscore_device_t *coredev, u8 pin_num,
2018         u8 new_level) {
2019
2020     u32 total_len;
2021     int rc;
2022     void *buffer;
2023
2024     struct set_gpio_msg {
2025         struct sms_msg_hdr x_msg_header;
2026         u32 msg_data[3]; /* keep it 3 ! */
2027     } *p_msg;
2028
2029     if ((new_level > 1) || (pin_num > MAX_GPIO_PIN_NUMBER))
2030         return -EINVAL;
2031
2032     total_len = sizeof(struct sms_msg_hdr) +
2033             (3 * sizeof(u32)); /* keep it 3 ! */
2034
2035     buffer = kmalloc(total_len + SMS_DMA_ALIGNMENT,
2036             GFP_KERNEL | coredev->gfp_buf_flags);
2037     if (!buffer)
2038         return -ENOMEM;
2039
2040     p_msg = (struct set_gpio_msg *) SMS_ALIGN_ADDRESS(buffer);
2041
2042     p_msg->x_msg_header.msg_src_id = DVBT_BDA_CONTROL_MSG_ID;
2043     p_msg->x_msg_header.msg_dst_id = HIF_TASK;
2044     p_msg->x_msg_header.msg_flags = 0;
2045     p_msg->x_msg_header.msg_type = MSG_SMS_GPIO_SET_LEVEL_REQ;
2046     p_msg->x_msg_header.msg_length = (u16) total_len;
2047     p_msg->msg_data[0] = pin_num;
2048     p_msg->msg_data[1] = new_level;
2049
2050     /* Send message to SMS */
2051     rc = smscore_sendrequest_and_wait(coredev, p_msg, total_len,
2052             &coredev->gpio_set_level_done);
2053
2054     if (rc != 0) {
2055         if (rc == -ETIME)
2056             pr_err("smscore_gpio_set_level timeout\n");
2057         else
2058             pr_err("smscore_gpio_set_level error\n");
2059     }
2060     kfree(buffer);
2061
2062     return rc;
2063 }
2064
2065 int smscore_gpio_get_level(struct smscore_device_t *coredev, u8 pin_num,
2066         u8 *level) {
2067
2068     u32 total_len;
2069     int rc;
2070     void *buffer;
2071
2072     struct set_gpio_msg {
2073         struct sms_msg_hdr x_msg_header;
2074         u32 msg_data[2];
2075     } *p_msg;
2076
2077
2078     if (pin_num > MAX_GPIO_PIN_NUMBER)
2079         return -EINVAL;
2080
2081     total_len = sizeof(struct sms_msg_hdr) + (2 * sizeof(u32));
2082
2083     buffer = kmalloc(total_len + SMS_DMA_ALIGNMENT,
2084             GFP_KERNEL | coredev->gfp_buf_flags);
2085     if (!buffer)
2086         return -ENOMEM;
2087
2088     p_msg = (struct set_gpio_msg *) SMS_ALIGN_ADDRESS(buffer);
2089
2090     p_msg->x_msg_header.msg_src_id = DVBT_BDA_CONTROL_MSG_ID;
2091     p_msg->x_msg_header.msg_dst_id = HIF_TASK;
2092     p_msg->x_msg_header.msg_flags = 0;
2093     p_msg->x_msg_header.msg_type = MSG_SMS_GPIO_GET_LEVEL_REQ;
2094     p_msg->x_msg_header.msg_length = (u16) total_len;
2095     p_msg->msg_data[0] = pin_num;
2096     p_msg->msg_data[1] = 0;
2097
2098     /* Send message to SMS */
2099     rc = smscore_sendrequest_and_wait(coredev, p_msg, total_len,
2100             &coredev->gpio_get_level_done);
2101
2102     if (rc != 0) {
2103         if (rc == -ETIME)
2104             pr_err("smscore_gpio_get_level timeout\n");
2105         else
2106             pr_err("smscore_gpio_get_level error\n");
2107     }
2108     kfree(buffer);
2109
2110     /* Its a race between other gpio_get_level() and the copy of the single
2111      * global 'coredev->gpio_get_res' to  the function's variable 'level'
2112      */
2113     *level = coredev->gpio_get_res;
2114
2115     return rc;
2116 }
2117
2118 static int __init smscore_module_init(void)
2119 {
2120     INIT_LIST_HEAD(&g_smscore_notifyees);
2121     INIT_LIST_HEAD(&g_smscore_devices);
2122     INIT_LIST_HEAD(&g_smscore_registry);
2123
2124     return 0;
2125 }
2126
2127 static void __exit smscore_module_exit(void)
2128 {
2129     mutex_lock(&g_smscore_deviceslock);
2130     while (!list_empty(&g_smscore_notifyees)) {
2131         struct smscore_device_notifyee_t *notifyee =
2132             (struct smscore_device_notifyee_t *)
2133                 g_smscore_notifyees.next;
2134
2135         list_del(&notifyee->entry);
2136         kfree(notifyee);
2137     }
2138     mutex_unlock(&g_smscore_deviceslock);
2139
2140     mutex_lock(&g_smscore_registrylock);
2141     while (!list_empty(&g_smscore_registry)) {
2142         struct smscore_registry_entry_t *entry =
2143             (struct smscore_registry_entry_t *)
2144                 g_smscore_registry.next;
2145
2146         list_del(&entry->entry);
2147         kfree(entry);
2148     }
2149     mutex_unlock(&g_smscore_registrylock);
2150
2151     pr_debug("\n");
2152 }
2153
2154 module_init(smscore_module_init);
2155 module_exit(smscore_module_exit);
2156
2157 MODULE_DESCRIPTION("Siano MDTV Core module");
2158 MODULE_AUTHOR("Siano Mobile Silicon, Inc. (uris@siano-ms.com)");
2159 MODULE_LICENSE("GPL");
2160
2161 /* This should match what's defined at smscoreapi.h */
2162 MODULE_FIRMWARE(SMS_FW_ATSC_DENVER);
2163 MODULE_FIRMWARE(SMS_FW_CMMB_MING_APP);
2164 MODULE_FIRMWARE(SMS_FW_CMMB_VEGA_12MHZ);
2165 MODULE_FIRMWARE(SMS_FW_CMMB_VENICE_12MHZ);
2166 MODULE_FIRMWARE(SMS_FW_DVBH_RIO);
2167 MODULE_FIRMWARE(SMS_FW_DVB_NOVA_12MHZ_B0);
2168 MODULE_FIRMWARE(SMS_FW_DVB_NOVA_12MHZ);
2169 MODULE_FIRMWARE(SMS_FW_DVB_RIO);
2170 MODULE_FIRMWARE(SMS_FW_FM_RADIO);
2171 MODULE_FIRMWARE(SMS_FW_FM_RADIO_RIO);
2172 MODULE_FIRMWARE(SMS_FW_DVBT_HCW_55XXX);
2173 MODULE_FIRMWARE(SMS_FW_ISDBT_HCW_55XXX);
2174 MODULE_FIRMWARE(SMS_FW_ISDBT_NOVA_12MHZ_B0);
2175 MODULE_FIRMWARE(SMS_FW_ISDBT_NOVA_12MHZ);
2176 MODULE_FIRMWARE(SMS_FW_ISDBT_PELE);
2177 MODULE_FIRMWARE(SMS_FW_ISDBT_RIO);
2178 MODULE_FIRMWARE(SMS_FW_DVBT_NOVA_A);
2179 MODULE_FIRMWARE(SMS_FW_DVBT_NOVA_B);
2180 MODULE_FIRMWARE(SMS_FW_DVBT_STELLAR);
2181 MODULE_FIRMWARE(SMS_FW_TDMB_DENVER);
2182 MODULE_FIRMWARE(SMS_FW_TDMB_NOVA_12MHZ_B0);
2183 MODULE_FIRMWARE(SMS_FW_TDMB_NOVA_12MHZ);