/*      $NetBSD: emcfanctl.c,v 1.1 2025/03/11 13:56:48 brad Exp $       */

/*
* Copyright (c) 2025 Brad Spencer <[email protected]>
*
* Permission to use, copy, modify, and distribute this software for any
* purpose with or without fee is hereby granted, provided that the above
* copyright notice and this permission notice appear in all copies.
*
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
* ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
* ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
* OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*/

#include <sys/cdefs.h>
#ifdef __RCSID
__RCSID("$NetBSD: emcfanctl.c,v 1.1 2025/03/11 13:56:48 brad Exp $");
#endif

/* Main userland program that can interfact with a EMC-210x and EMC-230x
* fan controller using emcfan(4).
*/

#include <stdio.h>
#include <stdint.h>
#include <unistd.h>
#include <stdbool.h>
#include <stdlib.h>
#include <string.h>
#include <inttypes.h>
#include <err.h>
#include <errno.h>
#include <fcntl.h>
#include <sys/ioctl.h>

#include <dev/i2c/emcfanreg.h>
#include <dev/i2c/emcfaninfo.h>

#define EXTERN extern
#include "emcfanctl.h"
#include "emcfanctlconst.h"
#include "emcfanctlutil.h"
#include "emcfanctloutputs.h"

int     valid_cmd(const struct emcfanctlcmd[], long unsigned int, char *);

static void
usage(void)
{
       const char *p = getprogname();

       fprintf(stderr, "Usage: %s [-jdh] device cmd args\n\n",
           p);

       for(long unsigned int i = 0;i < __arraycount(emcfanctlcmds);i++) {
               switch (emcfanctlcmds[i].id) {
               case EMCFANCTL_REGISTER:
                       for(long unsigned int j = 0;j < __arraycount(emcfanctlregistercmds);j++) {
                               fprintf(stderr,"%s [-jdh] device %s %s\n",
                                   p,
                                   emcfanctlcmds[i].cmd,
                                   emcfanctlregistercmds[j].helpargs);
                       }
                       break;
               case EMCFANCTL_FAN:
                       for(long unsigned int j = 0;j < __arraycount(emcfanctlfancmds);j++) {
                               switch (emcfanctlfancmds[j].id) {
                               case EMCFANCTL_FAN_DRIVE:
                               case EMCFANCTL_FAN_DIVIDER:
                                       for(long unsigned int k = 0;k < __arraycount(emcfanctlddcmds);k++) {
                                               fprintf(stderr,"%s [-jdh] device %s <n> %s %s\n",
                                                   p,
                                                   emcfanctlcmds[i].cmd,
                                                   emcfanctlfancmds[j].cmd,
                                                   emcfanctlddcmds[k].helpargs);
                                       }
                                       break;
                               case EMCFANCTL_FAN_MINEXPECTED_RPM:
                                       for(long unsigned int k = 0;k < __arraycount(emcfanctlddcmds);k++) {
                                               if (emcfanctlddcmds[k].id != EMCFANCTL_FAN_DD_WRITE) {
                                                       fprintf(stderr,"%s [-jdh] device %s <n> %s %s\n",
                                                           p,
                                                           emcfanctlcmds[i].cmd,
                                                           emcfanctlfancmds[j].cmd,
                                                           emcfanctlddcmds[k].helpargs);
                                               } else {
                                                       fprintf(stderr,"%s [-jdh] device %s <n> %s %s ",
                                                           p,
                                                           emcfanctlcmds[i].cmd,
                                                           emcfanctlfancmds[j].cmd,
                                                           emcfanctlddcmds[k].helpargs);
                                                       for(long unsigned int q = 0;q < __arraycount(fan_minexpectedrpm);q++) {
                                                               fprintf(stderr,"%d|",fan_minexpectedrpm[q].human_int);
                                                       }
                                                       fprintf(stderr,"\n");
                                               }
                                       }
                                       break;
                               case EMCFANCTL_FAN_EDGES:
                                       for(long unsigned int k = 0;k < __arraycount(emcfanctlddcmds);k++) {
                                               if (emcfanctlddcmds[k].id != EMCFANCTL_FAN_DD_WRITE) {
                                                       fprintf(stderr,"%s [-jdh] device %s <n> %s %s\n",
                                                           p,
                                                           emcfanctlcmds[i].cmd,
                                                           emcfanctlfancmds[j].cmd,
                                                           emcfanctlddcmds[k].helpargs);
                                               } else {
                                                       fprintf(stderr,"%s [-jdh] device %s <n> %s %s ",
                                                           p,
                                                           emcfanctlcmds[i].cmd,
                                                           emcfanctlfancmds[j].cmd,
                                                           emcfanctlddcmds[k].helpargs);
                                                       for(long unsigned int q = 0;q < __arraycount(fan_numedges);q++) {
                                                               fprintf(stderr,"%d|",fan_numedges[q].human_int);
                                                       }
                                                       fprintf(stderr,"\n");
                                               }
                                       }
                                       break;
                               case EMCFANCTL_FAN_POLARITY:
                                       for(long unsigned int k = 0;k < __arraycount(emcfanctlpcmds);k++) {
                                               fprintf(stderr,"%s [-jdh] device %s <n> %s %s\n",
                                                   p,
                                                   emcfanctlcmds[i].cmd,
                                                   emcfanctlfancmds[j].cmd,
                                                   emcfanctlpcmds[k].helpargs);
                                       }
                                       break;
                               case EMCFANCTL_FAN_PWM_BASEFREQ:
                                       for(long unsigned int k = 0;k < __arraycount(emcfanctlddcmds);k++) {
                                               if (emcfanctlddcmds[k].id != EMCFANCTL_FAN_DD_WRITE) {
                                                       fprintf(stderr,"%s [-jdh] device %s <n> %s %s\n",
                                                           p,
                                                           emcfanctlcmds[i].cmd,
                                                           emcfanctlfancmds[j].cmd,
                                                           emcfanctlddcmds[k].helpargs);
                                               } else {
                                                       fprintf(stderr,"%s [-jdh] device %s <n> %s %s ",
                                                           p,
                                                           emcfanctlcmds[i].cmd,
                                                           emcfanctlfancmds[j].cmd,
                                                           emcfanctlddcmds[k].helpargs);
                                                       for(long unsigned int q = 0;q < __arraycount(fan_pwm_basefreq);q++) {
                                                               if (fan_pwm_basefreq[q].instance > 0)
                                                                       break;
                                                               fprintf(stderr,"%d|",fan_pwm_basefreq[q].human_int);
                                                       }
                                                       fprintf(stderr,"\n");
                                               }
                                       }
                                       break;
                               case EMCFANCTL_FAN_PWM_OUTPUTTYPE:
                                       for(long unsigned int k = 0;k < __arraycount(emcfanctlotcmds);k++) {
                                               fprintf(stderr,"%s [-jdh] device %s <n> %s %s\n",
                                                   p,
                                                   emcfanctlcmds[i].cmd,
                                                   emcfanctlfancmds[j].cmd,
                                                   emcfanctlotcmds[k].helpargs);
                                       }
                                       break;
                               default:
                                       fprintf(stderr,"%s [-jdh] device %s %s\n",
                                           p,
                                           emcfanctlcmds[i].cmd,
                                           emcfanctlfancmds[j].helpargs);
                                       break;
                               };
                       }
                       break;
               case EMCFANCTL_APD:
               case EMCFANCTL_SMBUSTO:
                       for(long unsigned int j = 0;j < __arraycount(emcfanctlapdsmtocmds);j++) {
                               fprintf(stderr,"%s [-jdh] device %s %s\n",
                                   p,
                                   emcfanctlcmds[i].cmd,
                                   emcfanctlapdsmtocmds[j].helpargs);
                       }
                       break;
               default:
                       fprintf(stderr,"%s [-jdh] device %s %s\n",
                           p,emcfanctlcmds[i].cmd,emcfanctlcmds[i].helpargs);
                       break;
               };
       }
}

int
valid_cmd(const struct emcfanctlcmd c[], long unsigned int csize, char *cmdtocheck)
{
       int r = -1;

       for(long unsigned int i = 0;i < csize;i++) {
               if (strncmp(cmdtocheck,c[i].cmd,16) == 0) {
                       r = i;
                       break;
               }
       }

       return r;
}

int
main(int argc, char *argv[])
{
       int c;
       bool debug = false;
       uint8_t product_id;
       int product_family;
       int fd = -1, valid, error = 0, validsub = -1, validsubsub = -1;
       bool jsonify = false;
       int start_reg = 0xff, end_reg, value, tvalue, instance;
       int the_fan;

       while ((c = getopt(argc, argv, "djh")) != -1 ) {
               switch (c) {
               case 'd':
                       debug = true;
                       break;
               case 'j':
                       jsonify = true;
                       break;
               case 'h':
               default:
                       usage();
                       exit(0);
               }
       }

       argc -= optind;
       argv += optind;

       if (debug) {
               fprintf(stderr,"ARGC: %d\n", argc);
               fprintf(stderr,"ARGV[0]: %s ; ARGV[1]: %s ; ARGV[2]: %s ; ARGV[3]: %s; ARGV[4]: %s; ARGV[5]: %s\n",
                   argv[0],argv[1],argv[2],argv[3],argv[4],argv[5]);
       }

       if (argc <= 1) {
               usage();
               exit(0);
       }

       fd = open(argv[0], O_RDWR, 0);
       if (fd == -1) {
               err(EXIT_FAILURE, "open %s", argv[0]);
       }

       error = emcfan_read_register(fd, EMCFAN_PRODUCT_ID, &product_id, debug);

       if (error)
               err(EXIT_FAILURE, "read product_id %d", error);

       int iindex;
       iindex = emcfan_find_info(product_id);
       if (iindex == -1) {
               printf("Unknown info for product_id: %d\n",product_id);
               exit(2);
       }

       product_family = emcfan_chip_infos[iindex].family;

       /* Parse out the command line into what the requested action is */

       valid = valid_cmd(emcfanctlcmds,__arraycount(emcfanctlcmds),argv[1]);
       if (valid != -1) {
               switch (emcfanctlcmds[valid].id) {
               case EMCFANCTL_INFO:
                       error = output_emcfan_info(fd, product_id, product_family, jsonify, debug);
                       if (error != 0) {
                               errno = error;
                               err(EXIT_FAILURE, "output info");
                       }
                       break;
               case EMCFANCTL_APD:
                       if (argc >= 3) {
                               validsub = valid_cmd(emcfanctlapdsmtocmds,__arraycount(emcfanctlapdsmtocmds),argv[2]);
                               if (product_id == EMCFAN_PRODUCT_2103_24 ||
                                   product_id == EMCFAN_PRODUCT_2104 ||
                                   product_id == EMCFAN_PRODUCT_2106) {
                                       switch(emcfanctlapdsmtocmds[validsub].id) {
                                       case EMCFANCTL_APD_READ:
                                               error = output_emcfan_apd(fd, product_id, product_family, EMCFAN_CHIP_CONFIG, jsonify, debug);
                                               if (error != 0) {
                                                       fprintf(stderr, "Error output for apd subcommand: %d\n",error);
                                                       exit(1);
                                               }
                                               break;
                                       case EMCFANCTL_APD_ON:
                                       case EMCFANCTL_APD_OFF:
                                               tvalue = find_translated_bits_by_str(apd, __arraycount(apd), argv[2]);
                                               if (tvalue < 0) {
                                                       fprintf(stderr,"Error converting human value: %s\n", argv[4]);
                                                       exit(1);
                                               }
                                               error = emcfan_rmw_register(fd, EMCFAN_CHIP_CONFIG, 0, apd, __arraycount(apd), tvalue, debug);
                                               if (error != 0) {
                                                       errno = error;
                                                       err(EXIT_FAILURE, "read/modify/write register");
                                               }
                                               break;
                                       default:
                                               fprintf(stderr,"Unhandled subcommand to apd: %s %d\n\n", argv[2], validsub);
                                               usage();
                                               exit(1);
                                               break;
                                       };
                               } else {
                                       errno = EINVAL;
                                       err(EXIT_FAILURE, "This chip does not support the APD command");
                               }
                       } else {
                               fprintf(stderr,"Missing arguments to apd command\n\n");
                               usage();
                               exit(1);
                       }
                       break;
               case EMCFANCTL_SMBUSTO:
                       if (argc >= 3) {
                               if (product_id ==  EMCFAN_PRODUCT_2101 ||
                                   product_id == EMCFAN_PRODUCT_2101R) {
                                       start_reg = EMCFAN_2101_CHIP_CONFIG;
                                       instance = 2101;
                               } else {
                                       if (product_family == EMCFAN_FAMILY_230X) {
                                               start_reg = EMCFAN_CHIP_CONFIG;
                                               instance = 2301;
                                       } else {
                                               start_reg = EMCFAN_CHIP_CONFIG_2;
                                               instance = 2103;
                                       }
                               }

                               validsub = valid_cmd(emcfanctlapdsmtocmds,__arraycount(emcfanctlapdsmtocmds),argv[2]);
                               switch(emcfanctlapdsmtocmds[validsub].id) {
                               case EMCFANCTL_APD_READ:
                                       error = output_emcfan_smbusto(fd, product_id, product_family, start_reg, instance, jsonify, debug);
                                       if (error != 0) {
                                               fprintf(stderr, "Error output for SMBUS timeout subcommand: %d\n",error);
                                               exit(1);
                                       }
                                       break;
                               case EMCFANCTL_APD_ON:
                               case EMCFANCTL_APD_OFF:
                                       tvalue = find_translated_bits_by_str_instance(smbus_timeout, __arraycount(smbus_timeout), argv[2], instance);
                                       if (tvalue < 0) {
                                               fprintf(stderr,"Error converting human value: %s\n", argv[4]);
                                               exit(1);
                                       }
                                       error = emcfan_rmw_register(fd, start_reg, 0, smbus_timeout, __arraycount(smbus_timeout), tvalue, debug);
                                       if (error != 0) {
                                               errno = error;
                                               err(EXIT_FAILURE, "read/modify/write register");
                                       }
                                       break;
                               default:
                                       fprintf(stderr,"Unhandled subcommand to SMBUS timeout: %s %d\n\n", argv[2], validsub);
                                       usage();
                                       exit(1);
                                       break;
                               };
                       } else {
                               fprintf(stderr,"Missing arguments to SMBUS timeout command\n\n");
                               usage();
                               exit(1);
                       }
                       break;
               case EMCFANCTL_REGISTER:
                       if (argc >= 3) {
                               validsub = valid_cmd(emcfanctlregistercmds,__arraycount(emcfanctlregistercmds),argv[2]);
                               switch (emcfanctlregistercmds[validsub].id) {
                               case EMCFANCTL_REGISTER_LIST:
                                       output_emcfan_register_list(product_id, product_family, jsonify, debug);
                                       break;
                               case EMCFANCTL_REGISTER_READ:
                                       start_reg = end_reg = 0x00;
                                       if (argc >= 4) {
                                               start_reg = (uint8_t)strtoi(argv[3], NULL, 0, 0, 0xff, &error);
                                               if (error) {
                                                       start_reg = emcfan_reg_by_name(product_id, product_family, argv[3]);
                                                       if (start_reg == -1) {
                                                               fprintf(stderr,"Bad conversion for read register start: %s\n", argv[3]);
                                                               exit(1);
                                                       }
                                               }
                                               end_reg = start_reg;
                                               if (argc == 5) {
                                                       end_reg = (uint8_t)strtoi(argv[4], NULL, 0, 0, 0xff, &error);
                                                       if (error) {
                                                               end_reg = emcfan_reg_by_name(product_id, product_family, argv[4]);
                                                               if (end_reg == -1) {
                                                                       fprintf(stderr,"Bad conversion for read register end: %s\n", argv[4]);
                                                                       exit(1);
                                                               }
                                                       }
                                               }
                                       } else {
                                               end_reg = 0xff;
                                       }
                                       if (end_reg < start_reg) {
                                               fprintf(stderr,"Register end can not be less than register start: %d %d\n\n", start_reg, end_reg);
                                               usage();
                                               exit(1);
                                       }

                                       if (debug)
                                               fprintf(stderr,"register read: START_REG: %d 0x%02X, END_REG: %d 0x%02X\n",start_reg, start_reg, end_reg, end_reg);

                                       error = output_emcfan_register_read(fd, product_id, product_family, start_reg, end_reg, jsonify, debug);
                                       if (error != 0) {
                                               fprintf(stderr, "Error read register: %d\n",error);
                                               exit(1);
                                       }

                                       break;
                               case EMCFANCTL_REGISTER_WRITE:
                                       if (argc == 5) {
                                               start_reg = (uint8_t)strtoi(argv[3], NULL, 0, 0, 0xff, &error);
                                               if (error) {
                                                       start_reg = emcfan_reg_by_name(product_id, product_family, argv[3]);
                                                       if (start_reg == -1) {
                                                               fprintf(stderr,"Bad conversion for write register: %s\n", argv[3]);
                                                               exit(1);
                                                       }
                                               }

                                               value = (uint8_t)strtoi(argv[4], NULL, 0, 0, 0xff, &error);
                                               if (error) {
                                                       fprintf(stderr,"Could not convert value for register write.\n");
                                                       usage();
                                                       exit(1);
                                               }
                                       } else {
                                               fprintf(stderr,"Not enough arguments for register write.\n");
                                               usage();
                                               exit(1);
                                       }

                                       if (debug)
                                               fprintf(stderr,"register write: START_REG: %d 0x%02X, VALUE: %d 0x%02X\n",start_reg, start_reg, value, value);

                                       error = emcfan_write_register(fd, start_reg, value, debug);
                                       if (error != 0) {
                                               errno = error;
                                               err(EXIT_FAILURE, "write register");
                                       }

                                       break;
                               default:
                                       fprintf(stderr,"Unhandled subcommand to register: %s %d\n\n", argv[2], validsub);
                                       usage();
                                       exit(1);
                                       break;
                               };
                       } else {
                               fprintf(stderr,"Missing arguments to register command\n\n");
                               usage();
                               exit(1);
                       }
                       break;
               case EMCFANCTL_FAN:
                       if (argc >= 4) {
                               the_fan = strtoi(argv[2], NULL, 0, 1, emcfan_chip_infos[iindex].num_fans, &error);
                               if (error) {
                                       fprintf(stderr,"Bad conversion for fan number: %s\n", argv[2]);
                                       exit(1);
                               }
                               the_fan--;
                               validsub = valid_cmd(emcfanctlfancmds,__arraycount(emcfanctlfancmds),argv[3]);
                               switch (emcfanctlfancmds[validsub].id) {
                               case EMCFANCTL_FAN_STATUS:
                                       if (product_id != EMCFAN_PRODUCT_2101 &&
                                           product_id != EMCFAN_PRODUCT_2101R) {
                                               if (product_family == EMCFAN_FAMILY_230X) {
                                                       start_reg = EMCFAN_230X_FAN_STATUS;
                                                       end_reg = EMCFAN_230X_FAN_DRIVE_STATUS;
                                               } else {
                                                       start_reg = EMCFAN_210_346_FAN_STATUS;
                                                       end_reg = 0xff;
                                               }
                                       } else {
                                               errno = EINVAL;
                                               err(EXIT_FAILURE, "EMC2101 and EMC2101R do not support this subcommand");
                                       }
                                       break;
                               case EMCFANCTL_FAN_DRIVE:
                                       start_reg = emcfan_chip_infos[iindex].fan_drive_registers[the_fan];
                                       break;
                               case EMCFANCTL_FAN_DIVIDER:
                                       start_reg = emcfan_chip_infos[iindex].fan_divider_registers[the_fan];
                                       break;
                               case EMCFANCTL_FAN_MINEXPECTED_RPM:
                               case EMCFANCTL_FAN_EDGES:
                                       if (product_id != EMCFAN_PRODUCT_2101 &&
                                           product_id != EMCFAN_PRODUCT_2101R) {
                                               if (debug)
                                                       fprintf(stderr,"fan subcommand minexpected_rpm / edges: the_fan=%d\n",the_fan);
                                               if (product_family == EMCFAN_FAMILY_210X) {
                                                       the_fan = strtoi(argv[2], NULL, 0, 1, emcfan_chip_infos[iindex].num_tachs, &error);
                                                       if (error) {
                                                               fprintf(stderr,"Bad conversion for fan number: %s\n", argv[2]);
                                                               exit(1);
                                                       }
                                                       the_fan--;
                                                       switch(the_fan) {
                                                       case 0:
                                                               start_reg = EMCFAN_210_346_CONFIG_1;
                                                               break;
                                                       case 1:
                                                               start_reg = EMCFAN_210_346_CONFIG_2;
                                                               break;
                                                       default:
                                                               start_reg = 0xff;
                                                               break;
                                                       };
                                               } else {
                                                       switch(the_fan) {
                                                       case 0:
                                                               start_reg = EMCFAN_230X_CONFIG_1;
                                                               break;
                                                       case 1:
                                                               start_reg = EMCFAN_230X_CONFIG_2;
                                                               break;
                                                       case 2:
                                                               start_reg = EMCFAN_230X_CONFIG_3;
                                                               break;
                                                       case 3:
                                                               start_reg = EMCFAN_230X_CONFIG_4;
                                                               break;
                                                       case 4:
                                                               start_reg = EMCFAN_230X_CONFIG_5;
                                                               break;
                                                       default:
                                                               start_reg = 0xff;
                                                               break;
                                                       };
                                               }
                                       } else {
                                               errno = EINVAL;
                                               err(EXIT_FAILURE, "EMC2101 and EMC2101R do not support this subcommand");
                                       }
                                       break;
                               case EMCFANCTL_FAN_POLARITY:
                                       if (product_id != EMCFAN_PRODUCT_2101 &&
                                           product_id != EMCFAN_PRODUCT_2101R) {
                                               start_reg = EMCFAN_POLARITY_CONFIG;
                                       } else {
                                               start_reg = EMCFAN_2101_FAN_CONFIG;
                                       }
                                       break;
                               case EMCFANCTL_FAN_PWM_BASEFREQ:
                                       if (product_id != EMCFAN_PRODUCT_2101 &&
                                           product_id != EMCFAN_PRODUCT_2101R) {
                                               if (product_family == EMCFAN_FAMILY_210X)
                                                       start_reg = EMCFAN_210_346_PWM_BASEFREQ;
                                               else
                                                       if (the_fan <= 2)
                                                               start_reg = EMCFAN_230X_BASE_FREQ_123;
                                                       else
                                                               start_reg = EMCFAN_230X_BASE_FREQ_45;
                                       } else {
                                               errno = EINVAL;
                                               err(EXIT_FAILURE, "EMC2101 and EMC2101R do not support this subcommand");
                                       }
                                       break;
                               case EMCFANCTL_FAN_PWM_OUTPUTTYPE:
                                       if (product_family == EMCFAN_FAMILY_230X) {
                                               start_reg = EMCFAN_230X_OUTPUT_CONFIG;
                                       } else {
                                               errno = EINVAL;
                                               err(EXIT_FAILURE, "This subcommand is only supported on the EMC230X family");
                                       }
                                       break;
                               default:
                                       fprintf(stderr,"Unhandled subcommand to fan: %s %d\n\n", argv[3], validsub);
                                       usage();
                                       exit(1);
                                       break;
                               };
                               if (emcfanctlfancmds[validsub].id == EMCFANCTL_FAN_STATUS) {
                                       error = output_emcfan_fan_status(fd, product_id, product_family, start_reg, end_reg, the_fan, jsonify, debug);
                                       if (error != 0) {
                                               fprintf(stderr, "Error fan status for fan subcommand: %d\n",error);
                                               exit(1);
                                       }
                               }
                               if (emcfanctlfancmds[validsub].id == EMCFANCTL_FAN_DRIVE ||
                                   emcfanctlfancmds[validsub].id == EMCFANCTL_FAN_DIVIDER) {
                                       validsubsub = valid_cmd(emcfanctlddcmds,__arraycount(emcfanctlddcmds),argv[4]);
                                       switch(emcfanctlddcmds[validsubsub].id) {
                                       case EMCFANCTL_FAN_DD_READ:
                                               if (emcfanctlfancmds[validsub].id == EMCFANCTL_FAN_DRIVE)
                                                       error = output_emcfan_drive(fd, product_id, product_family, start_reg, jsonify, debug);
                                               else
                                                       error = output_emcfan_divider(fd, product_id, product_family, start_reg, jsonify, debug);
                                               if (error != 0) {
                                                       fprintf(stderr, "Error read drive / divider for fan subcommand: %d\n",error);
                                                       exit(1);
                                               }
                                               break;
                                       case EMCFANCTL_FAN_DD_WRITE:
                                               value = (uint8_t)strtoi(argv[5], NULL, 0, 0, 0xff, &error);
                                               if (error) {
                                                       fprintf(stderr,"Could not convert value for fan subcommand write.\n");
                                                       usage();
                                                       exit(1);
                                               }
                                               error = emcfan_write_register(fd, start_reg, value, debug);
                                               if (error != 0) {
                                                       errno = error;
                                                       err(EXIT_FAILURE, "write register");
                                               }
                                               break;
                                       default:
                                               fprintf(stderr,"Unhandled subsubcommand to fan: %s %d\n\n", argv[4], validsubsub);
                                               usage();
                                               exit(1);
                                               break;
                                       };
                               }
                               if (emcfanctlfancmds[validsub].id == EMCFANCTL_FAN_MINEXPECTED_RPM) {
                                       if (start_reg == 0xff) {
                                               fprintf(stderr,"fan minexpected rpm subcommand, unknown register\n");
                                               exit(1);
                                       }
                                       validsubsub = valid_cmd(emcfanctlddcmds,__arraycount(emcfanctlddcmds),argv[4]);
                                       switch(emcfanctlddcmds[validsubsub].id) {
                                       case EMCFANCTL_FAN_DD_READ:
                                               error = output_emcfan_minexpected_rpm(fd, product_id, product_family, start_reg, jsonify, debug);
                                               if (error != 0) {
                                                       fprintf(stderr, "Error read minexpected rpm subcommand: %d\n",error);
                                                       exit(1);
                                               }
                                               break;
                                       case EMCFANCTL_FAN_DD_WRITE:
                                               value = (int)strtoi(argv[5], NULL, 0, 0, 0xffff, &error);
                                               if (error) {
                                                       fprintf(stderr,"Could not convert value for minexpected rpm subcommand write.\n");
                                                       usage();
                                                       exit(1);
                                               }
                                               tvalue = find_translated_bits_by_hint(fan_minexpectedrpm, __arraycount(fan_minexpectedrpm), value);
                                               if (tvalue < 0) {
                                                       fprintf(stderr,"Error converting human value: %d %d\n",value, tvalue);
                                                       exit(1);
                                               }
                                               error = emcfan_rmw_register(fd, start_reg, value, fan_minexpectedrpm, __arraycount(fan_minexpectedrpm), tvalue, debug);
                                               if (error != 0) {
                                                       errno = error;
                                                       err(EXIT_FAILURE, "read/modify/write register");
                                               }
                                               break;
                                       default:
                                               fprintf(stderr,"Unhandled subsubcommand to minexpected rpm subcommand: %s %d\n\n", argv[4], validsubsub);
                                               usage();
                                               exit(1);
                                               break;
                                       };
                               }
                               if (emcfanctlfancmds[validsub].id == EMCFANCTL_FAN_EDGES) {
                                       if (start_reg == 0xff) {
                                               fprintf(stderr,"fan edges subcommand, unknown register\n");
                                               exit(1);
                                       }
                                       validsubsub = valid_cmd(emcfanctlddcmds,__arraycount(emcfanctlddcmds),argv[4]);
                                       switch(emcfanctlddcmds[validsubsub].id) {
                                       case EMCFANCTL_FAN_DD_READ:
                                               error = output_emcfan_edges(fd, product_id, product_family, start_reg, jsonify, debug);
                                               if (error != 0) {
                                                       fprintf(stderr, "Error read edges subcommand: %d\n",error);
                                                       exit(1);
                                               }
                                               break;
                                       case EMCFANCTL_FAN_DD_WRITE:
                                               value = (uint8_t)strtoi(argv[5], NULL, 0, 0, 9, &error);
                                               if (error) {
                                                       fprintf(stderr,"Could not convert value for edges subcommand write.\n");
                                                       usage();
                                                       exit(1);
                                               }
                                               tvalue = find_translated_bits_by_hint(fan_numedges, __arraycount(fan_numedges), value);
                                               if (tvalue < 0) {
                                                       fprintf(stderr,"Error converting human value: %d\n",value);
                                                       exit(1);
                                               }
                                               error = emcfan_rmw_register(fd, start_reg, value, fan_numedges, __arraycount(fan_numedges), tvalue, debug);
                                               if (error != 0) {
                                                       errno = error;
                                                       err(EXIT_FAILURE, "read/modify/write register");
                                               }
                                               break;
                                       default:
                                               fprintf(stderr,"Unhandled subsubcommand to minexpected rpm subcommand: %s %d\n\n", argv[4], validsubsub);
                                               usage();
                                               exit(1);
                                               break;
                                       };
                               }
                               if (emcfanctlfancmds[validsub].id == EMCFANCTL_FAN_POLARITY) {
                                       if (start_reg == 0xff) {
                                               fprintf(stderr,"fan polarity subcommand, unknown register\n");
                                               exit(1);
                                       }
                                       validsubsub = valid_cmd(emcfanctlpcmds,__arraycount(emcfanctlpcmds),argv[4]);
                                       switch(emcfanctlpcmds[validsubsub].id) {
                                       case EMCFANCTL_FAN_P_READ:
                                               error = output_emcfan_polarity(fd, product_id, product_family, start_reg, the_fan, jsonify, debug);
                                               if (error != 0) {
                                                       fprintf(stderr, "Error output for polarity subcommand: %d\n",error);
                                                       exit(1);
                                               }
                                               break;
                                       case EMCFANCTL_FAN_P_INVERTED:
                                       case EMCFANCTL_FAN_P_NONINVERTED:
                                               if (product_id == EMCFAN_PRODUCT_2101 ||
                                                   product_id == EMCFAN_PRODUCT_2101R) {
                                                       tvalue = find_translated_bits_by_str_instance(fan_polarity, __arraycount(fan_polarity), argv[4], 2101);
                                               } else {
                                                       tvalue = find_translated_bits_by_str_instance(fan_polarity, __arraycount(fan_polarity), argv[4], the_fan);
                                               }
                                               if (tvalue < 0) {
                                                       fprintf(stderr,"Error converting human value: %s\n", argv[4]);
                                                       exit(1);
                                               }
                                               error = emcfan_rmw_register(fd, start_reg, 0, fan_polarity, __arraycount(fan_polarity), tvalue, debug);
                                               if (error != 0) {
                                                       errno = error;
                                                       err(EXIT_FAILURE, "read/modify/write register");
                                               }
                                               break;
                                       default:
                                               fprintf(stderr,"Unhandled subsubcommand to polarity subcommand: %s %d\n\n", argv[4], validsubsub);
                                               usage();
                                               exit(1);
                                               break;
                                       };

                               }
                               if (emcfanctlfancmds[validsub].id == EMCFANCTL_FAN_PWM_BASEFREQ) {
                                       if (start_reg == 0xff) {
                                               fprintf(stderr,"fan base_freq subcommand, unknown register\n");
                                               exit(1);
                                       }
                                       validsubsub = valid_cmd(emcfanctlddcmds,__arraycount(emcfanctlddcmds),argv[4]);
                                       switch(emcfanctlddcmds[validsubsub].id) {
                                       case EMCFANCTL_FAN_DD_READ:
                                               if (debug)
                                                       fprintf(stderr,"%s: the_fan=%d\n",__func__,the_fan);
                                               if (product_id != EMCFAN_PRODUCT_2305)
                                                       error = output_emcfan_pwm_basefreq(fd, product_id, product_family, start_reg, the_fan, jsonify, debug);
                                               else
                                                       if (the_fan <= 2)
                                                               error = output_emcfan_pwm_basefreq(fd, product_id, product_family, start_reg, the_fan, jsonify, debug);
                                                       else
                                                               error = output_emcfan_pwm_basefreq(fd, product_id, product_family, start_reg,
                                                                   the_fan + 23050, jsonify, debug);
                                               if (error != 0) {
                                                       fprintf(stderr, "Error read base_freq subcommand: %d\n",error);
                                                       exit(1);
                                               }
                                               break;
                                       case EMCFANCTL_FAN_DD_WRITE:
                                               value = (int)strtoi(argv[5], NULL, 0, 0, 0xffff, &error);
                                               if (error) {
                                                       fprintf(stderr,"Could not convert value for base_freq subcommand write.\n");
                                                       usage();
                                                       exit(1);
                                               }
                                               if (product_id != EMCFAN_PRODUCT_2305)
                                                       tvalue = find_translated_bits_by_hint_instance(fan_pwm_basefreq, __arraycount(fan_pwm_basefreq), value, the_fan);
                                               else
                                                       if (the_fan <= 2)
                                                               tvalue = find_translated_bits_by_hint_instance(fan_pwm_basefreq, __arraycount(fan_pwm_basefreq), value, the_fan);
                                                       else
                                                               tvalue = find_translated_bits_by_hint_instance(fan_pwm_basefreq, __arraycount(fan_pwm_basefreq),
                                                                   value, the_fan + 23050);
                                               if (tvalue < 0) {
                                                       fprintf(stderr,"Error converting human value: %d %d\n",value, tvalue);
                                                       exit(1);
                                               }
                                               error = emcfan_rmw_register(fd, start_reg, value, fan_pwm_basefreq, __arraycount(fan_pwm_basefreq), tvalue, debug);
                                               if (error != 0) {
                                                       errno = error;
                                                       err(EXIT_FAILURE, "read/modify/write register");
                                               }
                                               break;
                                       default:
                                               fprintf(stderr,"Unhandled subsubcommand to base_freq subcommand: %s %d\n\n", argv[4], validsubsub);
                                               usage();
                                               exit(1);
                                               break;
                                       };
                                       break;
                               }
                               if (emcfanctlfancmds[validsub].id == EMCFANCTL_FAN_PWM_OUTPUTTYPE) {
                                       if (start_reg == 0xff) {
                                               fprintf(stderr,"fan pwm_output_type subcommand, unknown register\n");
                                               exit(1);
                                       }
                                       validsubsub = valid_cmd(emcfanctlotcmds,__arraycount(emcfanctlotcmds),argv[4]);
                                       switch(emcfanctlotcmds[validsubsub].id) {
                                       case EMCFANCTL_FAN_OT_READ:
                                               error = output_emcfan_pwm_output_type(fd, product_id, product_family, start_reg, the_fan, jsonify, debug);
                                               if (error != 0) {
                                                       fprintf(stderr, "Error output for pwm_output_type subcommand: %d\n",error);
                                                       exit(1);
                                               }
                                               break;
                                       case EMCFANCTL_FAN_OT_PUSHPULL:
                                       case EMCFANCTL_FAN_OT_OPENDRAIN:
                                               tvalue = find_translated_bits_by_str_instance(fan_pwm_output_type, __arraycount(fan_pwm_output_type), argv[4], the_fan);
                                               if (tvalue < 0) {
                                                       fprintf(stderr,"Error converting human value: %s\n", argv[4]);
                                                       exit(1);
                                               }
                                               error = emcfan_rmw_register(fd, start_reg, 0, fan_pwm_output_type, __arraycount(fan_pwm_output_type), tvalue, debug);
                                               if (error != 0) {
                                                       errno = error;
                                                       err(EXIT_FAILURE, "read/modify/write register");
                                               }
                                               break;
                                       default:
                                               fprintf(stderr,"Unhandled subsubcommand to pwm_output_type subcommand: %s %d\n\n", argv[4], validsubsub);
                                               usage();
                                               exit(1);
                                               break;
                                       };

                               }
                       } else {
                               fprintf(stderr,"Missing arguments to fan command\n\n");
                               usage();
                               exit(1);
                       }
                       break;
               default:
                       fprintf(stderr,"Unknown handling of command: %d\n",valid);
                       exit(2);
                       break;
               }
       } else {
               fprintf(stderr,"Unknown command: %s\n\n",argv[1]);
               usage();
               exit(1);
       }
       close(fd);
       exit(0);
}

You are viewing proxied material from ftp.icm.edu.pl. The copyright of proxied material belongs to its original authors. Any comments or complaints in relation to proxied material should be directed to the original authors of the content concerned. Please see the disclaimer for more details.