| /* |
| * Copyright (C) 2018 Knowles Electronics |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| |
| #include <stdio.h> |
| #include <stdlib.h> |
| #include <errno.h> |
| #include <getopt.h> |
| #include <stdbool.h> |
| #include <sys/ioctl.h> |
| #include <limits.h> |
| #include <string.h> |
| #include <linux/mfd/adnc/iaxxx-module.h> |
| |
| #define LOG_TAG "ia_sensor_param_test" |
| |
| #include <cutils/log.h> |
| |
| #define GETOPT_HELP_CHAR (CHAR_MIN - 2) |
| |
| #define DEV_NODE "/dev/iaxxx-module-celldrv" |
| |
| struct ia_sensor_mgr { |
| FILE *dev_node; |
| }; |
| |
| static struct option const long_options[] = |
| { |
| {"setparamid", required_argument, NULL, 's'}, |
| {"value", required_argument, NULL, 'v'}, |
| {"getparamid", required_argument, NULL, 'g'}, |
| {"help", no_argument, NULL, GETOPT_HELP_CHAR}, |
| {NULL, 0, NULL, 0} |
| }; |
| |
| void usage() { |
| fputs("\ |
| USAGE -\n\ |
| -------\n\ |
| 1) sensor_param_test -s <param_id> -v <param_val>\n\ |
| 2) sensor_param_test -g <param_id>\n\ |
| \n\ |
| In the first form, set a parameter with a value.\n\ |
| In the second form, get a value of a parameter\n\ |
| ", stdout); |
| |
| fputs("\n\ |
| OPTIONS - \n\ |
| ---------\n\ |
| -s Set a parameter using its ID.\n\ |
| -v Set this value for the parameter ID that was passed with\n\ |
| the option '-s'. Using this option alone is invalid.\n\ |
| -g Get the value of a parameter using its ID.\n\ |
| ", stdout); |
| |
| exit(EXIT_FAILURE); |
| } |
| |
| void set_param(struct ia_sensor_mgr *smd, int param_id, float param_val) { |
| int err = 0; |
| struct iaxxx_sensor_param sp; |
| |
| if (NULL == smd) { |
| ALOGE("%s: NULL handle passed", __func__); |
| return; |
| } |
| |
| sp.inst_id = 0; |
| sp.block_id = 0; |
| |
| sp.param_id = param_id; |
| sp.param_val = param_val; |
| |
| ALOGD("Set sensor param 0x%X with value %f", |
| param_id, param_val); |
| fprintf(stdout, "Set sensor param 0x%X with value %f\n", |
| param_id, param_val); |
| |
| err = ioctl(fileno(smd->dev_node), MODULE_SENSOR_SET_PARAM, (unsigned long) &sp); |
| if (-1 == err) { |
| ALOGE("%s: ERROR: MODULE_SENSOR_SET_PARAM IOCTL failed with error %d(%s)", __func__, errno, strerror(errno)); |
| return; |
| } |
| |
| } |
| |
| void get_param(struct ia_sensor_mgr *smd, int param_id) { |
| struct iaxxx_sensor_param sp; |
| int err = 0; |
| ALOGD ("Get param - param_id 0x%X", param_id); |
| |
| if (NULL == smd) { |
| ALOGE("%s: NULL handle passed", __func__); |
| return; |
| } |
| |
| sp.inst_id = 0; |
| sp.block_id = 0; |
| |
| sp.param_id = param_id; |
| err = ioctl(fileno(smd->dev_node), MODULE_SENSOR_GET_PARAM, (unsigned long) &sp); |
| if (-1 == err) { |
| ALOGE("%s: ERROR: MODULE_SENSOR_GET_PARAM IOCTL failed with error %d(%s)", __func__, errno, strerror(errno)); |
| return; |
| } else { |
| ALOGD("Value of param 0x%X is %zu", |
| sp.param_id, sp.param_val); |
| fprintf(stdout, "Value of param 0x%X is %zu\n", |
| sp.param_id, sp.param_val); |
| } |
| } |
| |
| |
| int main(int argc, char *argv[]) { |
| struct ia_sensor_mgr * smd; |
| char use_case; |
| int param_id = -1; |
| int c; |
| float param_val; |
| |
| if (argc <= 1) { |
| usage(); |
| } |
| |
| while ((c = getopt_long (argc, argv, "s:v:g:", long_options, NULL)) != -1) { |
| switch (c) { |
| case 's': |
| if (NULL == optarg) { |
| fprintf(stderr, "Incorrect usage, s option requires an argument"); |
| usage(); |
| } else { |
| param_id = strtol(optarg, NULL, 0); |
| use_case = 's'; |
| } |
| break; |
| case 'v': |
| if (NULL == optarg) { |
| fprintf(stderr, "Incorrect usage, v option requires an argument"); |
| usage(); |
| } else { |
| if ('s' == use_case) { |
| param_val = strtof(optarg, NULL); |
| } else { |
| fprintf(stderr, "Incorrect usage, v option should be the second option"); |
| usage(); |
| } |
| } |
| break; |
| case 'g': |
| if (NULL == optarg) { |
| fprintf(stderr, "Incorrect usage, g option requires an argument"); |
| usage(); |
| } else { |
| param_id = strtol(optarg, NULL, 0); |
| use_case = 'g'; |
| } |
| break; |
| case GETOPT_HELP_CHAR: |
| default: |
| usage(); |
| break; |
| } |
| } |
| |
| smd = (struct ia_sensor_mgr*) malloc(sizeof(struct ia_sensor_mgr)); |
| if (NULL == smd) { |
| ALOGE("%s: ERROR Failed to allocated memory for ia_sensor_mgr", __func__); |
| return -EINVAL; |
| } |
| |
| if((smd->dev_node = fopen(DEV_NODE, "rw")) == NULL) { |
| ALOGE("%s: ERROR file %s open for write error: %s\n", __func__, DEV_NODE, strerror(errno)); |
| free(smd); |
| return -EINVAL; |
| } |
| |
| |
| if ('s' == use_case) { |
| set_param(smd, param_id, param_val); |
| } else if ('g' == use_case) { |
| get_param(smd, param_id); |
| } |
| |
| if (smd->dev_node) { |
| fclose(smd->dev_node); |
| } |
| |
| if (smd) { |
| free(smd); |
| } |
| |
| return 0; |
| } |