/* * Hamlib Interface - provides registering for dynamically loadable backends. * Copyright (c) 2000-2005 by Stephane Fillod * * * This library is free software; you can redistribute it and/or * modify it under the terms of the GNU Lesser General Public * License as published by the Free Software Foundation; either * version 2.1 of the License, or (at your option) any later version. * * This library is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * Lesser General Public License for more details. * * You should have received a copy of the GNU Lesser General Public * License along with this library; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA * */ /** * \brief Dynamic registration of backends * \file register.c * * doc todo: Let's explain what's going on here! */ #ifdef HAVE_CONFIG_H #include "config.h" #endif #include #include #include #include #include #include #include #include #ifndef PATH_MAX # define PATH_MAX 1024 #endif #define RIG_BACKEND_MAX 32 #define DEFINE_INITRIG_BACKEND(backend) \ int MAKE_VERSIONED_FN(PREFIX_INITRIG, ABI_VERSION, backend(void *be_handle)); \ rig_model_t MAKE_VERSIONED_FN(PREFIX_PROBERIG, ABI_VERSION, backend(hamlib_port_t *port, rig_probe_func_t cfunc, rig_ptr_t data)) #define RIG_FUNCNAMA(backend) MAKE_VERSIONED_FN(PREFIX_INITRIG, ABI_VERSION, backend) #define RIG_FUNCNAMB(backend) MAKE_VERSIONED_FN(PREFIX_PROBERIG, ABI_VERSION, backend) #define RIG_FUNCNAM(backend) RIG_FUNCNAMA(backend),RIG_FUNCNAMB(backend) /* * RIG_BACKEND_LIST is defined here, please keep it up to data, * ie. each time you give birth to a new backend * Also, it should be possible to register "external" backend, * that is backend that were not known by Hamlib at compile time. * Maybe, riglist.h should reserve some numbers for them? --SF */ DEFINE_INITRIG_BACKEND(dummy); DEFINE_INITRIG_BACKEND(yaesu); DEFINE_INITRIG_BACKEND(kenwood); DEFINE_INITRIG_BACKEND(icom); DEFINE_INITRIG_BACKEND(pcr); DEFINE_INITRIG_BACKEND(aor); DEFINE_INITRIG_BACKEND(jrc); DEFINE_INITRIG_BACKEND(uniden); DEFINE_INITRIG_BACKEND(drake); DEFINE_INITRIG_BACKEND(lowe); DEFINE_INITRIG_BACKEND(racal); DEFINE_INITRIG_BACKEND(wj); DEFINE_INITRIG_BACKEND(skanti); DEFINE_INITRIG_BACKEND(winradio); DEFINE_INITRIG_BACKEND(tentec); DEFINE_INITRIG_BACKEND(alinco); DEFINE_INITRIG_BACKEND(kachina); DEFINE_INITRIG_BACKEND(tapr); DEFINE_INITRIG_BACKEND(flexradio); DEFINE_INITRIG_BACKEND(rft); DEFINE_INITRIG_BACKEND(kit); DEFINE_INITRIG_BACKEND(tuner); DEFINE_INITRIG_BACKEND(rs); DEFINE_INITRIG_BACKEND(prm80); DEFINE_INITRIG_BACKEND(adat); /*! \def rig_backend_list * \brief Static list of rig models. * * This is a NULL terminated list of available rig backends. Each entry * in the list consists of two fields: The branch number, which is an integer, * and the branch name, which is a character string. */ static struct { int be_num; const char *be_name; int (* be_init_all)(void * handle); rig_model_t (* be_probe_all)(hamlib_port_t*, rig_probe_func_t, rig_ptr_t); } rig_backend_list[RIG_BACKEND_MAX] = { { RIG_DUMMY, RIG_BACKEND_DUMMY, RIG_FUNCNAMA(dummy) }, { RIG_YAESU, RIG_BACKEND_YAESU, RIG_FUNCNAM(yaesu) }, { RIG_KENWOOD, RIG_BACKEND_KENWOOD, RIG_FUNCNAM(kenwood) }, { RIG_ICOM, RIG_BACKEND_ICOM, RIG_FUNCNAM(icom) }, { RIG_PCR, RIG_BACKEND_PCR, RIG_FUNCNAMA(pcr) }, { RIG_AOR, RIG_BACKEND_AOR, RIG_FUNCNAMA(aor) }, { RIG_JRC, RIG_BACKEND_JRC, RIG_FUNCNAMA(jrc) }, { RIG_UNIDEN, RIG_BACKEND_UNIDEN, RIG_FUNCNAM(uniden) }, { RIG_DRAKE, RIG_BACKEND_DRAKE, RIG_FUNCNAM(drake) }, { RIG_LOWE, RIG_BACKEND_LOWE, RIG_FUNCNAM(lowe) }, { RIG_RACAL, RIG_BACKEND_RACAL, RIG_FUNCNAMA(racal) }, { RIG_WJ, RIG_BACKEND_WJ, RIG_FUNCNAMA(wj) }, { RIG_SKANTI, RIG_BACKEND_SKANTI, RIG_FUNCNAMA(skanti) }, { RIG_WINRADIO, RIG_BACKEND_WINRADIO, RIG_FUNCNAMA(winradio) }, { RIG_TENTEC, RIG_BACKEND_TENTEC, RIG_FUNCNAMA(tentec) }, { RIG_ALINCO, RIG_BACKEND_ALINCO, RIG_FUNCNAMA(alinco) }, { RIG_KACHINA, RIG_BACKEND_KACHINA, RIG_FUNCNAMA(kachina) }, { RIG_TAPR, RIG_BACKEND_TAPR, RIG_FUNCNAMA(tapr) }, { RIG_FLEXRADIO, RIG_BACKEND_FLEXRADIO, RIG_FUNCNAMA(flexradio) }, { RIG_RFT, RIG_BACKEND_RFT, RIG_FUNCNAMA(rft) }, { RIG_KIT, RIG_BACKEND_KIT, RIG_FUNCNAMA(kit) }, { RIG_TUNER, RIG_BACKEND_TUNER, RIG_FUNCNAMA(tuner) }, { RIG_RS, RIG_BACKEND_RS, RIG_FUNCNAMA(rs) }, { RIG_PRM80, RIG_BACKEND_PRM80, RIG_FUNCNAMA(prm80) }, { RIG_ADAT, RIG_BACKEND_ADAT, RIG_FUNCNAM(adat) }, { 0, NULL }, /* end */ }; /* * This struct to keep track of known rig models. * It is chained, and used in a hash table, see below. */ struct rig_list { const struct rig_caps *caps; struct rig_list *next; }; #define RIGLSTHASHSZ 16 #define HASH_FUNC(a) ((a)%RIGLSTHASHSZ) /* * The rig_hash_table is a hash table pointing to a list of next==NULL * terminated caps. */ static struct rig_list *rig_hash_table[RIGLSTHASHSZ] = { NULL, }; static int rig_lookup_backend(rig_model_t rig_model); /* * Basically, this is a hash insert function that doesn't check for dup! */ int HAMLIB_API rig_register(const struct rig_caps *caps) { int hval; struct rig_list *p; if (!caps) return -RIG_EINVAL; 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; #endif 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; return RIG_OK; } /* * Get rig capabilities. * ie. rig_hash_table lookup */ const struct rig_caps * HAMLIB_API rig_get_caps(rig_model_t rig_model) { 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! */ } /* * lookup for backend index in rig_backend_list table, * according to BACKEND_NUM * return -1 if not found. */ static int rig_lookup_backend(rig_model_t rig_model) { int i; for (i=0; inext) { 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; } return -RIG_EINVAL; /* sorry, caps not registered! */ } /* * rig_list_foreach * executes cfunc on all the elements stored in the rig hash list */ int HAMLIB_API rig_list_foreach(int (*cfunc)(const struct rig_caps*, rig_ptr_t),rig_ptr_t data) { struct rig_list *p; int i; if (!cfunc) return -RIG_EINVAL; for (i=0; inext) if ((*cfunc)(p->caps,data) == 0) return RIG_OK; } return RIG_OK; } static int dummy_rig_probe(const hamlib_port_t *p, rig_model_t model, rig_ptr_t data) { rig_debug(RIG_DEBUG_TRACE, "Found rig, model %d\n", model); return RIG_OK; } /* * rig_probe_first * called straight by rig_probe */ rig_model_t rig_probe_first(hamlib_port_t *p) { int i; rig_model_t model; for (i=0; i