mirror
/
Hamlib
kopia lustrzana https://github.com/Hamlib/Hamlib
1
0
Forkuj 0
Kod Zgłoszenia Projekty Wydania Wiki Aktywność

tab reformat 

git-svn-id: https://hamlib.svn.sourceforge.net/svnroot/hamlib/trunk@1989 7ae35d74-ebe9-4afe-98af-79ac388436b8
Hamlib-1.2.5
Stéphane Fillod, F8CFE 2005-04-04 18:31:00 +00:00
rodzic 9346d0096a
commit 20f5e6fc3c
8 zmienionych plików z 1980 dodań i 1965 usunięć
Pokaż statystyki Ściągnij plik aktualizacji Ściągnij plik porównania Expand all files Collapse all files

449
src/conf.c
Wyświetl plik

@ -3,13 +3,13 @@
* \ingroup rig
* \brief Rig configuration interface
* \author Stephane Fillod
* \date 2000-2004
* \date 2000-2005
*/
/*
* Hamlib Interface - configuration interface
* Copyright (c) 2000-2004 by Stephane Fillod
* Copyright (c) 2000-2005 by Stephane Fillod
*
* $Id: conf.c,v 1.12 2004-10-02 10:32:08 fillods Exp $
* $Id: conf.c,v 1.13 2005-04-04 18:30:47 fillods Exp $
*
* This library is free software; you can redistribute it and/or modify
* it under the terms of the GNU Library General Public License as
@ -116,113 +116,113 @@ static const struct confparams frontend_cfg_params[] = {
*/
static int frontend_set_conf(RIG *rig, token_t token, const char *val)
{
const struct rig_caps *caps;
struct rig_state *rs;
const struct rig_caps *caps;
struct rig_state *rs;
caps = rig->caps;
rs = &rig->state;
caps = rig->caps;
rs = &rig->state;
switch(token) {
case TOK_PATHNAME:
strcpy(rs->rigport.pathname, val);
break;
case TOK_WRITE_DELAY:
rs->rigport.write_delay = atoi(val);
break;
case TOK_POST_WRITE_DELAY:
rs->rigport.post_write_delay = atoi(val);
break;
case TOK_TIMEOUT:
rs->rigport.timeout = atoi(val);
break;
case TOK_RETRY:
rs->rigport.retry = atoi(val);
break;
switch(token) {
case TOK_PATHNAME:
strcpy(rs->rigport.pathname, val);
break;
case TOK_WRITE_DELAY:
rs->rigport.write_delay = atoi(val);
break;
case TOK_POST_WRITE_DELAY:
rs->rigport.post_write_delay = atoi(val);
break;
case TOK_TIMEOUT:
rs->rigport.timeout = atoi(val);
break;
case TOK_RETRY:
rs->rigport.retry = atoi(val);
break;
case TOK_SERIAL_SPEED:
rs->rigport.parm.serial.rate = atoi(val);
break;
case TOK_DATA_BITS:
rs->rigport.parm.serial.data_bits = atoi(val);
break;
case TOK_STOP_BITS:
rs->rigport.parm.serial.stop_bits = atoi(val);
break;
case TOK_PARITY:
if (!strncmp(val, "None", 8))
rs->rigport.parm.serial.parity = RIG_PARITY_NONE;
else if (!strncmp(val, "Odd", 8))
rs->rigport.parm.serial.parity = RIG_PARITY_ODD;
else if (!strncmp(val, "Even", 8))
rs->rigport.parm.serial.parity = RIG_PARITY_EVEN;
else
return -RIG_EINVAL;
break;
case TOK_HANDSHAKE:
if (!strncmp(val, "None", 8))
rs->rigport.parm.serial.handshake = RIG_HANDSHAKE_NONE;
else if (!strncmp(val, "XONXOFF", 8))
rs->rigport.parm.serial.handshake = RIG_HANDSHAKE_XONXOFF;
else if (!strncmp(val, "Hardware", 8))
rs->rigport.parm.serial.handshake = RIG_HANDSHAKE_HARDWARE;
else
return -RIG_EINVAL;
break;
case TOK_RTS_STATE:
if (!strcmp(val, "Unset"))
rs->rigport.parm.serial.rts_state = RIG_SIGNAL_UNSET;
else if (!strcmp(val, "ON"))
rs->rigport.parm.serial.rts_state = RIG_SIGNAL_ON;
else if (!strcmp(val, "OFF"))
rs->rigport.parm.serial.rts_state = RIG_SIGNAL_OFF;
else
return -RIG_EINVAL;
break;
case TOK_DTR_STATE:
if (!strcmp(val, "Unset"))
rs->rigport.parm.serial.dtr_state = RIG_SIGNAL_UNSET;
else if (!strcmp(val, "ON"))
rs->rigport.parm.serial.dtr_state = RIG_SIGNAL_ON;
else if (!strcmp(val, "OFF"))
rs->rigport.parm.serial.dtr_state = RIG_SIGNAL_OFF;
else
return -RIG_EINVAL;
break;
case TOK_ITU_REGION:
rs->itu_region = atoi(val);
switch(rs->itu_region) {
case RIG_ITU_REGION1:
memcpy(rs->tx_range_list, caps->tx_range_list1,
sizeof(struct freq_range_list)*FRQRANGESIZ);
memcpy(rs->rx_range_list, caps->rx_range_list1,
sizeof(struct freq_range_list)*FRQRANGESIZ);
break;
case RIG_ITU_REGION2:
case RIG_ITU_REGION3:
default:
memcpy(rs->tx_range_list, caps->tx_range_list2,
sizeof(struct freq_range_list)*FRQRANGESIZ);
memcpy(rs->rx_range_list, caps->rx_range_list2,
sizeof(struct freq_range_list)*FRQRANGESIZ);
break;
}
break;
case TOK_VFO_COMP:
rs->vfo_comp = atof(val);
break;
case TOK_POLL_INTERVAL:
rs->poll_interval = atof(val);
break;
default:
case TOK_SERIAL_SPEED:
rs->rigport.parm.serial.rate = atoi(val);
break;
case TOK_DATA_BITS:
rs->rigport.parm.serial.data_bits = atoi(val);
break;
case TOK_STOP_BITS:
rs->rigport.parm.serial.stop_bits = atoi(val);
break;
case TOK_PARITY:
if (!strncmp(val, "None", 8))
rs->rigport.parm.serial.parity = RIG_PARITY_NONE;
else if (!strncmp(val, "Odd", 8))
rs->rigport.parm.serial.parity = RIG_PARITY_ODD;
else if (!strncmp(val, "Even", 8))
rs->rigport.parm.serial.parity = RIG_PARITY_EVEN;
else
return -RIG_EINVAL;
}
return RIG_OK;
break;
case TOK_HANDSHAKE:
if (!strncmp(val, "None", 8))
rs->rigport.parm.serial.handshake = RIG_HANDSHAKE_NONE;
else if (!strncmp(val, "XONXOFF", 8))
rs->rigport.parm.serial.handshake = RIG_HANDSHAKE_XONXOFF;
else if (!strncmp(val, "Hardware", 8))
rs->rigport.parm.serial.handshake = RIG_HANDSHAKE_HARDWARE;
else
return -RIG_EINVAL;
break;
case TOK_RTS_STATE:
if (!strcmp(val, "Unset"))
rs->rigport.parm.serial.rts_state = RIG_SIGNAL_UNSET;
else if (!strcmp(val, "ON"))
rs->rigport.parm.serial.rts_state = RIG_SIGNAL_ON;
else if (!strcmp(val, "OFF"))
rs->rigport.parm.serial.rts_state = RIG_SIGNAL_OFF;
else
return -RIG_EINVAL;
break;
case TOK_DTR_STATE:
if (!strcmp(val, "Unset"))
rs->rigport.parm.serial.dtr_state = RIG_SIGNAL_UNSET;
else if (!strcmp(val, "ON"))
rs->rigport.parm.serial.dtr_state = RIG_SIGNAL_ON;
else if (!strcmp(val, "OFF"))
rs->rigport.parm.serial.dtr_state = RIG_SIGNAL_OFF;
else
return -RIG_EINVAL;
break;
case TOK_ITU_REGION:
rs->itu_region = atoi(val);
switch(rs->itu_region) {
case RIG_ITU_REGION1:
memcpy(rs->tx_range_list, caps->tx_range_list1,
sizeof(struct freq_range_list)*FRQRANGESIZ);
memcpy(rs->rx_range_list, caps->rx_range_list1,
sizeof(struct freq_range_list)*FRQRANGESIZ);
break;
case RIG_ITU_REGION2:
case RIG_ITU_REGION3:
default:
memcpy(rs->tx_range_list, caps->tx_range_list2,
sizeof(struct freq_range_list)*FRQRANGESIZ);
memcpy(rs->rx_range_list, caps->rx_range_list2,
sizeof(struct freq_range_list)*FRQRANGESIZ);
break;
}
break;
case TOK_VFO_COMP:
rs->vfo_comp = atof(val);
break;
case TOK_POLL_INTERVAL:
rs->poll_interval = atof(val);
break;
default:
return -RIG_EINVAL;
}
return RIG_OK;
}
/*
@ -231,93 +231,93 @@ static int frontend_set_conf(RIG *rig, token_t token, const char *val)
*/
static int frontend_get_conf(RIG *rig, token_t token, char *val)
{
const struct rig_caps *caps;
struct rig_state *rs;
const char *s;
const struct rig_caps *caps;
struct rig_state *rs;
const char *s;
caps = rig->caps;
rs = &rig->state;
caps = rig->caps;
rs = &rig->state;
switch(token) {
case TOK_PATHNAME:
strcpy(val, rs->rigport.pathname);
break;
case TOK_WRITE_DELAY:
sprintf(val, "%d", rs->rigport.write_delay);
break;
case TOK_POST_WRITE_DELAY:
sprintf(val, "%d", rs->rigport.post_write_delay);
break;
case TOK_TIMEOUT:
sprintf(val, "%d", rs->rigport.timeout);
break;
case TOK_RETRY:
sprintf(val, "%d", rs->rigport.retry);
break;
case TOK_ITU_REGION:
sprintf(val, "%d",
rs->itu_region == 1 ? RIG_ITU_REGION1 : RIG_ITU_REGION2);
break;
case TOK_SERIAL_SPEED:
sprintf(val, "%d", rs->rigport.parm.serial.rate);
break;
case TOK_DATA_BITS:
sprintf(val, "%d", rs->rigport.parm.serial.data_bits);
break;
case TOK_STOP_BITS:
sprintf(val, "%d", rs->rigport.parm.serial.stop_bits);
break;
case TOK_PARITY:
switch (rs->rigport.parm.serial.parity) {
case RIG_PARITY_NONE: s = "None"; break;
case RIG_PARITY_ODD: s = "Odd"; break;
case RIG_PARITY_EVEN: s = "Even"; break;
default: return -RIG_EINVAL;
}
strcpy(val, s);
break;
case TOK_HANDSHAKE:
switch (rs->rigport.parm.serial.handshake) {
case RIG_HANDSHAKE_NONE: s = "None"; break;
case RIG_HANDSHAKE_XONXOFF: s = "XONXOFF"; break;
case RIG_HANDSHAKE_HARDWARE: s = "Hardware"; break;
default: return -RIG_EINVAL;
}
strcpy(val, s);
break;
case TOK_RTS_STATE:
switch (rs->rigport.parm.serial.rts_state) {
case RIG_SIGNAL_UNSET: s = "Unset"; break;
case RIG_SIGNAL_ON: s = "ON"; break;
case RIG_SIGNAL_OFF: s = "OFF"; break;
default: return -RIG_EINVAL;
}
strcpy(val, s);
break;
case TOK_DTR_STATE:
switch (rs->rigport.parm.serial.dtr_state) {
case RIG_SIGNAL_UNSET: s = "Unset"; break;
case RIG_SIGNAL_ON: s = "ON"; break;
case RIG_SIGNAL_OFF: s = "OFF"; break;
default: return -RIG_EINVAL;
}
strcpy(val, s);
break;
case TOK_VFO_COMP:
sprintf(val, "%f", rs->vfo_comp);
break;
case TOK_POLL_INTERVAL:
sprintf(val, "%d", rs->poll_interval);
break;
default:
return -RIG_EINVAL;
switch(token) {
case TOK_PATHNAME:
strcpy(val, rs->rigport.pathname);
break;
case TOK_WRITE_DELAY:
sprintf(val, "%d", rs->rigport.write_delay);
break;
case TOK_POST_WRITE_DELAY:
sprintf(val, "%d", rs->rigport.post_write_delay);
break;
case TOK_TIMEOUT:
sprintf(val, "%d", rs->rigport.timeout);
break;
case TOK_RETRY:
sprintf(val, "%d", rs->rigport.retry);
break;
case TOK_ITU_REGION:
sprintf(val, "%d",
rs->itu_region == 1 ? RIG_ITU_REGION1 : RIG_ITU_REGION2);
break;
case TOK_SERIAL_SPEED:
sprintf(val, "%d", rs->rigport.parm.serial.rate);
break;
case TOK_DATA_BITS:
sprintf(val, "%d", rs->rigport.parm.serial.data_bits);
break;
case TOK_STOP_BITS:
sprintf(val, "%d", rs->rigport.parm.serial.stop_bits);
break;
case TOK_PARITY:
switch (rs->rigport.parm.serial.parity) {
case RIG_PARITY_NONE: s = "None"; break;
case RIG_PARITY_ODD: s = "Odd"; break;
case RIG_PARITY_EVEN: s = "Even"; break;
default: return -RIG_EINVAL;
}
strcpy(val, s);
break;
case TOK_HANDSHAKE:
switch (rs->rigport.parm.serial.handshake) {
case RIG_HANDSHAKE_NONE: s = "None"; break;
case RIG_HANDSHAKE_XONXOFF: s = "XONXOFF"; break;
case RIG_HANDSHAKE_HARDWARE: s = "Hardware"; break;
default: return -RIG_EINVAL;
}
strcpy(val, s);
break;
return RIG_OK;
case TOK_RTS_STATE:
switch (rs->rigport.parm.serial.rts_state) {
case RIG_SIGNAL_UNSET: s = "Unset"; break;
case RIG_SIGNAL_ON: s = "ON"; break;
case RIG_SIGNAL_OFF: s = "OFF"; break;
default: return -RIG_EINVAL;
}
strcpy(val, s);
break;
case TOK_DTR_STATE:
switch (rs->rigport.parm.serial.dtr_state) {
case RIG_SIGNAL_UNSET: s = "Unset"; break;
case RIG_SIGNAL_ON: s = "ON"; break;
case RIG_SIGNAL_OFF: s = "OFF"; break;
default: return -RIG_EINVAL;
}
strcpy(val, s);
break;
case TOK_VFO_COMP:
sprintf(val, "%f", rs->vfo_comp);
break;
case TOK_POLL_INTERVAL:
sprintf(val, "%d", rs->poll_interval);
break;
default:
return -RIG_EINVAL;
}
return RIG_OK;
}
/**
@ -339,14 +339,16 @@ int HAMLIB_API rig_token_foreach(RIG *rig, int (*cfunc)(const struct confparams
const struct confparams *cfp;
if (!rig || !rig->caps || !cfunc)
return -RIG_EINVAL;
return -RIG_EINVAL;
for (cfp = rig->caps->cfgparams; cfp && cfp->name; cfp++)
if ((*cfunc)(cfp, data) == 0)
return RIG_OK;
if ((*cfunc)(cfp, data) == 0)
return RIG_OK;
for (cfp = frontend_cfg_params; cfp->name; cfp++)
if ((*cfunc)(cfp, data) == 0)
return RIG_OK;
if ((*cfunc)(cfp, data) == 0)
return RIG_OK;
return RIG_OK;
}
@ -362,17 +364,20 @@ int HAMLIB_API rig_token_foreach(RIG *rig, int (*cfunc)(const struct confparams
*/
const struct confparams * HAMLIB_API rig_confparam_lookup(RIG *rig, const char *name)
{
const struct confparams *cfp;
const struct confparams *cfp;
if (!rig || !rig->caps)
return NULL;
for (cfp = rig->caps->cfgparams; cfp && cfp->name; cfp++)
if (!strcmp(cfp->name, name))
return cfp;
for (cfp = frontend_cfg_params; cfp->name; cfp++)
if (!strcmp(cfp->name, name))
return cfp;
if (!rig || !rig->caps)
return NULL;
for (cfp = rig->caps->cfgparams; cfp && cfp->name; cfp++)
if (!strcmp(cfp->name, name))
return cfp;
for (cfp = frontend_cfg_params; cfp->name; cfp++)
if (!strcmp(cfp->name, name))
return cfp;
return NULL;
}
/**
@ -386,13 +391,13 @@ const struct confparams * HAMLIB_API rig_confparam_lookup(RIG *rig, const char *
*/
token_t HAMLIB_API rig_token_lookup(RIG *rig, const char *name)
{
const struct confparams *cfp;
const struct confparams *cfp;
cfp = rig_confparam_lookup(rig, name);
if (!cfp)
return RIG_CONF_END;
cfp = rig_confparam_lookup(rig, name);
if (!cfp)
return RIG_CONF_END;
return cfp->token;
return cfp->token;
}
/**
@ -411,16 +416,16 @@ token_t HAMLIB_API rig_token_lookup(RIG *rig, const char *name)
*/
int HAMLIB_API rig_set_conf(RIG *rig, token_t token, const char *val)
{
if (!rig || !rig->caps)
return -RIG_EINVAL;
if (!rig || !rig->caps)
return -RIG_EINVAL;
if (IS_TOKEN_FRONTEND(token))
return frontend_set_conf(rig, token, val);
if (IS_TOKEN_FRONTEND(token))
return frontend_set_conf(rig, token, val);
if (rig->caps->set_conf == NULL)
return -RIG_ENAVAIL;
if (rig->caps->set_conf == NULL)
return -RIG_ENAVAIL;
return rig->caps->set_conf(rig, token, val);
return rig->caps->set_conf(rig, token, val);
}
/**
@ -440,15 +445,15 @@ int HAMLIB_API rig_set_conf(RIG *rig, token_t token, const char *val)
*/
int HAMLIB_API rig_get_conf(RIG *rig, token_t token, char *val)
{
if (!rig || !rig->caps || !val)
return -RIG_EINVAL;
if (!rig || !rig->caps || !val)
return -RIG_EINVAL;
if (IS_TOKEN_FRONTEND(token))
return frontend_get_conf(rig, token, val);
if (IS_TOKEN_FRONTEND(token))
return frontend_get_conf(rig, token, val);
if (rig->caps->get_conf == NULL)
return -RIG_ENAVAIL;
if (rig->caps->get_conf == NULL)
return -RIG_ENAVAIL;
return rig->caps->get_conf(rig, token, val);
return rig->caps->get_conf(rig, token, val);
}

142
src/misc.c
Wyświetl plik

@ -1,8 +1,8 @@
/*
* Hamlib Interface - toolbox
* Copyright (c) 2000-2004 by Stephane Fillod
* Copyright (c) 2000-2005 by Stephane Fillod
*
* $Id: misc.c,v 1.34 2004-10-02 10:32:08 fillods Exp $
* $Id: misc.c,v 1.35 2005-04-04 18:30:51 fillods Exp $
*
* This library is free software; you can redistribute it and/or modify
* it under the terms of the GNU Library General Public License as
@ -106,15 +106,15 @@ HAMLIB_API to_bcd(unsigned char bcd_data[], unsigned long long freq, unsigned bc
/* '450'/3-> 5,0;x,4 */
for (i=0; i < bcd_len/2; i++) {
a = freq%10;
freq /= 10;
a |= (freq%10)<<4;
freq /= 10;
bcd_data[i] = a;
a = freq%10;
freq /= 10;
a |= (freq%10)<<4;
freq /= 10;
bcd_data[i] = a;
}
if (bcd_len&1) {
bcd_data[i] &= 0xf0;
bcd_data[i] |= freq%10; /* NB: high nibble is left uncleared */
bcd_data[i] &= 0xf0;
bcd_data[i] |= freq%10; /* NB: high nibble is left uncleared */
}
return bcd_data;
@ -132,13 +132,13 @@ unsigned long long HAMLIB_API from_bcd(const unsigned char bcd_data[], unsigned
freq_t f = 0;
if (bcd_len&1)
f = bcd_data[bcd_len/2] & 0x0f;
f = bcd_data[bcd_len/2] & 0x0f;
for (i=(bcd_len/2)-1; i >= 0; i--) {
f *= 10;
f += bcd_data[i]>>4;
f *= 10;
f += bcd_data[i] & 0x0f;
f *= 10;
f += bcd_data[i]>>4;
f *= 10;
f += bcd_data[i] & 0x0f;
}
return f;
@ -157,16 +157,16 @@ HAMLIB_API to_bcd_be(unsigned char bcd_data[], unsigned long long freq, unsigned
/* '450'/3 -> 4,5;0,x */
if (bcd_len&1) {
bcd_data[bcd_len/2] &= 0x0f;
bcd_data[bcd_len/2] |= (freq%10)<<4; /* NB: low nibble is left uncleared */
freq /= 10;
bcd_data[bcd_len/2] &= 0x0f;
bcd_data[bcd_len/2] |= (freq%10)<<4; /* NB: low nibble is left uncleared */
freq /= 10;
}
for (i=(bcd_len/2)-1; i >= 0; i--) {
a = freq%10;
freq /= 10;
a |= (freq%10)<<4;
freq /= 10;
bcd_data[i] = a;
a = freq%10;
freq /= 10;
a |= (freq%10)<<4;
freq /= 10;
bcd_data[i] = a;
}
return bcd_data;
@ -181,14 +181,14 @@ unsigned long long HAMLIB_API from_bcd_be(const unsigned char bcd_data[], unsign
freq_t f = 0;
for (i=0; i < bcd_len/2; i++) {
f *= 10;
f += bcd_data[i]>>4;
f *= 10;
f += bcd_data[i] & 0x0f;
f *= 10;
f += bcd_data[i]>>4;
f *= 10;
f += bcd_data[i] & 0x0f;
}
if (bcd_len&1) {
f *= 10;
f += bcd_data[bcd_len/2]>>4;
f *= 10;
f += bcd_data[bcd_len/2]>>4;
}
return f;
@ -209,7 +209,7 @@ void HAMLIB_API rig_set_debug(enum rig_debug_level_e debug_level)
*/
int HAMLIB_API rig_need_debug(enum rig_debug_level_e debug_level)
{
return (debug_level <= rig_debug_level);
return (debug_level <= rig_debug_level);
}
/*
@ -219,16 +219,16 @@ int HAMLIB_API rig_need_debug(enum rig_debug_level_e debug_level)
*/
void HAMLIB_API rig_debug(enum rig_debug_level_e debug_level, const char *fmt, ...)
{
va_list ap;
va_list ap;
if (debug_level <= rig_debug_level) {
va_start(ap, fmt);
/*
* Who cares about return code?
*/
vfprintf (stderr, fmt, ap);
va_end(ap);
}
if (debug_level <= rig_debug_level) {
va_start(ap, fmt);
/*
* Who cares about return code?
*/
vfprintf (stderr, fmt, ap);
va_end(ap);
}
}
#ifndef llabs
@ -242,24 +242,24 @@ void HAMLIB_API rig_debug(enum rig_debug_level_e debug_level, const char *fmt, .
*/
int HAMLIB_API sprintf_freq(char *str, freq_t freq)
{
double f;
char *hz;
double f;
char *hz;
if (llabs(freq) >= GHz(1)) {
hz = "GHz";
f = (double)freq/GHz(1);
} else if (llabs(freq) >= MHz(1)) {
hz = "MHz";
f = (double)freq/MHz(1);
} else if (llabs(freq) >= kHz(1)) {
hz = "kHz";
f = (double)freq/kHz(1);
} else {
hz = "Hz";
f = (double)freq;
}
if (llabs(freq) >= GHz(1)) {
hz = "GHz";
f = (double)freq/GHz(1);
} else if (llabs(freq) >= MHz(1)) {
hz = "MHz";
f = (double)freq/MHz(1);
} else if (llabs(freq) >= kHz(1)) {
hz = "kHz";
f = (double)freq/kHz(1);
} else {
hz = "Hz";
f = (double)freq;
}
return sprintf (str, "%g %s", f, hz);
return sprintf (str, "%g %s", f, hz);
}
const char * HAMLIB_API rig_strptrshift(rptr_shift_t shift)
@ -277,17 +277,17 @@ const char * HAMLIB_API rig_strstatus(enum rig_status_e status)
{
switch (status) {
case RIG_STATUS_ALPHA:
return "Alpha";
return "Alpha";
case RIG_STATUS_UNTESTED:
return "Untested";
return "Untested";
case RIG_STATUS_BETA:
return "Beta";
return "Beta";
case RIG_STATUS_STABLE:
return "Stable";
return "Stable";
case RIG_STATUS_BUGGY:
return "Buggy";
return "Buggy";
case RIG_STATUS_NEW:
return "New";
return "New";
}
return "";
}
@ -422,8 +422,9 @@ setting_t HAMLIB_API rig_parse_func(const char *s)
int i;
for (i=0 ; func_str[i].str != ""; i++)
if (!strcmp(s, func_str[i].str))
return func_str[i].func;
if (!strcmp(s, func_str[i].str))
return func_str[i].func;
return RIG_FUNC_NONE;
}
@ -482,8 +483,9 @@ setting_t HAMLIB_API rig_parse_level(const char *s)
int i;
for (i=0 ; level_str[i].str != ""; i++)
if (!strcmp(s, level_str[i].str))
return level_str[i].level;
if (!strcmp(s, level_str[i].str))
return level_str[i].level;
return RIG_LEVEL_NONE;
}
@ -520,10 +522,11 @@ setting_t HAMLIB_API rig_parse_parm(const char *s)
int i;
for (i=0 ; parm_str[i].str != ""; i++)
if (!strcmp(s, parm_str[i].str))
return parm_str[i].parm;
if (!strcmp(s, parm_str[i].str))
return parm_str[i].parm;
return RIG_PARM_NONE;
}
const char * HAMLIB_API rig_strparm(setting_t parm)
{
@ -565,8 +568,9 @@ vfo_op_t HAMLIB_API rig_parse_vfo_op(const char *s)
int i;
for (i=0 ; vfo_op_str[i].str != ""; i++)
if (!strcmp(s, vfo_op_str[i].str))
return vfo_op_str[i].vfo_op;
if (!strcmp(s, vfo_op_str[i].str))
return vfo_op_str[i].vfo_op;
return RIG_OP_NONE;
}

103
src/parallel.c
Wyświetl plik

@ -2,7 +2,7 @@
* Hamlib Interface - parallel communication low-level support
* Copyright (c) 2000-2005 by Stephane Fillod
*
* $Id: parallel.c,v 1.3 2005-04-03 12:27:16 fillods Exp $
* $Id: parallel.c,v 1.4 2005-04-04 18:30:55 fillods Exp $
*
* This library is free software; you can redistribute it and/or modify
* it under the terms of the GNU Library General Public License as
@ -319,28 +319,29 @@ int HAMLIB_API par_unlock(hamlib_port_t *port)
int par_ptt_set(hamlib_port_t *p, ptt_t pttx)
{
switch(p->type.ptt) {
case RIG_PTT_PARALLEL:
{
unsigned char reg;
int status;
switch(p->type.ptt) {
case RIG_PTT_PARALLEL:
{
unsigned char reg;
int status;
status = par_read_data(p, &reg);
if (status != RIG_OK)
return status;
if (pttx == RIG_PTT_ON)
reg |= 1 << p->parm.parallel.pin;
else
reg &= ~(1 << p->parm.parallel.pin);
status = par_read_data(p, &reg);
if (status != RIG_OK)
return status;
if (pttx == RIG_PTT_ON)
reg |= 1 << p->parm.parallel.pin;
else
reg &= ~(1 << p->parm.parallel.pin);
return par_write_data(p, reg);
}
default:
rig_debug(RIG_DEBUG_ERR,"Unsupported PTT type %d\n",
p->type.ptt);
return -RIG_EINVAL;
return par_write_data(p, reg);
}
return RIG_OK;
default:
rig_debug(RIG_DEBUG_ERR,"Unsupported PTT type %d\n",
p->type.ptt);
return -RIG_EINVAL;
}
return RIG_OK;
}
/*
@ -348,23 +349,24 @@ int par_ptt_set(hamlib_port_t *p, ptt_t pttx)
*/
int par_ptt_get(hamlib_port_t *p, ptt_t *pttx)
{
switch(p->type.ptt) {
case RIG_PTT_PARALLEL:
{
unsigned char reg;
int status;
switch(p->type.ptt) {
case RIG_PTT_PARALLEL:
{
unsigned char reg;
int status;
status = par_read_data(p, &reg);
*pttx = reg & (1<<p->parm.parallel.pin) ?
RIG_PTT_ON:RIG_PTT_OFF;
return status;
}
default:
rig_debug(RIG_DEBUG_ERR,"Unsupported PTT type %d\n",
p->type.ptt);
return -RIG_ENAVAIL;
status = par_read_data(p, &reg);
*pttx = reg & (1<<p->parm.parallel.pin) ?
RIG_PTT_ON:RIG_PTT_OFF;
return status;
}
return RIG_OK;
default:
rig_debug(RIG_DEBUG_ERR,"Unsupported PTT type %d\n",
p->type.ptt);
return -RIG_ENAVAIL;
}
return RIG_OK;
}
/*
@ -372,22 +374,23 @@ int par_ptt_get(hamlib_port_t *p, ptt_t *pttx)
*/
int par_dcd_get(hamlib_port_t *p, dcd_t *dcdx)
{
switch(p->type.dcd) {
case RIG_DCD_PARALLEL:
{
unsigned char reg;
int status;
switch(p->type.dcd) {
case RIG_DCD_PARALLEL:
{
unsigned char reg;
int status;
status = par_read_data(p, &reg);
*dcdx = reg & (1<<p->parm.parallel.pin) ?
RIG_DCD_ON:RIG_DCD_OFF;
return status;
}
default:
rig_debug(RIG_DEBUG_ERR,"Unsupported DCD type %d\n",
p->type.dcd);
return -RIG_ENAVAIL;
status = par_read_data(p, &reg);
*dcdx = reg & (1<<p->parm.parallel.pin) ?
RIG_DCD_ON:RIG_DCD_OFF;
return status;
}
return RIG_OK;
default:
rig_debug(RIG_DEBUG_ERR,"Unsupported DCD type %d\n",
p->type.dcd);
return -RIG_ENAVAIL;
}
return RIG_OK;
}

153
src/register.c
Wyświetl plik

@ -2,7 +2,7 @@
* Hamlib Interface - provides registering for dynamically loadable backends.
* Copyright (c) 2000-2005 by Stephane Fillod
*
* $Id: register.c,v 1.22 2005-04-03 12:27:16 fillods Exp $
* $Id: register.c,v 1.23 2005-04-04 18:30:56 fillods Exp $
*
* This library is free software; you can redistribute it and/or modify
* it under the terms of the GNU Library General Public License as
@ -62,9 +62,9 @@ static struct {
* It is chained, and used in a hash table, see below.
*/
struct rig_list {
const struct rig_caps *caps;
lt_dlhandle handle; /* handle returned by lt_dlopen() */
struct rig_list *next;
const struct rig_caps *caps;
lt_dlhandle handle; /* handle returned by lt_dlopen() */
struct rig_list *next;
};
#define RIGLSTHASHSZ 16
@ -84,30 +84,30 @@ static int rig_lookup_backend(rig_model_t rig_model);
*/
int HAMLIB_API rig_register(const struct rig_caps *caps)
{
int hval;
struct rig_list *p;
int hval;
struct rig_list *p;
if (!caps)
return -RIG_EINVAL;
if (!caps)
return -RIG_EINVAL;
rig_debug(RIG_DEBUG_VERBOSE, "rig_register (%d)\n",caps->rig_model);
rig_debug(RIG_DEBUG_VERBOSE, "rig_register (%d)\n",caps->rig_model);
#ifndef DONT_WANT_DUP_CHECK
if (rig_get_caps(caps->rig_model)!=NULL)
return -RIG_EINVAL;
if (rig_get_caps(caps->rig_model)!=NULL)
return -RIG_EINVAL;
#endif
p = (struct rig_list*)malloc(sizeof(struct rig_list));
if (!p)
return -RIG_ENOMEM;
p = (struct rig_list*)malloc(sizeof(struct rig_list));
if (!p)
return -RIG_ENOMEM;
hval = HASH_FUNC(caps->rig_model);
p->caps = caps;
p->handle = NULL;
p->next = rig_hash_table[hval];
rig_hash_table[hval] = p;
hval = HASH_FUNC(caps->rig_model);
p->caps = caps;
p->handle = NULL;
p->next = rig_hash_table[hval];
rig_hash_table[hval] = p;
return RIG_OK;
return RIG_OK;
}
/*
@ -117,13 +117,14 @@ int HAMLIB_API rig_register(const struct rig_caps *caps)
const struct rig_caps * HAMLIB_API rig_get_caps(rig_model_t rig_model)
{
struct rig_list *p;
struct rig_list *p;
for (p = rig_hash_table[HASH_FUNC(rig_model)]; p; p=p->next) {
if (p->caps->rig_model == rig_model)
return p->caps;
}
return NULL; /* sorry, caps not registered! */
for (p = rig_hash_table[HASH_FUNC(rig_model)]; p; p=p->next) {
if (p->caps->rig_model == rig_model)
return p->caps;
}
return NULL; /* sorry, caps not registered! */
}
/*
@ -133,14 +134,15 @@ const struct rig_caps * HAMLIB_API rig_get_caps(rig_model_t rig_model)
*/
static int rig_lookup_backend(rig_model_t rig_model)
{
int i;
int i;
for (i=0; i<RIG_BACKEND_MAX && rig_backend_list[i].be_name; i++) {
if (RIG_BACKEND_NUM(rig_model) ==
rig_backend_list[i].be_num)
return i;
}
return -1;
for (i=0; i<RIG_BACKEND_MAX && rig_backend_list[i].be_name; i++) {
if (RIG_BACKEND_NUM(rig_model) ==
rig_backend_list[i].be_num)
return i;
}
return -1;
}
/*
@ -151,54 +153,55 @@ static int rig_lookup_backend(rig_model_t rig_model)
*/
int HAMLIB_API rig_check_backend(rig_model_t rig_model)
{
const struct rig_caps *caps;
int be_idx;
int retval;
/* already loaded ? */
caps = rig_get_caps(rig_model);
if (caps)
return RIG_OK;
const struct rig_caps *caps;
int be_idx;
int retval;
/* already loaded ? */
caps = rig_get_caps(rig_model);
if (caps)
return RIG_OK;
be_idx = rig_lookup_backend(rig_model);
be_idx = rig_lookup_backend(rig_model);
/*
* Never heard about this backend family!
*/
if (be_idx == -1) {
rig_debug(RIG_DEBUG_VERBOSE, "rig_check_backend: unsupported "
"backend %d for model %d\n",
RIG_BACKEND_NUM(rig_model), rig_model
);
return -RIG_ENAVAIL;
}
retval = rig_load_backend(rig_backend_list[be_idx].be_name);
/*
* Never heard about this backend family!
*/
if (be_idx == -1) {
rig_debug(RIG_DEBUG_VERBOSE, "rig_check_backend: unsupported "
"backend %d for model %d\n",
RIG_BACKEND_NUM(rig_model), rig_model);
return -RIG_ENAVAIL;
}
return retval;
retval = rig_load_backend(rig_backend_list[be_idx].be_name);
return retval;
}
int HAMLIB_API rig_unregister(rig_model_t rig_model)
{
int hval;
struct rig_list *p,*q;
int hval;
struct rig_list *p,*q;
hval = HASH_FUNC(rig_model);
q = NULL;
for (p = rig_hash_table[hval]; p; p=p->next) {
if (p->caps->rig_model == rig_model) {
if (q == NULL)
rig_hash_table[hval] = p->next;
else
q->next = p->next;
free(p);
return RIG_OK;
}
q = p;
hval = HASH_FUNC(rig_model);
q = NULL;
for (p = rig_hash_table[hval]; p; p=p->next) {
if (p->caps->rig_model == rig_model) {
if (q == NULL)
rig_hash_table[hval] = p->next;
else
q->next = p->next;
free(p);
return RIG_OK;
}
return -RIG_EINVAL; /* sorry, caps not registered! */
q = p;
}
return -RIG_EINVAL; /* sorry, caps not registered! */
}
/*
@ -211,13 +214,14 @@ int HAMLIB_API rig_list_foreach(int (*cfunc)(const struct rig_caps*, rig_ptr_t),
int i;
if (!cfunc)
return -RIG_EINVAL;
return -RIG_EINVAL;
for (i=0; i<RIGLSTHASHSZ; i++) {
for (p=rig_hash_table[i]; p; p=p->next)
if ((*cfunc)(p->caps,data) == 0)
return RIG_OK;
for (p=rig_hash_table[i]; p; p=p->next)
if ((*cfunc)(p->caps,data) == 0)
return RIG_OK;
}
return RIG_OK;
}
@ -271,6 +275,7 @@ int rig_load_all_backends()
for (i=0; i<RIG_BACKEND_MAX && rig_backend_list[i].be_name; i++) {
rig_load_backend(rig_backend_list[i].be_name);
}
return RIG_OK;
}

2160
src/rig.c
Wyświetl plik

Plik diff jest za duży Load Diff

301
src/rot_conf.c
Wyświetl plik

@ -2,7 +2,7 @@
* Hamlib Interface - rotator configuration interface
* Copyright (c) 2000-2004 by Stephane Fillod
*
* $Id: rot_conf.c,v 1.4 2004-10-02 10:32:08 fillods Exp $
* $Id: rot_conf.c,v 1.5 2005-04-04 18:31:00 fillods Exp $
*
* This library is free software; you can redistribute it and/or modify
* it under the terms of the GNU Library General Public License as
@ -108,76 +108,76 @@ static const struct confparams rotfrontend_cfg_params[] = {
*/
int frontrot_set_conf(ROT *rot, token_t token, const char *val)
{
const struct rot_caps *caps;
struct rot_state *rs;
const struct rot_caps *caps;
struct rot_state *rs;
caps = rot->caps;
rs = &rot->state;
caps = rot->caps;
rs = &rot->state;
switch(token) {
case TOK_PATHNAME:
strcpy(rs->rotport.pathname, val);
break;
case TOK_WRITE_DELAY:
rs->rotport.write_delay = atoi(val);
break;
case TOK_POST_WRITE_DELAY:
rs->rotport.post_write_delay = atoi(val);
break;
case TOK_TIMEOUT:
rs->rotport.timeout = atoi(val);
break;
case TOK_RETRY:
rs->rotport.retry = atoi(val);
break;
switch(token) {
case TOK_PATHNAME:
strcpy(rs->rotport.pathname, val);
break;
case TOK_WRITE_DELAY:
rs->rotport.write_delay = atoi(val);
break;
case TOK_POST_WRITE_DELAY:
rs->rotport.post_write_delay = atoi(val);
break;
case TOK_TIMEOUT:
rs->rotport.timeout = atoi(val);
break;
case TOK_RETRY:
rs->rotport.retry = atoi(val);
break;
case TOK_SERIAL_SPEED:
rs->rotport.parm.serial.rate = atoi(val);
break;
case TOK_DATA_BITS:
rs->rotport.parm.serial.data_bits = atoi(val);
break;
case TOK_STOP_BITS:
rs->rotport.parm.serial.stop_bits = atoi(val);
break;
case TOK_PARITY:
if (!strncmp(val, "None", 8))
rs->rotport.parm.serial.parity = RIG_PARITY_NONE;
else if (!strncmp(val, "Odd", 8))
rs->rotport.parm.serial.parity = RIG_PARITY_ODD;
else if (!strncmp(val, "Even", 8))
rs->rotport.parm.serial.parity = RIG_PARITY_EVEN;
else
return -RIG_EINVAL;
break;
case TOK_HANDSHAKE:
if (!strncmp(val, "None", 8))
rs->rotport.parm.serial.handshake = RIG_HANDSHAKE_NONE;
else if (!strncmp(val, "XONXOFF", 8))
rs->rotport.parm.serial.handshake = RIG_HANDSHAKE_XONXOFF;
else if (!strncmp(val, "Hardware", 8))
rs->rotport.parm.serial.handshake = RIG_HANDSHAKE_HARDWARE;
else
return -RIG_EINVAL;
break;
case TOK_SERIAL_SPEED:
rs->rotport.parm.serial.rate = atoi(val);
break;
case TOK_DATA_BITS:
rs->rotport.parm.serial.data_bits = atoi(val);
break;
case TOK_STOP_BITS:
rs->rotport.parm.serial.stop_bits = atoi(val);
break;
case TOK_PARITY:
if (!strncmp(val, "None", 8))
rs->rotport.parm.serial.parity = RIG_PARITY_NONE;
else if (!strncmp(val, "Odd", 8))
rs->rotport.parm.serial.parity = RIG_PARITY_ODD;
else if (!strncmp(val, "Even", 8))
rs->rotport.parm.serial.parity = RIG_PARITY_EVEN;
else
return -RIG_EINVAL;
break;
case TOK_HANDSHAKE:
if (!strncmp(val, "None", 8))
rs->rotport.parm.serial.handshake = RIG_HANDSHAKE_NONE;
else if (!strncmp(val, "XONXOFF", 8))
rs->rotport.parm.serial.handshake = RIG_HANDSHAKE_XONXOFF;
else if (!strncmp(val, "Hardware", 8))
rs->rotport.parm.serial.handshake = RIG_HANDSHAKE_HARDWARE;
else
return -RIG_EINVAL;
break;
case TOK_MIN_AZ:
rs->min_az = atof(val);
break;
case TOK_MAX_AZ:
rs->max_az = atof(val);
break;
case TOK_MIN_EL:
rs->min_el = atof(val);
break;
case TOK_MAX_EL:
rs->max_el = atof(val);
break;
case TOK_MIN_AZ:
rs->min_az = atof(val);
break;
case TOK_MAX_AZ:
rs->max_az = atof(val);
break;
case TOK_MIN_EL:
rs->min_el = atof(val);
break;
case TOK_MAX_EL:
rs->max_el = atof(val);
break;
default:
return -RIG_EINVAL;
}
return RIG_OK;
default:
return -RIG_EINVAL;
}
return RIG_OK;
}
/*
@ -186,75 +186,75 @@ int frontrot_set_conf(ROT *rot, token_t token, const char *val)
*/
int frontrot_get_conf(ROT *rot, token_t token, char *val)
{
const struct rot_caps *caps;
struct rot_state *rs;
const char *s;
const struct rot_caps *caps;
struct rot_state *rs;
const char *s;
caps = rot->caps;
rs = &rot->state;
caps = rot->caps;
rs = &rot->state;
switch(token) {
case TOK_PATHNAME:
strcpy(val, rs->rotport.pathname);
break;
case TOK_WRITE_DELAY:
sprintf(val, "%d", rs->rotport.write_delay);
break;
case TOK_POST_WRITE_DELAY:
sprintf(val, "%d", rs->rotport.post_write_delay);
break;
case TOK_TIMEOUT:
sprintf(val, "%d", rs->rotport.timeout);
break;
case TOK_RETRY:
sprintf(val, "%d", rs->rotport.retry);
break;
case TOK_SERIAL_SPEED:
sprintf(val, "%d", rs->rotport.parm.serial.rate);
break;
case TOK_DATA_BITS:
sprintf(val, "%d", rs->rotport.parm.serial.data_bits);
break;
case TOK_STOP_BITS:
sprintf(val, "%d", rs->rotport.parm.serial.stop_bits);
break;
case TOK_PARITY:
switch (rs->rotport.parm.serial.parity) {
case RIG_PARITY_NONE: s = "None"; break;
case RIG_PARITY_ODD: s = "Odd"; break;
case RIG_PARITY_EVEN: s = "Even"; break;
default: return -RIG_EINVAL;
}
strcpy(val, s);
break;
case TOK_HANDSHAKE:
switch (rs->rotport.parm.serial.handshake) {
case RIG_HANDSHAKE_NONE: s = "None"; break;
case RIG_HANDSHAKE_XONXOFF: s = "XONXOFF"; break;
case RIG_HANDSHAKE_HARDWARE: s = "Hardware"; break;
default: return -RIG_EINVAL;
}
strcpy(val, s);
break;
case TOK_MIN_AZ:
sprintf(val, "%f", rs->min_az);
break;
case TOK_MAX_AZ:
sprintf(val, "%f", rs->max_az);
break;
case TOK_MIN_EL:
sprintf(val, "%f", rs->min_el);
break;
case TOK_MAX_EL:
sprintf(val, "%f", rs->max_el);
break;
default:
return -RIG_EINVAL;
switch(token) {
case TOK_PATHNAME:
strcpy(val, rs->rotport.pathname);
break;
case TOK_WRITE_DELAY:
sprintf(val, "%d", rs->rotport.write_delay);
break;
case TOK_POST_WRITE_DELAY:
sprintf(val, "%d", rs->rotport.post_write_delay);
break;
case TOK_TIMEOUT:
sprintf(val, "%d", rs->rotport.timeout);
break;
case TOK_RETRY:
sprintf(val, "%d", rs->rotport.retry);
break;
case TOK_SERIAL_SPEED:
sprintf(val, "%d", rs->rotport.parm.serial.rate);
break;
case TOK_DATA_BITS:
sprintf(val, "%d", rs->rotport.parm.serial.data_bits);
break;
case TOK_STOP_BITS:
sprintf(val, "%d", rs->rotport.parm.serial.stop_bits);
break;
case TOK_PARITY:
switch (rs->rotport.parm.serial.parity) {
case RIG_PARITY_NONE: s = "None"; break;
case RIG_PARITY_ODD: s = "Odd"; break;
case RIG_PARITY_EVEN: s = "Even"; break;
default: return -RIG_EINVAL;
}
strcpy(val, s);
break;
case TOK_HANDSHAKE:
switch (rs->rotport.parm.serial.handshake) {
case RIG_HANDSHAKE_NONE: s = "None"; break;
case RIG_HANDSHAKE_XONXOFF: s = "XONXOFF"; break;
case RIG_HANDSHAKE_HARDWARE: s = "Hardware"; break;
default: return -RIG_EINVAL;
}
strcpy(val, s);
break;
return RIG_OK;
case TOK_MIN_AZ:
sprintf(val, "%f", rs->min_az);
break;
case TOK_MAX_AZ:
sprintf(val, "%f", rs->max_az);
break;
case TOK_MIN_EL:
sprintf(val, "%f", rs->min_el);
break;
case TOK_MAX_EL:
sprintf(val, "%f", rs->max_el);
break;
default:
return -RIG_EINVAL;
}
return RIG_OK;
}
/*
@ -267,14 +267,14 @@ int HAMLIB_API rot_token_foreach(ROT *rot, int (*cfunc)(const struct confparams
const struct confparams *cfp;
if (!rot || !rot->caps || !cfunc)
return -RIG_EINVAL;
return -RIG_EINVAL;
for (cfp = rot->caps->cfgparams; cfp && cfp->name; cfp++)
if ((*cfunc)(cfp, data) == 0)
return RIG_OK;
if ((*cfunc)(cfp, data) == 0)
return RIG_OK;
for (cfp = rotfrontend_cfg_params; cfp->name; cfp++)
if ((*cfunc)(cfp, data) == 0)
return RIG_OK;
if ((*cfunc)(cfp, data) == 0)
return RIG_OK;
return RIG_OK;
}
@ -287,17 +287,17 @@ int HAMLIB_API rot_token_foreach(ROT *rot, int (*cfunc)(const struct confparams
*/
const struct confparams * HAMLIB_API rot_confparam_lookup(ROT *rot, const char *name)
{
const struct confparams *cfp;
const struct confparams *cfp;
if (!rot || !rot->caps)
return NULL;
for (cfp = rot->caps->cfgparams; cfp && cfp->name; cfp++)
if (!strcmp(cfp->name, name))
return cfp;
for (cfp = rotfrontend_cfg_params; cfp->name; cfp++)
if (!strcmp(cfp->name, name))
return cfp;
if (!rot || !rot->caps)
return NULL;
for (cfp = rot->caps->cfgparams; cfp && cfp->name; cfp++)
if (!strcmp(cfp->name, name))
return cfp;
for (cfp = rotfrontend_cfg_params; cfp->name; cfp++)
if (!strcmp(cfp->name, name))
return cfp;
return NULL;
}
/*
@ -305,13 +305,12 @@ const struct confparams * HAMLIB_API rot_confparam_lookup(ROT *rot, const char *
*/
token_t HAMLIB_API rot_token_lookup(ROT *rot, const char *name)
{
const struct confparams *cfp;
const struct confparams *cfp;
cfp = rot_confparam_lookup(rot, name);
if (!cfp)
return RIG_CONF_END;
cfp = rot_confparam_lookup(rot, name);
if (!cfp)
return RIG_CONF_END;
return cfp->token;
return cfp->token;
}

159
src/rot_reg.c
Wyświetl plik

@ -2,7 +2,7 @@
* Hamlib Interface - provides registering for dynamically loadable backends.
* Copyright (c) 2000-2004 by Stephane Fillod
*
* $Id: rot_reg.c,v 1.8 2005-04-03 12:27:17 fillods Exp $
* $Id: rot_reg.c,v 1.9 2005-04-04 18:31:00 fillods Exp $
*
* This library is free software; you can redistribute it and/or modify
* it under the terms of the GNU Library General Public License as
@ -62,9 +62,9 @@ static struct {
* It is chained, and used in a hash table, see below.
*/
struct rot_list {
const struct rot_caps *caps;
lt_dlhandle handle; /* handle returned by lt_dlopen() */
struct rot_list *next;
const struct rot_caps *caps;
lt_dlhandle handle; /* handle returned by lt_dlopen() */
struct rot_list *next;
};
#define ROTLSTHASHSZ 16
@ -84,30 +84,30 @@ static int rot_lookup_backend(rot_model_t rot_model);
*/
int HAMLIB_API rot_register(const struct rot_caps *caps)
{
int hval;
struct rot_list *p;
int hval;
struct rot_list *p;
if (!caps)
return -RIG_EINVAL;
if (!caps)
return -RIG_EINVAL;
rot_debug(RIG_DEBUG_VERBOSE, "rot_register (%d)\n",caps->rot_model);
rot_debug(RIG_DEBUG_VERBOSE, "rot_register (%d)\n",caps->rot_model);
#ifndef DONT_WANT_DUP_CHECK
if (rot_get_caps(caps->rot_model)!=NULL)
return -RIG_EINVAL;
if (rot_get_caps(caps->rot_model)!=NULL)
return -RIG_EINVAL;
#endif
p = (struct rot_list*)malloc(sizeof(struct rot_list));
if (!p)
return -RIG_ENOMEM;
p = (struct rot_list*)malloc(sizeof(struct rot_list));
if (!p)
return -RIG_ENOMEM;
hval = HASH_FUNC(caps->rot_model);
p->caps = caps;
p->handle = NULL;
p->next = rot_hash_table[hval];
rot_hash_table[hval] = p;
hval = HASH_FUNC(caps->rot_model);
p->caps = caps;
p->handle = NULL;
p->next = rot_hash_table[hval];
rot_hash_table[hval] = p;
return RIG_OK;
return RIG_OK;
}
/*
@ -117,13 +117,13 @@ int HAMLIB_API rot_register(const struct rot_caps *caps)
const struct rot_caps * HAMLIB_API rot_get_caps(rot_model_t rot_model)
{
struct rot_list *p;
struct rot_list *p;
for (p = rot_hash_table[HASH_FUNC(rot_model)]; p; p=p->next) {
if (p->caps->rot_model == rot_model)
return p->caps;
}
return NULL; /* sorry, caps not registered! */
for (p = rot_hash_table[HASH_FUNC(rot_model)]; p; p=p->next) {
if (p->caps->rot_model == rot_model)
return p->caps;
}
return NULL; /* sorry, caps not registered! */
}
/*
@ -133,14 +133,14 @@ const struct rot_caps * HAMLIB_API rot_get_caps(rot_model_t rot_model)
*/
static int rot_lookup_backend(rot_model_t rot_model)
{
int i;
int i;
for (i=0; i<ROT_BACKEND_MAX && rot_backend_list[i].be_name; i++) {
if (ROT_BACKEND_NUM(rot_model) ==
rot_backend_list[i].be_num)
return i;
}
return -1;
for (i=0; i<ROT_BACKEND_MAX && rot_backend_list[i].be_name; i++) {
if (ROT_BACKEND_NUM(rot_model) ==
rot_backend_list[i].be_num)
return i;
}
return -1;
}
/*
@ -151,54 +151,53 @@ static int rot_lookup_backend(rot_model_t rot_model)
*/
int HAMLIB_API rot_check_backend(rot_model_t rot_model)
{
const struct rot_caps *caps;
int be_idx;
int retval;
/* already loaded ? */
caps = rot_get_caps(rot_model);
if (caps)
return RIG_OK;
const struct rot_caps *caps;
int be_idx;
int retval;
/* already loaded ? */
caps = rot_get_caps(rot_model);
if (caps)
return RIG_OK;
be_idx = rot_lookup_backend(rot_model);
be_idx = rot_lookup_backend(rot_model);
/*
* Never heard about this backend family!
*/
if (be_idx == -1) {
rot_debug(RIG_DEBUG_VERBOSE, "rot_check_backend: unsupported "
"backend %d for model %d\n",
ROT_BACKEND_NUM(rot_model), rot_model
);
return -RIG_ENAVAIL;
}
retval = rot_load_backend(rot_backend_list[be_idx].be_name);
/*
* Never heard about this backend family!
*/
if (be_idx == -1) {
rot_debug(RIG_DEBUG_VERBOSE, "rot_check_backend: unsupported "
"backend %d for model %d\n",
ROT_BACKEND_NUM(rot_model), rot_model);
return -RIG_ENAVAIL;
}
retval = rot_load_backend(rot_backend_list[be_idx].be_name);
return retval;
return retval;
}
int HAMLIB_API rot_unregister(rot_model_t rot_model)
{
int hval;
struct rot_list *p,*q;
int hval;
struct rot_list *p,*q;
hval = HASH_FUNC(rot_model);
q = NULL;
for (p = rot_hash_table[hval]; p; p=p->next) {
if (p->caps->rot_model == rot_model) {
if (q == NULL)
rot_hash_table[hval] = p->next;
else
q->next = p->next;
free(p);
return RIG_OK;
}
q = p;
hval = HASH_FUNC(rot_model);
q = NULL;
for (p = rot_hash_table[hval]; p; p=p->next) {
if (p->caps->rot_model == rot_model) {
if (q == NULL)
rot_hash_table[hval] = p->next;
else
q->next = p->next;
free(p);
return RIG_OK;
}
return -RIG_EINVAL; /* sorry, caps not registered! */
q = p;
}
return -RIG_EINVAL; /* sorry, caps not registered! */
}
/*
@ -211,12 +210,12 @@ int HAMLIB_API rot_list_foreach(int (*cfunc)(const struct rot_caps*, rig_ptr_t),
int i;
if (!cfunc)
return -RIG_EINVAL;
return -RIG_EINVAL;
for (i=0; i<ROTLSTHASHSZ; i++) {
for (p=rot_hash_table[i]; p; p=p->next)
if ((*cfunc)(p->caps,data) == 0)
return RIG_OK;
for (p=rot_hash_table[i]; p; p=p->next)
if ((*cfunc)(p->caps,data) == 0)
return RIG_OK;
}
return RIG_OK;
}
@ -231,11 +230,11 @@ rot_model_t HAMLIB_API rot_probe_all(hamlib_port_t *p)
rot_model_t rot_model;
for (i=0; i<ROT_BACKEND_MAX && rot_backend_list[i].be_name; i++) {
if (rot_backend_list[i].be_probe) {
rot_model = (*rot_backend_list[i].be_probe)(p);
if (rot_model != ROT_MODEL_NONE)
return rot_model;
}
if (rot_backend_list[i].be_probe) {
rot_model = (*rot_backend_list[i].be_probe)(p);
if (rot_model != ROT_MODEL_NONE)
return rot_model;
}
}
return ROT_MODEL_NONE;
}
@ -246,7 +245,7 @@ int rot_load_all_backends()
int i;
for (i=0; i<ROT_BACKEND_MAX && rot_backend_list[i].be_name; i++) {
rot_load_backend(rot_backend_list[i].be_name);
rot_load_backend(rot_backend_list[i].be_name);
}
return RIG_OK;
}

478
src/rotator.c
Wyświetl plik

@ -2,7 +2,7 @@
* Hamlib Interface - main file
* Copyright (c) 2000-2005 by Stephane Fillod and Frank Singleton
*
* $Id: rotator.c,v 1.17 2005-02-20 02:38:29 fillods Exp $
* $Id: rotator.c,v 1.18 2005-04-04 18:31:00 fillods Exp $
*
* This library is free software; you can redistribute it and/or modify
* it under the terms of the GNU Library General Public License as
@ -105,16 +105,16 @@ static int remove_opened_rot(ROT *rot)
q = NULL;
for (p=opened_rot_list; p; p=p->next) {
if (p->rot == rot) {
if (q == NULL) {
opened_rot_list = opened_rot_list->next;
} else {
q->next = p->next;
}
free(p);
return RIG_OK;
if (p->rot == rot) {
if (q == NULL) {
opened_rot_list = opened_rot_list->next;
} else {
q->next = p->next;
}
q = p;
free(p);
return RIG_OK;
}
q = p;
}
return -RIG_EINVAL; /* Not found in list ! */
}
@ -144,8 +144,8 @@ int foreach_opened_rot(int (*cfunc)(ROT *, rig_ptr_t), rig_ptr_t data)
struct opened_rot_l *p;
for (p=opened_rot_list; p; p=p->next) {
if ((*cfunc)(p->rot,data) == 0)
return RIG_OK;
if ((*cfunc)(p->rot,data) == 0)
return RIG_OK;
}
return RIG_OK;
}
@ -165,90 +165,90 @@ int foreach_opened_rot(int (*cfunc)(ROT *, rig_ptr_t), rig_ptr_t data)
ROT * HAMLIB_API rot_init(rot_model_t rot_model)
{
ROT *rot;
const struct rot_caps *caps;
struct rot_state *rs;
int retcode;
ROT *rot;
const struct rot_caps *caps;
struct rot_state *rs;
int retcode;
rot_debug(RIG_DEBUG_VERBOSE,"rot:rot_init called \n");
rot_debug(RIG_DEBUG_VERBOSE,"rot:rot_init called \n");
rot_check_backend(rot_model);
rot_check_backend(rot_model);
caps = rot_get_caps(rot_model);
if (!caps)
return NULL;
caps = rot_get_caps(rot_model);
if (!caps)
return NULL;
/*
* okay, we've found it. Allocate some memory and set it to zeros,
* and especially the initialize the callbacks
*/
rot = calloc(1, sizeof(ROT));
if (rot == NULL) {
/*
* okay, we've found it. Allocate some memory and set it to zeros,
* and especially the initialize the callbacks
*/
rot = calloc(1, sizeof(ROT));
if (rot == NULL) {
/*
* FIXME: how can the caller know it's a memory shortage,
* and not "rot not found" ?
*/
return NULL;
}
rot->caps = caps;
/*
* populate the rot->state
* TODO: read the Preferences here!
* FIXME: how can the caller know it's a memory shortage,
* and not "rot not found" ?
*/
return NULL;
}
rs = &rot->state;
rot->caps = caps;
rs->comm_state = 0;
rs->rotport.type.rig = caps->port_type; /* default from caps */
/*
* populate the rot->state
* TODO: read the Preferences here!
*/
rs->rotport.write_delay = caps->write_delay;
rs->rotport.post_write_delay = caps->post_write_delay;
rs->rotport.timeout = caps->timeout;
rs->rotport.retry = caps->retry;
rs = &rot->state;
switch (caps->port_type) {
case RIG_PORT_SERIAL:
strncpy(rs->rotport.pathname, DEFAULT_SERIAL_PORT, FILPATHLEN);
rs->rotport.parm.serial.rate = caps->serial_rate_max; /* fastest ! */
rs->rotport.parm.serial.data_bits = caps->serial_data_bits;
rs->rotport.parm.serial.stop_bits = caps->serial_stop_bits;
rs->rotport.parm.serial.parity = caps->serial_parity;
rs->rotport.parm.serial.handshake = caps->serial_handshake;
break;
rs->comm_state = 0;
rs->rotport.type.rig = caps->port_type; /* default from caps */
case RIG_PORT_PARALLEL:
strncpy(rs->rotport.pathname, DEFAULT_PARALLEL_PORT, FILPATHLEN);
break;
rs->rotport.write_delay = caps->write_delay;
rs->rotport.post_write_delay = caps->post_write_delay;
rs->rotport.timeout = caps->timeout;
rs->rotport.retry = caps->retry;
default:
strncpy(rs->rotport.pathname, "", FILPATHLEN);
switch (caps->port_type) {
case RIG_PORT_SERIAL:
strncpy(rs->rotport.pathname, DEFAULT_SERIAL_PORT, FILPATHLEN);
rs->rotport.parm.serial.rate = caps->serial_rate_max; /* fastest ! */
rs->rotport.parm.serial.data_bits = caps->serial_data_bits;
rs->rotport.parm.serial.stop_bits = caps->serial_stop_bits;
rs->rotport.parm.serial.parity = caps->serial_parity;
rs->rotport.parm.serial.handshake = caps->serial_handshake;
break;
case RIG_PORT_PARALLEL:
strncpy(rs->rotport.pathname, DEFAULT_PARALLEL_PORT, FILPATHLEN);
break;
default:
strncpy(rs->rotport.pathname, "", FILPATHLEN);
}
rs->min_el = caps->min_el;
rs->max_el = caps->max_el;
rs->min_az = caps->min_az;
rs->max_az = caps->max_az;
rs->rotport.fd = -1;
/*
* let the backend a chance to setup his private data
* This must be done only once defaults are setup,
* so the backend init can override rot_state.
*/
if (caps->rot_init != NULL) {
retcode = caps->rot_init(rot);
if (retcode != RIG_OK) {
rot_debug(RIG_DEBUG_VERBOSE,"rot:backend_init failed!\n");
/* cleanup and exit */
free(rot);
return NULL;
}
}
rs->min_el = caps->min_el;
rs->max_el = caps->max_el;
rs->min_az = caps->min_az;
rs->max_az = caps->max_az;
rs->rotport.fd = -1;
/*
* let the backend a chance to setup his private data
* This must be done only once defaults are setup,
* so the backend init can override rot_state.
*/
if (caps->rot_init != NULL) {
retcode = caps->rot_init(rot);
if (retcode != RIG_OK) {
rot_debug(RIG_DEBUG_VERBOSE,"rot:backend_init failed!\n");
/* cleanup and exit */
free(rot);
return NULL;
}
}
return rot;
return rot;
}
/**
@ -270,70 +270,70 @@ ROT * HAMLIB_API rot_init(rot_model_t rot_model)
int HAMLIB_API rot_open(ROT *rot)
{
const struct rot_caps *caps;
struct rot_state *rs;
int status;
const struct rot_caps *caps;
struct rot_state *rs;
int status;
rot_debug(RIG_DEBUG_VERBOSE,"rot:rot_open called \n");
rot_debug(RIG_DEBUG_VERBOSE,"rot:rot_open called \n");
if (!rot || !rot->caps)
return -RIG_EINVAL;
if (!rot || !rot->caps)
return -RIG_EINVAL;
caps = rot->caps;
rs = &rot->state;
caps = rot->caps;
rs = &rot->state;
if (rs->comm_state)
return -RIG_EINVAL;
if (rs->comm_state)
return -RIG_EINVAL;
rs->rotport.fd = -1;
rs->rotport.fd = -1;
switch(rs->rotport.type.rig) {
case RIG_PORT_SERIAL:
status = serial_open(&rs->rotport);
if (status != 0)
return status;
break;
switch(rs->rotport.type.rig) {
case RIG_PORT_SERIAL:
status = serial_open(&rs->rotport);
if (status != 0)
return status;
break;
case RIG_PORT_PARALLEL:
status = par_open(&rs->rotport);
if (status < 0)
return status;
break;
case RIG_PORT_PARALLEL:
status = par_open(&rs->rotport);
if (status < 0)
return status;
break;
case RIG_PORT_DEVICE:
status = open(rs->rotport.pathname, O_RDWR, 0);
if (status < 0)
return -RIG_EIO;
rs->rotport.fd = status;
break;
case RIG_PORT_DEVICE:
status = open(rs->rotport.pathname, O_RDWR, 0);
if (status < 0)
return -RIG_EIO;
rs->rotport.fd = status;
break;
case RIG_PORT_NONE:
case RIG_PORT_RPC:
break; /* ez :) */
case RIG_PORT_NONE:
case RIG_PORT_RPC:
break; /* ez :) */
case RIG_PORT_NETWORK: /* not implemented yet! */
return -RIG_ENIMPL;
default:
return -RIG_EINVAL;
case RIG_PORT_NETWORK: /* not implemented yet! */
return -RIG_ENIMPL;
default:
return -RIG_EINVAL;
}
add_opened_rot(rot);
rs->comm_state = 1;
/*
* Maybe the backend has something to initialize
* In case of failure, just close down and report error code.
*/
if (caps->rot_open != NULL) {
status = caps->rot_open(rot);
if (status != RIG_OK) {
return status;
}
}
add_opened_rot(rot);
rs->comm_state = 1;
/*
* Maybe the backend has something to initialize
* In case of failure, just close down and report error code.
*/
if (caps->rot_open != NULL) {
status = caps->rot_open(rot);
if (status != RIG_OK) {
return status;
}
}
return RIG_OK;
return RIG_OK;
}
/**
@ -352,47 +352,47 @@ int HAMLIB_API rot_open(ROT *rot)
int HAMLIB_API rot_close(ROT *rot)
{
const struct rot_caps *caps;
struct rot_state *rs;
const struct rot_caps *caps;
struct rot_state *rs;
rot_debug(RIG_DEBUG_VERBOSE,"rot:rot_close called \n");
rot_debug(RIG_DEBUG_VERBOSE,"rot:rot_close called \n");
if (!rot || !rot->caps)
return -RIG_EINVAL;
if (!rot || !rot->caps)
return -RIG_EINVAL;
caps = rot->caps;
rs = &rot->state;
caps = rot->caps;
rs = &rot->state;
if (!rs->comm_state)
return -RIG_EINVAL;
if (!rs->comm_state)
return -RIG_EINVAL;
/*
* Let the backend say 73s to the rot.
* and ignore the return code.
*/
if (caps->rot_close)
caps->rot_close(rot);
/*
* Let the backend say 73s to the rot.
* and ignore the return code.
*/
if (caps->rot_close)
caps->rot_close(rot);
if (rs->rotport.fd != -1) {
switch(rs->rotport.type.rig) {
case RIG_PORT_SERIAL:
ser_close(&rs->rotport);
break;
case RIG_PORT_PARALLEL:
par_close(&rs->rotport);
break;
default:
close(rs->rotport.fd);
}
rs->rotport.fd = -1;
if (rs->rotport.fd != -1) {
switch(rs->rotport.type.rig) {
case RIG_PORT_SERIAL:
ser_close(&rs->rotport);
break;
case RIG_PORT_PARALLEL:
par_close(&rs->rotport);
break;
default:
close(rs->rotport.fd);
}
rs->rotport.fd = -1;
}
remove_opened_rot(rot);
remove_opened_rot(rot);
rs->comm_state = 0;
rs->comm_state = 0;
return RIG_OK;
return RIG_OK;
}
/**
@ -411,26 +411,26 @@ int HAMLIB_API rot_close(ROT *rot)
int HAMLIB_API rot_cleanup(ROT *rot)
{
rot_debug(RIG_DEBUG_VERBOSE,"rot:rot_cleanup called \n");
rot_debug(RIG_DEBUG_VERBOSE,"rot:rot_cleanup called \n");
if (!rot || !rot->caps)
return -RIG_EINVAL;
if (!rot || !rot->caps)
return -RIG_EINVAL;
/*
* check if they forgot to close the rot
*/
if (rot->state.comm_state)
rot_close(rot);
/*
* check if they forgot to close the rot
*/
if (rot->state.comm_state)
rot_close(rot);
/*
* basically free up the priv struct
*/
if (rot->caps->rot_cleanup)
rot->caps->rot_cleanup(rot);
/*
* basically free up the priv struct
*/
if (rot->caps->rot_cleanup)
rot->caps->rot_cleanup(rot);
free(rot);
free(rot);
return RIG_OK;
return RIG_OK;
}
@ -450,16 +450,16 @@ int HAMLIB_API rot_cleanup(ROT *rot)
*/
int HAMLIB_API rot_set_conf(ROT *rot, token_t token, const char *val)
{
if (!rot || !rot->caps)
return -RIG_EINVAL;
if (!rot || !rot->caps)
return -RIG_EINVAL;
if (IS_TOKEN_FRONTEND(token))
return frontrot_set_conf(rot, token, val);
if (IS_TOKEN_FRONTEND(token))
return frontrot_set_conf(rot, token, val);
if (rot->caps->set_conf == NULL)
return -RIG_ENAVAIL;
if (rot->caps->set_conf == NULL)
return -RIG_ENAVAIL;
return rot->caps->set_conf(rot, token, val);
return rot->caps->set_conf(rot, token, val);
}
/**
@ -478,16 +478,16 @@ int HAMLIB_API rot_set_conf(ROT *rot, token_t token, const char *val)
*/
int HAMLIB_API rot_get_conf(ROT *rot, token_t token, char *val)
{
if (!rot || !rot->caps || !val)
return -RIG_EINVAL;
if (!rot || !rot->caps || !val)
return -RIG_EINVAL;
if (IS_TOKEN_FRONTEND(token))
return frontrot_get_conf(rot, token, val);
if (IS_TOKEN_FRONTEND(token))
return frontrot_get_conf(rot, token, val);
if (rot->caps->get_conf == NULL)
return -RIG_ENAVAIL;
if (rot->caps->get_conf == NULL)
return -RIG_ENAVAIL;
return rot->caps->get_conf(rot, token, val);
return rot->caps->get_conf(rot, token, val);
}
/**
@ -507,23 +507,23 @@ int HAMLIB_API rot_get_conf(ROT *rot, token_t token, char *val)
int HAMLIB_API rot_set_position (ROT *rot, azimuth_t azimuth, elevation_t elevation)
{
const struct rot_caps *caps;
const struct rot_state *rs;
const struct rot_caps *caps;
const struct rot_state *rs;
if (CHECK_ROT_ARG(rot))
return -RIG_EINVAL;
if (CHECK_ROT_ARG(rot))
return -RIG_EINVAL;
caps = rot->caps;
rs = &rot->state;
caps = rot->caps;
rs = &rot->state;
if (azimuth < rs->min_az || azimuth > rs->max_az ||
elevation < rs->min_el || elevation > rs->max_el)
return -RIG_EINVAL;
if (azimuth < rs->min_az || azimuth > rs->max_az ||
elevation < rs->min_el || elevation > rs->max_el)
return -RIG_EINVAL;
if (caps->set_position == NULL)
return -RIG_ENAVAIL;
if (caps->set_position == NULL)
return -RIG_ENAVAIL;
return caps->set_position(rot, azimuth, elevation);
return caps->set_position(rot, azimuth, elevation);
}
/**
@ -543,17 +543,17 @@ int HAMLIB_API rot_set_position (ROT *rot, azimuth_t azimuth, elevation_t elevat
int HAMLIB_API rot_get_position (ROT *rot, azimuth_t *azimuth, elevation_t *elevation)
{
const struct rot_caps *caps;
const struct rot_caps *caps;
if (CHECK_ROT_ARG(rot) || !azimuth || !elevation)
return -RIG_EINVAL;
if (CHECK_ROT_ARG(rot) || !azimuth || !elevation)
return -RIG_EINVAL;
caps = rot->caps;
caps = rot->caps;
if (caps->get_position == NULL)
return -RIG_ENAVAIL;
if (caps->get_position == NULL)
return -RIG_ENAVAIL;
return caps->get_position(rot, azimuth, elevation);
return caps->get_position(rot, azimuth, elevation);
}
/**
@ -570,17 +570,17 @@ int HAMLIB_API rot_get_position (ROT *rot, azimuth_t *azimuth, elevation_t *elev
int HAMLIB_API rot_park (ROT *rot)
{
const struct rot_caps *caps;
const struct rot_caps *caps;
if (CHECK_ROT_ARG(rot))
return -RIG_EINVAL;
if (CHECK_ROT_ARG(rot))
return -RIG_EINVAL;
caps = rot->caps;
caps = rot->caps;
if (caps->park == NULL)
return -RIG_ENAVAIL;
if (caps->park == NULL)
return -RIG_ENAVAIL;
return caps->park(rot);
return caps->park(rot);
}
/**
@ -597,17 +597,17 @@ int HAMLIB_API rot_park (ROT *rot)
int HAMLIB_API rot_stop (ROT *rot)
{
const struct rot_caps *caps;
const struct rot_caps *caps;
if (CHECK_ROT_ARG(rot))
return -RIG_EINVAL;
if (CHECK_ROT_ARG(rot))
return -RIG_EINVAL;
caps = rot->caps;
caps = rot->caps;
if (caps->stop == NULL)
return -RIG_ENAVAIL;
if (caps->stop == NULL)
return -RIG_ENAVAIL;
return caps->stop(rot);
return caps->stop(rot);
}
/**
@ -625,17 +625,17 @@ int HAMLIB_API rot_stop (ROT *rot)
int HAMLIB_API rot_reset (ROT *rot, rot_reset_t reset)
{
const struct rot_caps *caps;
const struct rot_caps *caps;
if (CHECK_ROT_ARG(rot))
return -RIG_EINVAL;
if (CHECK_ROT_ARG(rot))
return -RIG_EINVAL;
caps = rot->caps;
caps = rot->caps;
if (caps->reset == NULL)
return -RIG_ENAVAIL;
if (caps->reset == NULL)
return -RIG_ENAVAIL;
return caps->reset(rot, reset);
return caps->reset(rot, reset);
}
/**
@ -675,14 +675,12 @@ int HAMLIB_API rot_move (ROT *rot, int direction, int speed)
*/
const char* HAMLIB_API rot_get_info(ROT *rot)
{
if (CHECK_ROT_ARG(rot))
return NULL;
if (CHECK_ROT_ARG(rot))
return NULL;
if (rot->caps->get_info == NULL)
return NULL;
if (rot->caps->get_info == NULL)
return NULL;
return rot->caps->get_info(rot);
return rot->caps->get_info(rot);
}